Å formatere tall riktig kan være en vanskelig oppgave. Og formatering av valutaer gir ytterligere utfordringer som involverer lokalisering. Heldigvis har Go funksjoner som hjelper.
Go-standardbiblioteket tilbyr ulike verktøy for formatering av tall. Strconv-pakken inkluderer funksjoner for å analysere og konvertere tall til og fra strenger.
Strconv-pakken
De strconv pakke er et kraftig verktøy for å konvertere mellom tall og strenger. Du kan bruke den til å jobbe med tall i ulike formater.
strconv er en del av standardbiblioteket, så det er relevant for mange av grunnleggende Go-konsepter du bør være kjent med. Slik kan du importere den:
import"strconv"
Pakken inneholder funksjoner for å konvertere tall til og fra strenger i ulike formater. Den inkluderer funksjoner for å arbeide med heltall og flyttall.
strconv kan også håndtere konvertering til og fra binære, oktale og heksadesimale formater samt vitenskapelig notasjon.
Formatering av heltall i Go
Strconv-pakkens Itoa funksjon gir funksjonalitet for å konvertere heltall til strenger. De Itoa funksjonen tar et heltall og returnerer strengrepresentasjonen av det hele tallet.
import (
"fmt"
"strconv"
)
funchoved-() {
heltall := 3043
stringVersion := strconv. Itoa (heltall)
fmt. Println (stringVersion) // Utdata: "3043"
}
Denne koden konverterer en heltallsverdi til en streng ved hjelp av Itoa. Den sender deretter ut den resulterende strengen til konsollen ved å bruke fmt pakke.
I tillegg til det Itoa funksjon, strconv gir:
- FormatInt for formatering av heltall som strenger med en gitt base
- AppendInt for å legge til heltall i strengform til en bit av byte.
Her er hvordan du kan bruke FormatInt funksjon for å formatere et heltall:
import (
"fmt"
"strconv"
)
funchoved-() {
heltall := 12345
strenger := strconv. FormatInt(int64(heltall), 10)
fmt. Println (strenger) // Utdata: "12345"
}
Denne koden bruker int64() for å konvertere den opprinnelige verdien til et 64-bits heltall. Den sender deretter resultatet til FormatInt, sammen med en base for konvertering, i dette tilfellet 10. FormatInt returnerer en streng som Println deretter utgang til konsollen.
De AppendInt funksjonen tar inn en byte skive, en int64 verdi og en base.
import (
"fmt"
"strconv"
)
funchoved-() {
heltall := 12345
byteSlice := gjøre([]byte, 0, 20)
byteSlice = strconv. AppendInt (byteSlice, int64(heltall), 10)
fmt. Println(streng(byteSlice)) // Utdata: "12345"
}
Legg merke til at AppendInt mottar et bytestykke å legge til, og returnerer det resulterende bytestykket. I dette tilfellet er den første byte-delen tom, men har en kapasitet på 20 for å lagre den resulterende strengrepresentasjonen av heltallet.
Parsing av strenger som heltall
De Atoi funksjon konverterer strenger til heltall. Den tar inn en streng som input og returnerer en heltallsrepresentasjon av den strengen sammen med en feiltype.
Her er hvordan du kan bruke Atoi funksjon for streng-til-heltall konvertering:
import (
"fmt"
"strconv"
)funchoved-() {
strenger := "123"
heltall, feil := strconv. Atoi (strenger)hvis feil!= null {
fmt. Println (feil)
}
fmt. Println (heltall)
}
Programmet sender ut heltallsverdien til konsollen:
Du kan også bruke ParseUint funksjon for å analysere strengrepresentasjonen av heltall uten fortegn.
pakke hoved-import (
"fmt"
"strconv"
)funchoved-() {
// analyser streng som base 10 og 0-bits heltall uten fortegn
val, feil := strconv. ParseUint("12345", 10, 0)
hvis feil!= null {
fmt. Println (feil)
} ellers {
fmt. Println (val) // Utgang: 12345
}
}
De ParseUint funksjonen analyserer 12345-strengen som en base ti, heltall uten fortegn. 0-bits størrelsen sikrer at den returnerer en standard int-type. Den returnerer den analyserte verdien og en feil.
Du kan bruke ParseFloat funksjon for å analysere en strengrepresentasjon av et flyttall.
import (
"fmt"
"strconv"
)funchoved-() {
// analyser streng som 64-bits flytende kommanummer
val, feil := strconv. ParseFloat("3.14", 64)
hvis feil!= null {
fmt. Println (feil)
} ellers {
fmt. Println (val) // Utgang: 3,14
}
}
De ParseFloat funksjonen analyserer strengen som et 64-bits flyttall og returnerer strengen og en feiltype.
Formatere valutaer i Go
Å bygge en applikasjon som samhandler med valutaer krever tallformatering og parsing. Å jobbe med forskjellige valutaer kan være en utfordring, men det strconv og regnskap pakker kan hjelpe deg med å formatere dem.
Slik kan du analysere en valutastreng til en flytende for operasjoner på valutaen:
import (
"fmt"
"strconv"
)funchoved-() {
// Valutastreng som skal analyseres
valutaStr := "$1,234.56"// Fjern valutasymbolet og konverter til en flyte
floatVal, feil := strconv. ParseFloat (valutaStr[1:], 64)hvis feil!= null {
fmt. Println (feil)
komme tilbake
}
// Skriv ut den analyserte flyteverdien
fmt. Println (floatVal) // Utgang: 1234,56
}
De valutaStr variabel er en strengrepresentasjon av en valutaverdi med et dollartegn som symbol. Programmet bruker ParseFloat funksjon for å analysere valutastrengen fra det andre elementet (etter valutasymbolet).
Konvensjonelt er det best å unngå å bruke flyter for valutaer, da de kan føre til feilberegninger og feil i produksjonen.
Alternativt kan du bruke en tredjepartspakke som regnskap som har funksjonalitet for formatering og analysering av valutaer.
Kjør denne terminalkommandoen i prosjektkatalogen din for å installere regnskapspakken:
gå til github.com/leekchan/accounting
Begynn med å lage en forekomst av Regnskap struktur. Husk at strukturer er en av Gos kjerneobjektorienterte funksjoner, i likhet med klasser fra andre språk. Du kan initialisere en regnskapsforekomst med et valutasymbol og en presisjonsverdi, blant andre alternativer.
Du kan bruke FormatMoney funksjonen til regnskapspakken for å formatere tall til valutaer.
pakke hoved-import (
"fmt"
"matte/stor""github.com/leekchan/accounting"
)
funchoved-() {
ac := regnskap. Regnskap{Symbol: "$", Presisjon: 2}
fmt. Println (ac. FormatMoney(123456789.213123))
fmt. Println (ac. FormatMoney(12345678))
fmt. Println (ac. FormatMoney (stor. NewRat(77777777, 3)))
fmt. Println (ac. FormatMoney (stor. NewRat(-77777777, 3)))
fmt. Println (ac. FormatMoneyBigFloat (stor. NewFloat(123456789.213123)))
}
De ac variabel er regnskapsinstansen. Dette programmet formaterer og skriver ut pengeverdier ved å bruke FormatMoney og FormatMoneyBigFloat metoder for regnskapsinstansen. De NewRat funksjon fra stor pakken lager et rasjonelt tall gitt en teller og en nevner. De NewFloat funksjonen hjelper med å representere store flyttall.
Go kan hjelpe deg med å formatere andre typer også
Go tilbyr mange funksjoner for å konvertere tall og valutaer på en enkel måte.
Språket tilbyr også et kraftig strengformateringssystem. Fmt-pakkens C-inspirerte Sprintf-funksjon lar deg lage formaterte strenger ved hjelp av en spesiell plassholdersyntaks. Du kan bruke Sprintf til å bygge strenger som inkluderer tall og valutaverdier, noe som gjør det enkelt å lage mennesker lesbare utdata.
