Docs ejecutables de Go: Slices

Q: ¿Qué diferencia hay entre la longitud y la capacidad de un slice en Go?

len(s) es cuántos elementos contiene ahora el slice. cap(s) es cuántos elementos caben en el array subyacente a partir del primer elemento del slice. append escribe en la capacidad sobrante cuando la hay, y reserva un array nuevo y más grande cuando no.

Q: ¿Cómo se añade a un slice en Go?

Llama a la función integrada append y vuelve a asignar el resultado: s = append(s, x). Puede añadir varios valores (append(s, 1, 2, 3)) u otro slice (append(s, other...)). Usa siempre el valor de retorno, porque append puede devolver un slice que apunta a un array nuevo.

Q: ¿Cómo elimino un elemento de un slice en Go?

Usa slices.Delete(s, i, i+1) (Go 1.21), que desplaza los elementos posteriores y devuelve el slice más corto. Desde Go 1.22 también pone a cero las posiciones liberadas del final. Si el orden no importa, intercambia con el último elemento y trunca: s[i] = s[len(s)-1]; s = s[:len(s)-1].

Q: ¿Cómo compruebo si un slice contiene un valor en Go?

Usa slices.Contains(s, v) del paquete estándar slices (Go 1.21). slices.Index(s, v) devuelve la posición o -1, y slices.ContainsFunc recibe un predicado. Para búsquedas repetidas sobre muchos datos, construye un map.

Q: ¿Qué diferencia hay entre un slice nil y un slice vacío en Go?

var s []int es nil; s := []int{} está vacío pero no es nil. Los dos tienen longitud 0 y los dos funcionan con len, range y append. La diferencia aparece en las comprobaciones s == nil y en encoding/json, que codifica un slice nil como null y uno vacío como [].

Un slice en un ejemplo

Un slice es una vista ampliable sobre un array. Se crea con un literal o con make, se hace crecer con append y su tamaño se lee con len.

package main

import "fmt"

func main() {
	langs := []string{"Go", "Rust"}
	langs = append(langs, "Zig", "C")
	fmt.Println(langs, len(langs))

	for i, l := range langs {
		fmt.Println(i, l)
	}

	fmt.Println(langs[1:3]) // elements 1 and 2
}

[]string no lleva longitud entre los corchetes. Esa es la diferencia con un tipo array como [4]string, cuyo tamaño es fijo.

Qué es un slice

Un valor slice es una cabecera pequeña con tres campos:

un puntero a un elemento de un array subyacente
una longitud: cuántos elementos puede ver el slice
una capacidad: cuántos elementos hay desde ese puntero hasta el final del array subyacente

Copiar un slice (asignarlo, pasarlo a una función) copia solo esta cabecera. Las dos copias apuntan a los mismos elementos. Casi todas las sorpresas con slices vienen de olvidar esto.

make: longitud y capacidad

make([]T, len, cap) reserva un array subyacente y devuelve un slice sobre él. La capacidad es opcional y por defecto es igual a la longitud.

package main

import "fmt"

func main() {
	a := make([]int, 3) // len 3, cap 3, all zeros
	fmt.Println(a, len(a), cap(a))

	b := make([]int, 0, 10) // len 0, room for 10
	fmt.Println(b, len(b), cap(b))

	for i := range 5 {
		b = append(b, i*i)
	}
	fmt.Println(b, len(b), cap(b)) // no reallocation happened
}

Una confusión habitual: make([]int, 5) seguido de cinco llamadas a append te da diez elementos, los cinco primeros a cero. Usa make([]int, 0, 5) cuando vayas a hacer append, o make([]int, 5) cuando vayas a asignar por índice.

Reservar capacidad de antemano cuando conoces el tamaño final evita crecimientos repetidos. Es una optimización, no un requisito.

append y el crecimiento

append añade elementos detrás de la longitud actual. Si la capacidad basta, escribe en el sitio. Si no, reserva un array más grande, copia los elementos antiguos y devuelve un slice que apunta al array nuevo.

package main

import "fmt"

func main() {
	var s []int
	prevCap := cap(s)
	for i := range 2000 {
		s = append(s, i)
		if cap(s) != prevCap {
			fmt.Printf("len %4d  cap %4d\n", len(s), cap(s))
			prevCap = cap(s)
		}
	}
}

La capacidad aproximadamente se duplica mientras el slice es pequeño y crece en un factor menor (tendiendo a 1,25x) una vez que pasa de 256 elementos. Los números exactos son un detalle del runtime que ha cambiado entre versiones de Go, así que nunca escribas código que dependa de ellos.

Como append puede devolver un array distinto, tienes que usar su resultado:

append(s, 4)     // compile error: append(s, 4) (value of type []int) is not used
s = append(s, 4) // correct

Añadir un slice entero usa la sintaxis de expansión: s = append(s, other...).

Recortar comparte el array subyacente

s[low:high] crea una nueva cabecera de slice sobre el mismo array, que cubre los índices desde low hasta high sin incluirlo. Se puede omitir cualquiera de los dos límites. No se copia ningún elemento.

package main

import "fmt"

func main() {
	nums := []int{10, 20, 30, 40, 50}
	mid := nums[1:4] // 20 30 40
	mid[0] = 99
	fmt.Println(nums) // the write shows up in nums

	fmt.Println(len(mid), cap(mid)) // cap runs to the end of nums
}

Salida:

[10 99 30 40 50]
3 4

Esa compartición es lo que hace barato recortar. También es el origen del bug de slices más famoso.

El bug de aliasing con append

Cuando un sub-slice tiene capacidad sobrante, hacer append sobre él escribe en el array del padre, encima de elementos que el padre todavía usa.

package main

import "fmt"

func main() {
	base := []int{1, 2, 3, 4, 5}
	first := base[:2] // [1 2], cap 5

	first = append(first, 100) // fits in capacity: overwrites base[2]
	fmt.Println(base)
	fmt.Println(first)

	// Two slices built from the same prefix clobber each other.
	prefix := make([]string, 0, 4)
	prefix = append(prefix, "cmd")
	a := append(prefix, "build")
	b := append(prefix, "test")
	fmt.Println(a, b) // both print test
}

Salida:

[1 2 100 4 5]
[1 2 100]
[cmd test] [cmd test]

a y b comparten la posición del array que va detrás de "cmd", así que el segundo append sobrescribió el primero. El código parece correcto y funciona siempre que la capacidad esté justo llena, y por eso este bug solo aparece a veces.

Dos arreglos:

La expresión de slice completa s[low:high:max] limita la capacidad a max-low. Sin capacidad sobrante, el siguiente append tiene que reservar memoria. first := base[:2:2] hace seguro el primer ejemplo.
Copia de forma explícita cuando un slice vaya a sobrevivir a la llamada o a recibir appends por su cuenta: slices.Clone(prefix) o append([]string(nil), prefix...).

Una trampa relacionada: un slice pequeño de un array enorme mantiene vivo el array entero para el recolector de basura. Si lees un archivo de 100 MB y te quedas con data[:10], los 100 MB se quedan en memoria. Clona la parte que conservas.

copy

La función integrada copy(dst, src) copia min(len(dst), len(src)) elementos y devuelve ese número. Nunca hace crecer dst.

package main

import (
	"fmt"
	"slices"
)

func main() {
	src := []int{1, 2, 3}

	dst := make([]int, len(src))
	n := copy(dst, src)
	dst[0] = 100
	fmt.Println(n, src, dst) // independent

	var empty []int
	fmt.Println(copy(empty, src)) // 0: dst has no length

	c := slices.Clone(src) // the one-line version (Go 1.21)
	fmt.Println(c)
}

copy trata correctamente el solapamiento entre origen y destino, así que copy(s[1:], s) desplaza los elementos a la derecha sin corromperlos.

El paquete slices

Desde Go 1.21, el paquete estándar slices tiene funciones genéricas para las operaciones que antes escribías a mano.

package main

import (
	"fmt"
	"slices"
)

func main() {
	s := []int{5, 2, 8, 2, 9}

	fmt.Println(slices.Contains(s, 8)) // true
	fmt.Println(slices.Index(s, 2))    // 1
	fmt.Println(slices.Max(s), slices.Min(s))

	slices.Sort(s)
	fmt.Println(s)
	i, found := slices.BinarySearch(s, 8)
	fmt.Println(i, found)

	s = slices.Compact(s) // drop adjacent duplicates
	fmt.Println(s)

	s = slices.Delete(s, 1, 2) // remove index 1
	fmt.Println(s)

	s = slices.Insert(s, 1, 3, 4)
	fmt.Println(s)

	slices.Reverse(s)
	fmt.Println(s, slices.Equal(s, []int{9, 8, 4, 3, 2}))
}

Función	Qué hace
`Contains`, `Index`	buscar un valor (`ContainsFunc`, `IndexFunc` reciben un predicado)
`Sort`, `SortFunc`, `SortStableFunc`	ordenar en el sitio
`BinarySearch`	buscar en un slice ordenado
`Insert`, `Delete`, `DeleteFunc`	insertar o quitar, devuelven el slice nuevo
`Compact`	quitar los duplicados consecutivos
`Equal`, `Compare`	comparar elemento a elemento
`Clone`, `Reverse`, `Max`, `Min`	lo que su nombre indica
`Collect`, `Sorted`, `Values`, `All`	trabajar con iteradores (Go 1.23)

Delete e Insert devuelven un slice que tienes que asignar, igual que append. Ordenar tiene su propia página: ordenación.

Quitar elementos mientras recorres por índice se salta elementos. Usa slices.DeleteFunc:

s = slices.DeleteFunc(s, func(n int) bool { return n%2 == 0 }) // drop evens

Slices 2D

Un slice de slices te da una cuadrícula cuyas filas pueden tener longitudes distintas. Cada fila tiene que reservarse por separado.

package main

import "fmt"

func main() {
	rows, cols := 3, 4
	grid := make([][]int, rows)
	for r := range grid {
		grid[r] = make([]int, cols)
	}
	grid[1][2] = 7

	for _, row := range grid {
		fmt.Println(row)
	}

	// Rows of different lengths are fine.
	triangle := [][]int{{1}, {1, 1}, {1, 2, 1}}
	fmt.Println(triangle)
}

Olvidar el make interior deja cada fila a nil, y grid[1][2] = 7 provoca un panic con index out of range [2] with length 0.

Slices nil y slices vacíos

package main

import (
	"encoding/json"
	"fmt"
)

func main() {
	var a []int  // nil
	b := []int{} // empty, not nil

	fmt.Println(len(a), len(b), a == nil, b == nil)

	a = append(a, 1) // append works on nil
	fmt.Println(a)

	ja, _ := json.Marshal(struct{ Items []int }{})
	jb, _ := json.Marshal(struct{ Items []int }{Items: []int{}})
	fmt.Println(string(ja), string(jb))
}

Un slice nil se comporta como uno vacío con len, cap, range y append, así que prefiere var s []T como estado cero. Inicializa a []T{} solo cuando la diferencia importe, que es sobre todo la salida JSON (null frente a []). Comprueba si está vacío con len(s) == 0, no con s == nil.

Slices y funciones

Una función que recibe un slice puede cambiar sus elementos, y quien la llama ve los cambios. No puede cambiar la longitud del slice de quien llama, porque recibió una copia de la cabecera. Una función que hace append tiene que devolver el slice nuevo:

func addAll(s []int, vals ...int) []int {
	return append(s, vals...)
}

Por eso append, slices.Delete y slices.Insert devuelven todos un slice.

Errores comunes

Ignorar el resultado de append. Descartarlo del todo no compila, pero asignar append(s, x) a una variable distinta de la que sigues usando es un bug de lógica.
Dos appends desde la misma base. Pueden compartir almacenamiento. Clona la base o usa una expresión de slice completa.
make([]T, n) y luego append. Deja n ceros al principio.
Índice fuera de rango. s[len(s)] provoca un panic. El último elemento es s[len(s)-1].
Comparar slices con ==. Solo compila s == nil. Usa slices.Equal.

Preguntas frecuentes

¿Qué diferencia hay entre la longitud y la capacidad de un slice en Go?

len(s) es cuántos elementos contiene ahora el slice. cap(s) es cuántos elementos caben en el array subyacente a partir del primer elemento del slice. append escribe en la capacidad sobrante cuando la hay, y reserva un array nuevo y más grande cuando no.

¿Cómo se añade a un slice en Go?

Llama a la función integrada append y vuelve a asignar el resultado: s = append(s, x). Puede añadir varios valores (append(s, 1, 2, 3)) u otro slice (append(s, other...)). Usa siempre el valor de retorno, porque append puede devolver un slice que apunta a un array nuevo.

¿Cómo elimino un elemento de un slice en Go?

Usa slices.Delete(s, i, i+1) (Go 1.21), que desplaza los elementos posteriores y devuelve el slice más corto. Desde Go 1.22 también pone a cero las posiciones liberadas del final. Si el orden no importa, intercambia con el último elemento y trunca: s[i] = s[len(s)-1]; s = s[:len(s)-1].

¿Cómo compruebo si un slice contiene un valor en Go?

Usa slices.Contains(s, v) del paquete estándar slices (Go 1.21). slices.Index(s, v) devuelve la posición o -1, y slices.ContainsFunc recibe un predicado. Para búsquedas repetidas sobre muchos datos, construye un map.

¿Qué diferencia hay entre un slice nil y un slice vacío en Go?

var s []int es nil; s := []int{} está vacío pero no es nil. Los dos tienen longitud 0 y los dos funcionan con len, range y append. La diferencia aparece en las comprobaciones s == nil y en encoding/json, que codifica un slice nil como null y uno vacío como [].

Conceptos relacionados