Golang-Saitenersatz

String in Golang ist einer der häufigsten Datentypen. Bei der Verarbeitung von Strings müssen wir häufig die String-Ersetzungsmethode verwenden. In diesem Artikel werden verschiedene Methoden zum Implementieren der Zeichenfolgenersetzung in Golang vorgestellt.

1. strings.Replace

strings.Replace ist die integrierte String-Ersetzungsfunktion in Golang. Der Funktionsprototyp lautet wie folgt: #🎜 🎜#

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

Parameterbeschreibung:

s: stellt die ursprüngliche Zeichenfolge dar, die ersetzt werden muss;
old: stellt die Zeichenfolge dar, die ersetzt werden muss ersetzt werden; #🎜 🎜#
• neu: stellt die neue Zeichenfolge dar, die ersetzt werden muss;
• n: stellt die Anzahl der Ersetzungen dar, -1 stellt alle Ersetzungen dar.
Der Beispielcode lautet wie folgt:

package main

import (
    "fmt"
    "strings"
)

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

Es ist zu beachten, dass strings.Replace eine neue Zeichenfolge zurückgibt und die ursprüngliche Zeichenfolge nicht ändert.

strings.ReplaceAll

strings.ReplaceAll ist eine vereinfachte Version der strings.Replace-Funktion und ihr Funktionsprototyp lautet wie folgt: # 🎜🎜#

func ReplaceAll(s, old, new string) string

# 🎜🎜#Der Beispielcode lautet wie folgt:

package main

import (
    "fmt"
    "strings"
)

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

strings.Replacer

strings.Replacer ist flexibler Methode zum Ersetzen von Zeichenfolgen in Golang. Mehrere Zeichen können gleichzeitig ersetzt werden, wobei beim Ersetzen die Groß- und Kleinschreibung nicht beachtet werden muss. Der Beispielcode lautet wie folgt:

3. 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
   }

Es ist zu beachten, dass strings.Replacer auch einen neuen String zurückgibt und den ursprünglichen String nicht ändert.

bytes.Replace

Zusätzlich zur Verwendung des Strings-Pakets zum Ersetzen von Strings können Sie auch die Funktion bytes.Replace für Byte-Arrays verwenden Ersatz. Da es sich bei der Zeichenfolge in Golang im Wesentlichen um eine schreibgeschützte Zeichenfolge handelt, muss die Zeichenfolge zur Verarbeitung in ein Byte-Array konvertiert werden. Der Beispielcode lautet wie folgt:

4. 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
   }

   Es ist zu beachten, dass bytes.Replace auch eine neue Bytesequenz zurückgibt, die zur Ausgabe in eine Zeichenfolgenform konvertiert werden muss.

   Zusammenfassend lässt sich sagen, dass das Ersetzen von Zeichenfolgen in Golang mithilfe des integrierten Strings-Pakets oder der zugehörigen Funktionen des Bytes-Pakets erreicht werden kann. Unter diesen sind strings.Replace, strings.ReplaceAll und strings.Replacer häufig verwendete Methoden zum Ersetzen von Zeichenfolgen.

   Das obige ist der detaillierte Inhalt vonGolang-Saitenersatz. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!