String-Manipulation in Go: So aktualisieren Sie Text

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

Das strings -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.

import "strings"


Suche nach Teilstrings

Das strings -Paket bietet drei Funktionen zum Suchen nach Teilzeichenfolgen: die Contains – Funktion, die ContainsAny – Funktion und die ContainsRune – Funktion.

Die Contains -Funktion prüft, ob die angegebene Zeichenfolge die Teilzeichenfolge enthält. Die ContainsAny -Funktion überprüft, ob die Zeichenfolge Zeichen in der Teilzeichenfolge enthält, und die ContainsRune -Funktion überprüft, ob die Zeichenfolge eine Rune (ein Unicode-Zeichen) enthält.

import (
    "fmt"
    "strings"
)


func main() {
    aString: = "Hello, World!"
    substring: = "World"
    characters: = "aeiou"
    aRune: = 'o'

    fmt.Println(strings.Contains(aString, substring)) // Output: true
    fmt.Println(strings.ContainsAny(aString, characters)) // Output: true
    fmt.Println(strings.ContainsRune(aString, aRune)) // Output: true
}


Sie können den Index einer Teilzeichenfolge mit den Funktionen Index , IndexAny , IndexByte und IndexFunc abrufen . Die Funktion Index gibt den Index eines Teilstrings zurück, wenn er in einem anderen gegebenen String vorkommt. Die IndexAny- Funktion gibt den Index der ersten Instanz eines Unicode-Codepunkts oder -1 zurück , wenn keines der Zeichen vorhanden ist.

import (
    "fmt"
    "strings"
)


func main() {
    aString: = "Hello, world!"
    substring: = "world"
    chars: = "wrld"
    byteCharacter: = byte('o')
    aRune: = rune('o')

    fmt.Println(strings.IndexFunc(aString, f)) // Output: 4
    fmt.Println(strings.IndexRune(aString, aRune)) // Output: 4
}


IndexByte gibt den Index der ersten Instanz des Bytezeichens in der Zeichenfolge oder -1 zurück . Die IndexFunc- Funktion gibt den Index in die Zeichenfolge des ersten Unicode-Punkts zurück, der eine bestimmte Funktion erfüllt. Schließlich gibt die IndexRune- Funktion den Index der ersten Instanz des Unicode-Codepunkts der Rune zurück.

Substrings in Go ersetzen

Die Funktionen Replace und ReplaceAll helfen beim Ersetzen von Teilzeichenfolgen. Die Replace -Funktion übernimmt die Zeichenfolge, die ursprüngliche Teilzeichenfolge sowie die Ersetzung und mehrere Ersetzungen. Die ReplaceAll- Funktion übernimmt nur die Zeichenfolge, die anfängliche Teilzeichenfolge und die Ersetzung.

import (
    "fmt"
    "strings"
)


func main() {
    theString: = "This is a test string to be modified."
    fmt.Println(strings.Replace(theString, "is", "was", 1))
    fmt.Println(strings.Replace(theString, "is", "was", -1))
    fmt.Println(strings.ReplaceAll(theString, "is", "was"))
}


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

Das strings -Paket enthält die Funktionen Split , SplitAfter , SplitAfterN und SplitN zum Aufteilen von Zeichenfolgen, die einen Teil der Zeichenfolgen zurückgeben.

Die Split -Methode teilt durch ein angegebenes Trennzeichen. Ähnlich wie die Split -Methode teilt die SplitAfter- Methode die Zeichenfolge, enthält jedoch das Trennzeichen in ihren Ergebnissen.

import (
    "fmt"
    "strings"
)


func main() {
    s: = "This is a test string to be split."

    fmt.Println(strings.Split(s, ""))
    fmt.Println(strings.SplitAfter(s, ""))
    fmt.Println(strings.SplitAfterN(s, "", 3))
    fmt.Println(strings.SplitN(s, "", 3))
}


Die SplitAfterN- Methode ähnelt der SplitAfter- Funktion, mit der Ausnahme, dass die Funktion die Zeichenfolge in ein angegebenes Maximum von Teilzeichenfolgen aufteilt. Die SplitN- Methode teilt die Zeichenfolge auf eine angegebene maximale Anzahl auf, ohne das Trennzeichen in die Teilzeichenfolgen aufzunehmen.

Sie können Strings mit der Join – Funktion aus dem Strings -Paket verbinden. Die Join- Funktion übernimmt ein Slice und ein Trennzeichen.

import (
    "fmt"
    "strings"
)


func main() {
    fmt.Println(strings.Join([]string{"Hello", "World"}, ":"))
   // Output: "Hello:World"
}


Manipulieren von String-Case

Das Manipulieren der Groß-/Kleinschreibung von Zeichenfolgen ist für viele Aufgaben praktisch, einschließlich der Arbeit mit der Dokumentation. Sie können die ToLower- Funktion für die Kleinschreibung, die ToUpper- Funktion für die Großschreibung und die ToTitle- Funktion für die Titel-Großschreibung verwenden.

import (
    "fmt"
    "strings"
)


func main() {
    s: = "This is a test string."

    fmt.Println(strings.ToLower(s)) // this is a test string.
    fmt.Println(strings.ToUpper(s)) // THIS IS A TEST STRING.
    fmt.Println(strings.ToTitle(s)) // THIS IS A TEST STRING.
}


Saitenaufbau in Go

String Builder sind ein Typ, der eine effiziente Verkettung in Go ermöglicht. Der bytes.Buffer- Typ ist einer der am häufigsten verwendeten String-Builder. Die bytes.Buffer- Methode implementiert einen erweiterbaren Byte-Puffer mit Lese- und Schreibmethoden für Operationen, was im Gegensatz zur + -Operation und der Join – Funktion effiziente String-Anhänge ermöglicht, ohne dass neue Kopien erstellt werden müssen.

import (
    "fmt"
    "strings"
)


func main() {
    var b strings.Builder

    // Convert the builder to a string again
    str = b.String()
    fmt.Println(str)
}


Die Hauptfunktion demonstriert, wie Sie den Typ strings.Builder zum effizienten Erstellen von Zeichenfolgen verwenden können. Die WriteString- Methode des Strings.Builder- Typs erweitert die Zeichenfolgenfolge untereinander, und die Len -Methode gibt die Länge der erstellten Zeichenfolge zurück.

Die String -Methode konvertiert den Inhalt des Builders in eine Zeichenfolge, und die Reset – Methode setzt den Builder für eine zusätzliche Zeichenfolgenerstellung zurück.

Die Cap- 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

Das strings -Paket bietet auch Funktionen zum Trimmen von Zeichenfolgen in den Funktionen Trim , TrimLeft , TrimPrefix , TrimRight , TrimSpace und TrimSuffix .

import (
    "strings"
    "fmt"
)


func main() {
    // the full string
    s: = "Hello, World!"

    // trims out a specific suffix
    fmt.Println(strings.TrimSuffix(s, suffix))
}


Die Hauptfunktion demonstriert, wie Sie die Funktionen zum Trimmen verwenden können. Die verschiedenen Funktionen trimmen den s -String 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.