Gestion de la monnaie dans Golang et autres langages de programmation

La gestion des devises dans les langages de programmation est un aspect essentiel du développement de logiciels, en particulier pour les applications traitant des transactions financières, du commerce électronique, des systèmes bancaires et comptables. Une représentation et une manipulation précises des valeurs monétaires sont essentielles pour éviter les erreurs pouvant entraîner des écarts financiers importants.

Cet article explorera les meilleures pratiques en matière de gestion des devises avec un exemple dans les langages Go.

Précision et exactitude

L'une des principales préoccupations lorsqu'il s'agit de devises est la précision. Contrairement aux nombres à virgule flottante, qui peuvent introduire des erreurs d’arrondi, les valeurs monétaires nécessitent une représentation précise.

pensez à suivre le code

package main

import "fmt"

func main() {

    var a float64 = 1.1
    var b float64 = 1.2
    var c float64 = 1.3
    fmt.Println(a + b + c)

}

Le code ci-dessus s'imprimerait

3.5999999999999996

La mémoire des ordinateurs étant limitée, la plupart des langages de programmation, y compris Go, stockent la virgule flottante basée sur la norme IEEE-754 en utilisant 32 ou 64 bits, même en utilisant une précision de 64 bits, il est impossible de stocker un nombre infini de chiffres, ce qui signifie que ces les nombres sont arrondis à un moment donné, ce qui les rend intrinsèquement imprécis, et plus les calculs sont effectués, plus ils deviennent imprécis.

Il existe de nombreuses façons de gérer ce problème, comme utiliser une bibliothèque tierce ou le langage de programmation que vous utilisez dispose d'un support natif. Dans Go, il existe plusieurs bibliothèques, dont :

• shopspring/décimal
• ericlagergren/décimal
• alpacahq/alpacadecimal
• govalues/decimal

merci à Kennfatt pour avoir organisé cette liste de bibliothèques

Choisir une bibliothèque

Choisir la bonne bibliothèque pour gérer la programmation monétaire implique plusieurs considérations. Voici un guide pour vous aider à choisir une bibliothèque décimale appropriée à vos besoins

1. Exactitude et précision

Assurez-vous que la bibliothèque prend en charge la précision et que l'exactitude répond à vos besoins. Recherchez des capacités de précision arbitraires si vous traitez de très grands nombres ou des calculs très précis.

2. Facilité d'utilisation

La bibliothèque doit disposer d'une documentation claire et complète. Il devrait être facile à intégrer à votre base de code et à vos flux de travail existants.

3. Performances

Considérez l'impact sur les performances, surtout si vous effectuez un grand nombre de calculs ou si vous opérez dans un environnement de trading à haute fréquence.

4. Caractéristique

Assurez-vous que les fonctionnalités correspondent à vos besoins, de l'arithmétique de base comme l'arrondi, l'addition, la soustraction, la multiplication, la division aux opérations mathématiques plus complexes.

5. Communauté et soutien

Une bibliothèque bien soutenue avec une communauté active peut être cruciale pour obtenir de l'aide et trouver des solutions aux problèmes. Recherchez des bibliothèques activement entretenues et mises à jour.

Utiliser un tiers

Cet article utilisera la bibliothèque tierce govalues/decimal pour l'exemple de code, car la documentation est simple et facile à lire et répond au besoin de démonstration de code

package main

import (
    "fmt"
    "github.com/govalues/decimal"
)

func main() {

    a, _ := decimal.Parse("1.1")
    b, _ := decimal.Parse("1.2")
    c, _ := decimal.Parse("1.3")

    a, _ = a.Add(b)
    a, _ = a.Add(c)
    fmt.Println(a.String())

}

Le code ci-dessus s'imprimerait

3.6

Dans l'exemple ci-dessus, il n'y a pas de perte de précision, mais comme la mémoire a un coût et n'est pas infinie, les chiffres après la virgule sont toujours limités, le contrôle du chiffre décimal est important, dans cet exemple, vous pouvez définir la taille en utilisant decimal.ParseExact()

Stockage et récupération

Le stockage dans des bases de données nécessite également une attention particulière pour maintenir la précision et la cohérence.

Utiliser des types de colonnes appropriés

La plupart des bases de données relationnelles ont des types spécifiques pour les valeurs monétaires, tels que DECIMAL ou NUMERIC.

Évitez le stockage à virgule flottante

Tout comme en programmation, évitez de stocker les valeurs monétaires sous forme de nombres à virgule flottante dans les bases de données.

Par exemple dans MySQL

CREATE TABLE `users` (
    `id` int,
    `balance` decimal(6, 2)
);

Démonstration MySQL complète en cours

package main

import (
    "database/sql"
    _ "github.com/go-sql-driver/mysql"
)

func main() {

    db, err := sql.Open("mysql", "root:root@tcp(127.0.0.1:3306)/test")
    if err != nil {
        panic(err)
    }

    _, err = db.Exec(`
        CREATE TABLE test (
            id int,
            balance_decimal decimal(16, 8),
            balance_float float(16, 8),
            PRIMARY KEY (id)
        );
    `)

    _, err = db.Exec("INSERT INTO test (id, balance_decimal, balance_float) VALUES (1, 1.1, 1.1)")
    _, err = db.Exec(`
        UPDATE test 
            SET 
                balance_decimal = balance_decimal + 1.2 , 
                balance_float   = balance_float + 1.2 
            WHERE id = 1;
    `)
}

Le code ci-dessus produirait

id	balance_decimal	balance_float
1	2.30000000	2.29999995

Data Transfer

Data transfer also requires careful consideration of precision. a correct format is required

For example in JSON format, using type string guaranteed precision across any programing language

package main

import (
    "encoding/json"
    "log"
)

type Data struct {
    Decimal string  `json:"decimal"`
    Float   float64 `json:"float"`
}

func main() {

    payload := []byte(`{"decimal":"999.99999999999999","float":999.99999999999999}`)

    result := Data{}

    _ = json.Unmarshal(payload, &result)

    log.Print("Decimal: ", result.Decimal)
    log.Print("Float: ", result.Float)

}

Above code would print

Decimal: 999.99999999999999
Float: 1000

Conclusion

Handling currency in programming languages requires careful attention to detail to ensure precision, accuracy, and consistency. By using appropriate data types, libraries, and best practices, developers can avoid common pitfalls and ensure their applications handle currency correctly. Proper handling of currency not only prevents financial errors but also enhances user trust and confidence in the application.

There's no single best library for everyone. Each project has different needs. You should think about what's good and bad about each library based on what your project requires.

External Link

• Full Code Example
• govalues/decimal Repo
• shopspring/decimal Repo
• ericlagergren/decimal Repo
• alpacahq/alpacadecimal Repo

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!