Le formatage correct des nombres peut être une tâche délicate. Et le formatage des devises apporte des défis supplémentaires impliquant la localisation. Heureusement, Go a des fonctionnalités pour vous aider.
La bibliothèque standard Go fournit divers outils pour formater les nombres. Le package strconv inclut des fonctions d'analyse et de conversion de nombres vers et depuis des chaînes.
Le paquet strconv
Le strconv package est un outil puissant pour la conversion entre les nombres et les chaînes. Vous pouvez l'utiliser pour travailler avec des nombres dans différents formats.
strconv fait partie de la bibliothèque standard, il est donc pertinent pour la plupart des les concepts de base de Go que vous devez connaître. Voici comment vous pouvez l'importer :
importer"strconv"
Le package fournit des fonctions pour convertir des nombres vers et à partir de chaînes dans différents formats. Il inclut des fonctions pour travailler avec des nombres entiers et des nombres à virgule flottante.
strconv peut également gérer la conversion vers et depuis les formats binaires, octaux et hexadécimaux ainsi que la notation scientifique.
Formatage des entiers en Go
Le paquet strconv Itoa La fonction fournit des fonctionnalités pour convertir des entiers en chaînes. Le Itoa La fonction prend un entier et renvoie la représentation sous forme de chaîne de cet entier.
importer (
"fmt"
"strconv"
)
fonctionprincipal() {
entiers := 3043
stringVersion := strconv. Itoa (entiers)
fmt. Println (chaîneVersion) // Sortie: "3043"
}
Ce code convertit une valeur entière en une chaîne en utilisant Itoa. Il envoie ensuite la chaîne résultante à la console en utilisant le fmt emballer.
En plus de Itoa fonction, strconv fournit :
- FormatEntier pour formater des entiers sous forme de chaînes avec une base donnée
- AppendInt pour ajouter des entiers sous forme de chaîne à une tranche d'octets.
Voici comment vous pouvez utiliser le FormatEntier fonction pour formater un entier :
importer (
"fmt"
"strconv"
)
fonctionprincipal() {
entiers := 12345
chaînes := strconv. EntierFormat(int64(entiers), 10)
fmt. Println (chaînes) // Sortie: "12345"
}
Ce code utilise int64() pour convertir la valeur d'origine en un entier 64 bits. Il transmet ensuite le résultat à FormatEntier, ainsi qu'une base de conversion, dans ce cas 10. FormatInt renvoie une chaîne qui Imprimerln puis sorties vers la console.
Le AppendInt fonction prend dans une tranche d'octet, un int64 valeur et une base.
importer (
"fmt"
"strconv"
)
fonctionprincipal() {
entiers := 12345
byteSlice := faire([]octet, 0, 20)
byteSlice = strconv. AppendInt (byteSlice, int64(entiers), 10)
fmt. Imprimerln(chaîne(byteSlice)) // Sortie: "12345"
}
Notez que AppendInt reçoit une tranche d'octets à ajouter et renvoie la tranche d'octets résultante. Dans ce cas, la tranche d'octets initiale est vide, mais a une capacité de 20 pour stocker la représentation sous forme de chaîne résultante de l'entier.
Analyser des chaînes en tant qu'entiers
Le Atoi La fonction convertit les chaînes en nombres entiers. Il prend une chaîne en entrée et renvoie une représentation entière de cette chaîne avec un type d'erreur.
Voici comment vous pouvez utiliser le Atoi fonction de conversion chaîne-entier :
importer (
"fmt"
"strconv"
)fonctionprincipal() {
chaînes := "123"
entiers, err := strconv. Atoi (cordes)si erreur != néant {
fmt. Println (erreur)
}
fmt. Println (entiers)
}
Le programme affiche la valeur entière sur la console :
Vous pouvez également utiliser le ParseUint fonction pour analyser la représentation sous forme de chaîne d'entiers non signés.
emballer principalimporter (
"fmt"
"strconv"
)fonctionprincipal() {
// analyse la chaîne en tant qu'entier non signé de base 10 et 0 bit
val, err := strconv. ParseUint("12345", 10, 0)
si erreur != néant {
fmt. Println (erreur)
} autre {
fmt. Imprimerln (val) // Sortie: 12345
}
}
Le ParseUint La fonction analyse la chaîne 12345 comme un entier non signé en base dix. La taille de 0 bit garantit qu'il renvoie un type int standard. Il renvoie la valeur analysée et une erreur.
Vous pouvez utiliser le ParseFloat fonction pour analyser une représentation sous forme de chaîne d'un nombre à virgule flottante.
importer (
"fmt"
"strconv"
)fonctionprincipal() {
// analyse la chaîne comme un nombre à virgule flottante 64 bits
val, err := strconv. ParseFloat("3.14", 64)
si erreur != néant {
fmt. Println (erreur)
} autre {
fmt. Imprimerln (val) // Sortie: 3.14
}
}
Le ParseFloat La fonction analyse la chaîne comme un nombre à virgule flottante 64 bits et renvoie la chaîne et un type d'erreur.
Formatage des devises en Go
La création d'une application qui interagit avec les devises nécessite le formatage et l'analyse des nombres. Travailler avec différentes devises peut être un défi, mais le strconv et comptabilité packages peuvent vous aider à les formater.
Voici comment vous pouvez analyser une chaîne de devise en un flottant pour les opérations sur la devise :
importer (
"fmt"
"strconv"
)fonctionprincipal() {
// Chaîne de devise à analyser
deviseStr := "$1,234.56"// Supprime le symbole monétaire et convertit en flottant
floatVal, erreur := strconv. ParseFloat (currencyStr[1:], 64)si erreur != néant {
fmt. Println (erreur)
retour
}
// Affiche la valeur flottante analysée
fmt. Println (floatVal) // Sortie: 1234.56
}
Le deviseStr variable est une représentation sous forme de chaîne d'une valeur monétaire avec un signe dollar comme symbole. Le programme utilise le ParseFloat fonction pour analyser la chaîne monétaire à partir du deuxième élément (après le symbole monétaire).
Classiquement, il est préférable d'éviter d'utiliser des flotteurs pour les devises car ils peuvent entraîner des erreurs de calcul et des bogues dans la production.
Alternativement, vous pouvez utiliser un package tiers comme comptabilité qui a des fonctionnalités pour le formatage et l'analyse des devises.
Exécutez cette commande de terminal dans le répertoire de votre projet pour installer le package de comptabilité :
allez sur github.com/leekchan/accounting
Commencez par créer une instance de Comptabilité structure. Rappelez-vous que les structures sont l'une des Principales fonctionnalités orientées objet de Go, similaire aux classes d'autres langues. Vous pouvez initialiser une instance de comptabilité avec un symbole monétaire et une valeur de précision, entre autres options.
Vous pouvez utiliser le FormatArgent fonction du progiciel comptable pour formater les nombres en devises.
emballer principalimporter (
"fmt"
"mathématiques/grand""github.com/leekchan/accounting"
)
fonctionprincipal() {
ac := comptabilité. Comptabilité{Symbole: "$", Précision: 2}
fmt. Printin (ac. FormatMoney(123456789.213123))
fmt. Printin (ac. FormatMoney(12345678))
fmt. Printin (ac. FormatMoney (gros. NouveauRat(77777777, 3)))
fmt. Printin (ac. FormatMoney (gros. NouveauRat(-77777777, 3)))
fmt. Printin (ac. FormatMoneyBigFloat (gros. NouveauFlottant(123456789.213123)))
}
Le courant alternatif variable est l'instance comptable. Ce programme formate et imprime les valeurs monétaires en utilisant le FormatArgent et FormatMoneyBigFlotteur méthodes de l'instance comptable. Le NouveauRat fonction de la grand package crée un nombre rationnel donné un numérateur et un dénominateur. Le NouveauFlottant La fonction permet de représenter de grands nombres à virgule flottante.
Go peut également vous aider à formater d'autres types
Go fournit de nombreuses fonctions pour convertir des nombres et des devises de manière simple.
Le langage offre également un puissant système de formatage de chaînes. La fonction Sprintf inspirée du C du package fmt vous permet de créer des chaînes formatées à l'aide d'une syntaxe d'espace réservé spéciale. Vous pouvez utiliser Sprintf pour créer des chaînes qui incluent des nombres et des valeurs monétaires, ce qui facilite la création d'une sortie lisible par l'homme.
