Sentencias if con inicialización y scope de variables

La sentencia if en Go permite incluir una instrucción de inicialización antes de la condición, separadas por un punto y coma ;. Esto permite declarar variables que solo existen dentro del ámbito (scope) del bloque if y su correspondiente else. Esta característica está diseñada para minimizar el “ruido” en el código, evitando que variables temporales de control de flujo contaminen el resto de la función. Es el patrón estándar para manejar errores de forma limpia: en lugar de declarar la variable antes, la declaras y la evalúas en una sola línea. Si intentas acceder a una variable declarada en este bloque fuera de él, el compilador lanzará un error de compilación porque su vida útil termina exactamente donde termina el bloque if-else.

package main

import (
	"errors"
	"fmt"
)

// buscarUsuario simula una consulta a una base de datos.
func buscarUsuario(id int) (string, error) {
	if id <= 0 {
		return "", errors.New("el ID debe ser mayor a cero")
	}
	if id == 404 {
		return "", errors.New("usuario no encontrado")
	}
	return "Carlos", nil
}

func main() {
	// 1. Caso estándar: Uso de una variable solo para validación.
	id := 10
	if id > 0 {
		fmt.Printf("ID %d es válido\n", id)
	}

	// 2. Patrón idiomático: if con statement inicial para manejo de errores.
	// Las variables 'nombre' y 'err' nacen aquí y mueren al salir del bloque.
	if nombre, err := buscarUsuario(1); err != nil {
		// 'err' es accesible aquí
		fmt.Printf("Error detectado: %v\n", err)
	} else {
		// 'nombre' y 'err' también son accesibles en el bloque else
		fmt.Printf("Usuario encontrado: %s (ID verificado)\n", nombre)
	}

	// 3. Inicialización para cálculos rápidos.
	if resultado := 10 * 5; resultado > 40 {
		fmt.Printf("El cálculo %d es mayor a 40\n", resultado)
	}
}

En el ejemplo anterior, fíjate en cómo buscarUsuario(1) devuelve un valor y un error. En lugar de declarar var err error arriba, usamos if nombre, err := buscarUsuario(1); err != nil. Esto hace que nombre y err sean locales a ese bloque. Si la condición err != nil es verdadera, entramos al primer bloque. Si es falsa, pasamos al else, donde tanto nombre como err siguen siendo válidos y accesibles. Esto es fundamental para mantener un código limpio: si no necesitas el nombre del usuario en el resto de la función main, no debería estar disponible en ella.

Además, notarás que Go no incluye un operador ternario (como condicion ? a : b en otros lenguajes). Esta es una decisión de diseño consciente para priorizar la legibilidad. En Go, prefieres un if-else explícito que sea fácil de leer para cualquier desarrollador, incluso si requiere más líneas de código.

El error frecuente

Un error común es intentar usar una variable declarada en el if inicial fuera de su bloque. El compilador te detendrá porque la variable no existe en ese contexto.

// Esto fallará al compilar
if err := realizarOperacion(); err != nil {
    fmt.Println(err)
}

// error: undefined: err
fmt.Println("El error fue:", err) 

Si necesitas que la variable persista después del bloque if, debes declararla antes de la sentencia if.

N° 34