Formatarea corectă a numerelor poate fi o sarcină dificilă. Iar formatarea monedelor aduce provocări suplimentare care implică localizarea. Din fericire, Go are funcții de ajutor.
Biblioteca standard Go oferă diverse instrumente pentru formatarea numerelor. Pachetul strconv include funcții pentru analizarea și conversia numerelor în și din șiruri.
Pachetul strconv
The strconv pachetul este un instrument puternic pentru conversia între numere și șiruri. Îl puteți folosi pentru a lucra cu numere în diferite formate.
strconv face parte din biblioteca standard, deci este relevant pentru multe dintre ele conceptele de bază Go cu care ar trebui să fii familiarizat. Iată cum îl puteți importa:
import"strconv"
Pachetul oferă funcții pentru conversia numerelor în și din șiruri în diferite formate. Include funcții pentru a lucra cu numere întregi și numere în virgulă mobilă.
strconv poate gestiona, de asemenea, conversia în și din formate binar, octal și hexazecimal, precum și notația științifică.
Formatarea numerelor întregi în Go
Pachetul strconv Itoa funcția oferă funcționalitate pentru conversia numerelor întregi în șiruri. The Itoa funcția ia un număr întreg și returnează reprezentarea șirului acelui întreg.
import (
"fmt"
"strconv"
)
funcprincipal() {
numere întregi := 3043
stringVersion := strconv. Itoa (numere întregi)
fmt. Println (stringVersion) // Ieșire: "3043"
}
Acest cod convertește o valoare întreagă într-un șir folosind Itoa. Apoi trimite șirul rezultat în consolă folosind fmt pachet.
În plus față de Itoa funcția, strconv oferă:
- FormatInt pentru formatarea numerelor întregi ca șiruri cu o bază dată
- AppendInt pentru adăugarea numerelor întregi sub formă de șir la o porțiune de octeți.
Iată cum puteți utiliza FormatInt funcția de formatare a unui număr întreg:
import (
"fmt"
"strconv"
)
funcprincipal() {
numere întregi := 12345
șiruri de caractere := strconv. FormatInt(int64(numere întregi), 10)
fmt. Println (șiruri) // Ieșire: "12345"
}
Acest cod folosește int64() pentru a converti valoarea inițială într-un număr întreg de 64 de biți. Apoi trece rezultatul la FormatInt, împreună cu o bază pentru conversie, în acest caz 10. FormatInt returnează un șir care Println apoi iese la consolă.
The AppendInt funcția preia o porțiune de octeți, an int64 valoare și o bază.
import (
"fmt"
"strconv"
)
funcprincipal() {
numere întregi := 12345
byteSlice := face([]octet, 0, 20)
byteSlice = strconv. AppendInt (byteSlice, int64(numere întregi), 10)
fmt. Println(şir(byteSlice)) // Ieșire: "12345"
}
Rețineți că AppendInt primește o porțiune de octeți la care să o adăugați și returnează porțiunea de octeți rezultată. În acest caz, porțiunea inițială de octeți este goală, dar are o capacitate de 20 pentru a stoca reprezentarea șirului rezultat al întregului.
Analizarea șirurilor de caractere ca numere întregi
The Atoi funcția convertește șiruri de caractere în numere întregi. Preia un șir ca intrare și returnează o reprezentare întreagă a acelui șir împreună cu un tip de eroare.
Iată cum puteți utiliza Atoi funcție pentru conversia șir în întreg:
import (
"fmt"
"strconv"
)funcprincipal() {
șiruri := "123"
numere întregi, err := strconv. Atoi (coarde)dacă greș!= zero {
fmt. Println (eroare)
}
fmt. Println (numere întregi)
}
Programul trimite valoarea întreagă în consolă:
De asemenea, puteți utiliza ParseUint funcția pentru a analiza reprezentarea șirului de numere întregi fără semn.
pachet principalimport (
"fmt"
"strconv"
)funcprincipal() {
// analizează șirul ca întreg de bază 10 și 0 biți fără semn
val, err := strconv. ParseUint("12345", 10, 0)
dacă greș!= zero {
fmt. Println (eroare)
} altfel {
fmt. Println (val) // Ieșire: 12345
}
}
The ParseUint funcția parsează șirul 12345 ca un număr întreg fără semn de bază. Dimensiunea de 0 biți asigură că returnează un tip int standard. Returnează valoarea analizată și o eroare.
Puteți folosi ParseFloat funcție pentru a analiza o reprezentare șir a unui număr în virgulă mobilă.
import (
"fmt"
"strconv"
)funcprincipal() {
// analizează șirul ca număr în virgulă mobilă pe 64 de biți
val, err := strconv. ParseFloat("3.14", 64)
dacă greș!= zero {
fmt. Println (eroare)
} altfel {
fmt. Println (val) // Ieșire: 3.14
}
}
The ParseFloat funcția parsează șirul ca un număr în virgulă mobilă de 64 de biți și returnează șirul și un tip de eroare.
Formatarea monedelor în Go
Crearea unei aplicații care interacționează cu monedele necesită formatarea și analizarea numerelor. Lucrul cu diferite valute poate fi o provocare, dar strconv și contabilitate pachetele vă pot ajuta să le formatați.
Iată cum puteți analiza un șir de monedă într-un float pentru operațiuni pe monedă:
import (
"fmt"
"strconv"
)funcprincipal() {
// Șir de monedă de analizat
currencyStr := "$1,234.56"// Eliminați simbolul valutar și convertiți-l într-un float
floatVal, err := strconv. ParseFloat (currencyStr[1:], 64)dacă greș!= zero {
fmt. Println (eroare)
întoarcere
}
// Imprimă valoarea flotantă analizată
fmt. Println (floatVal) // Ieșire: 1234,56
}
The currencyStr variabila este o reprezentare în șir a unei monede cu semnul dolar ca simbol. Programul folosește ParseFloat funcția de analiză a șirului de monedă pornind de la al doilea element (după simbolul monedei).
În mod convențional, cel mai bine este să evitați utilizarea floaturilor pentru monede, deoarece acestea pot duce la calcule greșite și erori în producție.
Alternativ, puteți utiliza un pachet terță parte, cum ar fi contabilitate care are funcționalitate pentru formatarea și analizarea monedelor.
Rulați această comandă de terminal în directorul de proiect pentru a instala pachetul de contabilitate:
du-te la github.com/leekchan/accounting
Începeți prin a crea o instanță a Contabilitate struct. Amintiți-vă că structurile sunt una dintre Funcțiile principale ale Go, orientate pe obiecte, similar cu clasele din alte limbi. Puteți inițializa o instanță de contabilitate cu un simbol valutar și o valoare de precizie, printre alte opțiuni.
Puteți folosi FormatBani funcția pachetului contabil de a formata numerele în monede.
pachet principalimport (
"fmt"
"matematic/mare"„github.com/leekchan/accounting”
)
funcprincipal() {
ac := contabilitate. Contabilitate{Simbol: "$", Precizie: 2}
fmt. Println (ac. FormatBani(123456789.213123))
fmt. Println (ac. FormatBani(12345678))
fmt. Println (ac. FormatBani (mare. NewRat(77777777, 3)))
fmt. Println (ac. FormatBani (mare. NewRat(-77777777, 3)))
fmt. Println (ac. FormatMoneyBigFloat (mare. NewFloat(123456789.213123)))
}
The ac variabila este instanța contabilă. Acest program formatează și imprimă valori monetare folosind FormatBani și Format MoneyBigFloat metode ale instanţei contabile. The NewRat funcția de la mare pachetul creează un număr rațional dat de un numărător și numitor. The NewFloat funcția ajută la reprezentarea numerelor mari în virgulă mobilă.
Go vă poate ajuta să formatați și alte tipuri
Go oferă o mulțime de funcții pentru a converti numere și monede într-un mod simplu.
Limbajul oferă, de asemenea, un sistem puternic de formatare a șirurilor. Funcția Sprintf inspirată de C a pachetului fmt vă permite să creați șiruri formatate folosind o sintaxă specială de substituent. Puteți utiliza Sprintf pentru a construi șiruri care includ numere și valori valutare, ceea ce face ușoară crearea rezultatelor care pot fi citite de om.
