Aprende Go desde cero

package main

import "fmt"

func main() {
	fmt.Println("¡Hola, mundo!")
	fmt.Println(2 + 3) // 5
}

package main

import "fmt"

func main() {
	nombre := "Ana"
	edad := 30
	var precio float64 = 19.99
	var activo bool // false (valor cero)

	fmt.Printf("%s tiene %d años. Total: %.2f. Activo: %t\n", nombre, edad, precio*3, activo)
}

package main

import "fmt"

func main() {
	for i := 1; i <= 3; i++ {
		fmt.Println("vuelta", i)
	}

	nota := 7
	switch {
	case nota >= 9:
		fmt.Println("Sobresaliente")
	case nota >= 5:
		fmt.Println("Aprobado")
	default:
		fmt.Println("Suspenso")
	}
}

package main

import "fmt"

func main() {
	notas := []int{7, 8, 9}
	notas = append(notas, 10)
	for i, n := range notas {
		fmt.Println(i, n)
	}

	stock := map[string]int{"teclado": 10, "raton": 0}
	if unidades, ok := stock["webcam"]; !ok {
		fmt.Println("No hay webcams en el catálogo", unidades)
	}
}

package main

import (
	"errors"
	"fmt"
)

func dividir(a, b float64) (float64, error) {
	if b == 0 {
		return 0, errors.New("división entre cero")
	}
	return a / b, nil
}

func main() {
	if r, err := dividir(10, 4); err == nil {
		fmt.Println(r) // 2.5
	}
	if _, err := dividir(1, 0); err != nil {
		fmt.Println("Error:", err)
	}
}

package main

import "fmt"

type Cuenta struct {
	Titular string
	Saldo   float64
}

func (c *Cuenta) Ingresar(cantidad float64) {
	c.Saldo += cantidad
}

func main() {
	c := Cuenta{Titular: "Ana"}
	c.Ingresar(50)
	fmt.Printf("%s: %.2f\n", c.Titular, c.Saldo) // Ana: 50.00
}

package main

import (
	"fmt"
	"math"
)

type Figura interface {
	Area() float64
}

type Circulo struct{ Radio float64 }
type Rectangulo struct{ Ancho, Alto float64 }

func (c Circulo) Area() float64    { return math.Pi * c.Radio * c.Radio }
func (r Rectangulo) Area() float64 { return r.Ancho * r.Alto }

func main() {
	figuras := []Figura{Circulo{1}, Rectangulo{2, 3}}
	for _, f := range figuras {
		fmt.Printf("%.2f\n", f.Area())
	}
}

package main

import (
	"fmt"
	"sync"
)

func cuadrado(n int, resultados chan<- int, wg *sync.WaitGroup) {
	defer wg.Done()
	resultados <- n * n
}

func main() {
	resultados := make(chan int, 3)
	var wg sync.WaitGroup
	for _, n := range []int{2, 3, 4} {
		wg.Add(1)
		go cuadrado(n, resultados, &wg)
	}
	wg.Wait()
	close(resultados)

	suma := 0
	for r := range resultados {
		suma += r
	}
	fmt.Println(suma) // 29
}

# En la terminal
go mod init ejemplo.com/tienda
go get github.com/google/uuid@latest
go mod tidy

// main.go
package main

import (
	"fmt"

	"github.com/google/uuid"
)

func main() {
	fmt.Println("Pedido", uuid.NewString())
}

package main

import (
	"encoding/json"
	"log"
	"net/http"
)

func main() {
	http.HandleFunc("GET /saludo/{nombre}", func(w http.ResponseWriter, r *http.Request) {
		w.Header().Set("Content-Type", "application/json")
		json.NewEncoder(w).Encode(map[string]string{"saludo": "Hola, " + r.PathValue("nombre")})
	})
	log.Println("Escuchando en http://localhost:8080")
	log.Fatal(http.ListenAndServe(":8080", nil))
}

package main

import (
	"cmp"
	"fmt"
	"slices"
)

func Maximo[T cmp.Ordered](a, b T) T {
	if a > b {
		return a
	}
	return b
}

func Filtrar[T any](lista []T, cumple func(T) bool) []T {
	var resultado []T
	for _, v := range lista {
		if cumple(v) {
			resultado = append(resultado, v)
		}
	}
	return resultado
}

func main() {
	fmt.Println(Maximo(3, 7), Maximo("pera", "manzana"))  // 7 pera

	pares := Filtrar([]int{1, 2, 3, 4}, func(n int) bool { return n%2 == 0 })
	fmt.Println(pares)                                     // [2 4]

	nombres := []string{"Luis", "Ana", "Marta"}
	slices.Sort(nombres)
	fmt.Println(nombres, slices.Contains(nombres, "Ana"))  // [Ana Luis Marta] true
}

package main

import (
	"errors"
	"fmt"
	"os"
)

func leerConfig(ruta string) ([]byte, error) {
	datos, err := os.ReadFile(ruta)
	if err != nil {
		return nil, fmt.Errorf("leer configuración: %w", err)
	}
	return datos, nil
}

func main() {
	_, err := leerConfig("no-existe.json")
	if errors.Is(err, os.ErrNotExist) {
		fmt.Println("Falta el archivo; uso la configuración por defecto")
	}
	fmt.Println(err)
	// leer configuración: open no-existe.json: no such file or directory
}

// archivo precio.go
package tienda

func ConIva(precio float64) float64 {
	return precio * 1.21
}

// archivo precio_test.go
package tienda

import "testing"

func TestConIva(t *testing.T) {
	casos := []struct {
		entrada, esperado float64
	}{
		{100, 121},
		{0, 0},
		{50, 60.5},
	}
	for _, c := range casos {
		if obtenido := ConIva(c.entrada); obtenido != c.esperado {
			t.Errorf("ConIva(%v) = %v; se esperaba %v", c.entrada, obtenido, c.esperado)
		}
	}
}
// go test ./...  →  ok  tienda  0.002s

package main

import (
	"encoding/json"
	"fmt"
)

type Pedido struct {
	ID       int      `json:"id"`
	Cliente  string   `json:"cliente"`
	Total    float64  `json:"total"`
	Notas    string   `json:"notas,omitempty"`
	interno  string   // minúscula: no se exporta ni se guarda en el JSON
}

func main() {
	p := Pedido{ID: 7, Cliente: "Ana", Total: 42.5, interno: "x"}
	datos, _ := json.Marshal(p)
	fmt.Println(string(datos))  // {"id":7,"cliente":"Ana","total":42.5}

	var leido Pedido
	err := json.Unmarshal([]byte(`{"id":8,"cliente":"Luis","total":10}`), &leido)
	fmt.Println(leido.Cliente, err)  // Luis <nil>
}

package main

import (
	"context"
	"fmt"
	"net/http"
	"time"
)

func consultar(ctx context.Context, url string) (int, error) {
	req, err := http.NewRequestWithContext(ctx, http.MethodGet, url, nil)
	if err != nil {
		return 0, err
	}
	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		return 0, err  // incluye «context deadline exceeded» si se pasa de tiempo
	}
	defer resp.Body.Close()
	return resp.StatusCode, nil
}

func main() {
	ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
	defer cancel()

	codigo, err := consultar(ctx, "https://go.dev")
	fmt.Println(codigo, err)  // 200 <nil> (o un error si tarda más de 2 segundos)
}