Wie man Strings in Go aufteilt

Key Takeaways

1. Go bietet mehrere Funktionen zum Aufteilen von Zeichenketten, einschließlich strings.Fields, strings.Split und strings.FieldsFunc.
2. Reguläre Ausdrücke können für komplexe Szenarien zur Zeichenkettenaufteilung verwendet werden.
3. Die Wahl der richtigen Methode hängt vom Trennzeichen-Typ und der Komplexität der Aufteilungsbedingung ab.

Zeichenkettenmanipulation ist ein grundlegender Aspekt der Programmierung, und das Aufteilen von Zeichenketten in Teilzeichenketten basierend auf bestimmten Trennzeichen ist eine übliche Aufgabe. In Go bietet das strings-Paket eine Vielzahl von Funktionen, um solche Operationen effizient zu handhaben. Dieser Artikel untersucht verschiedene Methoden zum Aufteilen von Zeichenketten in Go, einschließlich des Aufteilens nach Leerzeichen, spezifischen Zeichen oder Zeichenketten, mehreren Zeichen und der Verwendung regulärer Ausdrücke.

Aufteilen nach Leerzeichen

Um eine Zeichenkette nach Leerzeichen aufzuteilen, bietet Go die Funktion strings.Fields. Diese Funktion teilt die Eingabezeichenkette basierend auf Leerzeichen in Teilzeichenketten auf und gibt ein Slice dieser Teilzeichenketten zurück.

package main

import (
    "fmt"
    "strings"
)

func main() {
    str := "  foo bar  baz   "
    fields := strings.Fields(str)
    fmt.Printf("Felder sind: %q\n", fields)
}

Ausgabe:

Felder sind: ["foo" "bar" "baz"]

In diesem Beispiel ignoriert strings.Fields führende und nachfolgende Leerzeichen und teilt die Zeichenkette an jeder Sequenz von Leerzeichen auf.

Aufteilen nach spezifischen Zeichen oder Zeichenketten

Zum Aufteilen einer Zeichenkette nach einem bestimmten Zeichen oder einer Teilzeichenkette wird die Funktion strings.Split verwendet. Diese Funktion nimmt die Eingabezeichenkette und ein Trennzeichen entgegen und teilt die Zeichenkette bei jedem Vorkommen des Trennzeichens auf.

package main

import (
    "fmt"
    "strings"
)

func main() {
    str1 := "a,b,c"
    split1 := strings.Split(str1, ",")
    fmt.Printf("%q\n", split1)

    str2 := "a man a plan a canal panama"
    split2 := strings.Split(str2, "a ")
    fmt.Printf("%q\n", split2)
}

Ausgabe:

["a" "b" "c"]
 ["" "man " "plan " "canal panama"]

Im ersten Fall wird die Zeichenkette an jedem Komma aufgeteilt. Im zweiten Fall wird die Zeichenkette bei jedem Vorkommen der Teilzeichenkette "a " aufgeteilt.

Aufteilen nach mehreren Zeichen

Wenn das Trennzeichen aus mehreren Zeichen besteht, kann strings.FieldsFunc verwendet werden. Diese Funktion teilt die Zeichenkette basierend auf einer benutzerdefinierten Funktion, die bestimmt, ob ein Zeichen ein Trennzeichen ist.

package main

import (
    "fmt"
    "strings"
    "unicode"
)

func main() {
    str := "  foo1;bar2,baz3..."
    f := func(c rune) bool {
        return !unicode.IsLetter(c) && !unicode.IsNumber(c)
    }
    fields := strings.FieldsFunc(str, f)
    fmt.Printf("Felder sind: %q\n", fields)
}

Ausgabe:

Felder sind: ["foo1" "bar2" "baz3"]

In diesem Beispiel verwendet strings.FieldsFunc die Funktion f, um Trennzeichen zu bestimmen. Die Funktion f betrachtet jedes Zeichen, das kein Buchstabe oder eine Zahl ist, als Trennzeichen und teilt die Zeichenkette effektiv an Satzzeichen und Leerzeichen auf.

Aufteilen nach mehreren Zeichenketten

Ab Go 1.20 bietet die Standardbibliothek keine Funktion zum direkten Aufteilen einer Zeichenkette nach mehreren Teilzeichenketten. Diese Funktionalität kann jedoch durch das Verketten von Aufrufen von strings.Split oder durch die Verwendung regulärer Ausdrücke erreicht werden.

package main

import (
    "fmt"
    "regexp"
)

func main() {
    str := "Hello, This is my, first code in, Golang!"
    re := regexp.MustCompile(",\\s*")
    split := re.Split(str, -1)
    fmt.Println(split)
}

Ausgabe:

[Hello This is my first code in Golang!]

In diesem Beispiel wird ein regulärer Ausdruck verwendet, um die Zeichenkette an jedem Komma gefolgt von einer beliebigen Anzahl von Leerzeichen aufzuteilen.

Aufteilen mithilfe regulärer Ausdrücke

Für komplexere Aufteilungsszenarien bieten reguläre Ausdrücke ein leistungsstarkes Werkzeug. Die Split-Methode des regexp-Pakets ermöglicht das Aufteilen einer Zeichenkette basierend auf Mustern.

package main

import (
    "fmt"
    "regexp"
)

func main() {
    str := "Hello :), This is my, first code in, Golang!"
    re := regexp.MustCompile(`:\),\s*`)
    split := re.Split(str, -1)
    fmt.Println(split)
}

Ausgabe:

[Hello  This is my first code in Golang!]

Hier stimmt der reguläre Ausdruck :\),\s* mit dem Smiley :) überein, gefolgt von einer beliebigen Anzahl von Leerzeichen, wodurch die Zeichenkette entsprechend aufgeteilt wird.

Fazit

Go bietet robuste Werkzeuge zum Aufteilen von Zeichenketten durch seine strings- und regexp-Pakete. Abhängig von den spezifischen Anforderungen – wie der Art des Trennzeichens und der Komplexität der Aufteilungsbedingung – können Entwickler die geeignete Funktion auswählen, um Zeichenketten effizient in Teilzeichenketten aufzuteilen. Das Verständnis dieser Funktionen und ihrer Anwendungen ist für eine effektive Zeichenkettenmanipulation in Go unerlässlich.

FAQs

Was ist der Unterschied zwischen strings.Fields und strings.Split?

strings.Fields teilt basierend auf Leerzeichen auf und ignoriert leere Felder, während strings.Split bei jedem Vorkommen eines angegebenen Trennzeichens aufteilt.

Kann ich eine Zeichenkette in Go mit mehreren Trennzeichen aufteilen?

Ja, Sie können strings.FieldsFunc für die zeichenbasierte Aufteilung oder regexp.Split für die Aufteilung nach mehreren Teilzeichenketten verwenden.

Bietet Go eine integrierte Möglichkeit, nach mehreren Teilzeichenketten aufzuteilen?

Nein, aber Sie können regexp.Split mit einem regulären Ausdrucksmuster verwenden, um dies zu erreichen.

---

Wir sind Leapcell, Ihre erste Wahl für das Hosten von Go-Projekten.

Leapcell ist die Serverlose Plattform der nächsten Generation für Webhosting, asynchrone Aufgaben und Redis:

Multi-Sprachen Unterstützung

• Entwickeln Sie mit Node.js, Python, Go oder Rust.

Stellen Sie unbegrenzt Projekte kostenlos bereit

• Zahlen Sie nur für die Nutzung - keine Anfragen, keine Gebühren.

Unschlagbare Kosteneffizienz

• Pay-as-you-go ohne Leerlaufgebühren.
• Beispiel: $25 unterstützt 6,94 Millionen Anfragen bei einer durchschnittlichen Antwortzeit von 60 ms.

Optimierte Entwicklererfahrung

• Intuitive Benutzeroberfläche für mühelose Einrichtung.
• Vollautomatische CI/CD-Pipelines und GitOps-Integration.
• Echtzeitmetriken und -protokollierung für umsetzbare Erkenntnisse.

Mühelose Skalierbarkeit und hohe Leistung

• Auto-Skalierung zur einfachen Bewältigung hoher Parallelität.
• Null Betriebsaufwand - konzentrieren Sie sich einfach auf das Bauen.

Erfahren Sie mehr in der Dokumentation!

Folgen Sie uns auf X: @LeapcellHQ