Int a string, string a int y conversión de tipos en Golang

Go nunca convierte tipos de forma implícita. Conviertes entre tipos compatibles con T(v), y entre números y texto con el paquete strconv. Las dos conversiones más 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") formatea un int como texto decimal. strconv.Atoi ("ASCII to integer") analiza texto y lo convierte en un int, y devuelve un error cuando el texto no es un número válido. Comprueba siempre ese error.

La conversión T(v)

La sintaxis de conversión de Go parece una llamada a una función con el nombre del tipo de destino. Funciona en tres situaciones:

1. entre tipos numéricos (int, int64, float64, uint8, ...),
2. entre string y []byte o []rune,
3. entre tipos que comparten tipo subyacente (Celsius y 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)
}

Lee los resultados con atención:

• int(3.9) es 3 e int(-3.9) es -3. La conversión trunca hacia cero; no redondea. Usa antes math.Round, math.Floor o math.Ceil para elegir el comportamiento. math.Round redondea la mitad alejándose de cero, así que -3.5 se convierte en -4.
• uint8(300) es 44, porque solo sobreviven los 8 bits bajos (300 menos 256), e int8(200) es -56 por la misma razón. Ni error ni panic.
• Celsius y float64 comparten tipo subyacente, así que se convierten libremente, pero solo de forma explícita.

Los valores están en variables a propósito. Con constantes, las mismas conversiones no compilan.

Las constantes se comprueban, las variables no

Convertir una constante que no cabe es un error de compilación. Convertir una variable con el mismo valor da la vuelta en silencio:

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

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

Convertir una constante no entera a un tipo entero también se rechaza, mientras que el mismo valor en una variable se trunca:

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

Si el valor flotante está fuera del rango del tipo entero de destino (por ejemplo int64(1e20)), el resultado depende de la implementación: amd64 y arm64, por ejemplo, dan respuestas distintas. Comprueba el rango antes de convertir valores no fiables.

Convertir números en 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 recibe un byte de formato ('f' para notación fija, 'e' para exponente, 'g' para la más corta de las dos), una precisión (-1 significa "los menos dígitos que permiten recuperar el valor exacto") y el tamaño en bits del float original (64 o 32).

strconv es más rápido que fmt.Sprint, que mete el valor en una interfaz y pasa por la ruta de formato general de fmt. En un bucle caliente esa diferencia se nota; para conversiones ocasionales, elige lo que se lea mejor.

Convertir strings en números

ParseInt siempre devuelve un int64. El argumento bitSize (0, 8, 16, 32, 64) fija el rango que acepta, así que el resultado cabe con seguridad cuando lo conviertes a un tipo más pequeño. base 0 significa "deducirla del prefijo", así que 0x1f, 0o17, 0b101 y 1_000 se analizan todos.

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)
}

Cosas que muestra la salida:

• " 42" falla. Atoi acepta un signo opcional y dígitos, nada más. La entrada de bufio suele terminar en \n, así que recórtala.
• "4.2" no es válido para Atoi. Usa ParseFloat para decimales.
• Ante un error de fuera de rango, ParseInt devuelve el mayor valor que cabe (127 para int8) junto con el error. No uses el valor cuando el error no sea nil.
• Los errores son valores *strconv.NumError que envuelven strconv.ErrSyntax o strconv.ErrRange, así que errors.Is puede distinguirlos.

ParseBool acepta 1, t, T, TRUE, true, True y las formas equivalentes para false. "yes" y "on" son errores.

La trampa de string(65)

Convertir un entero a string no produce dígitos. Produce el carácter con ese code point Unicode:

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

El compilador lo acepta, pero go vet lo informa:

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

Si de verdad quieres el carácter, dilo con un rune: string(rune(n)). Si quieres el número como texto, usa strconv.Itoa(n). Convertir un rune o un byte a string es correcto y habitual:

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 y runes

string, []byte y []rune se convierten entre sí con T(v). Cada conversión copia los datos, porque los strings son inmutables y los slices no:

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
}

Convierte a []rune cuando necesites indexar o modificar por carácter; convierte a []byte para I/O, hashing y ediciones a nivel de byte. La página de runes y bytes explica UTF-8 en detalle.

Conversión frente a aserción de tipo

Una conversión cambia un valor de un tipo concreto a otro. Sacar el valor concreto de una interfaz (any, error, io.Reader) es una operación distinta, la aserción de tipo:

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

Primero la aserción, luego la conversión. La forma comma-ok n, ok := v.(int) evita un panic cuando el tipo es incorrecto.

Referencia rápida

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