Go Academy · Lección

Slices: listas dinámicas

make, append, copy, len y cap

Slices: listas dinámicas es una lección gratuita de Go Academy en CoddyKit. Esta es la lección 2 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Go Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Go Academy incluye 4 lecciones en total.

¿Qué es un slice?

Un slice es una vista de tamaño dinámico sobre un array subyacente. Tiene tres componentes: un puntero al array, una longitud y una capacidad.

Los slices son tipos de referencia; varios slices pueden compartir el mismo array subyacente
La mayoría de las operaciones similares a las de listas en Go utilizan slices, no arrays

Literales de slice y make

Cree slices con un literal o con make:

package main
import "fmt"

func main() {
    nums := []int{1, 2, 3, 4, 5}      // literal
    strs := make([]string, 3)          // len=3, cap=3, zero values
    buf  := make([]byte, 0, 64)        // len=0, cap=64
    fmt.Println(nums, strs, len(buf), cap(buf))
}

len y cap

len devuelve la cantidad de elementos que hay actualmente en el slice. cap devuelve la capacidad del array subyacente a partir del puntero inicial del slice.

package main
import "fmt"

func main() {
    s := make([]int, 3, 8)
    fmt.Println(len(s)) // 3
    fmt.Println(cap(s)) // 8
}

append: ampliar un slice

append añade elementos a un slice y asigna un nuevo array subyacente cuando se supera la capacidad:

package main
import "fmt"

func main() {
    s := []int{1, 2, 3}
    s = append(s, 4, 5)
    s = append(s, []int{6, 7, 8}...)
    fmt.Println(s) // [1 2 3 4 5 6 7 8]
}

Obtener un sub-slice

Utilice la sintaxis [low:high] para crear un sub-slice (comparte el array subyacente):

package main
import "fmt"

func main() {
    a := []int{0, 1, 2, 3, 4, 5}
    b := a[1:4]   // [1 2 3]
    c := a[:3]    // [0 1 2]
    d := a[3:]    // [3 4 5]
    fmt.Println(b, c, d)
}

copy: slices independientes

copy copia elementos entre slices y devuelve la cantidad copiada. El destino y el origen no comparten memoria:

package main
import "fmt"

func main() {
    src := []int{1, 2, 3}
    dst := make([]int, len(src))
    n := copy(dst, src)
    dst[0] = 99
    fmt.Println(src, dst, n) // [1 2 3] [99 2 3] 3
}

Slice nil frente a slice vacío

Un slice nil no tiene un array subyacente. Un slice vacío tiene un array subyacente, pero su longitud es 0. Ambos tienen len == 0:

package main
import "fmt"

func main() {
    var nilSlice []int
    emptySlice  := []int{}
    fmt.Println(nilSlice  == nil) // true
    fmt.Println(emptySlice == nil) // false
    fmt.Println(len(nilSlice), len(emptySlice)) // 0 0
    nilSlice = append(nilSlice, 1) // safe!
}

Eliminar un elemento

Go no tiene una función integrada para eliminar elementos de los slices. El enfoque idiomático utiliza append:

package main
import "fmt"

func main() {
    s := []int{1, 2, 3, 4, 5}
    i := 2 // delete index 2
    s = append(s[:i], s[i+1:]...)
    fmt.Println(s) // [1 2 4 5]
}

Insertar un elemento

Inserte en la posición i combinando append y slicing:

package main
import "fmt"

func main() {
    s := []int{1, 2, 4, 5}
    i := 2
    s = append(s[:i+1], s[i:]...)
    s[i] = 3
    fmt.Println(s) // [1 2 3 4 5]
}

Problema de los slices: array subyacente compartido

Los sub-slices comparten el array subyacente; modificar uno afecta al otro hasta que se produce una reasignación:

package main
import "fmt"

func main() {
    a := []int{1, 2, 3, 4}
    b := a[:2]   // shares backing array
    b[0] = 99
    fmt.Println(a) // [99 2 3 4] — a is changed!
}

Comprobación rápida

¿Qué devuelve append?

Resumen: slices

Conclusiones principales:

Los slices = puntero + len + cap; envuelven arrays
Utilice make para preasignar capacidad
Asigne siempre el resultado de append
copy crea slices independientes
Tenga en cuenta los arrays subyacentes compartidos en los sub-slices

Propuesta de práctica

Cree con make un slice de 5 enteros, añada tres valores más, cópielo en un slice nuevo y modifique la copia sin afectar al original. Imprima ambos.

Preguntas frecuentes

¿La lección «Slices: listas dinámicas» es gratis?

Sí — el texto completo de «Slices: listas dinámicas» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Go Academy, actualiza a CoddyKit PRO. El curso de Go Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Slices: listas dinámicas»?

make, append, copy, len y cap Practicas Go Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Go Academy?

No se requiere experiencia previa. Go Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 2 de 4.

¿Cuánto tiempo toma la lección «Slices: listas dinámicas»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Go Academy?

Sí. Cada lección de Go Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

← Volver a Go Academy