El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
HOME Mis cursos Finalizados
◄ Anterior
◄

Estructuras de Control

Siguiente ►
►

En este módulo, aprenderemos sobre las estructuras de control en Go, que son fundamentales para dirigir el flujo de ejecución de un programa. Las estructuras de control incluyen condicionales, bucles y otras construcciones que permiten tomar decisiones y repetir acciones.

Contenido

  1. Condicionales
  2. Bucles
  3. Switch
  4. Defer, Panic y Recover

Condicionales

Las estructuras condicionales permiten ejecutar diferentes bloques de código basados en ciertas condiciones.

if y else

La estructura if evalúa una condición y ejecuta un bloque de código si la condición es verdadera. La estructura else se puede usar para ejecutar un bloque de código alternativo si la condición es falsa.

package main

import "fmt"

func main() {
    x := 10

    if x > 5 {
        fmt.Println("x es mayor que 5")
    } else {
        fmt.Println("x es menor o igual a 5")
    }
}

else if

La estructura else if permite evaluar múltiples condiciones en secuencia.

package main

import "fmt"

func main() {
    x := 10

    if x > 15 {
        fmt.Println("x es mayor que 15")
    } else if x > 5 {
        fmt.Println("x es mayor que 5 pero menor o igual a 15")
    } else {
        fmt.Println("x es menor o igual a 5")
    }
}

Bucles

Los bucles permiten repetir un bloque de código varias veces. Go tiene una única estructura de bucle: for.

for

El bucle for en Go puede usarse de varias maneras.

Bucle clásico

package main

import "fmt"

func main() {
    for i := 0; i < 5; i++ {
        fmt.Println(i)
    }
}

Bucle tipo while

package main

import "fmt"

func main() {
    x := 0
    for x < 5 {
        fmt.Println(x)
        x++
    }
}

Bucle infinito

package main

import "fmt"

func main() {
    x := 0
    for {
        fmt.Println(x)
        x++
        if x == 5 {
            break
        }
    }
}

Switch

La estructura switch permite seleccionar entre múltiples bloques de código basados en el valor de una expresión.

Ejemplo básico

package main

import "fmt"

func main() {
    day := "Tuesday"

    switch day {
    case "Monday":
        fmt.Println("Hoy es lunes")
    case "Tuesday":
        fmt.Println("Hoy es martes")
    default:
        fmt.Println("No es lunes ni martes")
    }
}

Múltiples casos

package main

import "fmt"

func main() {
    day := "Saturday"

    switch day {
    case "Saturday", "Sunday":
        fmt.Println("Es fin de semana")
    default:
        fmt.Println("Es un día de semana")
    }
}

Defer, Panic y Recover

Estas son construcciones avanzadas que permiten manejar la ejecución diferida y la recuperación de errores.

defer

La instrucción defer pospone la ejecución de una función hasta que la función que la contiene termine.

package main

import "fmt"

func main() {
    defer fmt.Println("Esto se ejecutará al final")
    fmt.Println("Esto se ejecutará primero")
}

panic y recover

panic se usa para lanzar un error y recover se usa para manejarlo.

package main

import "fmt"

func main() {
    defer func() {
        if r := recover(); r != nil {
            fmt.Println("Recuperado del pánico:", r)
        }
    }()

    fmt.Println("Antes del pánico")
    panic("¡Algo salió mal!")
    fmt.Println("Esto no se ejecutará")
}

Ejercicios Prácticos

Ejercicio 1: Condicionales

Escribe un programa que lea un número del usuario y determine si es positivo, negativo o cero.

package main

import "fmt"

func main() {
    var num int
    fmt.Print("Introduce un número: ")
    fmt.Scan(&num)

    if num > 0 {
        fmt.Println("El número es positivo")
    } else if num < 0 {
        fmt.Println("El número es negativo")
    } else {
        fmt.Println("El número es cero")
    }
}

Ejercicio 2: Bucles

Escribe un programa que imprima los números del 1 al 10 usando un bucle for.

package main

import "fmt"

func main() {
    for i := 1; i <= 10; i++ {
        fmt.Println(i)
    }
}

Ejercicio 3: Switch

Escribe un programa que lea un día de la semana y determine si es un día laboral o un fin de semana.

package main

import "fmt"

func main() {
    var day string
    fmt.Print("Introduce un día de la semana: ")
    fmt.Scan(&day)

    switch day {
    case "Saturday", "Sunday":
        fmt.Println("Es fin de semana")
    default:
        fmt.Println("Es un día laboral")
    }
}

Conclusión

En esta sección, hemos cubierto las estructuras de control en Go, incluyendo condicionales, bucles y la instrucción switch. También hemos introducido las construcciones defer, panic y recover para el manejo avanzado de la ejecución y errores. Estas herramientas son fundamentales para controlar el flujo de ejecución de tus programas y manejar situaciones excepcionales de manera efectiva. En el próximo módulo, exploraremos las funciones en Go, que te permitirán modularizar y reutilizar tu código de manera eficiente.

◄ Anterior
◄
Siguiente ►
►
El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
© Copyright 2024. Todos los derechos reservados