Számok és pénznemek formázása a Go segítségével

A számok helyes formázása bonyolult feladat lehet. A pénznemek formázása pedig további kihívásokat jelent a lokalizáció terén. Szerencsére a Go olyan funkciókkal rendelkezik, amelyek segítenek.

A Go szabványkönyvtár különféle eszközöket biztosít a számok formázásához. Az strconv csomag olyan függvényeket tartalmaz, amelyek segítségével értelmezhetők és konvertálhatók a számok karakterláncokká és karakterláncokból.

Az strconv csomag

A strconv csomag egy hatékony eszköz a számok és karakterláncok közötti konvertáláshoz. Különféle formátumú számokkal dolgozhat.

Az strconv a szabványos könyvtár része, így sok számára releváns alapvető Go fogalmak, amelyeket ismernie kell. Így importálhatja:

import"strconv"

A csomag különféle formátumú számok karakterláncokká és karakterláncokból való konvertálására szolgáló funkciókat biztosít. Olyan függvényeket tartalmaz, amelyek egész számokkal és lebegőpontos számokkal dolgoznak.

Az strconv képes kezelni a bináris, oktális és hexadecimális formátumokba való konvertálást, valamint a tudományos jelöléseket is.

Egész számok formázása a Go-ban

Az strconv csomag Itoa A függvény egész számokat karakterláncokká konvertál. A Itoa A függvény egy egész számot vesz fel, és visszaadja ennek az egész számnak a karakterlánc reprezentációját.

import (
"fmt"
"strconv"
)
funcfő-() {
 egész számok := 3043
 stringVersion := strconv. Itoa (egész számok)
 fmt. Println (stringVersion) // Kimenet: "3043"
}

Ez a kód egy egész értéket karakterláncsá konvertál a használatával Itoa. Ezután a kapott karakterláncot a konzolra adja ki a fmt csomag.

Amellett, hogy a Itoa függvény, strconv biztosítja:

• FormatInt egész számok karakterláncként való formázásához adott bázissal
• AppendInt egész számok hozzáfűzéséhez karakterlánc formában egy bájtszelethez.

Íme, hogyan használhatja a FormatInt függvény egész szám formázásához:

import (
"fmt"
"strconv"
)
funcfő-() {
 egész számok := 12345
 strings := strconv. FormatInt(int64(egész számok), 10)
 fmt. Println (karakterláncok) // Kimenet: "12345"
}

Ez a kód használja int64() az eredeti érték 64 bites egész számmá alakításához. Ezután továbbítja az eredményt FormatInt, valamint egy átalakítási alap, jelen esetben 10. A FormatInt egy karakterláncot ad vissza, amely Println majd kimenet a konzolra.

A AppendInt függvény egy bájtszeletet vesz fel, an int64 érték, és egy alap.

import (
"fmt"
"strconv"
)
funcfő-() {
 egész számok := 12345
 byteSlice := készítsenek([]byte, 0, 20)
 byteSlice = strconv. AppendInt (byteSlice, int64(egész számok), 10)
 fmt. Println(húr(byteSlice)) // Kimenet: "12345"
}

Vegye figyelembe, hogy az AppendInt egy bájtszeletet kap, amelyhez hozzá kell fűzni, és az eredményül kapott bájtszeletet adja vissza. Ebben az esetben a kezdeti bájtszelet üres, de 20-as kapacitással rendelkezik az egész szám eredő karakterlánc-reprezentációjának tárolására.

Karakterláncok elemzése egész számként

A Atoi függvény a karakterláncokat egész számokká alakítja. Bemenetként egy karakterláncot vesz fel, és ennek a karakterláncnak egész számot ad vissza egy hibatípussal együtt.

Íme, hogyan használhatja a Atoi függvény karakterláncból egész számmá konvertálásához:

import (
"fmt"
"strconv"
)
funcfő-() {
 húrok := "123"
 egész számok, err := strconv. Atoi (húrok)
ha hiba! = nulla {
 fmt. Println (hiba)
 }
 fmt. Println (egész számok) 
}

A program az egész értéket adja ki a konzolnak:

Használhatja továbbá a ParseUint függvény az előjel nélküli egész számok karakterlánc reprezentációjának elemzéséhez.

csomag fő-
import (
"fmt"
"strconv"
)
funcfő-() {
// a karakterlánc elemzése 10-es alap és 0 bites előjel nélküli egész számként
 val, err := strconv. ParseUint("12345", 10, 0)
ha hiba! = nulla {
 fmt. Println (hiba)
 } más {
 fmt. Println (val) // Kimenet: 12345
 }
}

A ParseUint függvény az 12345 karakterláncot tízes alapjelű, előjel nélküli egész számként elemzi. A 0 bites méret biztosítja, hogy szabványos int típust ad vissza. Visszaadja az elemzett értéket és egy hibát.

Használhatja a ParseFloat függvény egy lebegőpontos szám karakterlánc-reprezentációjának elemzéséhez.

import (
"fmt"
"strconv"
)
funcfő-() {
// a karakterláncot 64 bites lebegőpontos számként elemzi
 val, err := strconv. ParseFloat("3.14", 64)
ha hiba! = nulla {
 fmt. Println (hiba)
 } más {
 fmt. Println (val) // Kimenet: 3.14
 }
}

A ParseFloat függvény 64 bites lebegőpontos számként elemzi a karakterláncot, és visszaadja a karakterláncot és egy hibatípust.

Pénznemek formázása a Go-ban

A pénznemekkel kölcsönhatásba lépő alkalmazás létrehozásához számformázásra és -elemzésre van szükség. A különböző pénznemekkel való munka kihívást jelenthet, de a strconv és könyvelés csomagok segíthetnek formázni őket.

A következőképpen elemezhet egy valutakarakterláncot lebegővé a pénznemre vonatkozó műveletekhez:

import (
"fmt"
"strconv"
)
funcfő-() {
// Az elemzendő pénznem karakterlánca
 valutaStr := "$1,234.56"
// Távolítsa el a valuta szimbólumot, és váltson lebegővé
 floatVal, err := strconv. ParseFloat (currencyStr[1:], 64)
ha hiba! = nulla {
 fmt. Println (hiba)
Visszatérés
 }
// Kinyomtatja az elemzett lebegő értéket
 fmt. Println (floatVal) // Kimenet: 1234.56
}

A valutaStr A változó egy valutaérték karakterlánc-ábrázolása, amelynek szimbóluma egy dollárjel. A program a ParseFloat függvény segítségével elemzi a valuta karakterláncot a második elemtől kezdve (a pénznem szimbólum után).

Hagyományosan a legjobb, ha kerüli a lebegő pénznemek használatát, mivel ez téves számításokat és hibákat eredményezhet a gyártás során.

Alternatív megoldásként használhat harmadik féltől származó csomagot, például könyvelés amely a pénznemek formázására és elemzésére alkalmas.

Futtassa ezt a terminálparancsot a projektkönyvtárban a könyvelési csomag telepítéséhez:

keresd meg a github.com/leekchan/accounting oldalt

Kezdje a példány létrehozásával a Könyvelés struct. Emlékezzünk vissza, hogy a struktúrák az egyik A Go alapvető objektumorientált szolgáltatásai, hasonlóan más nyelvű osztályokhoz. Inicializálhat egy könyvelési példányt egy pénznemszimbólum és egy precíziós érték segítségével, többek között.

Használhatja a FormatMoney a számviteli csomag funkciója a számok pénznemre formázásához.

csomag fő-
import (
"fmt"
"matematika/nagy"
"github.com/leekchan/accounting"
)
funcfő-() {
 ac := könyvelés. Számvitel{Szimbólum: "$", Pontosság: 2}
 fmt. Println (ac. FormatMoney(123456789.213123))
 fmt. Println (ac. FormatMoney(12345678))
 fmt. Println (ac. FormatMoney (nagy. NewRat(77777777, 3)))
 fmt. Println (ac. FormatMoney (nagy. NewRat(-77777777, 3)))
 fmt. Println (ac. FormatMoneyBigFloat (nagy. NewFloat(123456789.213123)))
}

A ac változó a számviteli példány. Ez a program a pénzbeli értékeket formázza és nyomtatja ki a FormatMoney és FormátumMoneyBigFloat a számviteli példány módszerei. A NewRat függvény a nagy csomag racionális számot hoz létre számlálóval és nevezővel. A NewFloat függvény segít a nagy lebegőpontos számok ábrázolásában.

A Go más típusok formázásában is segíthet

A Go számos funkciót kínál a számok és pénznemek egyszerű konvertálásához.

A nyelv erőteljes karakterláncformázó rendszert is kínál. Az fmt csomag C-ihlette Sprintf funkciója lehetővé teszi formázott karakterláncok létrehozását egy speciális helyőrző szintaxis használatával. A Sprintf segítségével számokat és pénznemértékeket tartalmazó karakterláncokat hozhat létre, így egyszerűvé téve az ember által olvasható kimenet létrehozását.