Golang concat Strings

Die String -Verkettung bezieht sich auf den Prozess der Kombination von zwei oder mehr Zeichenfolgen, um eine einzelne Zeichenfolge zu bilden. Es ist eines der wesentlichen String -Operationen in der Programmierung.

In diesem Leitfaden werden wir verschiedene Methoden zur Durchführung von String -Verkettung in der Go -Programmiersprache implodieren.

Die Grundlagen

Beginnen wir mit den grundlegendsten Teilen aller. So erstellen Sie eine Zeichenfolge in Go?

Wir können eine Zeichenfolge erstellen, indem wir die Zeichen in doppelten Quoten einschließen.

Zum Beispiel erstellt der folgende Code eine Zeichenfolge und speichert ihn in der variablen STR.

STR: = "Hallo Welt"

Die Verwendung von Doppelzitaten erstellt ein interpretiertes String -Literal, das Sonderzeichen wie Weißespace enthält.

Um eine wörtliche Zeichenfolge zu erstellen, können Sie Back-Ticks verwenden, wie im folgenden Beispiel gezeigt:

STR: = 'Hallo Welt' '

Eine wörtliche Zeichenfolge in Go unterstützt nicht die Verwendung von Sonderzeichen, einschließlich Fluchtsequenzen.

String -Verkettung - Der Additionsbetreiber

Wenn Sie nach dem schmerzlosen und einfachsten Weg zur Verkettung von Saiten suchen, entscheiden Sie sich wahrscheinlich für den Plus (|+) -Operator.

Unter Verwendung des Plus (+) -Operators können Sie mehrere Zeichenfolgen mit einem einzelnen Zeichenfolgenwert kombinieren, wie gezeigt:

Paket Main
func main ()
STR_1: = "Willkommen zu"
STR_2: = "LinuxHint"
full_string: = str_1 + str_2

Das obige Beispiel verwendet den Additionoperator, um zwei Zeichenfolgen zu kombinieren. Wir können dann das Ergebnis in die Variable speichern.

Sie können auch eine String -Verkettung mit einer der Druckmethoden aus dem FMT -Paket durchführen. Betrachten Sie das folgende Beispiel:

fmt.Println ("Willkommen zu" + "LinuxHint")

Die Funktion nimmt die beiden String -Literale und kombiniert sie mit einer einzigen Zeichenfolge.

Sie können auch zwei oder mehr Zeichenfolgen an eine beliebige Druckmethode aus dem FMT -Paket übergeben, ohne den Addition -Operator zu verwenden. Die Funktionen kombinieren die Saiten und fügen einen Raum zwischen ihnen hinzu.

Schauen Sie sich das Beispiel unten an:

fmt.Println ("Willkommen zu", "LinuxHint."))

Dieses Beispiel übergibt die Zeichenfolge an die Verkettung als Parameter, die durch ein Komma getrennt sind. Die resultierende Zeichenfolge ist wie gezeigt:

Willkommen bei LinuxHint.

Saiten.Join () Methode

Wir können auch die Joy () -Methode aus dem Strings -Paket verwenden, um die String -Verkettung durchzuführen. Die Funktionssyntax ist wie gezeigt:

func join (a [] String, Separator String) String

Die Funktion nimmt zwei Argumente an. Das erste ist ein Stück Saitentypen und die zweite ist eine Zeichenfolge, die den Separator beschreibt.

Die Funktion gibt dann eine einzelne Zeichenfolge zurück, die aus den Werten des Slice verkettet ist.

Denken Sie an das unten gezeigte Beispiel:

Paket Main
importieren (
"fmt"
"Saiten"
)
func main ()
STR: = [] String "Welcome", "to", "LinuxHint"
concat_str: = Zeichenfolgen.Join (Str, "")
fmt.Println (concat_str)

Die Funktion nimmt die String -Slice -Elemente auf und kombiniert sie mit einem einzelnen Zeichenfolge mit einem Speicherplatz als Trennzeichen.

Der resultierende Wert ist wie:

Willkommen bei LinuxHint

String -Formatierung - Sprintf

Wir können auch String -Formatierungsmuster verwenden,.

Das folgende Beispiel zeigt, wie die String -Verkettung mithilfe der Sprintf () -Methode durchgeführt wird.

STR_1: = "Hallo"
STR_2: = "Welt"
Concated_string: = fmt.Sprintf ("%s%s", str_1, str_2)
fmt.Println (Concated_string)

Hier verwenden wir das %S -Formatierer, um zwei Zeichenfolgen mit der Sprintf () -Methode zu verkettet.

Byes.Puffer () Methode

Golang enthält ein Bytes-Paket, das einen Puffertyp bietet, einen Puffer von Bytes mit variabler Größe mit Lese-/Schreibmethoden.

Wir können Zeichenfolgen mit der WriteString -Methode schreiben, damit wir sie in eine Zeichenfolge umwandeln können.

Ein Beispiel ist wie gezeigt:

Paket Main
importieren (
"Bytes"
"fmt"
)
func main ()
STR_1: = "Hallo"
STR_2: = "Welt"
var concat Bytes.Puffer
concat.WriteString (str_1)
concat.WriteString (str_2)
fmt.Println (concat.String ())

Die Methode WriteString () wendet die Zeichenfolge an die Bytes an.Puffertyp.

Saiten.Builder () Methode

Das Strings -Paket bietet uns auch einen Builder -Typ, mit dem wir Strings erstellen können. Es verfügt über eine WriteString -Methode, die den vom Bytes -Paket bereitgestellten ähnelt.

Betrachten Sie das Beispiel:

Paket Main
importieren (
"fmt"
"Saiten"
)
func main ()
STR_1: = "Hallo"
STR_2: = "Welt"
var concat saiten.Erbauer
concat.WriteString (str_1)
concat.WriteString (str_2)
fmt.Println (concat.String ())

Zusammenfassung

Diese Anleitung umfasste verschiedene Techniken, um eine String -Verkettung in Go durchzuführen. Mit dem Plus -Operator können Sie zwei oder mehr Saiten zusammen hinzufügen. Sie können sich auch für andere Methoden entscheiden, einschließlich der Join -Methode, Sprintf, Puffer und mehr.