Le formatage correct des nombres peut être une tâche délicate. Et le formatage des devises pose des problèmes supplémentaires liés à la localisation. Heureusement, Go dispose de fonctionnalités pour vous aider.
La bibliothèque standard de Go fournit divers outils pour le formatage des nombres. Le paquet strconv comprend des fonctions permettant d’analyser et de convertir des nombres en chaînes de caractères.
Le paquet strconv
Le site strconv est un outil puissant de conversion entre les nombres et les chaînes de caractères. 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 concepts de base de Go avec lesquels vous devriez être familier. Voici comment vous pouvez l’importer :
import "strconv"
Ce paquetage fournit des fonctions permettant de convertir des nombres en et depuis des chaînes de caractères de différents formats. Il comprend des fonctions permettant de travailler avec des entiers et des nombres à virgule flottante.
strconv peut également gérer la conversion de et vers les formats binaires, octaux et hexadécimaux ainsi que la notation scientifique.
Formatage des nombres entiers en Go
La fonction Itoa fournit une fonctionnalité permettant de convertir des entiers en chaînes de caractères. Le site Itoa prend un nombre entier et renvoie la représentation en chaîne de ce nombre entier.
import (
"fmt"
"strconv"
)
func main() {
integers := 3043
stringVersion := strconv.Itoa(integers)
fmt.Println(stringVersion) // Output: "3043"
}
Ce code convertit une valeur entière en une chaîne de caractères en utilisant la fonction Itoa. Il affiche ensuite la chaîne de caractères résultante sur la console à l’aide de la commande fmt paquet.
En plus de la Itoa strconv fournit une fonction :
- FormatInt pour le formatage des entiers en chaînes de caractères avec une base donnée
- AppendInt pour ajouter des entiers sous forme de chaîne à une tranche d’octets.
Voici comment vous pouvez utiliser la fonction FormatInt Fonction permettant de formater un nombre entier :
import (
"fmt"
"strconv"
)
func main() {
integers := 12345
strings := strconv.FormatInt(int64(integers), 10)
fmt.Println(strings) // Output: "12345"
}
Ce code utilise int64() pour convertir la valeur originale en un nombre entier de 64 bits. Elle transmet ensuite le résultat à FormatIntavec une base de conversion, dans ce cas 10. FormatInt renvoie une chaîne de caractères qui Println puis sort dans la console.
Le site AppendInt prend en compte une tranche d’octet, un fichier int64 et une base.
import (
"fmt"
"strconv"
)
func main() {
integers := 12345
byteSlice := make([]byte, 0, 20)
byteSlice = strconv.AppendInt(byteSlice, int64(integers), 10)
fmt.Println(string(byteSlice)) // Output: "12345"
}
Notez que AppendInt reçoit une tranche d’octets à ajouter, et retourne 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 de la chaîne de caractères résultante du nombre entier.
Analyse syntaxique des chaînes de caractères en tant qu’entiers
Le site Atoi La fonction Atoi convertit les chaînes de caractères en nombres entiers. Elle prend une chaîne en entrée et renvoie une représentation entière de cette chaîne ainsi qu’un type d’erreur.
Voici comment vous pouvez utiliser la fonction Atoi Fonction pour la conversion des chaînes de caractères en nombres entiers :
import (
"fmt"
"strconv"
)
func main() {
strings := "123"
integers, err := strconv.Atoi(strings)
if err != nil {
fmt.Println(err)
}
fmt.Println(integers)
}
Le programme sort la valeur entière sur la console :
Vous pouvez également utiliser la fonction ParseUint Fonction permettant d’analyser la représentation en chaîne des entiers non signés.
package main
import (
"fmt"
"strconv"
)
func main() {
// parse string as base 10 and 0-bit unsigned integer
val, err := strconv.ParseUint("12345", 10, 0)
if err != nil {
fmt.Println(err)
} else {
fmt.Println(val) // Output: 12345
}
}
Le site ParseUint La fonction ParseUint analyse la chaîne 12345 comme un entier non signé en base dix. La taille de 0 bit garantit qu’elle renvoie un type int standard. Elle renvoie la valeur analysée et une erreur.
Vous pouvez utiliser la fonction ParseFloat Fonction permettant d’analyser la représentation en chaîne d’un nombre à virgule flottante.
import (
"fmt"
"strconv"
)
func main() {
// parse string as 64-bit floating-point number
val, err := strconv.ParseFloat("3.14", 64)
if err != nil {
fmt.Println(err)
} else {
fmt.Println(val) // Output: 3.14
}
}
Le site ParseFloat analyse la chaîne de caractères comme un nombre à virgule flottante de 64 bits et renvoie la chaîne de caractères et un type d’erreur.
Formatage des devises en Go
Construire une application qui interagit avec des devises nécessite le formatage et l’analyse des nombres. Travailler avec des devises différentes peut être un défi, mais la strconv et comptabilité peuvent vous aider à les mettre en forme.
Voici comment analyser une chaîne de devise en un flottant pour les opérations sur la devise :
import (
"fmt"
"strconv"
)
func main() {
// Currency string to parse
currencyStr := "$1,234.56"
// Remove the currency symbol and convert to a float
floatVal, err := strconv.ParseFloat(currencyStr[1:], 64)
if err != nil {
fmt.Println(err)
return
}
// Print the parsed float value
fmt.Println(floatVal) // Output: 1234.56
}
Le site currencyStr est une représentation sous forme de chaîne de caractères d’une valeur monétaire dont le symbole est le signe du dollar. Le programme utilise la variable ParseFloat Fonction permettant d’analyser la chaîne de devises à partir du deuxième élément (après le symbole de la devise).
Par convention, il est préférable d’éviter d’utiliser des flottants pour les devises, car ils peuvent entraîner des erreurs de calcul et des bogues en production.
Alternativement, vous pouvez utiliser un paquet tiers tel que comptabilité qui dispose d’une fonctionnalité de formatage et d’analyse des devises.
Exécutez cette commande en terminal dans le répertoire de votre projet pour installer le package de comptabilité :
go get github.com/leekchan/accounting
Commencez par créer une instance du module Comptabilité struct. Rappelez-vous que les structures sont l’une des principales caractéristiques orientées objet de Go, similaires aux classes d’autres langages. Vous pouvez initialiser une instance de Comptabilité avec un symbole monétaire et une valeur de précision, entre autres options.
Vous pouvez utiliser la fonction FormatMoney Fonction du logiciel de comptabilité permettant de formater les chiffres en devises.
package main
import (
"fmt"
"math/big"
"github.com/leekchan/accounting"
)
func main() {
ac := accounting.Accounting{Symbol: "$", Precision: 2}
fmt.Println(ac.FormatMoney(123456789.213123))
fmt.Println(ac.FormatMoney(12345678))
fmt.Println(ac.FormatMoney(big.NewRat(77777777, 3)))
fmt.Println(ac.FormatMoney(big.NewRat(-77777777, 3)))
fmt.Println(ac.FormatMoneyBigFloat(big.NewFloat(123456789.213123)))
}
Le site ac La variable est l’instance de comptabilité. Ce programme met en forme et imprime des valeurs monétaires en utilisant la fonction FormatMoney et FormatMoneyBigFloat de l’instance comptable. L’adresse NewRat de la fonction grand Le paquet crée un nombre rationnel à partir d’un numérateur et d’un dénominateur. Le site NewFloat permet de représenter les grands nombres à virgule flottante.
Go peut vous aider à formater d’autres types également
Go fournit de nombreuses fonctions pour convertir les nombres et les devises de manière simple.
Le langage offre également un puissant système de formatage des chaînes de caractères. La fonction Sprintf du paquet fmt, inspirée du langage C, vous permet de créer des chaînes de caractères formatées à l’aide d’une syntaxe spéciale de caractères de remplacement. Vous pouvez utiliser Sprintf pour construire des chaînes incluant des chiffres et des valeurs monétaires, ce qui facilite la création de résultats lisibles par l’homme.