Asignación múltiple y el idiom comma-ok en Go

En Go, las funciones no están limitadas a devolver un solo valor. Puedes devolver tantos como necesites, lo que permite la asignación múltiple: la capacidad de recibir varios resultados en una sola instrucción. Esto es fundamental para el diseño de la biblioteca estándar y de tus propios paquetes, ya que permite que una función devuelva un resultado principal junto con información adicional, como un estado de éxito o un error.

Cuando una función devuelve múltiples valores, Go te obliga a ser explícito. Si intentas asignar un retorno múltiple a una sola variable, el compilador arrojará un error. Para ignorar un valor que no te interesa, utilizas el identificador en blanco (_), que le indica al compilador que ese valor debe descartarse deliberadamente. Esta característica es la que permite usar el “idioma” comma-ok para verificar si una clave existe en un mapa o si un valor tiene un tipo específico mediante una aserción de tipo. En términos de diseño, esto hace que el código sea mucho más legible que las tuplas de Python y mucho más seguro que los “parámetros de salida” de C, donde se pasan punteros para que la función modifique valores externos.

package main

import (
	"errors"
	"fmt"
)

// calcularDescuento devuelve el precio final y un error si el descuento es inválido.
func calcularDescuento(precio float64, descuento float64) (float64, error) {
	if descuento < 0 || descuento > 1,00 {
		return 0, errors.New("el descuento debe estar entre 0 y 1")
	}
	return precio * (1 - descuento), nil
}

func main() {
	// 1. Asignación múltiple con retorno de error
	// Recibimos el resultado y el error en una sola línea.
	precioFinal, err := calcularDescuento(100.0, 0.2)
	if err != nil {
		fmt.Println("Error:", err)
	} else {
		fmt.Println("Precio con descuento:", precioFinal)
	}

	// 2. El idiom "comma ok" para mapas
	// Los mapas en Go devuelven el valor y un booleano que indica si la clave existe.
	precios := map[string]float64{"laptop": 1200.0, "mouse": 25.0}
	valor, existe := precios["mouse"]
	if existe {
		fmt.Printf("El precio del mouse es: %.2f\n", valor)
	}

	// 3. Aserción de tipo con "comma ok"
	// Usamos un tipo interfaz (que puede contener cualquier valor) para el ejemplo.
	var contenido interface{} = "Hola, Go"
	texto, ok := contenido.(string)
	if ok {
		fmt.Println("El contenido es un string:", texto)
	}

	// 4. Intercambio de valores (swap) sin variable temporal
	// Go evalúa todos los valores de la derecha antes de asignar a la izquierda.
	a, b := 10, 20
	fmt.Printf("Antes del swap: a=%d, b=%d\n", a, b)
	a, b = b, a
	fmt.Printf("Después del swap: a=%d, b=%d\n", a, b)

	// 5. Descartar valores con el identificador en blanco (_)
	// Si solo nos interesa el error, ignoramos el valor del resultado.
	_, err = calcularDescuento(50.0, 1.5)
	if err != nil {
		fmt.Println("Error capturado correctamente:", err)
	}
}

Análisis del código

En la función calcularDescuento, la firma (float64, error) establece que siempre habrá dos valores de salida. En main, la primera asignación precioFinal, err := ... captura ambos. Si el error no es nil, sabemos que el cálculo falló.

Cuando consultamos el mapa precios, la expresión valor, existe := precios["mouse"] utiliza la capacidad de los mapas para devolver un booleano. Esto es vital: si solo hiciéramos valor := precios["teclado"] y la clave no existiera, valor sería 0.0 (el valor por defecto para float64), lo que podría confundirse con un precio real de cero. Al usar existe, diferenciamos claramente entre “el precio es 0” y “la clave no existe”.

La aserción de tipo contenido.(string) funciona de forma similar. Al usar la sintaxis de dos variables texto, ok := ..., evitamos que el programa falle si contenido no fuera un string. Finalmente, en la operación de swap, a, b = b, a, el runtime de Go evalúa los valores actuales de b y a y los coloca en una “tupla” temporal interna antes de realizar la asignación, lo que permite intercambiarlos sin que el primer valor se pierda durante el proceso.

El error frecuente

Un error muy común al trabajar con aserciones de tipo es olvidar el segundo valor de retorno (ok).

var contenido interface{} = 42 // Es un entero
texto := contenido.(string)    // ¡PANIC! El programa se detiene aquí.

Si intentas realizar una aserción de tipo directamente (sin la variable ok) y el tipo no coincide, Go lanzará un panic, lo que detiene la ejecución de tu programa inmediatamente. Siempre que no estés 100% seguro del tipo que contiene una interfaz, utiliza la forma de dos variables para manejar el caso de error de manera segura.

N° 25