Det kan være en vanskelig opgave at formatere tal korrekt. Og formatering af valutaer medfører yderligere udfordringer, der involverer lokalisering. Heldigvis har Go funktioner til at hjælpe.
Go-standardbiblioteket indeholder forskellige værktøjer til formatering af tal. Strconv-pakken indeholder funktioner til at parse og konvertere tal til og fra strenge.
Strconv-pakken
Det strconv pakke er et kraftfuldt værktøj til at konvertere mellem tal og strenge. Du kan bruge den til at arbejde med tal i forskellige formater.
strconv er en del af standardbiblioteket, så det er relevant for mange af de grundlæggende Go-koncepter, du bør være bekendt med. Sådan importerer du det:
importere"strconv"
Pakken indeholder funktioner til at konvertere tal til og fra strenge i forskellige formater. Den indeholder funktioner til at arbejde med heltal og flydende kommatal.
strconv kan også håndtere konvertering til og fra binære, oktale og hexadecimale formater samt videnskabelig notation.
Formatering af heltal i Go
strconv-pakkens Itoa funktion giver funktionalitet til at konvertere heltal til strenge. Det Itoa funktion tager et heltal og returnerer strengrepræsentationen af dette heltal.
importere (
"fmt"
"strconv"
)
funcvigtigste() {
heltal := 3043
stringVersion := strconv. Itoa (heltal)
fmt. Println (stringVersion) // Output: "3043"
}
Denne kode konverterer en heltalsværdi til en streng ved hjælp af Itoa. Den udsender derefter den resulterende streng til konsollen ved hjælp af fmt pakke.
Ud over Itoa funktion, strconv giver:
- FormatInt til formatering af heltal som strenge med en given base
- AppendInt til at tilføje heltal i strengform til et udsnit af bytes.
Her er, hvordan du kan bruge FormatInt funktion til at formatere et heltal:
importere (
"fmt"
"strconv"
)
funcvigtigste() {
heltal := 12345
strenge := strconv. FormatInt(int64(heltal), 10)
fmt. Println (strenge) // Output: "12345"
}
Denne kode bruger int64() at konvertere den oprindelige værdi til et 64-bit heltal. Det sender så resultatet videre til FormatInt, sammen med et grundlag for konvertering, i dette tilfælde 10. FormatInt returnerer en streng, som Udskrivln derefter udgang til konsollen.
Det AppendInt funktion indtager en byte skive, en int64 værdi og en base.
importere (
"fmt"
"strconv"
)
funcvigtigste() {
heltal := 12345
byteSlice := lave([]byte, 0, 20)
byteSlice = strconv. AppendInt (byteSlice, int64(heltal), 10)
fmt. Println(snor(byteSlice)) // Output: "12345"
}
Bemærk, at AppendInt modtager et byteudsnit, der skal tilføjes, og returnerer det resulterende byteudsnit. I dette tilfælde er den indledende byte skive tom, men har en kapacitet på 20 til at lagre den resulterende strengrepræsentation af heltal.
Parsing af strenge som heltal
Det Atoi funktion konverterer strenge til heltal. Den tager en streng ind som input og returnerer en heltalsrepræsentation af denne streng sammen med en fejltype.
Her er, hvordan du kan bruge Atoi funktion til streng-til-heltal konvertering:
importere (
"fmt"
"strconv"
)funcvigtigste() {
strenge := "123"
heltal, fejl := strconv. Atoi (strenge)hvis fejl!= nul {
fmt. Println (fejl)
}
fmt. Println (heltal)
}
Programmet udsender heltalsværdien til konsollen:
Du kan også bruge ParseUint funktion til at parse strengrepræsentationen af heltal uden fortegn.
pakke vigtigsteimportere (
"fmt"
"strconv"
)funcvigtigste() {
// parse streng som base 10 og 0-bit heltal uden fortegn
val, fejl := strconv. ParseUint("12345", 10, 0)
hvis fejl!= nul {
fmt. Println (fejl)
} andet {
fmt. Println (val) // Output: 12345
}
}
Det ParseUint funktionen analyserer 12345-strengen som en basis ti, heltal uden fortegn. 0-bit-størrelsen sikrer, at den returnerer en standard int-type. Det returnerer den analyserede værdi og en fejl.
Du kan bruge ParseFloat funktion til at parse en strengrepræsentation af et flydende kommatal.
importere (
"fmt"
"strconv"
)funcvigtigste() {
// parse streng som 64-bit flydende kommatal
val, fejl := strconv. ParseFloat("3.14", 64)
hvis fejl!= nul {
fmt. Println (fejl)
} andet {
fmt. Println (val) // Output: 3,14
}
}
Det ParseFloat funktion parser strengen som et 64-bit flydende kommatal og returnerer strengen og en fejltype.
Formatering af valutaer i Go
Opbygning af en applikation, der interagerer med valutaer, kræver talformatering og parsing. At arbejde med forskellige valutaer kan være en udfordring, men det strconv og regnskab pakker kan hjælpe dig med at formatere dem.
Sådan kan du parse en valutastreng til en float for operationer på valutaen:
importere (
"fmt"
"strconv"
)funcvigtigste() {
// Valutastreng at parse
valutaStr := "$1,234.56"// Fjern valutasymbolet og konverter til en float
floatVal, err := strconv. ParseFloat (currencyStr[1:], 64)hvis fejl!= nul {
fmt. Println (fejl)
Vend tilbage
}
// Udskriv den parsede flydende værdi
fmt. Println (floatVal) // Output: 1234,56
}
Det valutaStr variabel er en strengrepræsentation af en valutaværdi med et dollartegn som symbol. Programmet bruger ParseFloat funktion til at parse valutastrengen fra det andet element (efter valutasymbolet).
Konventionelt er det bedst at undgå at bruge floats til valutaer, da de kan resultere i fejlberegninger og fejl i produktionen.
Alternativt kan du bruge en tredjepartspakke som f.eks regnskab som har funktionalitet til formatering og parsing af valutaer.
Kør denne terminalkommando i dit projektbibliotek for at installere regnskabspakken:
gå til github.com/leekchan/accounting
Begynd med at oprette en forekomst af Regnskab struktur. Husk at strukturer er en af Go's kerne objektorienterede funktioner, svarende til klasser fra andre sprog. Du kan initialisere en regnskabsinstans med et valutasymbol og en præcisionsværdi blandt andre muligheder.
Du kan bruge FormatPenge funktion af regnskabspakken til at formatere tal til valutaer.
pakke vigtigsteimportere (
"fmt"
"matematik/stor""github.com/leekchan/accounting"
)
funcvigtigste() {
ac := regnskab. Regnskab{Symbol: "$", Præcision: 2}
fmt. Println (ac. FormatPenge(123456789.213123))
fmt. Println (ac. FormatPenge(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)))
}
Det ac variabel er den regnskabsmæssige instans. Dette program formaterer og udskriver pengeværdier ved hjælp af FormatPenge og FormatMoneyBigFloat regnskabsinstansens metoder. Det NewRat funktion fra stor pakke opretter et rationelt tal givet en tæller og en nævner. Det NewFloat funktion hjælper med at repræsentere store flydende decimaltal.
Go kan også hjælpe dig med at formatere andre typer
Go giver masser af funktioner til at konvertere tal og valutaer på en ligetil måde.
Sproget tilbyder også et kraftfuldt strengformateringssystem. Fmt-pakkens C-inspirerede Sprintf-funktion lader dig oprette formaterede strenge ved hjælp af en speciel pladsholdersyntaks. Du kan bruge Sprintf til at bygge strenge, der inkluderer tal og valutaværdier, hvilket gør det nemt at skabe et menneskeligt læsbart output.
