Wie Sie Zeichenketten in Go effizient verknüpfen

1. Mit dem Plus (+)-Operator
2. Mit mehreren Argumenten in der Funktion Print()
3. Mit der Funktion Join()
4. Methode Sprintf()
5. bytes.Buffer-Methode
6. strings.Builder-Methode
7. Anhängen mit += Operator
8. Vergleich verschiedener Methoden

Der Vorgang des Verschmelzens von zwei oder mehr strings zu einer einzigen neuen string wird als Saitenverkettung bezeichnet. Die Zeichenkettenverkettung ist eine der am häufigsten durchgeführten Operationen in der Programmierung. In diesem Artikel werden wir verschiedene Methoden zur Verkettung von Strings in der Go-Programmiersprache mit ihren Vor- und Nachteilen diskutieren.

Mit dem Plus (+)-Operator

Die Verwendung von + ist die einfachste und am weitesten verbreitete Methode zur Zeichenkettenverkettung. Manchmal wird der + Operator auch Verkettungsoperator genannt.

package main

import "fmt"

func main() {

    str_1 := "Welcome to "
    str_2 := "the Blog!!"
    fmt.Println("str_1: ", str_1)
    fmt.Println("str_2: ", str_2)
    fmt.Println("Combined String: ", str_1+str_2)
}

Ausgabe:

str_1:  Welcome to 
str_2:  the Blog!!
Combined String:  Welcome to the Blog!!

Mit mehreren Argumenten in der Funktion Print()

Wir können mehrere Zeichenketten als Argumente an die Print() Funktion in Go übergeben. Die Zeichenketten werden automatisch durch Hinzufügen von Leerzeichen zwischen den Zeichenketten verkettet.

package main

import "fmt"

func main() {

    fmt.Println("String", "Concatenation!!")
}      

Ausgabe:

String Concatenation!!

Mit der Funktion Join()

Wir können auch Zeichenketten mit der Funktion join() verknüpfen, die in einem Zeichenkettenpaket vorhanden ist, das eine Scheibe von Zeichenketten und ein Trennzeichen nimmt, um sie mit der Erzeugung einer einzelnen Zeichenkette zu verbinden.

Die Syntax:

func Join(str []string, sep string) string

wobei str die Scheibe von Zeichenketten ist, aus der wir Elemente verknüpfen, und sep das Trennzeichen zwischen den Scheiben ist.

   package main

import (
    "fmt"
    "strings" //for join() function
)

func main() {

    str_slices := []string{"This", "is",
        "String", "Concatenation!!"}

    str_concat := strings.Join(str_slices, "-")
    fmt.Println(str_concat)
}
  

Ausgabe:

This-is-String-Concatenation!!

Methode Sprintf()

Die Verwendung der Methode Sprintf() im Paket fmt ist auch eine der einfachsten Methoden zur Zeichenkettenverkettung.

package main

import "fmt"

func main() {
    str_1 := "We will"
    str_2 := " Rock"
    str_3 := " You!!"

    str_final := fmt.Sprintf("%s%s%s", str_1, str_2, str_3)

    fmt.Println(str_final)
} 

Ausgabe:

We will Rock You!!

bytes.Buffer-Methode

Eine effiziente Methode zur Verkettung von Zeichenketten ohne die Erzeugung des unnötigen String-Objekts ist die bytes.Buffer-Methode. Wir können Zeichenketten mit der Methode WriteString() in einen Byte-Puffer schreiben und diesen dann in eine Zeichenkette konvertieren.

package main

import (
    "bytes"
    "fmt"
)

func main() {
    var byte_buf bytes.Buffer

    byte_buf.WriteString("Hello ")
    byte_buf.WriteString("World!!")

    fmt.Println(byte_buf.String())
}

Ausgabe:

Hello World!!

strings.Builder-Methode

Diese Methode ermöglicht eine effiziente Verkettung von Zeichenketten, da sie im Vergleich zu anderen Verfahren sehr wenig Speicher benötigt.

package main

import (
    "fmt"
    "strings"
)

func main() {
    var str_build strings.Builder
    str_build.WriteString("Hello ")
    str_build.WriteString("World!!")
    fmt.Println(str_build.String())
}

Ausgabe:

Hello World!!

Anhängen mit += Operator

Sie ähnelt der Zeichenkettenverkettung mit dem Plus-Operator, ist aber etwas kürzer als die vorherige. Mit dem +=-Operator wird eine neue Zeichenkette rechts an die angegebene Zeichenkette angehängt.

package main

import "fmt"

func main() {
    str_1 := "Hello "

    str_1 += "World!!"
    fmt.Println("Final String:", str_1)

}

Ausgabe:

Final String: Hello World!!

Vergleich verschiedener Methoden

Die Methoden bytes.Buffer und strings.Builder sind wesentlich schneller als andere Methoden der String-Verkettung. Daher bevorzugen wir die Methoden bytes.Buffer und strings.Builder, wenn wir String-Verkettungen in großem Umfang durchführen müssen. Wenn die Anzahl der Verkettungen jedoch gering ist, können wir + oder += Operatoren verwenden.