if else en Golang: sintaxis, sentencia de inicio e if err != nil

El if de Go no lleva paréntesis alrededor de la condición, siempre necesita llaves y puede empezar con una sentencia corta que declara variables limitadas al if.

package main

import "fmt"

func grade(score int) string {
	var g string
	if score >= 90 {
		g = "A"
	} else if score >= 80 {
		g = "B"
	} else if score >= 70 {
		g = "C"
	} else {
		g = "F"
	}
	return g
}

func main() {
	for _, s := range []int{95, 83, 70, 42} {
		fmt.Println(s, grade(s))
	}
}

Las condiciones se comprueban de arriba abajo y se ejecuta la primera rama verdadera. else if y else son opcionales.

Reglas de sintaxis

Tres reglas cambian respecto a C, Java y JavaScript:

1. Sin paréntesis alrededor de la condición. if (x > 5) compila, pero gofmt quita los paréntesis.
2. Las llaves son obligatorias, incluso para una sola sentencia. No existe un if x > 5 return sin llaves.
3. else va en la misma línea que la llave de cierre. Go inserta un punto y coma después de una } al final de una línea, así que esto falla:

if x > 5 {
	fmt.Println("big")
}
else {
	fmt.Println("small")
}

syntax error: unexpected keyword else, expected }

Escribe } else { en una sola línea.

La condición tiene que ser un bool. Go no trata 0, "" ni nil como falso, así que if count {} e if name {} no compilan. Compara de forma explícita: if count > 0, if name != "", if user != nil.

Combina condiciones con && (y), || (o) y ! (no). Tanto && como || hacen cortocircuito, lo que hace seguras las comprobaciones de nil:

if user != nil && user.IsAdmin() {
	// user.IsAdmin() is only called when user is not nil
}

if con sentencia de inicio

Un if puede ejecutar una sentencia corta antes de la condición, separada por punto y coma. Las variables declaradas en ella son visibles en todas las ramas de ese if, y en ningún sitio después:

package main

import (
	"fmt"
	"strconv"
)

func main() {
	inputs := []string{"42", "-7", "abc"}

	for _, in := range inputs {
		if n, err := strconv.Atoi(in); err != nil {
			fmt.Printf("%q is not a number\n", in)
		} else if n < 0 {
			fmt.Printf("%d is negative\n", n)
		} else {
			fmt.Printf("%d doubled is %d\n", n, n*2)
		}
		// n and err do not exist here
	}

	stock := map[string]int{"apples": 3}
	if qty, ok := stock["apples"]; ok {
		fmt.Println("apples in stock:", qty)
	}
	if _, ok := stock["pears"]; !ok {
		fmt.Println("no pears")
	}
}

El patrón mantiene las variables de vida corta fuera del ámbito de alrededor. Aparece constantemente con búsquedas en maps (v, ok := m[k]), aserciones de tipo (s, ok := v.(string)) y errores.

La otra cara: si necesitas el valor después del if, decláralo antes. Un error habitual es poner un resultado en la sentencia de inicio e intentar usarlo más abajo.

El idioma if err != nil

Las funciones que pueden fallar devuelven un error al final. Compruébalo de inmediato, manéjalo o devuélvelo, y continúa con la ruta feliz sin sangría:

package main

import (
	"errors"
	"fmt"
	"strconv"
)

func parseAge(s string) (int, error) {
	n, err := strconv.Atoi(s)
	if err != nil {
		return 0, fmt.Errorf("age %q: %w", s, err)
	}
	if n < 0 || n > 150 {
		return 0, errors.New("age out of range")
	}
	return n, nil
}

func main() {
	for _, s := range []string{"34", "x", "200"} {
		age, err := parseAge(s)
		if err != nil {
			fmt.Println("error:", err)
			continue
		}
		fmt.Println("age:", age)
	}
}

Fíjate en que no hay else después de if err != nil { return ... }. El estilo de Go maneja el error, retorna y deja el flujo normal en el margen izquierdo. La página de manejo de errores cubre cómo envolver errores y comprobar sus tipos.

Retornos tempranos en lugar de anidar

Los bloques if muy anidados son difíciles de leer. Invierte las condiciones y retorna pronto; así cada comprobación se lee como una guarda:

// Nested
func canCheckout(u *User, cart *Cart) bool {
	if u != nil {
		if u.Verified {
			if len(cart.Items) > 0 {
				return true
			}
		}
	}
	return false
}

// Guards
func canCheckout(u *User, cart *Cart) bool {
	if u == nil || !u.Verified {
		return false
	}
	if len(cart.Items) == 0 {
		return false
	}
	return true
}

Los programadores de Go lo llaman mantener la ruta feliz alineada a la izquierda. Linters como revive marcan un else después de un bloque que termina en return, porque ese else añade sangría para nada.

if/else frente a switch

Una cadena larga de else if que compara un valor con varios casos se lee mejor como un switch. Un switch sin expresión sustituye a una cadena if/else if de condiciones arbitrarias:

switch {
case score >= 90:
	return "A"
case score >= 80:
	return "B"
default:
	return "F"
}

Usa if para una o dos ramas, y switch cuando haya tres o más.

Sin operador ternario

Go no tiene cond ? a : b. Asigna con if:

label := "odd"
if n%2 == 0 {
	label = "even"
}

La página del operador ternario explica por qué y muestra las alternativas.

Errores comunes

• Sombrear con :=. if x, err := f(); err == nil { ... } declara un x nuevo solo para el if. Un x exterior no se actualiza.
• Asignación en la condición. if x = 5 {} es un error de compilación (cannot use assignment x = 5 as value), no un bug silencioso como en C. Usa ==.
• Comparar flotantes con ==. if total == 0.3 falla con valores calculados. Compara con una tolerancia.
• Comprobar el error equivocado. Después de a, err := f() y b, err := g(), asegúrate de que cada if err != nil va justo detrás de su llamada.

if x > 10 {
	fmt.Println("big")
} else if x > 5 {
	fmt.Println("medium")
} else {
	fmt.Println("small")
}