Att formatera siffror korrekt kan vara en knepig uppgift. Och formatering av valutor medför ytterligare utmaningar som involverar lokalisering. Lyckligtvis har Go funktioner som hjälper.
Go-standardbiblioteket tillhandahåller olika verktyg för att formatera siffror. Paketet strconv innehåller funktioner för att analysera och konvertera tal till och från strängar.
Strconv-paketet
De strconv paket är ett kraftfullt verktyg för att konvertera mellan tal och strängar. Du kan använda den för att arbeta med siffror i olika format.
strconv är en del av standardbiblioteket, så det är relevant för många av de grundläggande Go-koncept som du bör känna till. Så här importerar du det:
importera"strconv"
Paketet innehåller funktioner för att konvertera tal till och från strängar i olika format. Den innehåller funktioner för att arbeta med heltal och flyttal.
strconv kan också hantera konvertering till och från binära, oktala och hexadecimala format samt vetenskaplig notation.
Formatera heltal i Go
Strconv-paketet Itoa funktion ger funktionalitet för att konvertera heltal till strängar. De Itoa funktion tar ett heltal och returnerar strängrepresentationen av det heltal.
importera (
"fmt"
"strconv"
)
funchuvud() {
heltal := 3043
stringVersion := strconv. Itoa (heltal)
fmt. Println (stringVersion) // Utdata: "3043"
}
Denna kod konverterar ett heltalsvärde till en sträng med hjälp av Itoa. Den matar sedan ut den resulterande strängen till konsolen med hjälp av fmt paket.
Utöver Itoa funktion, strconv ger:
- FormatInt för att formatera heltal som strängar med en given bas
- AppendInt för att lägga till heltal i strängform till en bit av byte.
Så här kan du använda FormatInt funktion för att formatera ett heltal:
importera (
"fmt"
"strconv"
)
funchuvud() {
heltal := 12345
strängar := strconv. FormatInt(int64(heltal), 10)
fmt. Println (strängar) // Utdata: "12345"
}
Denna kod använder int64() för att konvertera det ursprungliga värdet till ett 64-bitars heltal. Det skickar sedan resultatet till FormatInt, tillsammans med en bas för konvertering, i detta fall 10. FormatInt returnerar en sträng som Println matas sedan ut till konsolen.
De AppendInt funktion tar in ett bytesnitt, en int64 värde och en bas.
importera (
"fmt"
"strconv"
)
funchuvud() {
heltal := 12345
byteSlice := göra([]byte, 0, 20)
byteSlice = strconv. AppendInt (byteSlice, int64(heltal), 10)
fmt. Println(sträng(byteSlice)) // Utdata: "12345"
}
Observera att AppendInt tar emot ett bytesegment att lägga till och returnerar det resulterande bytesegmentet. I det här fallet är den initiala byte-delen tom, men har en kapacitet på 20 för att lagra den resulterande strängrepresentationen av heltal.
Analysera strängar som heltal
De Atoi funktion konverterar strängar till heltal. Den tar in en sträng som indata och returnerar en heltalsrepresentation av den strängen tillsammans med en feltyp.
Så här kan du använda Atoi funktion för sträng-till-heltalskonvertering:
importera (
"fmt"
"strconv"
)funchuvud() {
strängar := "123"
heltal, err := strconv. Atoi (strängar)om fel!= noll {
fmt. Println (fel)
}
fmt. Println (heltal)
}
Programmet matar ut heltalsvärdet till konsolen:
Du kan också använda ParseUint funktion för att analysera strängrepresentationen av heltal utan tecken.
paket huvudimportera (
"fmt"
"strconv"
)funchuvud() {
// analysera sträng som bas 10 och 0-bitars heltal utan tecken
val, fel := strconv. ParseUint("12345", 10, 0)
om fel!= noll {
fmt. Println (fel)
} annan {
fmt. Println (val) // Utgång: 12345
}
}
De ParseUint funktion tolkar 12345-strängen som en bas tio, heltal utan tecken. 0-bitars storlek säkerställer att den returnerar en standard int-typ. Den returnerar det analyserade värdet och ett fel.
Du kan använda ParseFloat funktion för att analysera en strängrepresentation av ett flyttal.
importera (
"fmt"
"strconv"
)funchuvud() {
// analysera sträng som 64-bitars flyttal
val, fel := strconv. ParseFloat("3.14", 64)
om fel!= noll {
fmt. Println (fel)
} annan {
fmt. Println (val) // Utgång: 3,14
}
}
De ParseFloat funktionen analyserar strängen som ett 64-bitars flyttal och returnerar strängen och en feltyp.
Formatera valutor i Go
Att bygga ett program som interagerar med valutor kräver sifferformatering och analys. Att arbeta med olika valutor kan vara en utmaning, men strconv och bokföring paket kan hjälpa dig att formatera dem.
Så här kan du analysera en valutasträng till en flytande för operationer på valutan:
importera (
"fmt"
"strconv"
)funchuvud() {
// Valutasträng att analysera
valutaStr := "$1,234.56"// Ta bort valutasymbolen och konvertera till en flytande
floatVal, err := strconv. ParseFloat (currencyStr[1:], 64)om fel!= noll {
fmt. Println (fel)
lämna tillbaka
}
// Skriv ut det analyserade flytvärdet
fmt. Println (floatVal) // Utgång: 1234,56
}
De valutaStr variabel är en strängrepresentation av ett valutavärde med ett dollartecken som symbol. Programmet använder ParseFloat funktion för att analysera valutasträngen med början från det andra elementet (efter valutasymbolen).
Konventionellt är det bäst att undvika att använda flytande valutor eftersom de kan leda till felberäkningar och buggar i produktionen.
Alternativt kan du använda ett tredjepartspaket som bokföring som har funktionalitet för formatering och analys av valutor.
Kör det här terminalkommandot i din projektkatalog för att installera bokföringspaketet:
gå till github.com/leekchan/accounting
Börja med att skapa en instans av Bokföring struktur. Kom ihåg att strukturer är en av Gos kärnobjektorienterade funktioner, liknande klasser från andra språk. Du kan initiera en redovisningsinstans med en valutasymbol och ett precisionsvärde, bland andra alternativ.
Du kan använda FormatMoney bokföringspaketets funktion för att formatera siffror till valutor.
paket huvudimportera (
"fmt"
"matte/stor""github.com/leekchan/accounting"
)
funchuvud() {
ac := bokföring. Bokföring{Symbol: "$", Precision: 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 (big. NewFloat(123456789.213123)))
}
De ac variabel är redovisningsinstansen. Detta program formaterar och skriver ut monetära värden med hjälp av FormatMoney och FormatMoneyBigFloat redovisningsinstansens metoder. De NewRat funktion från stor paket skapar ett rationellt tal givet en täljare och nämnare. De NewFloat funktionen hjälper till att representera stora flyttal.
Go kan hjälpa dig att formatera andra typer också
Go erbjuder massor av funktioner för att konvertera siffror och valutor på ett enkelt sätt.
Språket erbjuder också ett kraftfullt strängformateringssystem. Fmt-paketets C-inspirerade Sprintf-funktion låter dig skapa formaterade strängar med hjälp av en speciell platshållarsyntax. Du kan använda Sprintf för att bygga strängar som inkluderar siffror och valutavärden, vilket gör det enkelt att skapa läsbar utdata.
