golang string replacement

String (string) in golang is one of the very common data types. When processing strings, we often need to use the string replacement method. This article will introduce several methods to implement string replacement in golang.

1. strings.Replace

strings.Replace is the built-in string replacement function in golang. Its function prototype is as follows:

func Replace(s, old, new string, n int) string

Parameter description:

• s: represents the original string that needs to be replaced;
• old: represents the string that needs to be replaced;
• new: represents the new character that needs to be replaced. String;
• n: indicates the number of replacements, -1 indicates all replacements.

The sample code is as follows:

package main

import (
    "fmt"
    "strings"
)

func main() {
    str := "hello world"
    newStr := strings.Replace(str, "l", "*", -1)
    fmt.Println(newStr) // he**o wor*d
}

It should be noted that strings.Replace will return a new string and will not modify the original string.

2. strings.ReplaceAll

strings.ReplaceAll is a simplified version of the strings.Replace function. Its function prototype is as follows:

func ReplaceAll(s, old, new string) string

The sample code is as follows:

package main

import (
    "fmt"
    "strings"
)

func main() {
    str := "hello, world"
    newStr := strings.ReplaceAll(str, ",", " ")
    fmt.Println(newStr) // hello  world
}

3. strings.Replacer

strings.Replacer is a more flexible string replacement method in golang. It can replace multiple characters at once and allows replacement without distinction. Upper and lower case. The sample code is as follows:

package main

import (
    "fmt"
    "strings"
)

func main() {
    str := "hello, world"
    r := strings.NewReplacer(",", " ", "world", "golang", "l", "L")
    newStr := r.Replace(str)
    fmt.Println(newStr) // hello golang
}

It should be noted that strings.Replacer will also return a new string and will not modify the original string.

4. bytes.Replace

In addition to using the strings package for string replacement, you can also use the bytes.Replace function for byte array replacement. Since the string in golang is essentially a read-only character sequence, the string needs to be converted into a byte array for processing. The sample code is as follows:

package main

import (
    "bytes"
    "fmt"
)

func main() {
    str := "hello, world"
    oldByte := []byte(",")
    newByte := []byte(" ")
    newBytes := bytes.Replace([]byte(str), oldByte, newByte, -1)
    newStr := string(newBytes)
    fmt.Println(newStr) // hello  world
}

It should be noted that bytes.Replace will also return a new byte sequence, which needs to be converted into a string form for output.

To sum up, string replacement in golang can be achieved using the related functions of the built-in strings package or bytes package. Among them, strings.Replace, strings.ReplaceAll and strings.Replacer are commonly used string replacement methods.

The above is the detailed content of golang string replacement. For more information, please follow other related articles on the PHP Chinese website!