Formatar números corretamente pode ser uma tarefa complicada. E a formatação de moedas traz desafios adicionais envolvendo localização. Felizmente, Go tem recursos para ajudar.
A biblioteca padrão Go fornece várias ferramentas para formatar números. O pacote strconv inclui funções para analisar e converter números de e para strings.
O pacote strconv
O strconv pacote é uma ferramenta poderosa para converter entre números e strings. Você pode usá-lo para trabalhar com números em vários formatos.
strconv faz parte da biblioteca padrão, por isso é relevante para muitos dos conceitos básicos de Go com os quais você deve estar familiarizado. Veja como você pode importá-lo:
importar"strconv"
O pacote fornece funções para converter números de e para strings em vários formatos. Inclui funções para trabalhar com inteiros e números de ponto flutuante.
strconv também pode lidar com a conversão de e para formatos binários, octais e hexadecimais, bem como notação científica.
Formatando inteiros em Go
O pacote strconv Itoa A função fornece funcionalidade para converter números inteiros em strings. O Itoa A função pega um inteiro e retorna a representação de string desse inteiro.
importar (
"fmt"
"strconv"
)
funçãoprincipal() {
inteiros := 3043
stringVersão := strconv. Itoa (inteiros)
fmt. Println (stringVersion) // Saída: "3043"
}
Este código converte um valor inteiro em uma string usando Itoa. Em seguida, ele envia a string resultante para o console usando o fmt pacote.
Em adição a Itoa função, strconv fornece:
- FormatInt para formatar números inteiros como strings com uma determinada base
- AppendInt para anexar números inteiros em forma de string a uma fatia de bytes.
Veja como você pode usar o FormatInt função para formatar um número inteiro:
importar (
"fmt"
"strconv"
)
funçãoprincipal() {
inteiros := 12345
strings := strconv. FormatInt(int64(inteiros), 10)
fmt. Println (strings) // Saída: "12345"
}
Este código usa int64() para converter o valor original em um inteiro de 64 bits. Em seguida, passa o resultado para FormatInt, juntamente com uma base para conversão, neste caso 10. FormatInt retorna uma string que Println em seguida, envia para o console.
O AppendInt função leva em uma fatia de byte, um int64 valor e uma base.
importar (
"fmt"
"strconv"
)
funçãoprincipal() {
inteiros := 12345
byteSlice := fazer([]byte, 0, 20)
byteSlice = strconv. AppendInt (byteSlice, int64(inteiros), 10)
fmt. Imprimirln(corda(byteSlice)) // Saída: "12345"
}
Observe que AppendInt recebe uma fatia de byte para anexar e retorna a fatia de byte resultante. Nesse caso, a fatia de byte inicial está vazia, mas tem uma capacidade de 20 para armazenar a representação de string resultante do inteiro.
Analisando Strings como Inteiros
O Atoi A função converte strings em números inteiros. Ele recebe uma string como entrada e retorna uma representação inteira dessa string junto com um tipo de erro.
Veja como você pode usar o Atoi função para conversão de string para inteiro:
importar (
"fmt"
"strconv"
)funçãoprincipal() {
strings := "123"
inteiros, erro := strconv. Atoi (cordas)se erro != nada {
fmt. Println (err)
}
fmt. Println (inteiros)
}
O programa gera o valor inteiro para o console:
Você também pode usar o ParseUint função para analisar a representação de cadeia de inteiros sem sinal.
pacote principalimportar (
"fmt"
"strconv"
)funçãoprincipal() {
// analisa string como base 10 e inteiro sem sinal de 0 bit
val, err := strconv. ParseUint("12345", 10, 0)
se erro != nada {
fmt. Println (err)
} outro {
fmt. Println (val) // Saída: 12345
}
}
O ParseUint A função analisa a string 12345 como um inteiro sem sinal de base dez. O tamanho de 0 bit garante que ele retorne um tipo int padrão. Ele retorna o valor analisado e um erro.
Você pode usar o ParseFloat função para analisar uma representação de string de um número de ponto flutuante.
importar (
"fmt"
"strconv"
)funçãoprincipal() {
// analisa a string como um número de ponto flutuante de 64 bits
val, err := strconv. ParseFloat("3.14", 64)
se erro != nada {
fmt. Println (err)
} outro {
fmt. Println (val) // Saída: 3.14
}
}
O ParseFloat A função analisa a string como um número de ponto flutuante de 64 bits e retorna a string e um tipo de erro.
Formatando moedas em Go
Construir um aplicativo que interage com moedas requer formatação e análise de números. Trabalhar com moedas diferentes pode ser um desafio, mas o strconv e contabilidade pacotes podem ajudá-lo a formatá-los.
Veja como você pode analisar uma string de moeda em um float para operações na moeda:
importar (
"fmt"
"strconv"
)funçãoprincipal() {
// string de moeda para analisar
moedaStr := "$1,234.56"// Remove o símbolo da moeda e converte para float
floatVal, erro := strconv. ParseFloat (moedaStr[1:], 64)se erro != nada {
fmt. Println (err)
retornar
}
// Imprime o valor float analisado
fmt. Println (floatVal) // Saída: 1234.56
}
O moedaStr variável é uma representação de string de um valor de moeda com um cifrão como símbolo. O programa usa o ParseFloat função para analisar a string de moeda a partir do segundo elemento (após o símbolo de moeda).
Convencionalmente, é melhor evitar o uso de floats para moedas, pois podem resultar em erros de cálculo e bugs na produção.
Alternativamente, você pode usar um pacote de terceiros como contabilidade que tem funcionalidade para formatar e analisar moedas.
Execute este comando de terminal no diretório do projeto para instalar o pacote de contabilidade:
acesse github.com/leekchan/accounting
Comece criando uma instância do Contabilidade struct. Lembre-se de que as estruturas são uma das Principais recursos orientados a objetos do Go, semelhante a classes de outros idiomas. Você pode inicializar uma instância de Accounting com um símbolo de moeda e um valor de precisão, entre outras opções.
Você pode usar o FormatMoney função do pacote de contabilidade para formatar números em moedas.
pacote principalimportar (
"fmt"
"matemática/grande""github.com/leekchan/accounting"
)
funçãoprincipal() {
ac := contabilidade. Contabilidade{Símbolo: "$", Precisão: 2}
fmt. Imprimir (ac. FormatoMoney(123456789.213123))
fmt. Imprimir (ac. FormatoMoney(12345678))
fmt. Imprimir (ac. FormatMoney (grande. NovoRat(77777777, 3)))
fmt. Imprimir (ac. FormatMoney (grande. NovoRat(-77777777, 3)))
fmt. Imprimir (ac. FormatoMoneyBigFloat (big. NovoFloat(123456789.213123)))
}
O ac variável é a instância contábil. Este programa formata e imprime valores monetários usando o FormatMoney e FormatoMoneyBigFloat métodos da instância contábil. O NewRat função do grande pacote cria um número racional dado um numerador e denominador. O NewFloat A função ajuda a representar grandes números de ponto flutuante.
Go pode ajudá-lo a formatar outros tipos também
O Go oferece muitas funções para converter números e moedas de maneira direta.
A linguagem também oferece um poderoso sistema de formatação de strings. A função Sprintf inspirada em C do pacote fmt permite que você crie strings formatadas usando uma sintaxe de espaço reservado especial. Você pode usar o Sprintf para criar strings que incluem números e valores monetários, facilitando a criação de uma saída legível por humanos.
