10 Slicing y Ranging

🧠 Introducción

En esta lección aprenderás a trabajar con subconjuntos de datos, copiar, insertar y eliminar elementos en slices. Son operaciones fundamentales para manipular colecciones de forma eficiente y flexible.

1. ✂️ Slicing en Go

El slicing permite extraer una parte de un array o slice.

🔤 Sintaxis:

go
CopyEdit
slice[start:end]

• start: índice de inicio (incluido).
• end: índice final (excluido).

✅ Ejemplo:

go
CopyEdit
c := [4]string{"iOS", "Android", "Windows", "MacOS"}

fmt.Println(c[0:2]) // ["iOS", "Android"]
fmt.Println(c[:2])  // ["iOS", "Android"]
fmt.Println(c[1:])  // ["Android", "Windows", "MacOS"]
fmt.Println(c[:])   // Todos los elementos

2. 🧠 Slicing y Memoria

Cuando haces slicing, el nuevo slice comparte el mismo array subyacente. Los cambios afectan a ambos.

go
CopyEdit
t := []int{1, 2, 3, 4, 5}
t = t[2:4]
fmt.Println(t)      // [3 4]
fmt.Println(len(t)) // 2
fmt.Println(cap(t)) // 3 → porque hay espacio después del índice 2

3. 🔁 Iterar sobre Slices o Arrays

Usamos for-range:

go
CopyEdit
t := []int{1, 2, 3, 4, 5}

for i, v := range t {
    fmt.Printf("Índice: %d, Valor: %d\n", i, v)
}

4. 🧬 Copiar Slices

Para crear una copia independiente, usa copy.

go
CopyEdit
t := []int{1, 2, 3, 4, 5}
v := make([]int, len(t))
copy(v, t)

v[0] = 99
fmt.Println(t) // [1 2 3 4 5]
fmt.Println(v) // [99 2 3 4 5]

Si el slice destino es más pequeño, solo se copian los elementos que quepan.

go
CopyEdit
v := make([]int, 2)
copy(v, t)
fmt.Println(v) // [1 2]

5. ➕ Insertar Elementos

Go no tiene una función incorporada, pero puedes usar append + slicing:

go
CopyEdit
func insert(orig []int, index int, value int) ([]int, error) {
    if index < 0 {
        return nil, errors.New("Index cannot be less than 0")
    }
    if index >= len(orig) {
        return append(orig, value), nil
    }
    orig = append(orig[:index+1], orig[index:]...)
    orig[index] = value
    return orig, nil
}

go
CopyEdit
t := []int{1, 2, 3, 4, 5}
t, err := insert(t, 2, 99)
fmt.Println(t) // [1 2 99 3 4 5]

6. ❌ Eliminar Elementos

Puedes eliminar elementos usando append:

go
CopyEdit
func delete(orig []int, index int) ([]int, error) {
    if index < 0 || index >= len(orig) {
        return nil, errors.New("Index out of range")
    }
    return append(orig[:index], orig[index+1:]...), nil
}

go
CopyEdit
t := []int{1, 2, 3, 4, 5}
t, err := delete(t, 2)
fmt.Println(t) // [1 2 4 5]

✅ Conclusión

• Slicing te permite trabajar con subconjuntos de datos.
• Los slices comparten memoria con el array original, salvo que uses copy.
• Puedes insertar o eliminar elementos combinando slicing y append.
• Estas operaciones te permiten escribir código más flexible y eficiente.

🛠️ Práctica recomendada

1. Crea un slice con los números del 1 al 10.
2. Usa slicing para obtener:
   • Los primeros 3.
   • Los últimos 4.
   • Del elemento 3 al 6 (sin incluir el índice 6).
3. Crea una copia del slice y modifica el primero de la copia. Verifica que el original no cambie.
4. Inserta el valor 99 en la posición 5.
5. Elimina el valor de la posición 2.

🚀 Siguientes pasos

Con estas habilidades puedes trabajar con cualquier colección en Go. Te recomiendo continuar con:

• 🧱 Structs en Go: para crear tus propios tipos de datos.
• 🔑 Maps: colecciones clave-valor para acceso rápido.
• 🧠 Funciones avanzadas con slices: filtrar, buscar y transformar colecciones.