Fundamentos y toolchain

# Windows (tu caso), macOS y Linux:
winget install GoLang.Go        # o: brew install go / sudo apt install golang

$ go version
go version go1.24.5 windows/amd64

# Un proyecto nuevo son dos comandos. Sin arquetipos, sin spring initializr:
$ mkdir hola; cd hola
$ go mod init github.com/daniel/hola
$ go run .                       # compila Y ejecuta en un paso

package main

import "fmt" // la stdlib se importa por ruta; lo no usado NO compila

func main() {
	fmt.Println("Hola desde Go") // sin punto y coma: los pone el compilador
}

package main

import "fmt"

const Pi = 3.14159 // const sin tipo: se adapta al contexto (más flexible que final)

// iota genera secuencias: el enum minimalista de Go
const (
	Pendiente = iota // 0
	EnCurso          // 1
	Hecha            // 2
)

func main() {
	var edad int          // 0     ← zero value, nunca "basura" ni null
	var nombre string     // ""    ← string vacío, NO nil
	var activo bool       // false
	precio := 19.99       // float64 inferido (:= solo dentro de funciones)
	x, y := 10, 20        // asignación múltiple, como Python

	fmt.Println(edad, nombre, activo, precio, x+y)
}

// Retorno múltiple: adiós Optional<T>, adiós tuplas artificiales
func dividir(a, b float64) (float64, error) {
	if b == 0 {
		return 0, fmt.Errorf("división entre cero")
	}
	return a / b, nil
}

// Variádicas, como los varargs de Java
func sumar(nums ...int) int {
	total := 0
	for _, n := range nums {
		total += n
	}
	return total
}

func main() {
	resultado, err := dividir(10, 3)
	if err != nil {
		fmt.Println("error:", err)
		return
	}
	fmt.Println(resultado)

	// Closures: idénticas a las de JavaScript que usas en React
	contador := 0
	incrementar := func() int {
		contador++
		return contador
	}
	fmt.Println(incrementar(), incrementar()) // 1 2

	fmt.Println(sumar(1, 2, 3, 4)) // 10
}

// 1. for clásico
for i := 0; i < 5; i++ { fmt.Println(i) }

// 2. for como while
for saldo > 0 { saldo -= pago }

// 3. for infinito (tu while(true))
for { procesarSiguiente() }

// 4. for range: el for-each universal (slices, maps, strings, canales)
for i, fruta := range []string{"mango", "kiwi"} {
	fmt.Println(i, fruta)
}

// 5. range sobre enteros (Go 1.22+): como range(5) de Python
for i := range 5 { fmt.Println(i) }

// if con sentencia de inicialización: el err vive SOLO dentro del if
if err := guardar(usuario); err != nil {
	return err
}

// switch sin break (rompe solo), acepta condiciones tipo if/else-if
switch {
case hora < 12:
	fmt.Println("buenos días")
case hora < 19:
	fmt.Println("buenas tardes")
default:
	fmt.Println("buenas noches")
}

func procesarArchivo(ruta string) error {
	f, err := os.Open(ruta)
	if err != nil {
		return err
	}
	defer f.Close() // se ejecuta al salir de la función, pase lo que pase

	// ... trabajar con f sin preocuparte de cerrarlo en cada return ...
	return nil
}

// Los defer se apilan en orden LIFO (último en entrar, primero en salir)
func demo() {
	defer fmt.Println("3º")
	defer fmt.Println("2º")
	fmt.Println("1º")
} // imprime: 1º, 2º, 3º

// Paquete precios calcula descuentos y totales con impuestos.
// (comentario sobre "package": documenta el paquete entero)
package precios

// AplicarDescuento devuelve el precio tras aplicar el cupón.
// Un cupón desconocido no es un error: simplemente no descuenta.
func AplicarDescuento(precio float64, cupon string) float64 {
	// ...
}