Variables y tipos de datos en Go

¿Qué es y para qué sirve?

Imagina que estás jugando un videojuego y quieres recordar cuántas vidas tienes. Tomas un papelito, escribes «vidas = 3» y lo guardas en una caja. Luego, cuando un monstruo te golpea, abres la caja, miras el papelito, restas 1 y escribes «vidas = 2». Pues bien, esa caja con el papelito es una variable en programación. Almacena algún valor (un número, un texto o algo más) y permite cambiarlo.

Y un tipo de dato es como una etiqueta en la caja: «aquí solo números», «aquí solo palabras», «aquí solo verdadero/falso». Si intentas poner la palabra «hola» en una caja para números, el programa dirá: «¡Oye, así no se puede!» — y se romperá. Los tipos de datos son necesarios para que la computadora sepa cómo manejar la información: los números se pueden sumar, las palabras se pueden unir, y lo verdadero/falso se puede verificar.

En Go (el lenguaje de programación de Google), las variables y los tipos de datos son la base. Sin ellos no podrás escribir ningún programa. Incluso una calculadora simple o un juego de «Adivina el número» — en todas partes se necesitan variables. Así que vamos a entender cómo funciona esto.

Sintaxis y ejemplos de código

En Go, las variables se declaran de dos maneras: de forma corta (para código rápido) y de forma completa (cuando se necesita especificar el tipo). Mira los ejemplos.

// Ejemplo 1: Declaración corta (solo para variables nuevas)
package main

import "fmt"

func main() {
    // Creamos la variable "age" (edad) y le damos el valor 12 inmediatamente
    age := 12
    // Mostramos en pantalla
    fmt.Println("Mi edad:", age)
    
    // Cambiamos el valor
    age = 13
    fmt.Println("Ahora tengo:", age)
}

Comentario: := es como una varita mágica. Crea la variable y adivina por sí misma qué tipo tiene (en este caso, número). fmt.Println es el comando «imprime». Observa: después de age = 13 no escribimos :=, porque la variable ya existe.

// Ejemplo 2: Declaración completa con tipo
package main

import "fmt"

func main() {
    // Decimos: "Crea una variable name de tipo string (cadena) con el valor "Ana""
    var name string = "Ana"
    fmt.Println("Hola,", name)
    
    // Se puede declarar sin valor (entonces será una cadena vacía)
    var nickname string
    nickname = "SuperCodificador"
    fmt.Println("Tu apodo:", nickname)
}

Comentario: var es la palabra clave «variable». Después va el nombre, luego el tipo (string — texto), luego el valor. Si no se da un valor, Go mismo asigna un «valor vacío»: para números — 0, para cadenas — "" (cadena vacía).

// Ejemplo 3: Diferentes tipos de datos
package main

import "fmt"

func main() {
    // Números: enteros (int) y decimales (float64)
    var apples int = 10          // número entero
    var price float64 = 2.5      // número decimal (con punto)
    
    // Cadena (texto)
    var greeting string = "¡Hola, mundo!"
    
    // Booleano (verdadero/falso)
    var isHappy bool = true      // true = verdadero, false = falso
    
    fmt.Println("Manzanas:", apples)
    fmt.Println("Precio por kg:", price)
    fmt.Println("Mensaje:", greeting)
    fmt.Println("¿Feliz?", isHappy)
}

Comentario: int — números enteros (1, 100, -5). float64 — números con punto decimal (3.14, 0.5). string — texto entre comillas. bool — solo true o false. Si se confunden los tipos, Go se quejará.

// Ejemplo 4: Varias variables a la vez
package main

import "fmt"

func main() {
    // Se pueden declarar varias variables del mismo tipo en una línea
    var x, y int = 5, 10
    fmt.Println("x + y =", x + y)
    
    // O de diferentes tipos (pero rara vez se hace así)
    var (
        name string = "Vasya"
        age  int    = 15
    )
    fmt.Println(name, age)
}

Comentario: Si se necesitan muchas variables, se pueden agrupar en un bloque var (...). Esto es conveniente y se lee más fácilmente.

// Ejemplo 5: Error al cambiar de tipo
package main

import "fmt"

func main() {
    var score int = 100
    // score = "cien" // ¡ERROR! No se puede reemplazar un número por una cadena
    fmt.Println("Puntos:", score)
    
    // Correcto: solo número
    score = 200
    fmt.Println("Nuevos puntos:", score)
}

Comentario: Si se descomenta la línea score = "cien", el programa no se ejecutará. Go es estricto: una vez que declaraste int, solo números.

Comparación con Python

Python es como el hermano menor de Go: es más simple y hace muchas cosas por ti. Pero Go tiene sus propias características. Mira la tabla:

Ejemplo en Python (cómo se vería):

# Python: no se especifica el tipo
age = 12
name = "Ana"
price = 2.5
is_happy = True

# Incluso se puede hacer así (pero es mejor no hacerlo)
age = "doce"  # Python lo permite, pero esto es confuso

En Go siempre sabes qué tipo tiene una variable. Esto ayuda a evitar errores tontos. Python es más flexible, pero debido a esto los principiantes a menudo se confunden: «¿Tengo un número o una cadena?».

Errores típicos de principiantes

1. Olvidar := o var
   age = 12 — ¡error! Se necesita age := 12 o var age int = 12. A Go no le gusta cuando las variables