Creación y uso de slices dinámicos en Go

Contenido del curso

Introducción y Configuración

Fundamentos de Go

Estructuras de Datos y Funciones

Manejo de Errores y Concurrencia

Buenas Prácticas en Go

Tomar examen

Cursos Empresas Blog Live Conf Eventos Precios

0:008:25

Creación y uso de slices dinámicos en Go

Curso de Go

Clase 10 de 28

Clase 10 / 28

Recursos

Los slices son un tipo de dato que destaca en el lenguaje de programación Go por mejorar significativamente el rendimiento y flexibilidad en el manejo de información. Estas estructuras permiten trabajar de manera eficiente con conjuntos de datos, ya que pueden crecer dinámicamente según la necesidad, a diferencia de los arreglos tradicionales.

¿Qué diferencia un slice de un arreglo tradicional en Go?

Los slices en Go se caracterizan por su capacidad de redimensionarse automáticamente, a diferencia de un arreglo fijo que tiene una longitud predefinida. Esta funcionalidad convierte a los slices en herramientas esenciales cuando se necesita una estructura flexible que pueda ajustarse rápidamente a los datos variables.

¿Cómo declarar y utilizar un slice en Go?

Un slice se declara usando la función make, que especifica tanto el tipo como la longitud inicial del mismo. Por ejemplo:

arregloCadenas := make([]string, 3)
arregloCadenas[0] = "a"
arregloCadenas[1] = "b"
arregloCadenas[2] = "c"

Esta sintaxis inicial hace que un arreglo sencillo se convierta en un slice, adaptándose a las necesidades que surgen durante la ejecución del programa.

¿Cómo agregar elementos a un slice dinámicamente?

Mientras los arreglos tienen un límite definido desde su creación, los slices pueden crecer en tiempo de ejecución con el método append. Ejemplo:

arregloCadenas = append(arregloCadenas, "d", "e", "f")

Esto muestra cómo el slice puede incrementar automáticamente su tamaño sin necesidad de intervenciones adicionales.

¿Cómo comparar slices y arreglos en Go?

La comparación entre arreglos y slices en Go puede realizarse mediante el método slices.Equal. Para utilizarlo, es necesario importar el paquete específico:

import "slices"

segundoArreglo := []string{"g", "h", "i"}
tercerArreglo := []string{"g", "h", "i"}

if slices.Equal(segundoArreglo, tercerArreglo) {
    fmt.Println("Arreglos son iguales")
}

A través de estas operaciones, es posible verificar rápidamente la igualdad entre estas estructuras de datos.

¿Qué ventajas tiene utilizar slices en tus programas en Go?

Las principales ventajas que ofrecen los slices son:

Alto rendimiento en la gestión de memoria y datos.
Capacidad de crecimiento dinámico en ejecución.
Facilidad en la manipulación y comparación de datos.

Los slices proporcionan una solución poderosa para situaciones en las que los arreglos tradicionales muestran limitaciones, optimizando así el desarrollo y el mantenimiento del código.

¿Has tenido alguna experiencia usando slices en Go? Comparte tu opinión o dudas en los comentarios para seguir aprendiendo juntos.

Ronaldo Jiménez

Hace un año

Tanto la declaración con make y normal son slices, es decir, colecciones dinámicas, Lo que las diferencia es:

Declaración literal de slice:

equipos := []string{"Barcelona", "Real Madrid", "Juventus", "PSG"}

Creas un slice literal ya inicializado con esos elementos.
El len (longitud) es 4.
La cap (capacidad) también es 4.
Es inmutable en cuanto a tamaño inicial: no puedes declarar menos elementos de los que pusiste, aunque luego sí puedes hacer append para crecer dinámicamente.

Declaración con make:

datos := make([]string, 4) // slice de 4 strings vacíos

Creas un slice vacío pero con espacio reservado.
Todos los elementos están en su valor cero ("" en el caso de string).
El len es 4, porque ya tiene 4 elementos vacíos.
Puedes especificar capacidad distinta de longitud:

Ronaldo Jiménez

Hace un año

datos := make([]string, 0, 10) // longitud 0, capacidad 10

Aquí no hay elementos aún (len=0), pero puedes hacer hasta 10 append sin que Go tenga que realocar memoria.

🔹 Diferencia clave

Literal ([]string{...}): → Lo usas cuando ya conoces los valores iniciales.
make([]T, len, cap): → Lo usas cuando quieres un slice vacío o con valores cero, pero con cierta longitud y/o capacidad predefinida para optimizar o controlar memoria.

Introducción y Configuración

Características y ventajas del lenguaje de programación Go

Instala Go en WSL con un comando

Paquetes en Go sin npm ni pip

Fundamentos de Go

Formas de declarar variables en Go

Conversión de tipos en Go

if else y operador módulo en Go

Cuatro formas de usar for en Go

Estructuras de Datos y Funciones

Sentencia switch en Go con ejemplos reales

Arreglos en Go: fijos e inferidos

Creación y uso de slices dinámicos en Go

Mapas en Go: creación, acceso y manipulación de datos clave-valor

Cómo crear y usar funciones personalizadas en Go

Retorno de múltiples valores en Go

Funciones variadic en Go con tres puntos

Funciones recursivas en Go con Fibonacci

Punteros en Go para optimizar rendimiento del sistema

Runas en Go: bytes vs caracteres reales

Declaración y uso de estructuras de datos en Go

Implementación de enumeradores en Go para controlar estados

Manejo de Errores y Concurrencia

Errores personalizados en Go

Goroutines y channels en Go

Select para ordenar goroutines en Go

Timeouts en goroutines con time.After

Workers en Go con goroutines y channels

Buenas Prácticas en Go

JSON con Marshal y Unmarshal en Go

Conversión de texto plano a hash con SHA256 en Go

Variables de ambiente en Go con paquetes externos

Cierre de curso de Go: consejos para consolidar el aprendizaje

Creación y uso de slices dinámicos en Go