Fundamentos de Tipos de Datos

10 ejemplos para empezar con el sistema de tipos y el comportamiento de la memoria de Go - 7 básicos y 3 intermedios.

Prerrequisitos

Instale Go 1.26.x y ejecute los ejemplos desde cualquier directorio de módulo:

go version   # se espera go1.26.x
mkdir -p /tmp/go-types-demo && cd /tmp/go-types-demo
go mod init example.com/types-demo

Guarde cada fragmento como main.go (o combine en un solo main con funciones separadas) y ejecute go run ..

Ejemplos Básicos

1. Valores Cero

Cada variable declarada sin un inicializador recibe el valor cero de su tipo.

package main
 
import "fmt"
 
func main() {
	var i int
	var s string
	var p *int
	fmt.Printf("int=%d string=%q ptr=%v\n", i, s, p)
}

0, "", false, nil son los valores cero comunes para tipos numéricos, de cadena, booleanos y similares a referencias.
El valor cero no es "no establecido" - es un estado válido para el que debe diseñar (especialmente slices y mapas nil).
Use var cuando el valor cero sea significativo; use := con un literal cuando no lo sea.

Relacionado: Modelo de Memoria de Go - por qué la semántica de valor comienza en los valores cero.

2. Arrays vs Slices

Los arrays tienen un tamaño fijo en el tipo; los slices son vistas dinámicas sobre un array subyacente.

package main
 
import "fmt"
 
func main() {
	var arr [3]int = [3]int{1, 2, 3}
	sl := []int{10, 20, 30}
	fmt.Println(len(arr), len(sl), cap(sl))
}

[3]int y [4]int son tipos diferentes - los arrays rara vez son parámetros de función en las APIs.
Los slices son el tipo de secuencia idiomático - las cabeceras se pasan por valor, el array subyacente se comparte.
len es la longitud; cap es la capacidad desde el primer elemento del slice hasta el final del array subyacente.

Relacionado: Internos de Slice - puntero, len, cap y layout de append.

3. Mapas y Comportamiento Nil

Los mapas asocian claves con valores. Un mapa nil es legible pero no escribible.

package main
 
import "fmt"
 
func main() {
	var m map[string]int
	fmt.Println(m["missing"]) // 0, no hay panic
	m = make(map[string]int)
	m["go"] = 1
	fmt.Println(m["go"])
}

Leer una clave faltante devuelve el valor cero del tipo de valor - use la forma coma-ok para detectar la presencia.
Escribir en un mapa nil provoca un panic - siempre use make o un literal antes de insertar.
Los mapas no son seguros para escrituras concurrentes sin un mutex o sync.Map.

Relacionado: Internos de Mapas - crecimiento y orden de iteración.

4. Literales de Struct y Etiquetas de Campo

Los structs agrupan campos con semántica de valor a menos que almacene punteros.

package main
 
import (
	"encoding/json"
	"fmt"
)
 
type User struct {
	ID   int    `json:"id"`
	Name string `json:"name"`
}
 
func main() {
	u := User{ID: 1, Name: "Ada"}
	b, _ := json.Marshal(u)
	fmt.Println(string(b))
}

Los campos exportados comienzan con mayúscula - encoding/json solo ve campos exportados.
La asignación de structs copia todos los campos - incluyendo campos de slice y mapa (las cabeceras se comparten).
Las etiquetas de campo son cadenas de metadatos analizadas por reflect en tiempo de ejecución.

Relacionado: Alineación de Structs - padding y unsafe.Sizeof.

5. Punteros y Operadores de Dirección

& toma una dirección; * desreferencia. Go no tiene aritmética de punteros en código seguro.

package main
 
import "fmt"
 
func bump(n *int) {
	*n++
}
 
func main() {
	x := 10
	bump(&x)
	fmt.Println(x)
}

No puede tomar la dirección de un índice de mapa ni de la mayoría de los temporales - el compilador impone la seguridad de la memoria.
new(T) devuelve *T inicializado a cero - equivalente a var v T; return &v cuando escapa.
La desreferencia de puntero nil provoca un panic - verifique antes de usar en APIs defensivas.

Relacionado: Punteros unsafe - cuándo unsafe.Pointer está justificado.

6. Interfaces Vacías y Tipadas

interface{} (o any) contiene cualquier valor; otras interfaces contienen valores con métodos específicos.

package main
 
import "fmt"
 
type Greeter interface {
	Greet() string
}
 
type Person struct{ Name string }
 
func (p Person) Greet() string { return "hello, " + p.Name }
 
func describe(v any) {
	fmt.Printf("%T %v\n", v, v)
}
 
func main() {
	var g Greeter = Person{Name: "Ada"}
	describe(g)
	fmt.Println(g.Greet())
}

Las interfaces se satisfacen implícitamente - sin palabra clave implements.
%T imprime el tipo dinámico - esencial al depurar parámetros any.
Una interfaz nil (var i any) difiere de una interfaz que contiene un puntero nil tipado.

Relacionado: Internos de Interfaces - itables y tipo dinámico.

7. Canales para Señalización

Los canales transfieren valores entre goroutines con semántica de bloqueo.

package main
 
import "fmt"
 
func main() {
	ch := make(chan int, 1)
	ch <- 42
	v := <-ch
	fmt.Println(v)
}

make(chan T) no tiene búfer - sincronización de envío y recepción.
La capacidad make(chan T, n) almacena en búfer n envíos sin un receptor coincidente.
Cerrar un canal señala la finalización - los receptores obtienen el valor cero y ok == false.

Relacionado: Internos de Canales - reglas de bloqueo en detalle.

Ejemplos Intermedios

8. Asignaciones de Tipo y Switches de Tipo

Extraiga tipos concretos de interfaces de forma segura.

package main
 
import "fmt"
 
func parse(v any) {
	switch x := v.(type) {
	case int:
		fmt.Println("int", x*2)
	case string:
		fmt.Println("string", len(x))
	default:
		fmt.Printf("otro %T\n", x)
	}
}
 
func main() {
	parse(21)
	parse("go")
}

La asignación de dos valores x, ok := v.(int) evita el panic en asignaciones fallidas.
Los switches de tipo se despachan según el tipo dinámico - comunes en decodificadores JSON y APIs de plugins.
Asignar al tipo concreto incorrecto provoca un panic en la forma de un solo valor.

Relacionado: Interfaz Nil vs Puntero Nil - trampas de asignación con nil tipado.

9. Compartición de Slices y `copy`

La creación de sub-slices comparte un array subyacente; copy duplica elementos en un slice existente.

package main
 
import "fmt"
 
func main() {
	src := []int{1, 2, 3, 4}
	dst := make([]int, 2)
	n := copy(dst, src[1:])
	fmt.Println(dst, n, src)
}

copy devuelve el número de elementos copiados - el mínimo de len(dst) y len(src).
La creación de sub-slices no copia datos - mutar dst puede afectar a src si se superponen.
Use append a un nuevo slice con capacidad suficiente cuando necesite una copia independiente.

Relacionado: Internos de Slice - cuándo append reasigna.

10. `make` vs `new`

make inicializa slices, mapas y canales; new asigna un solo valor y devuelve un puntero.

package main
 
import "fmt"
 
func main() {
	s := make([]byte, 0, 64)
	m := make(map[string]struct{})
	c := make(chan struct{})
	p := new(int)
	fmt.Printf("slice cap=%d map=%v chan=%v *p=%d\n", cap(s), m != nil, c != nil, *p)
}

make devuelve un valor inicializado (no nil) listo para usar.
new(T) rara vez es necesario - var v T; &v o literales son más claros para structs.
La capacidad en make([]T, 0, n) evita el crecimiento repetido de append en bucles intensivos.

Relacionado: Tipos de Datos y Mejores Prácticas de Memoria - elección de layouts para el rendimiento.

Enlaces Externos Relacionados

A Tour of Go - Introducción interactiva oficial a Go.
Go by Example - Ejemplos de código prácticos anotados.
Documentación de la Biblioteca Estándar de Go - Referencia completa de la biblioteca estándar.
Get Programming with Go (Manning) - Nathan Youngman & Roger Peppé.
The Go Programming Language (ebook) - Donovan & Kernighan.

Versiones de Stack: Esta página fue escrita para Go 1.26.x (GC por defecto Green Tea, go fix modernizadores - verificar parche en la compilación), chi (última - verificar en la compilación), gin (última - verificar en la compilación), echo (última - verificar en la compilación), google.golang.org/grpc (última - verificar en la compilación), sigs.k8s.io/controller-runtime (última - verificar en la compilación), kubebuilder (última - verificar en la compilación), tinygo (última - verificar objetivos de placa en la compilación), wazero (última - verificar en la compilación) y golangci-lint (última - verificar conjunto de linters en la compilación).

Prerrequisitos

Instale Go 1.26.x y ejecute los ejemplos desde cualquier directorio de módulo:

go version   # se espera go1.26.x
mkdir -p /tmp/go-types-demo && cd /tmp/go-types-demo
go mod init example.com/types-demo

Guarde cada fragmento como main.go (o combine en un solo main con funciones separadas) y ejecute go run ..

Ejemplos Básicos

1. Valores Cero

Cada variable declarada sin un inicializador recibe el valor cero de su tipo.

package main
 
import "fmt"
 
func main() {
	var i int
	var s string
	var p *int
	fmt.Printf("int=%d string=%q ptr=%v\n", i, s, p)
}

0, "", false, nil son los valores cero comunes para tipos numéricos, de cadena, booleanos y similares a referencias.
El valor cero no es "no establecido" - es un estado válido para el que debe diseñar (especialmente slices y mapas nil).
Use var cuando el valor cero sea significativo; use := con un literal cuando no lo sea.

Relacionado: Modelo de Memoria de Go - por qué la semántica de valor comienza en los valores cero.

2. Arrays vs Slices

Los arrays tienen un tamaño fijo en el tipo; los slices son vistas dinámicas sobre un array subyacente.

package main
 
import "fmt"
 
func main() {
	var arr [3]int = [3]int{1, 2, 3}
	sl := []int{10, 20, 30}
	fmt.Println(len(arr), len(sl), cap(sl))
}

[3]int y [4]int son tipos diferentes - los arrays rara vez son parámetros de función en las APIs.
Los slices son el tipo de secuencia idiomático - las cabeceras se pasan por valor, el array subyacente se comparte.
len es la longitud; cap es la capacidad desde el primer elemento del slice hasta el final del array subyacente.

Relacionado: Internos de Slice - puntero, len, cap y layout de append.

3. Mapas y Comportamiento Nil

Los mapas asocian claves con valores. Un mapa nil es legible pero no escribible.

package main
 
import "fmt"
 
func main() {
	var m map[string]int
	fmt.Println(m["missing"]) // 0, no hay panic
	m = make(map[string]int)
	m["go"] = 1
	fmt.Println(m["go"])
}

Leer una clave faltante devuelve el valor cero del tipo de valor - use la forma coma-ok para detectar la presencia.
Escribir en un mapa nil provoca un panic - siempre use make o un literal antes de insertar.
Los mapas no son seguros para escrituras concurrentes sin un mutex o sync.Map.

Relacionado: Internos de Mapas - crecimiento y orden de iteración.

4. Literales de Struct y Etiquetas de Campo

Los structs agrupan campos con semántica de valor a menos que almacene punteros.

package main
 
import (
	"encoding/json"
	"fmt"
)
 
type User struct {
	ID   int    `json:"id"`
	Name string `json:"name"`
}
 
func main() {
	u := User{ID: 1, Name: "Ada"}
	b, _ := json.Marshal(u)
	fmt.Println(string(b))
}

Los campos exportados comienzan con mayúscula - encoding/json solo ve campos exportados.
La asignación de structs copia todos los campos - incluyendo campos de slice y mapa (las cabeceras se comparten).
Las etiquetas de campo son cadenas de metadatos analizadas por reflect en tiempo de ejecución.

Relacionado: Alineación de Structs - padding y unsafe.Sizeof.

5. Punteros y Operadores de Dirección

& toma una dirección; * desreferencia. Go no tiene aritmética de punteros en código seguro.

package main
 
import "fmt"
 
func bump(n *int) {
	*n++
}
 
func main() {
	x := 10
	bump(&x)
	fmt.Println(x)
}

No puede tomar la dirección de un índice de mapa ni de la mayoría de los temporales - el compilador impone la seguridad de la memoria.
new(T) devuelve *T inicializado a cero - equivalente a var v T; return &v cuando escapa.
La desreferencia de puntero nil provoca un panic - verifique antes de usar en APIs defensivas.

Relacionado: Punteros unsafe - cuándo unsafe.Pointer está justificado.

6. Interfaces Vacías y Tipadas

interface{} (o any) contiene cualquier valor; otras interfaces contienen valores con métodos específicos.

package main
 
import "fmt"
 
type Greeter interface {
	Greet() string
}
 
type Person struct{ Name string }
 
func (p Person) Greet() string { return "hello, " + p.Name }
 
func describe(v any) {
	fmt.Printf("%T %v\n", v, v)
}
 
func main() {
	var g Greeter = Person{Name: "Ada"}
	describe(g)
	fmt.Println(g.Greet())
}

Las interfaces se satisfacen implícitamente - sin palabra clave implements.
%T imprime el tipo dinámico - esencial al depurar parámetros any.
Una interfaz nil (var i any) difiere de una interfaz que contiene un puntero nil tipado.

Relacionado: Internos de Interfaces - itables y tipo dinámico.

7. Canales para Señalización

Los canales transfieren valores entre goroutines con semántica de bloqueo.

package main
 
import "fmt"
 
func main() {
	ch := make(chan int, 1)
	ch <- 42
	v := <-ch
	fmt.Println(v)
}

make(chan T) no tiene búfer - sincronización de envío y recepción.
La capacidad make(chan T, n) almacena en búfer n envíos sin un receptor coincidente.
Cerrar un canal señala la finalización - los receptores obtienen el valor cero y ok == false.

Relacionado: Internos de Canales - reglas de bloqueo en detalle.

Ejemplos Intermedios

8. Asignaciones de Tipo y Switches de Tipo

Extraiga tipos concretos de interfaces de forma segura.

package main
 
import "fmt"
 
func parse(v any) {
	switch x := v.(type) {
	case int:
		fmt.Println("int", x*2)
	case string:
		fmt.Println("string", len(x))
	default:
		fmt.Printf("otro %T\n", x)
	}
}
 
func main() {
	parse(21)
	parse("go")
}

La asignación de dos valores x, ok := v.(int) evita el panic en asignaciones fallidas.
Los switches de tipo se despachan según el tipo dinámico - comunes en decodificadores JSON y APIs de plugins.
Asignar al tipo concreto incorrecto provoca un panic en la forma de un solo valor.

Relacionado: Interfaz Nil vs Puntero Nil - trampas de asignación con nil tipado.

9. Compartición de Slices y `copy`

La creación de sub-slices comparte un array subyacente; copy duplica elementos en un slice existente.

package main
 
import "fmt"
 
func main() {
	src := []int{1, 2, 3, 4}
	dst := make([]int, 2)
	n := copy(dst, src[1:])
	fmt.Println(dst, n, src)
}

copy devuelve el número de elementos copiados - el mínimo de len(dst) y len(src).
La creación de sub-slices no copia datos - mutar dst puede afectar a src si se superponen.
Use append a un nuevo slice con capacidad suficiente cuando necesite una copia independiente.

Relacionado: Internos de Slice - cuándo append reasigna.

10. `make` vs `new`

make inicializa slices, mapas y canales; new asigna un solo valor y devuelve un puntero.

package main
 
import "fmt"
 
func main() {
	s := make([]byte, 0, 64)
	m := make(map[string]struct{})
	c := make(chan struct{})
	p := new(int)
	fmt.Printf("slice cap=%d map=%v chan=%v *p=%d\n", cap(s), m != nil, c != nil, *p)
}

make devuelve un valor inicializado (no nil) listo para usar.
new(T) rara vez es necesario - var v T; &v o literales son más claros para structs.
La capacidad en make([]T, 0, n) evita el crecimiento repetido de append en bucles intensivos.

Relacionado: Tipos de Datos y Mejores Prácticas de Memoria - elección de layouts para el rendimiento.

Enlaces Externos Relacionados

A Tour of Go - Introducción interactiva oficial a Go.
Go by Example - Ejemplos de código prácticos anotados.
Documentación de la Biblioteca Estándar de Go - Referencia completa de la biblioteca estándar.
Get Programming with Go (Manning) - Nathan Youngman & Roger Peppé.
The Go Programming Language (ebook) - Donovan & Kernighan.

Versiones de Stack: Esta página fue escrita para Go 1.26.x (GC por defecto Green Tea, go fix modernizadores - verificar parche en la compilación), chi (última - verificar en la compilación), gin (última - verificar en la compilación), echo (última - verificar en la compilación), google.golang.org/grpc (última - verificar en la compilación), sigs.k8s.io/controller-runtime (última - verificar en la compilación), kubebuilder (última - verificar en la compilación), tinygo (última - verificar objetivos de placa en la compilación), wazero (última - verificar en la compilación) y golangci-lint (última - verificar conjunto de linters en la compilación).

Fundamentos de Tipos de Datos

Buscar en la documentación

Fundamentos de Tipos de Datos