Domina la sintaxis básica de Go: variables, tipos y control de flujo

Introducción

Go, también llamado Golang, es el lenguaje de programación creado por Google que combina la simplicidad de un lenguaje interpretado con la velocidad de un compilado. Si recién estás empezando a codificar en Go o venís de otro lenguaje y necesitás ponerte al día con la sintaxis esencial, este artículo es para vos.

En este post vas a aprender:

• Cómo declarar variables y asignarles valores, tanto con la forma tradicional como con la declaración corta (:=).
• Qué tipos de datos básicos maneja Go y cómo usarlos.
• Estructuras de control de flujo: if, for, switch y select (breve mención).
• Buenas prácticas al nombrar variables y estructurar el código.
• Los errores más comunes que suelen dar los que recién se inician en Go.

Todo con ejemplos prácticos y la salida esperada para que puedas probarlos en tu máquina.

1. Declaración de variables

1.1 Declaración tradicional con var

En Go, la forma clásica de declarar una variable es usando la palabra clave var seguida del nombre, el tipo y, opcionalmente, el valor inicial.

package main

import "fmt"

func main() {
    var nombre string = "Ana"
    var edad int = 27
    var saldo float64 = 1034.50
    var activo bool = true

    fmt.Printf("Nombre: %s, Edad: %d, Saldo: %.2f, Activo: %t
", nombre, edad, saldo, activo)
}

Salida esperada

Nombre: Ana, Edad: 27, Saldo: 1034.50, Activo: true

1.2 Declaración sin inicializador (valor cero)

Si omitís el valor inicial, Go asigna automáticamente el valor cero del tipo. Esto es útil cuando la variable será rellenada más adelante.

var contador int      // 0
var mensaje string   // ""
var lista []int       // nil (slice vacío)

1.3 Declaración corta con :=

Dentro de una función, la forma más cómoda y frecuente es usar la asignación corta :=. El compilador infiere el tipo a partir del valor a la derecha.

package main

import "fmt"

func main() {
    nombre := "Luis"
    edad := 31
    saldo := 250.75
    activo := false

    fmt.Printf("%s tiene %d años, saldo $%.2f, activo: %t
", nombre, edad, saldo, activo)
}

Salida esperada

Luis tiene 31 años, saldo $250.75, activo: false

Tip: := solo se puede usar dentro de funciones; fuera de ellas (a nivel de paquete) debes usar var.

2. Tipos de datos básicos

Go es fuertemente tipado, lo que significa que cada variable tiene un tipo fijo en tiempo de compilación.

2.1 Conversión de tipos

En Go, la conversión se hace explícitamente usando la sintaxis Tipo(valor). No hay conversiones implícitas.

package main

import "fmt"

func main() {
    var i int = 42
    var f float64 = float64(i) // conversión explícita
    var s string = fmt.Sprintf("%d", i) // convertir a string
    fmt.Println(i, f, s)
}

Salida esperada

42 42.0 42

3. Control de flujo

3.1 Condicional if

package main

import "fmt"

func main() {
    edad := 20
    if edad >= 18 {
        fmt.Println("Mayor de edad")
    } else {
        fmt.Println("Menor de edad")
    }
}

Salida

Mayor de edad

3.1.1 Declaración de variable dentro del if

Puedes declarar y usar una variable dentro de la condición.

if saldo := 1500.0; saldo > 1000 {
    fmt.Println("Saldo alto")
}

3.2 Bucle for

Go tiene un solo bucle: for. Puede usarse como while, como bucle clásico y como iterador sobre rangos.

3.2.1 Bucle clásico

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

Salida

0
1
2
3
4

3.2.2 Bucle tipo while

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

Salida

0
1
2

3.2.3 Iterando sobre slices con range

nombres := []string{"Ana", "Beto", "Clara"}
for idx, nombre := range nombres {
    fmt.Printf("%d: %s
", idx, nombre)
}

Salida

0: Ana
1: Beto
2: Clara

3.3 Sentencia switch

switch en Go es más potente que en muchos lenguajes; no necesita break y puede evaluar expresiones.

valor := 3
switch valor {
case 1:
    fmt.Println("Uno")
case 2, 3:
    fmt.Println("Dos o Tres")
default:
    fmt.Println("Otro número")
}

Salida

Dos o Tres

3.3.1 switch sin condición (equivalente a if‑else encadenado)

switch {
case valor < 0:
    fmt.Println("Negativo")
case valor == 0:
    fmt.Println("Cero")
default:
    fmt.Println("Positivo")
}

3.4 select (breve mención)

En programas concurrentes con canales, select permite esperar en varios canales a la vez. No lo profundizaremos aquí, pero es buena idea saber que existe.

4. Buenas prácticas y errores comunes

4.1 Nombres claros y en camelCase

Go sigue la convención de camelCase para nombres de variables y funciones. Los nombres que empiezan con mayúscula son exportados (visibles fuera del paquete).

var totalVentas int // privado
func CalcularPromedio() {} // exportado

4.2 Evitar variables sin uso

El compilador marcará como error cualquier variable declarada y nunca utilizada. Si necesitás un placeholder, usa _.

_, err := strconv.Atoi("123") // se ignora err si no lo vas a usar

4.3 No mezclar var y := en el mismo bloque

Mantener consistencia ayuda a la legibilidad. Dentro de una función, prefirír := para variables locales y var solo cuando necesitás especificar el tipo o declarar sin inicializar.

4.4 Conocer el valor cero

Olvidar que los tipos tienen valores cero puede llevar a bugs sutiles (por ejemplo, slices nil vs []int{}). Usa make para crear slices con capacidad inicial.

lista := make([]int, 0) // slice vacío, no nil

4.5 Errores de conversión implícita

A diferencia de JavaScript o Python, Go no convierte automáticamente entre tipos numéricos. Siempre usa conversiones explícitas.

var a int = 5
var b float64 = a // ERROR
var b float64 = float64(a) // CORRECTO

4.6 Uso correcto de if con asignación corta

Asegurate de no reutilizar la variable fuera del bloque si la declaraste dentro del if.

if x := compute(); x > 0 {
    fmt.Println(x) // x solo existe aquí
}
// fmt.Println(x) // <-- compile error

5. Conclusión

En este artículo cubrimos los fundamentos de la sintaxis de Go:

• Declaración de variables con var y :=.
• Tipos primitivos y cómo convertir entre ellos.
• Estructuras de control de flujo (if, for, switch).
• Buenas prácticas para evitar los errores más comunes.

Con estos conceptos ya podés escribir programas Go simples y entender código más complejo. El siguiente paso natural es explorar funciones, paquetes y la concurrencia con goroutines y canales.

Próximos pasos recomendados:

1. Crear un pequeño proyecto que lea datos de la consola y los procese usando for y switch.
2. Experimentar con paquetes externos (por ejemplo, github.com/google/uuid).
3. Sumergirte en la documentación oficial de Go para profundizar en temas avanzados.

¡Manos a la obra y feliz codificación en Go!