String-Verarbeitung und reguläre Ausdrücke in der Go-Sprache

String-Verarbeitung und reguläre Ausdrücke in der Go-Sprache

Go-Sprache ist eine stark typisierte Sprache, in der String ein häufig verwendeter Datentyp ist. Im Prozess der Programmentwicklung ist die Zeichenfolgenverarbeitung ein sehr wichtiger Teil. In diesem Artikel werden die grundlegenden Operationen der Zeichenfolgenverarbeitung und die Verwendung regulärer Ausdrücke in der Go-Sprache vorgestellt.

1. String-Verarbeitung

Der String-Typ der Go-Sprache ist eine unveränderliche Bytesequenz, das heißt, nach der Erstellung kann sein Wert nicht mehr geändert werden. Zeichenfolgen können durch doppelte Anführungszeichen oder Backticks dargestellt werden. Escape-Sequenzen können in Zeichenfolgen in doppelte Anführungszeichen verwendet werden, z. B.
, um ein Zeilenumbruchzeichen darzustellen. Backtick-Strings können beliebige Zeichen enthalten, einschließlich mehrzeiligem Text und Escape-Zeichen.

1. String-Verkettung

Sie können den +-Operator in der Go-Sprache verwenden, um zwei Strings zu verbinden, zum Beispiel:

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

2. String-Aufteilung

Sie können die Funktion Split() im Strings-Paket verwenden, um den String zu teilen . Zum Beispiel:

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

3. String-Ersetzung

Sie können die Funktion „Replace()“ im Strings-Paket verwenden, um Strings zu ersetzen. Zum Beispiel:

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

4. String-Suche

Sie können die Funktion Index() oder Contains() im Strings-Paket verwenden, um Strings zu finden. Zum Beispiel:

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

5. Konvertierung der Groß- und Kleinschreibung von Zeichenfolgen

Sie können die Funktionen ToUpper() und ToLower() im Strings-Paket verwenden, um die Groß- und Kleinschreibung einer Zeichenfolge umzuwandeln. Zum Beispiel:

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

2. Reguläre Ausdrücke

Reguläre Ausdrücke sind ein Werkzeug zur Beschreibung von Zeichenfolgen und können feststellen, ob eine Zeichenfolge einem bestimmten Muster entspricht. Die Go-Sprache verfügt über ein integriertes Regexp-Paket, das reguläre Ausdrücke verwenden kann, um Zeichenfolgen abzugleichen und zu bearbeiten.

1. Grundlegende Metazeichen regulärer Ausdrücke

• .: Entspricht jedem Zeichen.
• d: Entspricht Zahlen, entsprechend [0-9].
• D: Entspricht jedem Zeichen außer Zahlen, entsprechend ¹
• w: Entspricht Buchstaben und Zahlen, entspricht [a-zA-Z0-9]
• W: Entspricht allen Zeichen, die keine Buchstaben und Zahlen sind, entspricht ²
• s: Entspricht Leerzeichen wie Leerzeichen oder Tabulatorzeichen
• S: Übereinstimmung mit Nicht-Leerzeichenzeichen
• ^: Übereinstimmung mit dem Anfang der Zeichenfolge
• $: Übereinstimmung mit dem Ende der Zeichenfolge
• []: Übereinstimmung mit einem beliebigen Zeichen innerhalb der eckigen Klammern
• [^]: Übereinstimmung mit einem beliebigen Zeichen Zeichen außer den Zeichen in eckigen Klammern

2. Funktion für reguläre Ausdrücke

• MatchString(Musterzeichenfolge, s-Zeichenfolge) bool: Bestimmen Sie, ob die s-Zeichenfolge mit dem regulären Ausdruck des Musters übereinstimmt. Das Muster
• FindString(Musterzeichenfolge, s-Zeichenfolge) string: Suchen Sie die erste Teilzeichenfolge, die mit dem Muster des regulären Ausdrucks im s-String übereinstimmt, und geben Sie die Teilzeichenfolge zurück ein String-Slice. n stellt die maximale Anzahl von Übereinstimmungen dar
• ReplaceAllString(pattern string, s string, repl string) string: Verwenden Sie repl string, um alle Teilzeichenfolgen in s string zu ersetzen, die mit dem Muster des regulären Ausdrucks übereinstimmen, und geben Sie die ersetzte Zeichenfolge zurück

Beispiele von regulären Ausdrücken

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

   Zusammenfassung

   In diesem Artikel wird die Verwendung der Zeichenfolgenverarbeitung und regulärer Ausdrücke in der Go-Sprache vorgestellt. Die Zeichenfolgenverarbeitung umfasst grundlegende Vorgänge wie Verkettung, Aufteilung, Ersetzen, Suchen und Groß-/Kleinschreibungsumwandlung. Mit regulären Ausdrücken können Zeichenfolgen abgeglichen und bearbeitet werden, die einem bestimmten Muster entsprechen. Die Beherrschung dieser Vorgänge kann die Verarbeitung von Zeichenfolgen erleichtern und die Effizienz der Programmentwicklung verbessern.

   ---

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

   Das obige ist der detaillierte Inhalt vonString-Verarbeitung und reguläre Ausdrücke in der Go-Sprache. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!