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:
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:
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.
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:
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:
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.
El profe pareciera que no dominara el lenguaje, el autocompletado aunque útil en entornos dónde se necesita automatizar cosas que ya se conocen o son simples, en éste contexto no me parece adecuado para explicar porque hace el profe no esté obligado a explicar con la debida profundidad los temas.
Definición según la docummentación: Los slices son abstracciones de los arrays, los cuales en Go, los arrays son estructuras de tamaño fijo que contienen elementos del mismo tipo. Su tamaño es parte del tipo, lo que significa que [4]int y [5]int son tipos distintos e incompatibles.
Los slices en go proporcionan una vista flexible y dinámica sobre sus elementos, a diferencia de los arrays, los slices pueden cambiar de tamaño
Al utilizar la función make([]string, 3), se inicializa un slice con una longitud y capacidad predefinidas de 3. Esto implica que, inicialmente, solo los índices 0, 1 y 2 son válidos para la asignación directa de valores. Cualquier intento de acceder o modificar un índice fuera de este rango, como en el ejemplo (comentado) de arreglos[3] = "Adios", resultaría en un error de ejecución por "índice fuera de rango".
La función append juega un papel fundamental aquí, ya que nos permite añadir elementos a un slice de manera dinámica, incrementando su longitud más allá de su capacidad inicial.
Tener la capacidad predefinida ayuda al rendimiento.
Cuando haces append a un slice sin capacidad definida o el slice se queda sin capacidad, Go tiene que:
Crear un nuevo array más grande (usualmente el doble de tamaño)
Copiar todos los elementos del array viejo al nuevo
Desechar el array viejo
Es buena practica colocar con make la capacidad deacuerdo al contexto, igual si lo sobrepasa no se daña el codigo, pasa lo que detallé arriba, entonces alli pierdes rendimiento.
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:
package data_structure
import "fmt"
func Slice() {
// Crear slice de equipos
equipos := []string{"Barcelona", "Real Madrid", "Juventus", "PSG"}
// Agregar un elemento al final
equipos = append(equipos, "Manchester City")
equipos = append(equipos, "Bayern Munich")
// Crear un slice a partir de otro
favoritos := equipos[0:2]
equipos[0] = "Cali"
// Imprimir los equipos
for idx, equipo := range equipos {
fmt.Println(idx, equipo)
}
fmt.Println("Favoritos: ")
for _, favorito := range favoritos {
fmt.Println(favorito)
}
// longitud y capacidad
fmt.Printf("Longitud: %d, Capacidad: %d\n", len(equipos), cap(equipos))
// capacidad es el tamaño del array subyacente
// capacidad inicial es 4, al agregar un elemento se duplica a 8
// tipo
fmt.Printf("El tipo de dato es: %T\n", equipos)
// Uso de ... para desempaquetar
// Definimos dos slices
numeros1 := []int{1, 2, 3}
numeros2 := []int{4, 5, 6}
// Usamos `append` con `...` para combinar ambos slices
resultado := append(numeros1, numeros2...)
// ... expande los elementos del slice resultante como
// argumentos individuales para la función append, Esto es necesario porque append
// espera una lista de elementos, no otro slice.
// Mostramos el resultado
fmt.Println(resultado) // Salida: [1 2 3 4 5 6]
}
Espero que no todo el curso vaya a ser una lectura // traduccion de como este que es solo . no quiero ser hater, pero eso no esta bien, ya van varias varias clases que son todas de ahi
Resolviendo lo que el profesor ha dejado he descubierto que en Go existe el desempaquetado de los arreglos, así en vez de que en el arreglo original se vea como [a, b, c, d, e, [f, g]]
El profe pareciera que no dominara el lenguaje, el autocompletado aunque útil en entornos dónde se necesita automatizar cosas que ya se conocen o son simples, en éste contexto no me parece adecuado para explicar porque hace el profe no esté obligado a explicar con la debida profundidad los temas.
Definición según la docummentación: Los slices son abstracciones de los arrays, los cuales en Go, los arrays son estructuras de tamaño fijo que contienen elementos del mismo tipo. Su tamaño es parte del tipo, lo que significa que [4]int y [5]int son tipos distintos e incompatibles.
Los slices en go proporcionan una vista flexible y dinámica sobre sus elementos, a diferencia de los arrays, los slices pueden cambiar de tamaño
No creo que sea que el profesor no domina Go, sino que usar copilot en estos ambientes no aporta nada, de hecho hace la tarea de enseñar y atender mucho más difícil.
A como explica el profe, si tiene conocimientos profundos sobre el lenguaje, da ejemplos claros y de todo tipo, explicando cada uno.
El problema es que conceptos como slices o arrays, me parece perfecto que no se profundicen siendo que hay cursos como Programación Básica o el de Fundamentos destinados a profundizar mas sobre esas definiciones.
Y el uso de copilot es a gustos y colores, personalmente creo que es mejor, siendo que le da la posibilidad al profesor de centrarse en explicar los conceptos y no quedarnos viendo como alguien escribe mas de lo que explica.
Lo entendido en esta clase
Al utilizar la función make([]string, 3), se inicializa un slice con una longitud y capacidad predefinidas de 3. Esto implica que, inicialmente, solo los índices 0, 1 y 2 son válidos para la asignación directa de valores. Cualquier intento de acceder o modificar un índice fuera de este rango, como en el ejemplo (comentado) de arreglos[3] = "Adios", resultaría en un error de ejecución por "índice fuera de rango".
La función append juega un papel fundamental aquí, ya que nos permite añadir elementos a un slice de manera dinámica, incrementando su longitud más allá de su capacidad inicial.
Tener la capacidad predefinida ayuda al rendimiento.
Cuando haces append a un slice sin capacidad definida o el slice se queda sin capacidad, Go tiene que:
Crear un nuevo array más grande (usualmente el doble de tamaño)
Copiar todos los elementos del array viejo al nuevo
Desechar el array viejo
Es buena practica colocar con make la capacidad deacuerdo al contexto, igual si lo sobrepasa no se daña el codigo, pasa lo que detallé arriba, entonces alli pierdes rendimiento.
Tanto la declaración con make y normal son slices, es decir, colecciones dinámicas, Lo que las diferencia es:
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:
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.
package data_structure
import "fmt"func Slice(){// Crear slice de equipos equipos :=[]string{"Barcelona","Real Madrid","Juventus","PSG"}// Agregar un elemento al final equipos =append(equipos,"Manchester City") equipos =append(equipos,"Bayern Munich")// Crear un slice a partir de otro favoritos := equipos[0:2] equipos[0]="Cali"// Imprimir los equiposfor idx, equipo := range equipos { fmt.Println(idx, equipo)} fmt.Println("Favoritos: ")for _, favorito := range favoritos { fmt.Println(favorito)}// longitud y capacidad fmt.Printf("Longitud: %d, Capacidad: %d\n",len(equipos),cap(equipos))// capacidad es el tamaño del array subyacente// capacidad inicial es 4, al agregar un elemento se duplica a 8// tipo fmt.Printf("El tipo de dato es: %T\n", equipos)// Uso de ... para desempaquetar// Definimos dos slices numeros1 :=[]int{1,2,3} numeros2 :=[]int{4,5,6}// Usamos `append` con `...` para combinar ambos slices resultado :=append(numeros1, numeros2...)// ... expande los elementos del slice resultante como// argumentos individuales para la función append, Esto es necesario porque append// espera una lista de elementos, no otro slice.// Mostramos el resultado fmt.Println(resultado)// Salida: [1 2 3 4 5 6]}
Estas son de esas clases que me hacen dejar un curso por la mitad.. copian y pegando código sin explicar bien lo que hay?
Te dejo mis apuntes para que no te desanimes, quizá te sirvan:
y este curso:
En pocas palabras lo qu entendí es:
Arreglo se define la cantidad de elementos
var arreglo [5]int
lista2 := [...]int{1, 2, 3, 4, 5, 6}
Los slices no se definen o se usa make para definir
var arregloCadenas []string
tercerArreglo := []string{"g", "h", "i"}
cadenas = make([]string, 3)
En este caso, arregloCadenas sigue siendo un slice no un arreglo como el primero ya que se puede agregar mas elementos
Espero que no todo el curso vaya a ser una lectura // traduccion de como este que es solo . no quiero ser hater, pero eso no esta bien, ya van varias varias clases que son todas de ahi
Resolviendo lo que el profesor ha dejado he descubierto que en Go existe el desempaquetado de los arreglos, así en vez de que en el arreglo original se vea como [a, b, c, d, e, [f, g]]
Aquí algunos insights:
Un slice en Go es una forma más flexible de manejar colecciones de datos en comparación con un arreglo.
Sintaxis:
Un arreglo se define con un tamaño fijo, por ejemplo: var arr [3]int.
Un slice se crea con make, por ejemplo: slice := make([]int, 0) o mediante una inicialización literal: slice := []int{1, 2, 3}.
Uso:
Utiliza un arreglo cuando conoces el tamaño de la colección de antemano y no necesitas modificarla.
Usa un slice cuando requieres flexibilidad para agregar o eliminar elementos, ya que se redimensiona automáticamente.
Esto te permitirá manejar datos de manera más eficiente en tus aplicaciones Go.