Das korrekte Formatieren von Zahlen kann eine knifflige Aufgabe sein. Und die Formatierung von Währungen bringt zusätzliche Herausforderungen bei der Lokalisierung mit sich. Glücklicherweise hat Go hilfreiche Funktionen.
Die Go-Standardbibliothek bietet verschiedene Tools zum Formatieren von Zahlen. Das Paket strconv enthält Funktionen zum Analysieren und Konvertieren von Zahlen in und aus Zeichenfolgen.
Das strconv-Paket
Der Strconv Paket ist ein leistungsstarkes Werkzeug zum Konvertieren zwischen Zahlen und Zeichenfolgen. Sie können damit mit Zahlen in verschiedenen Formaten arbeiten.
strconv ist Teil der Standardbibliothek und daher für viele relevant grundlegende Go-Konzepte, mit denen Sie vertraut sein sollten. So können Sie es importieren:
importieren"strconv"
Das Paket bietet Funktionen zum Konvertieren von Zahlen in und aus Zeichenfolgen in verschiedenen Formaten. Es enthält Funktionen zum Arbeiten mit Ganzzahlen und Gleitkommazahlen.
strconv kann auch die Konvertierung in und aus binären, oktalen und hexadezimalen Formaten sowie die wissenschaftliche Notation handhaben.
Formatieren von ganzen Zahlen in Go
Die strconv-Pakete Itoa -Funktion bietet Funktionen zum Konvertieren von Ganzzahlen in Zeichenfolgen. Der Itoa Die Funktion nimmt eine Ganzzahl und gibt die Zeichenfolgendarstellung dieser Ganzzahl zurück.
importieren (
"fmt"
"strconv"
)
Funkhauptsächlich() {
Ganzzahlen := 3043
stringVersion := strconv. Itoa (Ganzzahlen)
fmt. Println (stringVersion) // Ausgabe: "3043"
}
Dieser Code wandelt einen ganzzahligen Wert mithilfe von in eine Zeichenfolge um Itoa. Anschließend wird die resultierende Zeichenfolge mithilfe von an die Konsole ausgegeben fmt Paket.
In Ergänzung zu Itoa Funktion, strconv bietet:
- FormatInt zum Formatieren von ganzen Zahlen als Zeichenketten mit einer gegebenen Basis
- AppendInt zum Anhängen von Ganzzahlen in Zeichenfolgenform an einen Byte-Slice.
So können Sie die verwenden FormatInt Funktion zum Formatieren einer Ganzzahl:
importieren (
"fmt"
"strconv"
)
Funkhauptsächlich() {
Ganzzahlen := 12345
Zeichenketten := strconv. FormatInt(int64(Ganzzahlen), 10)
fmt. Println (Strings) // Ausgabe: "12345"
}
Dieser Code verwendet int64() um den ursprünglichen Wert in eine 64-Bit-Ganzzahl umzuwandeln. Anschließend übergibt er das Ergebnis an FormatInt, zusammen mit einer Basis für die Konvertierung, in diesem Fall 10. FormatInt gibt eine Zeichenfolge zurück, die Druckln gibt dann an die Konsole aus.
Der AppendInt Funktion nimmt einen Byte-Slice, an int64 Wert und eine Basis.
importieren (
"fmt"
"strconv"
)
Funkhauptsächlich() {
Ganzzahlen := 12345
byteSlice := machen([]Byte, 0, 20)
byteSlice = strconv. AppendInt (byteSlice, int64(Ganzzahlen), 10)
fmt. Println(Schnur(byteSlice)) // Ausgabe: "12345"
}
Beachten Sie, dass AppendInt einen Byte-Slice zum Anhängen empfängt und den resultierenden Byte-Slice zurückgibt. In diesem Fall ist der anfängliche Byte-Slice leer, hat aber eine Kapazität von 20, um die resultierende Zeichenfolgendarstellung der Ganzzahl zu speichern.
Strings als ganze Zahlen analysieren
Der Atoi Funktion wandelt Strings in Ganzzahlen um. Es nimmt eine Zeichenfolge als Eingabe auf und gibt eine Ganzzahldarstellung dieser Zeichenfolge zusammen mit einem Fehlertyp zurück.
So können Sie die verwenden Atoi Funktion für die String-to-Integer-Konvertierung:
importieren (
"fmt"
"strconv"
)Funkhauptsächlich() {
Saiten := "123"
ganze Zahlen, err := strconv. Atoi (Streicher)Wenn äh != Null {
fmt. Println (err)
}
fmt. Println (Ganzzahlen)
}
Das Programm gibt den ganzzahligen Wert an die Konsole aus:
Sie können auch die verwenden ParseUint -Funktion zum Analysieren der Zeichenfolgendarstellung von Ganzzahlen ohne Vorzeichen.
Paket hauptsächlichimportieren (
"fmt"
"strconv"
)Funkhauptsächlich() {
// Zeichenfolge als Basis 10 und 0-Bit-Ganzzahl ohne Vorzeichen analysieren
val, err := strconv. ParseUint("12345", 10, 0)
Wenn äh != Null {
fmt. Println (err)
} anders {
fmt. Println (val) // Ausgabe: 12345
}
}
Der ParseUint -Funktion analysiert die Zeichenfolge 12345 als vorzeichenlose Ganzzahl zur Basis zehn. Die 0-Bit-Größe stellt sicher, dass ein Standard-int-Typ zurückgegeben wird. Es gibt den geparsten Wert und einen Fehler zurück.
Du kannst den... benutzen ParseFloat -Funktion zum Analysieren einer Zeichenfolgendarstellung einer Gleitkommazahl.
importieren (
"fmt"
"strconv"
)Funkhauptsächlich() {
// Zeichenfolge als 64-Bit-Gleitkommazahl parsen
val, err := strconv. ParseFloat("3.14", 64)
Wenn äh != Null {
fmt. Println (err)
} anders {
fmt. Println (val) // Ausgabe: 3.14
}
}
Der ParseFloat -Funktion analysiert die Zeichenfolge als 64-Bit-Gleitkommazahl und gibt die Zeichenfolge und einen Fehlertyp zurück.
Währungen in Go formatieren
Das Erstellen einer Anwendung, die mit Währungen interagiert, erfordert die Formatierung und Analyse von Zahlen. Das Arbeiten mit verschiedenen Währungen kann eine Herausforderung sein, aber die Strconv Und Buchhaltung Pakete können Ihnen bei der Formatierung helfen.
So können Sie eine Währungszeichenfolge für Operationen mit der Währung in einen Gleitkommawert parsen:
importieren (
"fmt"
"strconv"
)Funkhauptsächlich() {
// Zu parsender Währungsstring
Währungsstr := "$1,234.56"// Währungssymbol entfernen und in Float umwandeln
floatVal, err := strconv. ParseFloat (currencyStr[1:], 64)Wenn äh != Null {
fmt. Println (err)
zurückkehren
}
// Drucken Sie den geparsten Gleitkommawert
fmt. Println (floatVal) // Ausgabe: 1234,56
}
Der WährungStr Variable ist eine Zeichenfolgendarstellung eines Währungswerts mit einem Dollarzeichen als Symbol. Das Programm verwendet die ParseFloat -Funktion, um die Währungszeichenfolge beginnend mit dem zweiten Element (nach dem Währungssymbol) zu analysieren.
Herkömmlicherweise ist es am besten, die Verwendung von Floats für Währungen zu vermeiden, da dies zu Fehlkalkulationen und Fehlern in der Produktion führen kann.
Alternativ können Sie ein Drittanbieterpaket wie verwenden Buchhaltung mit Funktionen zum Formatieren und Analysieren von Währungen.
Führen Sie diesen Terminalbefehl in Ihrem Projektverzeichnis aus, um das Buchhaltungspaket zu installieren:
Gehen Sie zu github.com/leekchan/accounting
Beginnen Sie mit dem Erstellen einer Instanz der Buchhaltung Struktur. Denken Sie daran, dass Strukturen eine davon sind Die objektorientierten Kernfunktionen von Go, ähnlich wie Klassen aus anderen Sprachen. Sie können eine Accounting-Instanz unter anderem mit einem Währungssymbol und einem Genauigkeitswert initialisieren.
Du kannst den... benutzen Geld formatieren Funktion des Buchhaltungspakets zum Formatieren von Zahlen in Währungen.
Paket hauptsächlichimportieren (
"fmt"
"Mathe/groß""github.com/leekchan/accounting"
)
Funkhauptsächlich() {
ac := Buchhaltung. Buchhaltung{Symbol: "$", Präzision: 2}
fmt. Println (ac. FormatGeld(123456789.213123))
fmt. Println (ac. FormatGeld(12345678))
fmt. Println (ac. FormatMoney (groß. NeueRatte(77777777, 3)))
fmt. Println (ac. FormatMoney (groß. NeueRatte(-77777777, 3)))
fmt. Println (ac. FormatMoneyBigFloat (groß. NewFloat(123456789.213123)))
}
Der ac Variable ist die Abrechnungsinstanz. Dieses Programm formatiert und druckt Geldwerte mit der Geld formatieren Und FormatMoneyBigFloat Methoden der Abrechnungsinstanz. Der NeueRatte Funktion aus der groß Paket erstellt eine rationale Zahl aus Zähler und Nenner. Der NewFloat -Funktion hilft bei der Darstellung großer Gleitkommazahlen.
Go kann Ihnen auch beim Formatieren anderer Typen helfen
Go bietet viele Funktionen, um Zahlen und Währungen unkompliziert umzurechnen.
Die Sprache bietet auch ein leistungsfähiges String-Formatierungssystem. Mit der C-inspirierten Sprintf-Funktion des fmt-Pakets können Sie formatierte Zeichenfolgen mit einer speziellen Platzhaltersyntax erstellen. Sie können Sprintf verwenden, um Zeichenfolgen zu erstellen, die Zahlen und Währungswerte enthalten, wodurch es einfach ist, eine für Menschen lesbare Ausgabe zu erstellen.