String processing methods in Go language

In the Go language, string processing is one of the most common operations. String processing generally includes the following aspects: string concatenation, segmentation, replacement, interception, case conversion, matching, regularization, etc. Below, we will introduce some commonly used string processing methods one by one.

1. String concatenation (Concatenation)

String concatenation refers to concatenating two or more strings to form a new string.

In Go language, you can use the plus sign ( ) or the fmt.Sprintf() function to implement string concatenation. Among them, the plus sign ( ) connects two strings, such as:

str1 := "hello"
str2 := "world"
str3 := str1 + " " + str2
fmt.Println(str3)

The result is: hello world

The fmt.Sprintf() function can connect any number of strings and other types of The variables are converted into a string and spliced ​​together, such as:

str1 := "hello"
num := 123
str3 := fmt.Sprintf("%s %d", str1, num)
fmt.Println(str3)

The result is: hello 123

2. String splitting (Splitting)

String Splitting means splitting a string into multiple substrings according to the specified delimiter.

In Go language, you can use the strings.Split() function to achieve string splitting, for example:

str1 := "hello,world"
strs := strings.Split(str1, ",")
for _, str := range strs {
    fmt.Println(str)
}

The result is:

hello
world

3. String replacement (Replacing)

String replacement refers to replacing a specified substring in a string with another string.

In the Go language, you can use the strings.Replace() function to implement string replacement, for example:

str1 := "hello world"
str2 := strings.Replace(str1, "world", "golang", -1)
fmt.Println(str2)

The result is: hello golang

where -1 represents replacement All matches. If you need to replace a specified number of matches, you can replace -1 with a specific value.

4. String interception (Substr)

String interception refers to intercepting a part of a string as a new string.

In the Go language, you can use the strings.Substr() function to implement string interception, for example:

str1 := "hello world"
str2 := str1[0:5]
fmt.Println(str2)

The result is: hello

where, [0:5] Indicates that starting from the 0th character, intercept a substring of length 5.

5. Case Conversion

Case conversion refers to converting the uppercase and lowercase letters in a string.

In Go language, you can use strings.ToLower() and strings.ToUpper() functions to achieve case conversion, for example:

str1 := "Hello World"
str2 := strings.ToLower(str1)
fmt.Println(str2)
str3 := strings.ToUpper(str1)
fmt.Println(str3)

The result is:

hello world
HELLO WORLD

6. String matching (Matching)

String matching refers to finding a specified substring in a string.

In Go language, you can use the strings.Contains() function to achieve string matching, for example:

str1 := "hello world"
matched := strings.Contains(str1, "world")
if matched {
    fmt.Println("matched")
} else {
    fmt.Println("not matched")
}

The result is: matched

Among them, strings.Contains() The function has two parameters, the first parameter is the string that needs to be searched, and the second parameter is the substring that needs to be matched.

7. Regular Expression Matching

Regular expression matching refers to matching a specified string according to a regular expression in a string.

In Go language, you can use the regexp package to implement regular expression matching, for example:

str1 := "hello world"
matched, err := regexp.MatchString("wo.*d", str1)
if err != nil {
    fmt.Println(err)
}
if matched {
    fmt.Println("matched")
} else {
    fmt.Println("not matched")
}

The result is: matched

Among them, the regexp.MatchString() function has two Parameters, the first parameter is the regular expression, and the second parameter is the string to be matched.

To sum up, the Go language provides a wealth of string processing methods, and we can choose the appropriate method for string processing according to actual needs.

The above is the detailed content of String processing methods in Go language. For more information, please follow other related articles on the PHP Chinese website!