lunes 21 octubre 2024

Cómo usar slices en Go

Los slices en Go son estructuras de datos dinámicas que permiten manejar colecciones de elementos, similares a los arrays, pero con una capacidad flexible. A diferencia de los arrays, los slices pueden cambiar de tamaño y proporcionar una forma más eficiente y fácil de trabajar con subconjuntos de elementos.

¿Qué son los slices en Go?

Un slice es una referencia a una porción de un array. Tiene tres propiedades: longitud (número de elementos), capacidad (número de elementos subyacentes que puede contener), y una referencia a los datos almacenados en un array. Aunque parecen similares a los arrays, los slices son más versátiles y permiten operaciones dinámicas como agregar y eliminar elementos.

Ejemplo básico de slice

package main

import "fmt"

func main() {
    // Crear un slice con tres elementos
    numeros := []int{1, 2, 3}
    fmt.Println(numeros)  // Imprime: [1 2 3]
}

En este ejemplo, se crea un slice llamado numeros que contiene tres enteros. A diferencia de los arrays, no se especifica su tamaño.

Características de los slices

1. Capacidad dinámica: Un slice puede crecer o reducirse según sea necesario, a diferencia de los arrays que tienen un tamaño fijo.

2. Compartir memoria: Los slices comparten memoria con el array subyacente, lo que los hace eficientes en cuanto a memoria.

3. Operaciones sencillas: Es fácil agregar, eliminar o modificar elementos en un slice usando funciones integradas como append().

Crear slices en Go

Puedes crear slices de varias maneras:

1. Desde un array existente:

array := [5]int{1, 2, 3, 4, 5}
   slice := array[1:4] // Crea un slice desde el índice 1 al 3
   fmt.Println(slice)   // Imprime: [2 3 4]

2. Usando la función make():

slice := make([]int, 3) // Crea un slice con longitud 3 y capacidad 3
   fmt.Println(slice)      // Imprime: [0 0 0]

Modificar un slice

Los slices se pueden modificar directamente, y cualquier cambio afectará el array subyacente.

package main

import "fmt"

func main() {
    array := [5]int{1, 2, 3, 4, 5}
    slice := array[1:4] // Crea un slice [2, 3, 4]
    slice[0] = 10       // Cambia el valor del primer elemento del slice
    fmt.Println(array)  // Imprime: [1 10 3 4 5]
}

Operaciones comunes con slices

1. Agregar elementos con append():

slice := []int{1, 2}
   slice = append(slice, 3, 4) // Agrega 3 y 4 al slice
   fmt.Println(slice)          // Imprime: [1 2 3 4]

2. Obtener la longitud y capacidad:

slice := []int{1, 2, 3}
   fmt.Println(len(slice))  // Longitud: 3
   fmt.Println(cap(slice))  // Capacidad: 3 (la capacidad puede variar)

3. Copiar slices con copy():

src := []int{1, 2, 3}
   dest := make([]int, len(src))
   copy(dest, src)          // Copia el contenido de src a dest
   fmt.Println(dest)        // Imprime: [1 2 3]

Algunos ejemplos

Slice vacío

slice := []int{}           // Crea un slice vacío
slice = append(slice, 1)   // Agrega un elemento
fmt.Println(slice)         // Imprime: [1]

Subslice

nums := []int{10, 20, 30, 40, 50}
sub := nums[1:4]           // Crea un slice [20, 30, 40]
fmt.Println(sub)           // Imprime: [20 30 40]

Referencia oficial

Para más información sobre los slices en Go, puedes visitar la documentación oficial de Go sobre slices.

Etiquetas:

Creado por:

Jorge García

Fullstack developer