Die Manipulation von Zeichenfolgen ist in der Softwareentwicklung von grundlegender Bedeutung. Die meisten Programmiersprachen bieten schließlich einen String-Typ an. Ein String ist eine Folge von Zeichen: Buchstaben, Zahlen und Symbole.
Die String-Manipulation ist für verschiedene Anwendungen praktisch, von der Textverarbeitung und Datenanalyse bis hin zur Webentwicklung. Beliebte Operationen zur Bearbeitung von Zeichenfolgen sind Verkettung, Datenvalidierung, Extraktion und Formatierung. Go stellt in der Standardbibliothek ein String-Manipulationspaket namens „strings“ bereit.
Das Saitenpaket
Der Saiten Paket bietet verschiedene nützliche Funktionen für die String-Manipulation und andere Operationen. Das Paket enthält Funktionen für Substring-Operationen, Trimmen, Vergleichen von Strings, String-Konvertierung, String-Erstellung, Aufteilen und mehr.
Sie können das Zeichenfolgenpaket importieren, indem Sie den Paketnamen in Ihrer Importliste angeben.
importieren"Saiten"
Suche nach Teilstrings
Der Saiten Paket bietet drei Funktionen für die Suche nach Teilzeichenfolgen: die Enthält Funktion, die EnthältAlle Funktion und die EnthältRune Funktion.
Der Enthält Die Funktion prüft, ob die angegebene Zeichenfolge die Teilzeichenfolge enthält. Der EnthältAlle Funktion prüft, ob die Zeichenfolge Zeichen in der Teilzeichenfolge enthält, und die EnthältRune Funktion prüft, ob der String eine Rune (ein Unicode-Zeichen) enthält.
importieren (
"fmt"
"Saiten"
)Funkhauptsächlich() {
eine Zeichenfolge := "Hallo Welt!"
Teilstring := "Welt"
Zeichen := "aeiou"
aRune := 'Ö'
fmt. Println (Zeichenfolgen. Enthält (aString, Teilstring)) // Ausgabe: wahr
fmt. Println (Zeichenfolgen. ContainsAny (aString, Zeichen)) // Ausgabe: wahr
fmt. Println (Zeichenfolgen. EnthältRune (aString, aRune)) // Ausgabe: wahr
}
Sie können den Index eines Teilstrings mit abrufen Index, IndexAny, IndexByte, Und IndexFunk Funktionen. Der Index Die Funktion gibt den Index eines Teilstrings zurück, wenn er in einem anderen gegebenen String vorkommt. Der IndexAny Die Funktion gibt den Index der ersten Instanz von zurück ein Unicode-Codepunkt oder -1 wenn keines der Zeichen vorhanden ist.
importieren (
"fmt"
"Saiten"
)Funkhauptsächlich() {
eine Zeichenfolge := "Hallo Welt!"
Teilstring := "Welt"
Zeichen := "Welt"
byteZeichen := Byte('Ö')
aRune := Rune('Ö')fmt. Println (Zeichenfolgen. Index (aString, Teilstring)) // Ausgabe: 7
fmt. Println (Zeichenfolgen. IndexAny (String, Zeichen)) // Ausgabe: 7
fmt. Println (Zeichenfolgen. IndexByte (aString, byteCharacter)) // Ausgabe: 4
f := Funk(R Rune)bool {
zurückkehren r == 'Ö'
}
fmt. Println (Zeichenfolgen. IndexFunc (aString, f)) // Ausgabe: 4
fmt. Println (Zeichenfolgen. IndexRune (aString, aRune)) // Ausgabe: 4
}
IndexByte gibt den Index der ersten Instanz des Byte-Zeichens in der Zeichenfolge or zurück -1. Der IndexFunk Die Funktion gibt den Index in die Zeichenfolge des ersten Unicode-Punkts zurück, der eine bestimmte Funktion erfüllt. Endlich, das IndexRune Die Funktion gibt den Index der ersten Instanz des Unicode-Codepunkts der Rune zurück.
Substrings in Go ersetzen
Der Ersetzen Und Alles ersetzen Funktionshilfe beim Ersetzen von Teilzeichenfolgen. Der Ersetzen Die Funktion übernimmt die Zeichenfolge, die ursprüngliche Teilzeichenfolge sowie die Ersetzung und mehrere Ersetzungen. Der Alles ersetzen Die Funktion übernimmt nur die Zeichenfolge, die anfängliche Teilzeichenfolge und die Ersetzung.
importieren (
"fmt"
"Saiten"
)
Funkhauptsächlich() {
dieString := "Dies ist eine zu ändernde Testzeichenfolge."
fmt. Println (Zeichenfolgen. Ersetzen (theString, "Ist", "War", 1))
fmt. Println (Zeichenfolgen. Ersetzen (theString, "Ist", "War", -1))
fmt. Println (Zeichenfolgen. Alle ersetzen (theString, "Ist", "War"))
}
Beachten Sie, dass Sie sowohl Replace als auch ReplaceAll verwenden können, um jedes Vorkommen innerhalb der Zeichenfolge zu ersetzen.
Aufteilen und Verbinden von Zeichenfolgen
Der Saiten Paket enthält die Teilt, SplitNach, SplitAfterN, Und SplitN Funktionen zum Teilen von Strings, die einen Teil der Strings zurückgeben.
Der Teilt Methode wird durch ein angegebenes Trennzeichen geteilt. Ähnlich wie Teilt Methode, die SplitNach -Methode teilt die Zeichenfolge, enthält jedoch das Trennzeichen in ihren Ergebnissen.
importieren (
"fmt"
"Saiten"
)Funkhauptsächlich() {
s := "Dies ist eine zu teilende Testzeichenkette."
fmt. Println (Zeichenfolgen. Teilen (s, " "))
fmt. Println (Zeichenfolgen. TeilenNachher (s, " "))
fmt. Println (Zeichenfolgen. SplitAfterN(s, " ", 3))
fmt. Println (Zeichenfolgen. SplitN(s, " ", 3))
}
Der SplitAfterN Die Methode ähnelt der SplitNach -Funktion, mit der Ausnahme, dass die Funktion die Zeichenfolge in eine angegebene Höchstzahl von Teilzeichenfolgen aufteilt. Der SplitN -Methode teilt die Zeichenfolge auf eine angegebene maximale Anzahl auf, ohne das Trennzeichen in die Teilzeichenfolgen aufzunehmen.
Sie können Zeichenfolgen mit dem verbinden Verbinden Funktion aus der Saiten Paket. Der Verbinden Die Funktion nimmt ein Slice und ein Trennzeichen auf.
importieren (
"fmt"
"Saiten"
)
Funkhauptsächlich() {
fmt. Println (Zeichenfolgen. Verbinden([]Schnur{"Hallo", "Welt"}, ":"))
// Ausgabe: "Hallo: Welt"
}
Manipulieren von String-Case
Das Manipulieren von String Case ist praktisch für viele Aufgaben, einschließlich Arbeiten mit Dokumentation. Du kannst den... benutzen Zu senken Funktion für Kleinschreibung, die NachOber Funktion für Großschreibung und die Zum Titel Funktion für Titelgehäuse.
importieren (
"fmt"
"Saiten"
)Funkhauptsächlich() {
s := "Dies ist eine Testzeichenfolge."
fmt. Println (Zeichenfolgen. ToLower (s)) // Dies ist eine Testzeichenfolge.
fmt. Println (Zeichenfolgen. ToUpper (s)) // DIES IST EIN TESTSTRING.
fmt. Println (Zeichenfolgen. ZuTitel (s)) // DIES IST EIN TESTSTRING.
}
Saitenaufbau in Go
String Builder sind ein Typ, der eine effiziente Verkettung in Go ermöglicht. Der Byte. Puffer type ist einer der am häufigsten verwendeten String-Builder. Der Byte. Puffer -Methode implementiert einen erweiterbaren Puffer von Bytes mit Lese- und Schreibmethoden für Operationen, was im Gegensatz zu effizientes Anhängen von Zeichenfolgen ermöglicht, ohne dass neue Kopien erstellt werden müssen + Betrieb und die Verbinden Funktion.
importieren (
"fmt"
"Saiten"
)Funkhauptsächlich() {
Var b-Saiten. Baumeister// Einige Strings in den Builder schreiben
B. WriteString("Das ")
B. WriteString("Ist ")
B. WriteString("A ")
B. WriteString("prüfen ")
B. WriteString("Schnur.")// Holen Sie sich die Länge des Builders
fmt. Println (geb. Länge())// Konvertiere den Builder in einen String
str := b. Zeichenkette()
fmt. Println (str)// Den Builder zurücksetzen
B. Zurücksetzen()// Schreibe einige weitere Strings in den Builder
B. WriteString("Das ")
B. WriteString("Ist ")
B. WriteString("andere ")
B. WriteString("prüfen ")
B. WriteString("Schnur.")// Holen Sie sich die Kapazität des Builders
fmt. Println (geb. Deckel())
// Konvertiere den Builder erneut in einen String
str = b. Zeichenkette()
fmt. Println (str)
}
Der hauptsächlich Funktion demonstriert, wie Sie die verwenden können Saiten. Baumeister Typ für effizienten Saitenaufbau. Der WriteString Methode der Saiten. Baumeister type erweitert die Folge von Strings untereinander, und die Len Die Methode gibt die Länge des erstellten Strings zurück.
Der Schnur -Methode konvertiert den Inhalt des Builders in eine Zeichenfolge und die Zurücksetzen -Methode setzt den Builder für zusätzliche Zeichenfolgenerstellung zurück.
Der Deckel -Methode gibt die Kapazität des Builders zurück. Dies ist der aktuelle Speicherplatz, den Go für die Zeichenfolge zugewiesen hat.
Fadentrimmen in Go
Der Saiten -Paket bietet auch Funktionen zum Trimmen von Zeichenfolgen in der Trimmen, TrimLinks, TrimPrefix, Rechts trimmen, TrimSpace, Und TrimSuffix Funktionen.
importieren (
"Saiten"
"fmt"
)Funkhauptsächlich() {
// die vollständige Zeichenfolge
s := "Hallo Welt!"// das Element für die Trimmung
Präfix := "Hallo"
Zusatz := "Welt!"// trimmt einen String um den angegebenen Trim-Set
fmt. Println (Zeichenfolgen. Trimmen (s, "!"))// schneidet Leerzeichen am Anfang und am Ende der Zeichenfolge ab
fmt. Println (Zeichenfolgen. TrimSpace (s))// trimmt vom linken String um den angegebenen Trim-Set
fmt. Println (Zeichenfolgen. TrimLinks (s, "Hallo"))// schneidet von der rechten Zeichenfolge um den angegebenen Trimmsatz ab
fmt. Println (Zeichenfolgen. TrimRight (s, "Welt!"))// schneidet ein Präfix ab
fmt. Println (Zeichenfolgen. TrimPrefix (s, Präfix))
// schneidet ein bestimmtes Suffix ab
fmt. Println (Zeichenfolgen. TrimSuffix (s, Suffix))
}
Der hauptsächlich Funktion demonstriert, wie Sie die Funktionen zum Trimmen verwenden können. Die verschiedenen Funktionen trimmen die S Zeichenfolge auf verschiedene Weise:
Sie können Zeichenfolgen in Go formatieren
Die Go-Standardbibliothek stellt auch das fmt-Paket für die Zeichenfolgenformatierung bereit. Das fmt-Paket verwendet Formatierungsverben im C-Stil für eine effiziente Zeichenfolgenformatierung in Go.
