Use regular expressions in golang to verify whether the input is a legal unified social credit code

In Golang development, sometimes it is necessary to verify whether the input is a legal unified social credit code. The unified social credit code is an 18-digit code composed of numbers and English letters, which is unique and identifying to the company. So, in Golang, how to use regular expressions to verify whether the input is a legal unified social credit code? This article will introduce you how to use regular expressions for verification.

1. Unified Social Credit Code Format

The Unified Social Credit Code consists of 18 digits and capital letters and can be divided into three parts:

• The first part is the registration management department code, consisting of numbers or capital letters;
• The second part is the institution category code, consisting of numbers or capital letters;
• The third part is the registration management The administrative division code of the agency consists of numbers;

The following is the format of the unified social credit code:

ABCDEFGHJKLMNPQRTUWXY0123456789

The first digit is the registration management department code, 9 Represents the industrial and commercial sector.

The second digit is the organization category code, 1 is the agency, 2 is the public institution, 3 is the enterprise, and 9 is other.

The 3rd to 8th digits are the administrative division code, which refers to the administrative region (province, autonomous region, municipality directly under the Central Government, etc.) where the registration management agency is located.

The 9th to 17th digits are the organization code, or the corporate organization code.

The 18th digit is the check code, used to verify whether the entered unified social credit code is legal.

2. Golang regular expression

In Golang, you can use the functions in the regexp package for regular expression matching. The following are the three main functions in the regexp package:

• MatchString(pattern string, s string) (bool, error): used to match whether the string s conforms to the regular expression pattern.
• Compile(expr string) (*Regexp, error): Used to compile the string expr into a regular expression of Regexp type.
• MustCompile(expr string) *Regexp: has the same effect as the Compile function, but will panic when compilation errors occur.

Use regular expressions to verify the unified social credit code. You can first express the rules in string form, then use the Compile or MustCompile function to compile it into a Regexp type, and finally use the MatchString function to match the input characters. string.

3. Use regular expressions to verify the unified social credit code

The following is a sample program that uses regular expressions to verify the unified social credit code:

package main

import (
    "fmt"
    "regexp"
)

func main() {
    // 编译正则表达式
    re := regexp.MustCompile(`^[A-Z0-9]{18}$`)

    // 输入待验证的统一社会信用代码
    var input string
    fmt.Println("请输入统一社会信用代码：")
    fmt.Scanln(&input)

    // 验证输入是否符合规则
    if re.MatchString(input) {
        fmt.Println("输入的统一社会信用代码合法")
    } else {
        fmt.Println("输入的统一社会信用代码不合法")
    }
}

In the above example program, the ^[A-Z0-9]{18}$ regular expression is first used to compile a regular expression for verifying the unified social credit code, where ^ represents the beginning, $ represents the end, [A-Z0-9] represents uppercase letters and numbers, {18} represents the length of 18 characters. Next, the program prompts the user to enter the unified social credit code to be verified, and uses the MatchString function for verification. If the rules are met, it will output "The entered unified social credit code is legal", otherwise it will output "The entered unified social credit code is illegal".

4. Summary

In Golang development, using regular expressions for input validation is a common method. For the verification of the unified social credit code, you can use regular expressions to verify whether its format is correct. When writing regular expressions, you need to write them according to the rules, paying attention to requirements such as character type and length. When using the MatchString function for matching, the regular expression needs to be compiled into a Regexp type object, and then the object is used for matching. By using regular expressions for input validation, you can effectively ensure that the input data complies with regulations, thereby improving the stability and security of the program.

The above is the detailed content of Use regular expressions in golang to verify whether the input is a legal unified social credit code. For more information, please follow other related articles on the PHP Chinese website!