Retornar múltiples valores desde una función es una de las características más potentes de Go y una de las razones por las que muchos desarrolladores se enamoran del lenguaje. Si vienes de Java, Python o C#, vas a notar que Go simplifica algo que en otros lenguajes requiere tuplas, arreglos o estructuras adicionales.

¿Por qué Go permite retornar más de un valor en una función?

La idea nació como una solución elegante para devolver, por ejemplo, un resultado y los datos involucrados al mismo tiempo. En lenguajes como Python esto se logra con una tuple, en C# con un arreglo, y en Java directamente te topas con pared. Go, en cambio, lo trae integrado en su sintaxis [0:30].

¿Qué significa retornar múltiples valores en Go? Es la capacidad de una función para devolver dos o más resultados en una sola llamada, sin necesidad de envolverlos en estructuras auxiliares.

Esta característica posiciona a Go como uno de los pioneros en retorno múltiple nativo, algo que después influyó en la forma en que otros lenguajes abordaron el problema.

¿Cómo se declara una función con valores múltiples en Go?

La sintaxis es directa: defines la función con la palabra reservada func, declaras los parámetros entre paréntesis y, en lugar de un solo tipo de retorno, colocas los tipos esperados entre paréntesis después del nombre.

En el ejercicio práctico, se crea un archivo main.go con la estructura típica: package main y la función main [2:00]. Luego se declara una función llamada valoresMultiples que recibe tres cadenas como parámetros: nombre, nombreDos y apellido.

go func valoresMultiples(nombre string, nombreDos string, apellido string) (map[string]string, map[string]string) { mapaUno := make(map[string]string) mapaDos := make(map[string]string)

mapaUno[nombre] = apellido
mapaDos[nombreDos] = apellido

return mapaUno, mapaDos

}

La función make es indispensable aquí: sin ella el mapa no existiría en memoria y no podrías devolverlo [3:45].

¿Cómo se reciben dos valores devueltos por una función?

Del lado de quien llama la función, se asignan ambos retornos a dos variables en una sola línea:

go mapaPrimerNombre, mapaSegundoNombre := valoresMultiples("Amin", "Miranda", "Espinosa") fmt.Println(mapaPrimerNombre) fmt.Println(mapaSegundoNombre)

Go infiere los tipos automáticamente como map[string]string gracias a la declaración corta :=. Al ejecutar go run main.go, la salida muestra Amin Espinosa en el primer mapa y Miranda Espinosa en el segundo, sin necesidad de ciclos ni estructuras adicionales [5:30].

¿Para qué sirve el guion bajo al recibir valores múltiples?

Go es estricto: si declaras una variable y no la usas, el compilador te marca error. El guion bajo (_) soluciona esto cuando solo te interesa uno de los valores devueltos.

go _, nombre := valoresMultiples("Amin", "Miranda", "Espinosa")

En este caso, el primer mapa se descarta y nombre toma únicamente el segundo registro. Es una forma limpia de omitir valores que no necesitas sin generar variables muertas en tu código [6:50].

¿Cuándo debo usar el guion bajo en Go? Úsalo cuando una función devuelve varios valores pero solo te interesa procesar algunos. Evita errores de compilación por variables no utilizadas.

¿Qué ventajas tiene devolver mapas desde una función?

En el ejercicio se construyen dos mapas con la misma estructura: cadena como llave y cadena como valor. La diferencia con un mapa de ejercicios anteriores es justamente el tipo del valor, que antes era un entero.

• Permite asociar pares clave-valor de forma directa.
• Evita concatenaciones manuales o ciclos for.
• Hace que la función sea reutilizable para distintos pares de nombres.

Un detalle importante: al asignar la llave, no debes usar comillas alrededor de nombre porque ya es una variable. Copilot suele sugerirlo entre comillas, pero eso convertiría el nombre del parámetro en una cadena literal y romperías la lógica [4:40].

¿Y si quiero concatenar en lugar de usar mapas?

Este es el reto que se propone al final: en vez de devolver dos mapas, modifica la función para que retorne dos cadenas concatenadas con los nombres de tus familiares. Es una forma rápida de practicar retorno múltiple combinado con manipulación de strings y ver cómo cambia la firma de la función.

¿Ya intentaste implementar esta función con tu propia familia? Cuéntanos en los comentarios cómo resolviste la concatenación y qué diferencias notaste frente al uso de mapas.