String processing and regular expressions in Go language

String processing and regular expressions in Go language

Go language is a strongly typed language, in which string is a commonly used data type. In the process of program development, string processing is a very important part. This article will introduce the basic operations of string processing and the use of regular expressions in the Go language.

1. String processing

The string type of Go language is an immutable byte sequence, that is, once created, its value cannot be modified. Strings can be represented using double quotes or backticks. Escape sequences can be used in double-quoted strings, such as
to represent a newline character. Backtick strings can contain any characters, including multiline text and escape characters.

1. String connection

Operators can be used in Go language to connect two strings, for example:

str1 := "Hello"
str2 := "world"
str3 := str1 + " " + str2
fmt.Println(str3) // output: Hello world

2. String splitting

You can use the Split() function in the strings package to split a string. For example:

str := "Hello world"
arr := strings.Split(str, " ")
fmt.Println(arr) // output: [Hello world]

3. String replacement

You can use the Replace() function in the strings package to replace strings. For example:

str := "Hello world"
newStr := strings.Replace(str, "world", "Go", 1)
fmt.Println(newStr) // output: Hello Go

4. String search

You can use the Index() or Contains() function in the strings package to find strings. For example:

str := "Hello world"
index := strings.Index(str, "world")
fmt.Println(index) // output: 6
isContains := strings.Contains(str, "Hello")
fmt.Println(isContains) // output: true

5. String case conversion

You can use the ToUpper() and ToLower() functions in the strings package to convert the case of a string. For example:

str := "Hello WORLD"
newStr1 := strings.ToUpper(str)
newStr2 := strings.ToLower(str)
fmt.Println(newStr1) // output: HELLO WORLD
fmt.Println(newStr2) // output: hello world

2. Regular expressions

Regular expressions are a tool used to describe strings and can determine whether a string matches a certain pattern. The Go language has a built-in regexp package that can use regular expressions to match and manipulate strings.

1. Basic metacharacters of regular expressions

• .: Match any character
• d: Match numbers, equivalent to [0 -9]
• D: Matches any characters except numbers, equivalent to ¹
• w: Matches letters and numbers, equivalent In [a-zA-Z0-9]
• W: matches any character that is not letters and numbers, equivalent to ²
##s : Matches whitespace characters such as spaces or tabs
S: Matches non-whitespace characters
^: Matches the beginning of the string
$: Matches the end of the string
[]: Matches any character within the brackets
[^]: Matches any character except the characters within the brackets

Regular Expression function

MatchString(pattern string, s string) bool: Determine whether the s string matches the pattern regular expression pattern
FindString(pattern string, s string) string: Find the first substring that matches the pattern regular expression pattern in s string, and return the substring
FindAllString(pattern string, s string, n int) []string: in Find all substrings matching the pattern regular expression pattern in the s string and return a string slice. n represents the maximum number of matches
ReplaceAllString(pattern string, s string, repl string) string: Use repl string to replace all substrings in s string that match the pattern regular expression pattern, and return the replaced characters String

Example of regular expression

package main

import (
    "fmt"
    "regexp"
)

func main() {
    str1 := "abc123"
    str2 := "Hello world"
    pattern1 := `d+`
    pattern2 := `wo..d`
    isMatch1, _ := regexp.MatchString(pattern1, str1)
    isMatch2, _ := regexp.MatchString(pattern2, str2)
    fmt.Println(isMatch1) // output: true
    fmt.Println(isMatch2) // output: true
    
    re := regexp.MustCompile(pattern1)
    match1 := re.FindString(str1)
    fmt.Println(match1) // output: 123
    
    matchAll1 := re.FindAllString(str1, -1)
    fmt.Println(matchAll1) // output: [123]
    
    repl := re.ReplaceAllString(str1, "456")
    fmt.Println(repl) // output: abc456
    
    re2 := regexp.MustCompile(pattern2)
    match2 := re2.FindString(str2)
    fmt.Println(match2) // output: world
}

Summary
This article introduces the use of string processing and regular expressions in the Go language . String processing includes basic operations such as concatenation, splitting, replacing, searching, and case conversion. Regular expressions can be used to match and manipulate strings that match a certain pattern. Mastering these operations can make it easier to process strings and improve program development efficiency.

---

0-9
1. ↩
a-zA-Z0-9
2. ↩

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