Fundamentos de Go: Variables, Constantes, Estructuras de Control y Datos

¡Hola a todos! En este módulo del curso de Go, vamos a explorar los fundamentos del lenguaje. Ya hemos configurado el entorno de desarrollo y hemos escrito nuestro primer programa, pero ahora es el momento de aprender a trabajar con variables, operadores, estructuras de control y estructuras de datos fundamentales.

Declaración de Variables en Go

En Go, podemos declarar variables de dos maneras diferentes. La primera es utilizando la palabra clave var, seguida del nombre de la variable y luego el tipo de dato que almacenará. Por ejemplo:

    var name string
    var age int

Para guardar un dato en la variable, escribimos el nombre de la variable seguido del símbolo = y el valor que queremos almacenar. Para acceder al valor de la variable, simplemente referenciamos su nombre.

La segunda forma de declarar variables es utilizando la inferencia de tipos, que permite a Go deducir el tipo de la variable basado en el valor asignado. Para esto, usamos := después del nombre de la variable:

    name := "Roberto"
    age := 30

Constantes en Go

Las constantes se declaran utilizando la palabra clave const y su valor no puede cambiar durante la ejecución del programa. Go tiene tipos de datos comunes como:

• Strings: texto (string)
• Enteros: números enteros (int)
• Flotantes: números decimales (float)
• Booleanos: verdadero o falso (bool)

En cuanto a los flotantes, Go ofrece dos tipos: float32 y float64. Por defecto, se asigna float64, que representa de 15 a 17 dígitos significativos, mientras que float32 representa de 6 a 9.

Conversión de Tipos en Go

Go permite la conversión de tipos explícita cuando es necesario. Por ejemplo, podemos convertir un int a float64 utilizando la función float64:

    A := 5
    B := float64(A)  

También es posible convertir de un string a un int, pero no se puede hacer directamente. Para ello, utilizamos la función Atoi del paquete strconv.

    import "strconv"

    number, err := strconv.Atoi("123")

En este caso, number contendrá el número convertido y err contendrá cualquier error que pueda ocurrir durante la conversión.

Operadores en Go

Go soporta varios operadores. Los más comunes son:

• Operadores Aritméticos: para sumar, restar, multiplicar, dividir o obtener el resto de una división.
• Operadores Lógicos: AND, OR, NOT.
• Operadores de Comparación: igual a, diferente de, menor que, mayor que, etc.

Estructuras de Control en Go

Las estructuras de control son esenciales para dirigir cómo se ejecuta tu programa. Vamos a ver cómo usar condicionales para manejar diferentes situaciones en tu código.

Condicionales If

La estructura If es simple. Se escribe la palabra If seguida de la condición y el bloque de código que se ejecutará si la condición se cumple:

    if age >= 18 {
        fmt.Println("Eres mayor de edad.")
    } else {
        fmt.Println("Eres menor de edad.")
    }

En este caso, si age es 18 o más, se ejecutará el primer bloque. Si es menor, se ejecutará el bloque del else.

Else-If

También podemos usar Else-If para realizar verificaciones adicionales:

    if age >= 18 {
        fmt.Println("Eres mayor de edad.")
    } else if age > 0 {
        fmt.Println("Eres menor de edad.")
    } else {
        fmt.Println("Edad no válida.")
    }

Switch

La estructura Switch es una forma concisa de manejar múltiples condiciones:

    switch day {
    case "Monday":
        fmt.Println("Inicio de semana.")
    case "Friday":
        fmt.Println("Fin de semana.")
    default:
        fmt.Println("Día regular.")
    }

Bucles en Go

El bucle For es el principal bucle en Go y puede actuar como un bucle típico o como un bucle estilo While. Aquí hay un ejemplo de un bucle tradicional:

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

También puedes usar For como un While indicando solo la condición:

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

Recuerda que puedes usar Break para salir de un bucle prematuramente o Continue para saltar una iteración.

Estructuras de Datos en Go

Las estructuras de datos más importantes en Go son arrays, slices y maps. Vamos a empezar con los arrays.

Arrays

Los arrays en Go tienen un tamaño fijo y todos sus elementos deben ser del mismo tipo:

    var arr [5]int
    arr[0] = 1
    arr[1] = 2

Los arrays tienen un límite; no puedes agregar elementos en índices fuera de ese límite.

Slides

Los slices son más flexibles que los arrays, ya que pueden crecer o reducir su tamaño dinámicamente:

    var slice []int
    slice = append(slice, 1, 2, 3)

Puedes crear sub-slices de manera eficiente utilizando el nombre del slice seguido de corchetes:

    subSlice := slice[1:3]

Maps

Los maps almacenan pares clave-valor y son útiles para asociar datos de manera rápida:

    ages := make(map[string]int)
    ages["Roberto"] = 32
    fmt.Println(ages["Roberto"])

Resumen

En resumen, hemos cubierto cómo manejar variables y constantes, usar operadores, implementar control de flujo y trabajar con arrays, slices y maps. Estos son los bloques de construcción de cualquier programa en Go. En el próximo módulo, nos adentraremos en funciones y estructuras, así que no te lo pierdas.

Para más información y recursos, puedes unirte a nuestra comunidad en Discord o convertirte en miembro de nuestro canal en YouTube.