Het correct opmaken van getallen kan een lastige taak zijn. En het opmaken van valuta's brengt extra uitdagingen met zich mee met betrekking tot lokalisatie. Gelukkig heeft Go functies om te helpen.
De Go-standaardbibliotheek biedt verschillende hulpmiddelen voor het opmaken van getallen. Het strconv-pakket bevat functies voor het ontleden en converteren van getallen van en naar tekenreeksen.
Het strconv-pakket
De strconv package is een krachtig hulpmiddel voor het converteren tussen getallen en strings. U kunt het gebruiken om met getallen in verschillende formaten te werken.
strconv maakt deel uit van de standaardbibliotheek, dus het is relevant voor veel van de basis Go-concepten waarmee u bekend moet zijn. Zo kunt u het importeren:
importeren"strconv"
Het pakket biedt functies voor het converteren van getallen van en naar strings in verschillende formaten. Het bevat functies om te werken met gehele getallen en getallen met drijvende komma.
strconv kan ook de conversie van en naar binaire, octale en hexadecimale formaten aan, evenals wetenschappelijke notatie.
Gehele getallen opmaken in Go
Het strconv-pakket Itoa functie biedt functionaliteit voor het converteren van gehele getallen naar tekenreeksen. De Itoa functie neemt een geheel getal en retourneert de tekenreeksrepresentatie van dat gehele getal.
importeren (
"fmt"
"strconv"
)
funcvoornaamst() {
gehele getallen := 3043
stringversie := strconv. Itoa (gehele getallen)
fmt. Println (stringversie) // Uitvoer: "3043"
}
Deze code converteert een geheel getal naar een tekenreeks met behulp van Itoa. Vervolgens voert het de resulterende tekenreeks uit naar de console met behulp van de fmt pakket.
Naast de Itoa functie, strconv biedt:
- FormaatInt voor het formatteren van gehele getallen als strings met een gegeven grondtal
- AppendInt voor het toevoegen van gehele getallen in tekenreeksvorm aan een stukje bytes.
Hier ziet u hoe u de FormaatInt functie om een geheel getal op te maken:
importeren (
"fmt"
"strconv"
)
funcvoornaamst() {
gehele getallen := 12345
strings := strconv. FormaatInt(int64(gehele getallen), 10)
fmt. Println (tekenreeksen) // Uitvoer: "12345"
}
Deze code gebruikt int64() om de oorspronkelijke waarde om te zetten in een 64-bits geheel getal. Vervolgens geeft het het resultaat door aan FormaatInt, samen met een basis voor conversie, in dit geval 10. FormatInt retourneert een string die Println vervolgens uitgevoerd naar de console.
De AppendInt functie neemt een byte slice in, een int64 waarde en een basis.
importeren (
"fmt"
"strconv"
)
funcvoornaamst() {
gehele getallen := 12345
byteslice := maken([]byte, 0, 20)
byteSlice = strconv. AppendInt (byteSlice, int64(gehele getallen), 10)
fmt. Println(snaar(byteSlice)) // Uitvoer: "12345"
}
Merk op dat AppendInt een bytesegment ontvangt om aan toe te voegen en het resulterende bytesegment retourneert. In dit geval is de initiële byte-slice leeg, maar heeft een capaciteit van 20 om de resulterende tekenreeksrepresentatie van het gehele getal op te slaan.
Tekenreeksen ontleden als gehele getallen
De Atooi functie converteert tekenreeksen naar gehele getallen. Het neemt een tekenreeks als invoer en retourneert een integer-representatie van die tekenreeks samen met een fouttype.
Hier ziet u hoe u de Atooi functie voor conversie van tekenreeks naar geheel getal:
importeren (
"fmt"
"strconv"
)funcvoornaamst() {
snaren := "123"
gehele getallen, fout := strconv. Atoi (strijkers)als fout!= nihil {
fmt. Println (fout)
}
fmt. Println (gehele getallen)
}
Het programma voert de gehele waarde uit naar de console:
U kunt ook de ParseUint functie om de tekenreeksrepresentatie van niet-ondertekende gehele getallen te ontleden.
pakket voornaamstimporteren (
"fmt"
"strconv"
)funcvoornaamst() {
// ontleed string als grondtal 10 en 0-bits geheel getal zonder teken
val, fout := strconv. ParseUint("12345", 10, 0)
als fout!= nihil {
fmt. Println (fout)
} anders {
fmt. Println (waarde) // Uitvoer: 12345
}
}
De ParseUint functie ontleedt de 12345-tekenreeks als een geheel getal zonder teken met grondtal tien. De 0-bits grootte zorgt ervoor dat het een standaard int-type retourneert. Het retourneert de geparseerde waarde en een fout.
U kunt de ParseFloat functie om een tekenreeksrepresentatie van een getal met drijvende komma te ontleden.
importeren (
"fmt"
"strconv"
)funcvoornaamst() {
// ontleed tekenreeks als 64-bits getal met drijvende komma
val, fout := strconv. ParseFloat("3.14", 64)
als fout!= nihil {
fmt. Println (fout)
} anders {
fmt. Println (waarde) // Uitvoer: 3.14
}
}
De ParseFloat functie ontleedt de tekenreeks als een 64-bits getal met drijvende komma en retourneert de tekenreeks en een fouttype.
Valuta's opmaken in Go
Het bouwen van een applicatie die met valuta communiceert, vereist getalopmaak en -parsing. Werken met verschillende valuta's kan een uitdaging zijn, maar de strconv En boekhouding pakketten kunnen u helpen ze te formatteren.
Hier ziet u hoe u een valutatekenreeks kunt ontleden tot een vlotter voor bewerkingen op de valuta:
importeren (
"fmt"
"strconv"
)funcvoornaamst() {
// Valutatekenreeks om te ontleden
valutaStr := "$1,234.56"// Verwijder het valutasymbool en converteer naar een float
floatVal, fout := strconv. ParseFloat (valutaStr[1:], 64)als fout!= nihil {
fmt. Println (fout)
opbrengst
}
// Druk de geparseerde float-waarde af
fmt. Println (floatVal) // Uitvoer: 1234,56
}
De valutaStr variabele is een tekenreeksweergave van een valutawaarde met een dollarteken als symbool. Het programma maakt gebruik van de ParseFloat functie om de valutatekenreeks te ontleden vanaf het tweede element (na het valutasymbool).
Gewoonlijk is het het beste om het gebruik van praalwagens voor valuta's te vermijden, omdat dit kan leiden tot misrekeningen en bugs in de productie.
Als alternatief kunt u een pakket van derden gebruiken, zoals boekhouding die functionaliteit heeft voor het formatteren en ontleden van valuta's.
Voer deze terminalopdracht uit in uw projectdirectory om het boekhoudpakket te installeren:
ga naar github.com/leekchan/accounting
Begin met het maken van een instantie van de Boekhouding structuur. Bedenk dat structs er een van zijn Go's belangrijkste objectgeoriënteerde functies, vergelijkbaar met lessen uit andere talen. U kunt een Accounting-exemplaar onder andere initialiseren met een valutasymbool en een precisiewaarde.
U kunt de FormaatGeld functie van het boekhoudpakket om getallen om te zetten in valuta's.
pakket voornaamstimporteren (
"fmt"
"wiskunde/groot""github.com/leekchan/boekhouding"
)
funcvoornaamst() {
ac := boekhouding. Boekhouding{Symbool: "$", Precisie: 2}
fmt. Println (ac. FormaatMoney(123456789.213123))
fmt. Println (ac. FormaatMoney(12345678))
fmt. Println (ac. FormaatGeld (big. NieuwRat(77777777, 3)))
fmt. Println (ac. FormaatGeld (big. NieuwRat(-77777777, 3)))
fmt. Println (ac. FormaatMoneyBigFloat (big. NieuwFloat(123456789.213123)))
}
De ac variabele is de boekhoudkundige instantie. Dit programma formatteert en drukt geldwaarden af met behulp van de FormaatGeld En FormaatMoneyBigFloat methodes van de boekhoudkundige instantie. De NieuwRat functie uit de groot pakket creëert een rationaal getal gegeven een teller en noemer. De NieuweFloat functie helpt bij het weergeven van grote getallen met drijvende komma.
Go kan u ook helpen bij het formatteren van andere typen
Go biedt tal van functies om getallen en valuta op een eenvoudige manier om te rekenen.
De taal biedt ook een krachtig tekenreeksopmaaksysteem. Met de C-geïnspireerde Sprintf-functie van het fmt-pakket kunt u opgemaakte tekenreeksen maken met behulp van een speciale tijdelijke aanduiding-syntaxis. U kunt Sprintf gebruiken om strings te bouwen die getallen en valutawaarden bevatten, waardoor het gemakkelijk is om voor mensen leesbare uitvoer te maken.
