Golang -String nach int

Golang oder Go ist eine kostenlose, simpistische, moderne und open-Source-Programmiersprache. Es ist eine hochrangige Sprache und bietet vielseitige Funktionen und Datentypen für die moderne Entwicklung.

Ein Datentyp, der von der Go -Programmiersprache nativ bereitgestellt wird, ist eine Zeichenfolge. Mit einer String können Sie eine Folge von Zeichen speichern, einschließlich alphanumerischer Zeichen.

In einigen Fällen können Sie einen numerischen Wert in einem String -Format gespeichert haben. Um alle Operationen mit einem INT -Typ auszuführen, müssen Sie ihn in ein INT konvertieren.

Dieses Tutorial hilft Ihnen dabei, verschiedene Methoden und Techniken zur Konvertierung einer Zeichenfolge in einen Int in Go zu entdecken.

Golang erstellen String

In Go verwenden wir doppelte Anführungszeichen, um eine Zeichenfolge darzustellen. Im Folgenden wird ein Beispielprogramm gezeigt:

Paket Main
importieren "fmt"
func main ()
var value = "1000"
fmt.Println (Wert)

Wir haben eine Zeichenfolgenvariable, die im Beispielprogramm einen "numerischen" Wert besitzt. Denken Sie daran, dass der Wert uns numerisch erscheinen kann, aber der Wert ist eine Zeichenfolge für den Compiler.

Wenn also ein mathematischer Operation am Wert versucht wird, gibt der Compiler einen Fehler zurück.

Paket Main
importieren "fmt"
func main ()
var value = "1000"
fmt.Println (Wert * 3)

Die Ausgabe des Compiler wird:

$ go run string_to_int.gehen
# Kommandozeilenargumente
.\ string_to_int.GO: 7: 14: Ungültiger Betrieb: Wert * 3 (nicht übereinstimmende Typ -String und Untyped int)

Golang Parse String to int #1

Go stellt die ATOI () -Funktion aus dem StrConv -Paket zur Verfügung, um eine Zeichenfolge an einen Int -Typ zu analysieren.

https: // pkg.gehen.dev/strconv#atoi

Zum Beispiel, um den Variablenwert aus dem vorherigen Programm in ein int zu konvertieren:

Paket Main
importieren (
"fmt"
"Strconv"
)
func main ()
Wert: = "1000"
Wenn n, err: = strconv.Atoi (Wert); err == nil
fmt.Println (n * 3)

Aus dem obigen Programm starten wir zunächst das StrConv -Paket. Dies gibt uns Zugriff auf die ATOI () -Funktion. Wir verwenden dann die ATOI () -Funktion, um die Zeichenfolge zu einem INT analysieren und eine mathematische Operation durchführen.

Wir können den Typ des Werts untersuchen wie:

Paket Main
importieren (
"fmt"
"Strconv"
)
func main ()
Wert: = "1000"
Wenn n, err: = strconv.Atoi (Wert); err == nil
fmt.Printf ("%t \ n", n)
fmt.Println (n * 3)

Das Programm führt zu Ausgabe als:

$ go run string_to_int.gehen
int
3000

Obwohl wir die ATOI () -Funktion verwenden, um eine Zeichenfolge in ein INT umzuwandeln, müssen wir sicherstellen, dass der Wert in ein INT konvertiert werden kann.

Wenn wir versuchen, eine Zeichenfolge wie einen Namen in ein INT umzuwandeln, erhöht die Funktion einen Fehler.

Nehmen wir zum Beispiel das unten stehende Programm:

Paket Main
importieren (
"fmt"
"Protokoll"
"Strconv"
)
func main ()
Wert: = "LinuxHint"
n, arr: = strconv.Atoi (Wert)
Protokoll.Tödlich (arr)
fmt.Println (n)

Im obigen Code versuchen wir, die Zeichenfolge „LinuxHint“ in eine Zeichenfolge umzuwandeln, die ein nicht unterstütztes Format ist.

Der obige Code sollte einen Fehler aufnehmen als:

$ go run string_to_int.gehen
2022/05/31 02:15:22 STRCONV.ATOI: Parsen "LinuxHint": Ungültige Syntax
Beendenstatus 1

Golang Parse String zu int #2

Im StrConv -Paket haben wir Zugriff auf die ParseInt -Funktion, mit der wir eine Zeichenfolge auf eine bestimmte Basis analysieren können (0, 2 bis 36).

https: // pkg.gehen.dev/strconv#parsesint

Nehmen wir ein Beispiel wie unten gezeigt:

Paket Main
importieren (
"fmt"
"Strconv"
)
func main ()
Wert: = "1000"
Wenn n, err: = strconv.ParseInt (Wert, 10, 64); err == nil
fmt.Printf (" %t: %v \ n", n, n)

Achten Sie auf die ParseinT () -Funktion. Wir verabschieden drei Hauptargumente darin: Der erste ist der Wert, den wir an einen int analysieren möchten, und die zweite repräsentiert die Basis. Die Basis ist ein Wert von 0 oder 2 bis 36.

Das endgültige Argument ist die Bitgröße, die den Ganzzahltyp angibt, den der resultierende Wert anpasst. Zu den akzeptierten Werten gehören 0, 8, 16, 32 und 64, die an int, int8, int16, int32 und int64 entspricht.

Abschließende Gedanken

Sie haben gelernt, wie man eine Zeichenfolge in einen Int -Typ in diesem Tutorial umwandelt.