Formatage des nombres et des devises avec Go

La conversion entre nombres et chaînes est une tâche courante, vous gagnerez donc beaucoup de temps et réduisez les bugs si vous êtes familier avec ces techniques.

Formater correctement les nombres peut être une tâche délicate. Et le formatage des devises entraîne des défis supplémentaires en matière de localisation. Heureusement, Go propose des fonctionnalités pour vous aider.

La bibliothèque standard Go fournit divers outils pour formater les nombres. Le package strconv comprend des fonctions d'analyse et de conversion de nombres vers et depuis des chaînes.

Le paquet strconv

Le package strconv est un outil puissant pour la conversion entre nombres et 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 de nombreux concepts de base de Go que vous devriez connaître. Voici comment vous pouvez l’importer :

import "strconv"

Le package fournit des fonctions pour convertir des nombres vers et depuis des chaînes dans différents formats. Il comprend des fonctions permettant de 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 dans Go

La fonction Itoa du package strconv fournit des fonctionnalités permettant de convertir des entiers en chaînes. La fonction Itoa prend un entier et renvoie la représentation sous forme de chaîne de cet 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 chaîne à l'aide de Itoa. Il affiche ensuite la chaîne résultante sur la console à l'aide du package fmt.

En plus de la fonction Itoa, strconv fournit :

FormatInt 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 utiliser la fonction FormatInt pour formater un 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 d'origine en un entier de 64 bits. Il transmet ensuite le résultat à FormatInt, ainsi qu'une base de conversion, dans ce cas 10. FormatInt renvoie une chaîne que Println envoie ensuite à la console.

La fonction AppendInt prend une tranche d'octets, une valeur 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 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 sous forme d'entiers

La fonction Atoi convertit les chaînes en entiers. Il 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 utiliser la fonction Atoi pour la conversion de chaîne en entier :

import (
    "fmt"
    "strconv"
)
func main() {
    strings := "123"
    integers, err := strconv.Atoi(strings)
    if err != nil {
        fmt.Println(err)
    }
    fmt.Println(integers) 
}

Le programme affiche la valeur entière sur la console :

Vous pouvez également utiliser la fonction ParseUint pour analyser la représentation sous forme de chaîne d'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
    }
}

La fonction ParseUint 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 la fonction ParseFloat pour analyser une représentation sous forme de 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
    }
}

La fonction ParseFloat analyse la chaîne comme un nombre à virgule flottante de 64 bits et renvoie la chaîne ainsi qu'un type d'erreur.

Formatage des devises dans Go

Créer 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 les packages strconv et accounting peuvent vous aider à les formater.

Voici comment analyser une chaîne de devise en 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
}

La variable currencyStr est une représentation sous forme de chaîne d'une valeur monétaire avec un signe dollar comme symbole. Le programme utilise la fonction ParseFloat pour analyser la chaîne monétaire à partir du deuxième élément (après le symbole monétaire).

Conventionnellement, 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 bugs en production.

Vous pouvez également utiliser un package tiers tel que comptabilité qui possède des fonctionnalités de formatage et d'analyse des devises.

Exécutez cette commande de 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 de la structure Accounting. Rappelez-vous que les structures sont l’une des principales fonctionnalités orientées objet de Go, similaires aux classes d’autres langages. Vous pouvez initialiser une instance Accounting avec un symbole monétaire et une valeur de précision, entre autres options.

Vous pouvez utiliser la fonction FormatMoney du logiciel de comptabilité pour formater les nombres 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)))
}

La variable ac est l'instance comptable. Ce programme formate et imprime les valeurs monétaires à l'aide des méthodes FormatMoney et FormatMoneyBigFloat de l'instance comptable. La fonction NewRat du package big crée un nombre rationnel à partir d'un numérateur et d'un dénominateur. La fonction NewFloat 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 chiffres et des devises de manière simple.