Muy bien, vamos a sumergirnos en una de las características más versátiles y esenciales de Go - Slices. Si viene de otro idioma, puede pensar en rebanadas como similares a las matrices. Y sí, tienen algunas similitudes, ¡pero las rodajas aportan mucho más potencia, flexibilidad y magia específica de GO a la mesa! ?

¿Qué es una porción de todos modos? ?

en Go, las cortes son un tipo que le permite trabajar con listas de elementos (como una matriz), pero son dinámicos, lo que significa que pueden crecer y encogerse según sea necesario. No es necesario especificar una longitud fija por adelantado como lo haría con una matriz. Están respaldados por matrices debajo del capó, pero obtienes mucho más control. Piense en ellos como el hermano más fresco y flexible de las matrices.

Entonces, una porción en GO es en realidad una "ventana" sobre una matriz subyacente. Puede cambiar el tamaño de esta ventana cultivándola o encogiéndola, y es tan suave como cortar un pedazo de pastel. ?

creando una porción?
Crear una porción es bastante sencilla:

// Using a literal
numbers := []int{1, 2, 3, 4, 5}

// Using the make function
sliceOfStrings := make([]string, 5) // a slice of 5 strings, each 

inicializado en una cadena vacía
Con la marca, le estás diciendo que cree una porción de cierta longitud, pero respaldado por una matriz que logra. Por lo tanto, no necesita preocuparse por los detalles de asignación de memoria. ?

Longitud y capacidad?

Dos conceptos cruciales en las cortes son longitud y capacidad. La longitud es el número de elementos actualmente en el corte, mientras que la capacidad es el número total de elementos que puede contener antes de cambiar el tamaño.

numbers := []int{1, 2, 3}
fmt.Println(len(numbers)) // 3
fmt.Println(cap(numbers)) // 3 (same as length here)

Cuando comience a agregar elementos, Go duplicará la capacidad siempre que se llene, por lo que no tiene que preocuparse por golpear un techo.

numbers = append(numbers, 4)
fmt.Println(len(numbers)) // 4
fmt.Println(cap(numbers)) // probably 6 now, depending on Go’s growth 

patrón
Agregar a las cortes: la magia incorporada de Go? ✨
Agregar elementos a una porción es tan fácil como el pastel con la función de anexo de Go. Puede agregar uno o más elementos a la vez, y ir manejará todo el cambio de tamaño y la memoria para usted.

numbers := []int{1, 2, 3}
numbers = append(numbers, 4, 5, 6) // Adding multiple elements at once
fmt.Println(numbers) // [1 2 3 4 5 6]

Esta función de resolución automática hace que las cortes sean muy útiles, especialmente si no sabe qué tan grande será su lista.

Cortar una porción?

cortar en Go es en realidad donde las cosas se vuelven muy divertidas. Puede crear un "sub-corte" de una porción existente sin copiar los elementos.

numbers := []int{10, 20, 30, 40, 50}
subSlice := numbers[1:4] // Just takes a "slice" of the original slice
fmt.Println(subSlice) // [20 30 40]

en números [1: 4], el primer índice (1) es inclusivo, y el último índice (4) es exclusivo. Terminas con los elementos en las posiciones 1, 2 y 3, pero no 4.

Este sub-Slice todavía comparte la misma matriz subyacente con la porción original, por lo que los cambios a uno afectarán al otro:

subSlice[0] = 25
fmt.Println(numbers) // [10 25 30 40 50]
fmt.Println(subSlice) // [25 30 40]

Para evitar cualquier cambio involuntario, puede usar Copy para crear una versión independiente de la porción:

newSlice := make([]int, len(subSlice))
copy(newSlice, subSlice)

¿Cambiar la capacidad con la anexión?

Si necesita una porción que sea mayor que su capacidad actual, Append creará automáticamente una matriz nueva y más grande en segundo plano y copiará todo. Esto es increíblemente eficiente y una gran parte de lo que hace que las rodajas sean increíbles. Cuando append crea una nueva matriz, asigna el doble de la capacidad anterior, ¡dándole espacio para crecer!

¿La eficiencia de corte y memoria?

Aquí hay un poco de secreto de Go: mientras que cortar es súper poderoso, a veces puede conducir a fugas de memoria si no tiene cuidado. Dado que las cortes se refieren a la misma matriz subyacente, la matriz puede permanecer en la memoria incluso si solo está usando una pequeña porción de ella.

Por ejemplo:

bigSlice := make([]int, 1_000_000) // A big slice with a lot of elements
smallSlice := bigSlice[:10]        // A tiny slice from it

// Now `smallSlice` only uses 10 elements, but the underlying array with
// 1,000,000 elements is still in memory! ?

En casos como este, es mejor usar Copy para crear una porción genuinamente independiente que solo contenga los datos que necesita, liberando el resto de la memoria.

miniSlice := make([]int, len(smallSlice))
copy(miniSlice, smallSlice) // Now `miniSlice` is completely separate!

Slices multidimensionales?

¿necesita más de una dimensión? ¡También puede crear rebanadas multidimensionales! Esto puede ser útil para cosas como cuadrículas o mesas. Simplemente declare una porción de rebanadas:

matrix := [][]int{
    {1, 2, 3},
    {4, 5, 6},
    {7, 8, 9},
}
fmt.Println(matrix) // [[1 2 3] [4 5 6] [7 8 9]]

Cada "fila" es una porción en sí misma, por lo que puede cultivarlos de forma independiente si es necesario.

matrix[0] = append(matrix[0], 10)
fmt.Println(matrix) // [[1 2 3 10] [4 5 6] [7 8 9]]

¿La porción nula?

una porción nil es simplemente una porción que aún no se ha inicializado. Tiene longitud y capacidad de cero, pero aún se puede usar con funciones como agregar sin entrar en pánico.

var nilSlice []int // Declared, but not initialized
fmt.Println(len(nilSlice)) // 0
fmt.Println(cap(nilSlice)) // 0

Cuando agregue una porción nil, vaya, simplemente lo inicializa automáticamente. Es un buen truco para tener la manga.

¿Peligros y mejores prácticas?
Esté atento a la memoria compartida: recuerde, las cortes comparten memoria con la matriz original. Esto es excelente para el rendimiento, pero tenga cuidado al cortar partes de una gran matriz para evitar mantener datos innecesarios en la memoria.

Tenga cuidado con el cambio de tamaño: cuando agregue, Go puede necesitar crear una nueva matriz subyacente si la capacidad actual está llena. Esto puede ser más eficiente que hacer muchos pequeños su tamaño, pero tenga en cuenta la sobrecarga si se trata de grandes conjuntos de datos.

Evite la optimización prematura: GO maneja mucha asignación de memoria y cambia el tamaño automáticamente con cortes. A menudo, tratar de microgestión estos detalles pueden terminar haciendo que su código sea más desordenado y menos eficiente. Confiar en la mecánica de corte de Go para hacer lo correcto en la mayoría de los casos.