Tutorial Go: Estructuras de control

Sentencias if, else if, else

En Go, las sentencias if permiten ejecutar bloques de código basados en condiciones booleanas. La estructura básica de una sentencia if es similar a otros lenguajes de programación, pero con ciertas particularidades propias de Go. La sintaxis es la siguiente:

if condición {
    // bloque de código si la condición es verdadera
}

Go no requiere paréntesis alrededor de la condición, pero las llaves {} son obligatorias incluso si el bloque contiene una sola línea de código. Esto asegura claridad y consistencia en el código.

Las sentencias else if y else se utilizan para manejar múltiples condiciones. Si la condición en un if no se cumple, se evalúa la condición de un else if, y así sucesivamente. La estructura es la siguiente:

if condición1 {
    // bloque de código si condición1 es verdadera
} else if condición2 {
    // bloque de código si condición2 es verdadera
} else {
    // bloque de código si ninguna condición anterior es verdadera
}

Cada else if puede tener su propia condición, y el bloque else es opcional, ejecutándose solo si todas las condiciones anteriores son falsas.

En una sentencia if, Go permite declarar e inicializar variables que solo estarán disponibles dentro del ámbito de la sentencia if y sus else if correspondientes. Esta característica es útil para evaluar condiciones basadas en valores que se calculan en el momento. Por ejemplo:

if valor, err := funciónQueRetornaError(); err != nil {
    // manejar el error
} else {
    // usar valor
}

En este ejemplo, valor y err son accesibles dentro de todo el bloque if-else. Esta declaración compacta es una práctica común en Go para manejar errores y condiciones complejas de manera eficiente.

Es importante notar que Go no admite la construcción de else if en una única palabra (elseif), como ocurre en otros lenguajes. Cada condición debe ser claramente separada por un espacio entre else y if.

Uso de switch y case

En el lenguaje Go, la estructura switch proporciona una manera concisa de ejecutar diferentes bloques de código basados en el valor de una expresión. A diferencia de otros lenguajes, el switch en Go no requiere un break explícito para salir del caso, ya que cada caso se rompe automáticamente después de ejecutarse, a menos que se utilice la palabra clave fallthrough.

La sintaxis básica de un switch es:

switch expresión {
case valor1:
    // bloque de código para valor1
case valor2:
    // bloque de código para valor2
default:
    // bloque de código si no coincide ningún caso
}

La expresión en un switch puede ser cualquier tipo, y no está limitada a ser un número entero como en algunos otros lenguajes. Esto permite evaluar cadenas, booleanos, y cualquier tipo comparable. Si la expresión en el switch está ausente, se evalúa como true por defecto, permitiendo que los casos sean condiciones booleanas:

switch {
case condición1:
    // bloque de código si condición1 es verdadera
case condición2:
    // bloque de código si condición2 es verdadera
default:
    // bloque de código si ninguna condición es verdadera
}

El uso de fallthrough permite continuar con la ejecución del siguiente caso, independientemente de si la condición es verdadera o no. Sin embargo, su uso debe ser cuidadoso ya que puede llevar a un comportamiento inesperado si no se gestiona adecuadamente:

switch valor := obtenerValor(); valor {
case 1:
    fmt.Println("Uno")
    fallthrough
case 2:
    fmt.Println("Dos")
case 3:
    fmt.Println("Tres")
}

Este ejemplo imprimirá "Uno" y "Dos" si obtenerValor() devuelve 1, debido al uso de fallthrough.

El switch en Go también permite múltiples valores por caso, lo que facilita el manejo de varias condiciones en un solo bloque:

switch valor {
case 1, 2, 3:
    fmt.Println("Uno, Dos o Tres")
case 4, 5, 6:
    fmt.Println("Cuatro, Cinco o Seis")
default:
    fmt.Println("Otro valor")
}

El uso de switch es preferido en Go para comparar múltiples condiciones debido a su claridad y eficiencia. Al evitar la necesidad de múltiples bloques if-else, se mejora la legibilidad y mantenimiento del código. Además, proporciona un mecanismo más limpio y seguro para evaluar condiciones múltiples, minimizando errores comunes asociados con el uso de break en otros lenguajes.