Gos String Builder (String Builder)

Gos String Builder String Builder



Strings sind einer der grundlegendsten Datentypen in Go und vielen anderen Programmiersprachen. Mit Strings können wir eine Folge von Zeichen speichern.
In Go stellen wir die Strings als eine Folge von Strings dar, die in doppelte Anführungszeichen eingeschlossen sind, wie zum Beispiel „Hello, World“.

Strings sind unveränderlich, wenn es um Go geht. Sobald wir eine Zeichenfolge definiert haben, können wir ihren Inhalt daher nicht direkt ändern. Um den Inhalt zu ändern, müssen Sie eine neue Instanz einer Zeichenfolge mit geändertem Inhalt erstellen.

Eine Sache, die Sie in Go bemerken werden, ist, dass die Ausführung von String-Operationen wie der String-Verkettung zu Leistungsproblemen führen kann. Dies liegt daran, dass wir jedes Mal eine neue Zeichenfolge erstellen, was sehr ineffizient sein kann. Glücklicherweise verfügt Go über einen Typ namens „strings.Builder“, der in dieser Hinsicht hilfreich sein kann.







In diesem Tutorial werden wir die Besonderheiten dieses Typs erkunden und alles darüber erfahren.



Wie Strings in Go funktionieren

Bevor wir uns mit dem String-Builder in Go befassen, wollen wir zunächst verstehen, wie Strings in Go funktionieren.



Wie bereits erwähnt, sind Zeichenfolgen unveränderlich. Daher erstellen wir bei Aufgaben wie der Verkettung eine neue Instanz der Zeichenfolge.





str1 := 'Hallo, '
str2 := 'Welt!'
Ergebnis := str1 + str2

In diesem Fall erstellt die angegebene Operation eine neue Zeichenfolge, um das resultierende „Hello, World!“ zu speichern. Zeichenfolge.

Golang Strings.Builder

Der „strings.Builder“-Typ in Go ist Teil des „strings“-Pakets und seine Aufgabe besteht darin, eine bessere und effizientere Möglichkeit zum Erstellen und Bearbeiten der Strings bereitzustellen, ohne Kopien zu erstellen.



Der „Builder“-Typ verfügt über viele Methoden zur String-Manipulation wie Anhängen, Einfügen, Ändern der Strings und mehr.

Es verwendet einen Puffer zum Speichern der Zwischenergebnisse, was es effizienter macht, wenn wir große Strings erstellen oder viele String-Operationen ausführen müssen.

Strings Builder (Grundkenntnisse)

Beginnen wir mit den Grundlagen und besprechen wir die Verwendung des Typs „Builder“.

Damit wir „strings.Builder“ verwenden können, müssen wir eine Instanz mit der Funktion „NewBuilder“ erstellen. Ein Beispiel ist wie folgt:

Paket main
importieren (
„fmt“
„Saiten“
)
Funktion main ( ) {
var builder strings.Builder
}

Wir können auch wie folgt einen Builder mit einem anfänglichen String-Inhalt erstellen:

builder := strings.NewBuilder ( 'Hallo' )

String Builder-Operationen

Lassen Sie uns die Methoden und Operationen besprechen, die wir für den Typ „Builder“ ausführen können.

Anhängen der Strings
Um die Strings an eine Instanz vom Typ „Builder“ anzuhängen, können wir die Methode WriteString() verwenden, wie im folgenden Beispiel gezeigt:

Paket main
importieren (
„fmt“
„Saiten“
)

Funktion main ( ) {
var builder strings.Builder
builder.WriteString ( „https://“ )
builder.WriteString ( „linuxhint.com“ )
URL := builder.String ( )
fmt.Println ( URL )
}

Im gegebenen Beispiel beginnen wir mit der Erstellung eines leeren String-Builders. Anschließend hängen wir mit der Funktion „WriteString“ zwei Strings daran an.

Schließlich rufen wir den verketteten String mit der String()-Methode ab und geben ihn wie folgt auf der Konsole aus:

https: // linuxhint.com

Den Builder löschen
Wir können den Inhalt eines „strings.Builder“ löschen und ihn wiederverwenden, indem wir die „Reset“-Methode aufrufen, wie im folgenden Beispiel gezeigt:

Paket main
importieren (
„fmt“
„Saiten“
)
Funktion main ( ) {
var builder strings.Builder
builder.WriteString ( „https://“ )
fmt.Println ( builder.String ( ) )
builder.Reset ( )
builder.WriteString ( „linuxhint.com“ )
URL := builder.String ( )

fmt.Println ( URL )
}

Im gegebenen Beispiel erstellen wir zunächst einen neuen Builder und hängen einen https:// string into it an.

Anschließend verwenden wir die Funktion „Reset()“, um den Builder zu löschen und ihn für die Wiederverwendung bereit zu machen. Wir tun dies, indem wir eine neue Zeichenfolge hineinschreiben, die „linuxhint.com“ lautet.

Die resultierende Ausgabe lautet wie folgt:

https: //
linuxhint.com

Verwendung von Byte-Slices
In Go werden Strings unter der Haube als Byte-Slices dargestellt. Dies macht die normalen Zeichenfolgen zu einer schreibgeschützten Ansicht einer Bytefolge.

Es besteht daher kein Zweifel, dass Sie auf Fälle stoßen werden, in denen Sie die Byte-Slices an einen String-Builder anhängen müssen.

Dazu können wir die Methode „Write“ wie folgt verwenden:

Paket main
importieren (
„fmt“
„Saiten“
)
Funktion main ( ) {
var builder strings.Builder
Bytes := [ ] Byte ( „https://linuxhint.com“ )
builder.Write ( Bytes )
URL := builder.String ( )
fmt.Println ( URL )
}

Hier hast du es!

Warum brauchen Sie einen String Builder?

Sie fragen sich vielleicht: Warum brauche ich einen String-Builder? Die kurze Antwort lautet: Nein. Der normale String in Go ist für eine Vielzahl von Anwendungsfällen mehr als ausreichend.

Ein Hauptvorteil der Verwendung des Builders ist jedoch die Flexibilität, einen String mit einem zusätzlichen Leistungsvorteil zu erstellen, der in einem normalen String nicht vorhanden ist.

Da beim Erstellen von Zeichenfolgen unnötige Speicherzuweisungen und Kopiervorgänge vermieden werden, ist dies effizienter als eine einfache Zeichenfolgenverkettung mit dem „+“-Operator.

Abschluss

In diesem Tutorial haben wir die meisten Dinge gelernt, die wir über den Typ „Builder“ in Go wissen müssen. Leider ist es nicht möglich, im Rahmen dieses Tutorials alle Funktionen des Typs „Builder“ zu besprechen. Wir empfehlen Ihnen daher, die Dokumentation auf zusätzliche Informationen zum Typ „Builder“ zu prüfen.