No se puede convertir interface{} a string: cómo domesticar los genéricos en Go

Introducción: ¿por qué Go se queja de sus datos?

Imagine: está escribiendo en Go, todo va bien, pero de repente el compilador muestra un mensaje frío: cannot convert data (type interface {}) to type string: need type assertion. ¿Le suena? Si ha trabajado con Go al menos una semana, seguro que este error le ha visitado. Asusta a los principiantes, pero en realidad es una puerta al mundo de type assertion, uno de los mecanismos más potentes y a la vez más traicioneros del lenguaje.

En este artículo no solo analizaremos el error. Entenderemos por qué Go es tan estricto, cómo convertir correctamente interface{} a string y otros tipos, y cómo no caer en la trampa del panic. ¿Listo? ¡Allá vamos!

¿Qué es interface{} y por qué es complicado?

En Go, interface{} (interfaz vacía) es un tipo que puede almacenar un valor de cualquier tipo. Suena mágico, pero hay que pagar un precio: Go no permite simplemente tomar y asignar un valor de una variable interface{} a un tipo específico. El lenguaje requiere una confirmación explícita: «Oye, sé exactamente que dentro hay un string, permíteme sacarlo».

Esa confirmación se llama type assertion (afirmación de tipo). Sin ella, el compilador muestra ese mismo error:

var data interface{} = "hello"\n// Error:\nstr := data // cannot use data (type interface{}) as type string\n

¿Por qué? Porque data es una caja negra. El compilador no sabe lo que hay dentro. Puede ser un string, un número o incluso una estructura. La seguridad es lo primero.

Type Assertion: ¿salvador o fuente de pánico?

Type assertion es una sintaxis que permite «verificar» y «extraer» el valor de interface{}. Se ve así:

str := data.(string)\n

Pero hay un detalle: si data no es un string, su programa fallará con un panic. Por eso los desarrolladores experimentados usan la forma de verificación (comma ok idiom):

str, ok := data.(string)\nif !ok {\n    // Manejamos el error: no es un string\n    fmt.Println("Error: los datos no son un string")\n    return\n}\nfmt.Println(str)\n

Ahora, si data es un número, el programa no fallará, solo informará del error. Use siempre la forma de verificación si no está 100% seguro del tipo.

Ejemplo de la vida real: analizando JSON con interface{}

El escenario más común donde aparece nuestro error es al trabajar con JSON. Cuando analiza JSON sin una estructura estricta, Go convierte todo en map[string]interface{}. Y aquí comienza la diversión.

Supongamos que tenemos este JSON:

{\n  "name": "Alice",\n  "age": 30\n}\n

Lo analizamos:

jsonStr := `{"name": "Alice", "age": 30}`\nvar result map[string]interface{}\njson.Unmarshal([]byte(jsonStr), &result)\n\n// Intentamos obtener name\nname := result["name"].(string) // Funciona, pero es peligroso\nfmt.Println(name) // Alice\n\n// Intentamos obtener age como string — ¡pánico!\nage := result["age"].(string) // panic: interface conversion: interface {} is float64, not string\n

¿Por qué el pánico? Porque los números en JSON se analizan por defecto como float64, no como string. Conclusión: nunca haga type assertion sin verificación.

Código correcto:

if name, ok := result["name"].(string); ok {\n    fmt.Println("Name:", name)\n}\nif age, ok := result["age"].(float64); ok {\n    fmt.Println("Age:", int(age))\n}\n

Type Switch: cuando hay muchos tipos

A veces no sabe qué tipo hay dentro de interface{}. Para estos casos, Go ofrece type switch, una construcción que verifica todas las opciones posibles:

var data interface{} = getSomeData()\n\nswitch v := data.(typ