Golang -Saiten

Eine Zeichenfolge bezieht sich auf eine Sequenz von einem oder mehreren Zeichen, einschließlich Buchstaben, Zahlen und Sonderzeichen. Saiten sind in den meisten Programmiersprachen trotz der simplen Definition ein kritisches Konzept.

Dies liegt daran, dass Saiten uns helfen, mit Textinformationen in unseren Programmen zu arbeiten. In der Regel ist es schwierig, eine nicht triviale Anwendung ohne Verwendung von Zeichenfolgen zu erstellen.

In diesem Leitfaden werden wir die Grundlagen der Arbeit mit Saiten in der Go -Programmiersprache behandeln.

Was ist eine Zeichenfolge?

In Go bezeichnen wir eine Zeichenfolge als schreibgeschützte Bytesscheibe. Wir können eine Zeichenfolge in Go erstellen, indem wir die Abfolge von Zeichen in Doppelzitaten oder Back -Zitate einschließen.

Denken Sie daran, dass die Methode, mit der Sie eine Zeichenfolge in Go Matters erstellen, anwenden.

Die Verwendung von Ticks (") zum Erstellen einer Zeichenfolge in Go erstellt eine rohe String -Literal. Eine rohe Saitenliteral bedeutet, dass die Saite mit Ausnahme einer Rückschläfchen ein beliebiges Zeichen enthalten kann.

Das folgende Beispiel zeigt eine rohe Streicherliteral.

RAW_string: = 'Dies ist eine Zeichenfolge'

Im Gegensatz zu interpretierten String -Literalen, die mit doppelten Zitaten erstellt wurden. Zum Beispiel, \ n, das ein neues Zeilenzeichen in interpretierten Zeichenfolgen einfügen kann, drucken wir es so wie in Roh -String -Literalen.

Um eine interpretierte String-Literal in Go zu erstellen, legen Sie die Zeichensatz in Doppelquoten ein, wie im folgenden Beispiel gezeigt:

Interpreted_string: = "Dies ist eine Zeichenfolge"

Hier werden Gegenreaktionen interpretiert, um eine besondere Bedeutung zu haben. Um beispielsweise eine neue Zeile in die Zeichenfolge einzufügen, können wir \ n als:

Interpreted_string: = "Dies ist \ n eine Zeichenfolge"

Es ist üblich, interpretierte String buchstäblich zu verwenden, da Sie Sonderzeichen hinzufügen und Sequenzen entkommen können.

Gehen Sie, drucken String

Sie können eine Zeichenfolge in Go mit der Println () -Methode aus dem FMT -Paket ausdrucken. Stellen Sie sicher, dass Sie das Paket importieren, bevor Sie die Methode aufrufen. Ein Beispielcode ist wie gezeigt:

Paket Main
importieren "fmt"
func main ()
fmt.Println ("Dies ist eine Zeichenfolge")

Der obige Code verwendet die FMT.Println () Methode zum Drucken eines interpretierten String -Literales. Sie können auch eine Zeichenfolge als Variable speichern und in der Methode verweisen, wie gezeigt:

Paket Main
importieren "fmt"
func main ()
my_string: = "Dies ist eine Zeichenfolge"
fmt.Println (my_string)

String -Operationen in Go

Es gibt eine Sammlung von Operationen, die Sie an String -Typen ausführen können. Go bietet eine Reihe von Methoden, um String -Operationen im Strings -Paket durchzuführen.

https: // pkg.gehen.Dev/Saiten

Lassen Sie uns einige Vorgänge ansehen, die Sie auf Saiten ausführen können.

String-Verkettung

String -Verkettung bezieht sich auf die Technik, zwei oder mehr String -Literale zusammen zu kombinieren, um eine neue Zeichenfolge zu erstellen.

In Go können wir Zeichenfolgen mit dem Additions -Operator (+) verkettet.

Lassen Sie uns beispielsweise die Zeichenfolgen „Linux“ und „Hinweis“ wie gezeigt kombinieren.

Paket Main
importieren "fmt"
func main ()
fmt.Println ("Linux" + "Hinweis")

Wenn wir den oben genannten Code ausführen, sollten wir eine Ausgabe erhalten wie bei:

$ goVe golang_strings.gehen
LinuxHint

Denken Sie daran, dass Sie den Additionoperator (+) nicht mit Werten verschiedener Typen verwenden können. Wenn Sie beispielsweise versuchen, eine Zeichenfolge und eine INT zusammenzuschließen, erhalten Sie einen Fehler wie:

fmt.Println ("Linux" + 12)

Der obige Code gibt einen Fehler zurück als:

Ungültige Operation: "Linux" + 12 (nicht übereinstimmende Typen und Untyped Int)

Eine Möglichkeit, dies zu überwinden. Dadurch konvertiert der numerische Wert in eine Zeichenfolge, sodass Sie eine String -Verkettung durchführen können.

Die String-Verkettung führt immer zu einer neuen Zeichenfolge, die Sie in einer Variablen speichern und in anderen Teilen Ihres Programms wiederverwenden können.

Saite in Kleinbuchstaben oder Großbuchstaben konvertieren

Wie bereits erwähnt, bietet GO uns das Strings -Paket, mit dem Sie Vorgänge auf String -Typen ausführen können.

Zwei nützliche Methoden aus dem Paket sind Tolower und Toupper, die eine Schnur in Kleinbuchstaben bzw. Großbuchstaben umwandeln.

HINWEIS: In Go sind Stringstypen unveränderlich. Dies bedeutet, dass Sie den ursprünglichen Wert der Zeichenfolge nach dem Erstellen nicht ändern können.

Das folgende Beispiel wandelt die Zeichenfolge "LinuxHint" in Kleinbuchstaben um.

Paket Main
importieren "fmt"
"Saiten" importieren "
func main ()
My_String: = "LinuxHint"
fmt.Println (Saiten.Tolower (my_string))

Die Funktion Tolower () nimmt die Zeichenfolge, um als Argument in Kleinbuchstaben umzuwandeln. Anschließend gibt es die Reihenfolge der Zeichen der String zurück, die in Kleinbuchstaben konvertiert ist. Die Funktion gibt eine neue Zeichenfolge zurück, da Zeichenfolgen unveränderliche Datentypen sind.

Wenn wir den oben genannten Code ausführen, sollten wir eine Ausgabe erhalten wie bei:

LinuxHint

Um eine Zeichenfolge in Großbuchstaben umzuwandeln, können wir die Methode toupper () verwenden, wie im folgenden Beispiel gezeigt:

My_String: = "LinuxHint"
fmt.Println (Saiten.Toupper (my_string))

Die resultierende Zeichenfolge ist wie gezeigt:

LinuxHint

Stringlänge erhalten

Um die Länge einer Zeichenfolge in Go zu erhalten, können Sie die Len () -Methode verwenden und die Zeichenfolge als Argument übergeben.

Die Methode gibt die Anzahl der Zeichen in der Zeichenfolge zurück.

Zum Beispiel:

My_String: = "LinuxHint"
fmt.Println (len (my_string))

Sobald wir den obigen Code ausgeführt haben, sollten wir die Anzahl der Zeichen der Zeichenfolge erhalten wie:

$ goVe golang_strings.gehen
9

Die Anzahl der Zeichen bezieht sich in diesem Fall auf alle Charaktere, die in doppelten Zitaten eingeschlossen sind, einschließlich Symbolen und anderen Sonderzeichen.

Überprüfen Sie, ob die Zeichenfolge enthält

Sie können auch nach einem Substring in Go mit der entsprechenden Methode suchen. Die Methode akzeptiert die Hauptzeichenfolge, in der nach dem Substring und dem Substring gesucht werden soll, und als Argumente.

Die Funktion gibt dann einen booleschen Wert zurück, wenn das Substring gefunden wird und ansonsten falsch ist.

Betrachten Sie das unten gezeigte Beispiel:

Paket Main
importieren (
"fmt"
"Saiten"
)
func main ()
full_string: = "Willkommen im Go -Programmieren Langugae!"
fmt.Println (Saiten.Enthält (full_string, "go"))

Sobald wir den oben genannten Code ausgeführt haben, sollten wir eine Ausgabe erhalten wie bei:

$ goVe golang_strings.gehen
WAHR

Das Substring „Go“ befindet sich in der variablen Full_String; Die Funktion gibt wahr zurück.

Abschluss

Dieses Tutorial deckt die Grundlagen der Arbeit mit Saiten in Go ab. Wenn Sie in Go anfangen, überprüfen Sie unsere Tutorials zum Thema, um mehr zu erfahren. Sie können die Dokumentation auch nach zusätzlichen Informationen überprüfen.