Eine Einführung in das Strings-Paket in Go

Einführung

Dasstring-Paket von Go verfügt über mehrere Funktionen, um mitstring data type zu arbeiten. Mit diesen Funktionen können Sie Zeichenfolgen einfach ändern und bearbeiten. Wir können uns Funktionen als Aktionen vorstellen, die wir an Elementen unseres Codes ausführen. Integrierte Funktionen sind diejenigen, die in der Programmiersprache Go definiert sind und für uns sofort verfügbar sind.

In diesem Lernprogramm werden verschiedene Funktionen vorgestellt, mit denen wir in Go mit Zeichenfolgen arbeiten können.

Strings in Groß- und Kleinbuchstaben schreiben

Die Funktionenstrings.ToUpper undstrings.ToLower geben eine Zeichenfolge zurück, bei der alle Buchstaben einer Originalzeichenfolge in Groß- oder Kleinbuchstaben umgewandelt wurden. Da Zeichenfolgen unveränderliche Datentypen sind, handelt es sich bei der zurückgegebenen Zeichenfolge um eine neue Zeichenfolge. Alle Zeichen in der Zeichenfolge, die keine Buchstaben sind, werden nicht geändert.

Um die Zeichenfolge"Sammy Shark" in Großbuchstaben umzuwandeln, verwenden Sie die Funktionstrings.ToUpper:

ss := "Sammy Shark"
fmt.Println(strings.ToUpper(ss))

OutputSAMMY SHARK

So konvertieren Sie in Kleinbuchstaben:

fmt.Println(strings.ToLower(ss))

Outputsammy shark

Da Sie das Paketstringsverwenden, müssen Sie es zuerst in ein Programm importieren. Zum Konvertieren der Zeichenfolge in Groß- und Kleinbuchstaben lautet das gesamte Programm wie folgt:

package main

import (
    "fmt"
    "strings"
)

func main() {
    ss := "Sammy Shark"
    fmt.Println(strings.ToUpper(ss))
    fmt.Println(strings.ToLower(ss))
}

Die Funktionenstrings.ToUpper undstrings.ToLower erleichtern das Auswerten und Vergleichen von Zeichenfolgen, indem die Groß- und Kleinschreibung durchgehend konsistent gemacht wird. Wenn ein Benutzer beispielsweise seinen Namen in Kleinbuchstaben schreibt, können wir dennoch feststellen, ob sich sein Name in unserer Datenbank befindet, indem wir ihn mit einer Großbuchstabenversion vergleichen.

String-Suchfunktionen

Dasstrings-Paket verfügt über eine Reihe von Funktionen, mit denen ermittelt werden kann, ob eine Zeichenfolge eine bestimmte Zeichenfolge enthält.

Funktion Use

Funktion	Use
`strings.HasPrefix`	Durchsucht die Zeichenfolge von Anfang an
`strings.HasSuffix`	Durchsucht die Zeichenfolge vom Ende
`strings.Contains`	Sucht irgendwo in der Zeichenfolge
`strings.Count`	Zählt, wie oft die Zeichenfolge angezeigt wird

strings.HasPrefix

Durchsucht die Zeichenfolge von Anfang an

strings.HasSuffix

Durchsucht die Zeichenfolge vom Ende

strings.Contains

Sucht irgendwo in der Zeichenfolge

strings.Count

Zählt, wie oft die Zeichenfolge angezeigt wird

Mitstrings.HasPrefix undstrings.HasSuffix können Sie überprüfen, ob eine Zeichenfolge mit einem bestimmten Zeichensatz beginnt oder endet.

Um beispielsweise zu überprüfen, ob die Zeichenfolge"Sammy Shark" mitSammy beginnt und mitShark endet:

ss := "Sammy Shark"
fmt.Println(strings.HasPrefix(ss, "Sammy"))
fmt.Println(strings.HasSuffix(ss, "Shark"))

Outputtrue
true

Mit der Funktionstrings.Contains würden Sie prüfen, ob"Sammy Shark" die SequenzSh enthält:

fmt.Println(strings.Contains(ss, "Sh"))

Outputtrue

Um zu sehen, wie oft der BuchstabeS in der PhraseSammy Shark vorkommt:

fmt.Println(strings.Count(ss, "S"))

Output2

[.note] #Note: Bei allen Zeichenfolgen in Go wird zwischen Groß- und Kleinschreibung unterschieden. Dies bedeutet, dassSammy nicht mitsammy identisch ist.
#

Die Verwendung vons in Kleinbuchstaben, um eine Zählung vonSammy Shark zu erhalten, ist nicht dasselbe wie die Verwendung vonS in Großbuchstaben:

fmt.Println(strings.Count(ss, "s"))

Output0

Da sichS vons unterscheidet, wird0 zurückgegeben.

Zeichenfolgenfunktionen sind nützlich, wenn Sie Zeichenfolgen in Ihrem Programm vergleichen oder durchsuchen möchten.

Stringlänge bestimmen

Die integrierte Funktionlen() gibt die Anzahl der Zeichen in einer Zeichenfolge zurück. Diese Funktion ist nützlich, wenn Sie minimale oder maximale Kennwortlängen erzwingen oder größere Zeichenfolgen abschneiden müssen, um sie für die Verwendung als Abkürzungen in bestimmten Grenzen zu halten.

Um diese Funktion zu demonstrieren, ermitteln wir die Länge einer satzlangen Zeichenfolge:

import (
    "fmt"
    "strings"
)

func main() {
        openSource := "Sammy contributes to open source."
        fmt.Println(len(openSource))
}

Output33

Wir setzen die VariableopenSource gleich der Zeichenfolge"Sammy contributes to open source." und übergeben diese Variable dann mitlen(openSource) an die Funktionlen(). Schließlich haben wir die Funktion an die Funktionfmt.Println()übergeben, damit wir die Programmausgabe auf dem Bildschirm sehen können.

Beachten Sie, dass die Funktionlen()alle Zeichen zählt, die durch doppelte Anführungszeichen gebunden sind - einschließlich Buchstaben, Zahlen, Leerzeichen und Symbolen.

Funktionen zur String-Manipulation

Die Funktionenstrings.Join,strings.Split undstrings.ReplaceAll sind einige zusätzliche Möglichkeiten, um Zeichenfolgen in Go zu bearbeiten.

Die Funktionstrings.Join ist nützlich, um ein Stück Zeichenfolgen zu einer neuen einzelnen Zeichenfolge zu kombinieren.

Um eine durch Kommas getrennte Zeichenfolge aus einem Zeichenfolgenabschnitt zu erstellen, verwenden wir diese Funktion wie folgt:

fmt.Println(strings.Join([]string{"sharks", "crustaceans", "plankton"}, ","))

Outputsharks,crustaceans,plankton

Wenn wir in unserer neuen Zeichenfolge ein Komma und ein Leerzeichen zwischen Zeichenfolgenwerten hinzufügen möchten, können wir unseren Ausdruck einfach mit einem Leerzeichen nach dem Komma umschreiben:strings.Join([]string{"sharks", "crustaceans", "plankton"}, ", ").

So wie wir Strings zusammenfügen können, können wir auch Strings aufteilen. Dazu können wir die Funktionstrings.Splitverwenden und die Leerzeichen aufteilen:

balloon := "Sammy has a balloon."
s := strings.Split(balloon, " ")
fmt.Println(s)

Output[Sammy has a balloon]

Die Ausgabe ist eine Zeichenfolge. Dastrings.Println verwendet wurde, ist es schwierig, die Ausgabe anhand der Ausgabe zu erkennen. Um zu sehen, dass es sich tatsächlich um ein Stück Zeichenfolgen handelt, verwenden Sie die Funktionfmt.Printf mit dem Verb%q, um die Zeichenfolgen zu zitieren:

fmt.Printf("%q", s)

Output["Sammy" "has" "a" "balloon."]

Eine weitere nützliche Funktion nebenstrings.Split iststrings.Fields. Der Unterschied besteht darin, dassstrings.Fields alle Leerzeichen ignoriert und nur die tatsächlichenfields in einer Zeichenfolge aufteilt:

data := "  username password     email  date"
fields := strings.Fields(data)
fmt.Printf("%q", fields)

Output["username" "password" "email" "date"]

Die Funktionstrings.ReplaceAll kann eine ursprüngliche Zeichenfolge verwenden und eine aktualisierte Zeichenfolge mit einigen Ersetzungen zurückgeben.

Nehmen wir an, der Ballon, den Sammy hatte, ist verloren. Da Sammy diesen Ballon nicht mehr hat, würden wir die Teilzeichenfolge"has" von der ursprünglichen Zeichenfolgeballoon in"had" in einer neuen Zeichenfolge ändern:

fmt.Println(strings.ReplaceAll(balloon, "has", "had"))

In den Klammern steht zuerstballoon für die Variable, in der die ursprüngliche Zeichenfolge gespeichert ist. Die zweite Teilzeichenfolge"has" möchten ersetzt werden, und die dritte Teilzeichenfolge"had" ersetzen wir durch diese zweite Teilzeichenfolge. Unsere Ausgabe würde so aussehen, wenn wir dies in ein Programm integrieren:

OutputSammy had a balloon.

Mit den Zeichenfolgenfunktionenstrings.Join,strings.Split undstrings.ReplaceAll können Sie die Zeichenfolgen in Go besser steuern.

Fazit

In diesem Tutorial wurden einige der gebräuchlichen String-Paketfunktionen für den String-Datentyp beschrieben, mit denen Sie in Ihren Go-Programmen mit Strings arbeiten und diese bearbeiten können.

Sie können mehr über andere Datentypen inUnderstanding Data Types erfahren und mehr über Zeichenfolgen inAn Introduction to Working with Strings lesen.

TOC