Golang: int para string, string para int e conversão de tipos

Go nunca converte tipos implicitamente. Você converte entre tipos compatíveis com T(v), e entre números e texto com o pacote strconv. As duas conversões mais buscadas:

package main

import (
	"fmt"
	"strconv"
)

func main() {
	// int to string
	n := 42
	s := strconv.Itoa(n)
	fmt.Println(s, len(s))

	// string to int
	parsed, err := strconv.Atoi("1234")
	if err != nil {
		fmt.Println("error:", err)
		return
	}
	fmt.Println(parsed + 1)
}

strconv.Itoa ("integer to ASCII") formata um int como texto decimal. strconv.Atoi ("ASCII to integer") interpreta um texto como int e devolve um erro quando o texto não é um número válido. Sempre verifique esse erro.

A conversão T(v)

A sintaxe de conversão do Go parece uma chamada de função com o nome do tipo de destino. Ela funciona em três situações:

1. entre tipos numéricos (int, int64, float64, uint8, ...),
2. entre string e []byte ou []rune,
3. entre tipos que compartilham o tipo subjacente (Celsius e float64).

package main

import (
	"fmt"
	"math"
)

type Celsius float64

func main() {
	count := 7
	total := 2.5

	// numeric conversions
	avg := total / float64(count)
	fmt.Printf("%.3f\n", avg)

	// float to int truncates toward zero
	up, down := 3.9, -3.9
	fmt.Println(int(up), int(down))
	fmt.Println(int(math.Round(up)), int(math.Round(-3.5)))

	// narrowing an integer keeps the low bits
	big, mid := 300, 200
	fmt.Println(uint8(big), int8(mid))

	// named type to underlying type and back
	t := Celsius(21.5)
	f := float64(t)
	fmt.Println(t, f)
}

Leia os resultados com atenção:

• int(3.9) é 3 e int(-3.9) é -3. A conversão trunca em direção a zero; ela não arredonda. Use antes math.Round, math.Floor ou math.Ceil para escolher o comportamento. math.Round arredonda a metade para longe do zero, então -3.5 vira -4.
• uint8(300) é 44, porque só sobram os 8 bits mais baixos (300 menos 256), e int8(200) é -56 pelo mesmo motivo. Sem erro, sem panic.
• Celsius e float64 compartilham o tipo subjacente, então convertem livremente, mas só de forma explícita.

Os valores estão em variáveis de propósito. Com constantes, as mesmas conversões não compilam.

Constantes são verificadas, variáveis não

Converter uma constante que não cabe no tipo é erro de compilação. Converter uma variável com o mesmo valor dá a volta em silêncio:

fmt.Println(uint8(300)) // compile error
x := 300
fmt.Println(uint8(x)) // 44

./main.go:6:20: constant 300 overflows uint8

Converter uma constante não inteira para um tipo inteiro também é rejeitado, enquanto o mesmo valor em uma variável é truncado:

./main.go:7:18: cannot convert -3.9 (untyped float constant) to type int

Se o valor float estiver fora da faixa do tipo inteiro de destino (por exemplo int64(1e20)), o resultado depende da implementação: amd64 e arm64, por exemplo, dão respostas diferentes. Confira a faixa antes de converter valores não confiáveis.

Convertendo números em strings

package main

import (
	"fmt"
	"strconv"
)

func main() {
	var id int64 = 9007199254740993
	fmt.Println(strconv.FormatInt(id, 10))
	fmt.Println(strconv.FormatInt(255, 2), strconv.FormatInt(255, 16))

	f := 1234.5678
	fmt.Println(strconv.FormatFloat(f, 'f', 2, 64))  // fixed, 2 decimals
	fmt.Println(strconv.FormatFloat(f, 'e', 3, 64))  // scientific
	fmt.Println(strconv.FormatFloat(f, 'f', -1, 64)) // shortest exact form
	fmt.Println(strconv.FormatFloat(0.1, 'f', -1, 64))

	fmt.Println(fmt.Sprintf("%.1f%%", 45.67))
	fmt.Println("item-" + strconv.Itoa(7))
}

FormatFloat recebe um byte de formato ('f' para notação fixa, 'e' para expoente, 'g' para o que for mais curto), uma precisão (-1 significa "o menor número de dígitos que volta exatamente ao mesmo valor") e o tamanho em bits do float original (64 ou 32).

strconv é mais rápido que fmt.Sprint, que empacota o valor em uma interface e passa pelo caminho de formatação genérico do fmt. Em um laço quente essa diferença aparece; para conversões ocasionais, escolha o que for mais legível.

Convertendo strings em números

ParseInt sempre devolve um int64. O argumento bitSize (0, 8, 16, 32, 64) define a faixa aceita, então o resultado com certeza cabe quando você o converte para um tipo menor. base 0 significa "deduzir pelo prefixo", então 0x1f, 0o17, 0b101 e 1_000 são todos aceitos.

package main

import (
	"errors"
	"fmt"
	"strconv"
	"strings"
)

func main() {
	inputs := []string{"42", " 42", "4.2", "abc", "99999999999999999999"}
	for _, in := range inputs {
		n, err := strconv.Atoi(in)
		fmt.Printf("%-24q -> %d, %v\n", in, n, err)
	}

	// trim first when the input may have spaces or a newline
	n, err := strconv.Atoi(strings.TrimSpace(" 42\n"))
	fmt.Println(n, err)

	// ParseInt with a size limit
	v, err := strconv.ParseInt("300", 10, 8)
	fmt.Println(v, err)

	// base 0 reads the prefix
	h, _ := strconv.ParseInt("0xff", 0, 64)
	fmt.Println(h)

	// inspect the error kind
	_, err = strconv.Atoi("12a")
	if errors.Is(err, strconv.ErrSyntax) {
		fmt.Println("not a number")
	}
	_, err = strconv.ParseInt("300", 10, 8)
	if errors.Is(err, strconv.ErrRange) {
		fmt.Println("too big for int8")
	}

	price, err := strconv.ParseFloat("19.99", 64)
	fmt.Println(price*2, err)

	ok, err := strconv.ParseBool("true")
	fmt.Println(ok, err)
}

O que a saída mostra:

• " 42" falha. O Atoi aceita um sinal opcional e dígitos, nada mais. Entradas lidas com bufio costumam terminar em \n, então remova isso.
• "4.2" é inválido para o Atoi. Use ParseFloat para decimais.
• Em um erro de faixa, ParseInt devolve o maior valor que cabe (127 para int8) junto com o erro. Não use o valor quando o erro não for nil.
• Os erros são valores *strconv.NumError que empacotam strconv.ErrSyntax ou strconv.ErrRange, então errors.Is consegue diferenciá-los.

ParseBool aceita 1, t, T, TRUE, true, True e as formas equivalentes de false. "yes" e "on" dão erro.

A armadilha do string(65)

Converter um inteiro para string não gera dígitos. Gera o caractere com aquele code point Unicode:

n := 65
s := string(n) // "A", not "65"

O compilador aceita, mas o go vet reporta:

./main.go:10:7: conversion from int to string yields a string of one rune, not a string of digits

Se você quer mesmo o caractere, deixe isso claro com uma rune: string(rune(n)). Se quer o número como texto, use strconv.Itoa(n). Converter uma rune ou um byte para string é normal e comum:

package main

import (
	"fmt"
	"strconv"
)

func main() {
	n := 65
	fmt.Println(strconv.Itoa(n)) // "65"
	fmt.Println(string(rune(n))) // "A"

	letter := 'é'
	fmt.Println(string(letter))

	word := "go"
	fmt.Println(string(word[0])) // a byte converted to a one-character string
}

Strings, bytes e runes

string, []byte e []rune se convertem entre si com T(v). Cada conversão copia os dados, porque strings são imutáveis e slices não:

package main

import "fmt"

func main() {
	s := "héllo"

	b := []byte(s) // UTF-8 bytes
	r := []rune(s) // Unicode code points

	fmt.Println(len(b), b)
	fmt.Println(len(r), r)

	r[1] = 'e'
	fmt.Println(string(r))

	b[0] = 'H'
	fmt.Println(string(b), s) // s is unchanged
}

Converta para []rune quando precisar indexar ou modificar por caractere; converta para []byte para I/O, hashing e edições no nível de byte. A página de runes e bytes explica o UTF-8 em detalhes.

Conversão ou type assertion

Uma conversão muda um valor de um tipo concreto para outro. Tirar o valor concreto de dentro de uma interface (any, error, io.Reader) é outra operação, a type assertion:

var v any = 42

n := v.(int)       // type assertion: v holds an int, give it to me
f := float64(n)    // conversion: int to float64
// f := float64(v) // compile error: cannot convert v (variable of interface type any)
//                  // to type float64: need type assertion

Primeiro a assertion, depois a conversão. A forma vírgula-ok n, ok := v.(int) evita um panic quando o tipo está errado.

Referência rápida

n, err := strconv.Atoi("42")
if err != nil {
	// not a valid integer
}