Rebanadas (Slice) en Go

Los slices en Go son una abstracción de los arrays.

La longitud de los arrays en Go no se puede cambiar; en ciertos escenarios esta colección no es muy adecuada. Go proporciona un tipo integrado flexible y potente llamado slice ("array dinámico"). Comparado con los arrays, la longitud de un slice no es fija; se pueden añadir elementos y, al añadirlos, la capacidad del slice puede aumentar.


Definir slices

Puedes declarar un array sin tamaño especificado para definir un slice:

var identifier []type

Un slice no necesita indicar su longitud.

o usarmake()la función para crear el slice:

var slice1 []type = make([]type, len)

也可以简写为

slice1 := make([]type, len)

También se puede especificar la capacidad, dondecapacityes un parámetro opcional.

make([]T, length, capacity)

Aquí len es la longitud del array y también la longitud inicial del slice.

Inicialización de slices

s :=[] int {1,2,3 } 

Inicializar el slice directamente,[]indica que es un tipo slice,{1,2,3}los valores de inicialización son respectivamente1,2,3, y sucap=len=3。

s := arr[:] 

inicializar el slices, es una referencia al array arr.

s := arr[startIndex:endIndex] 

Crea un nuevo slice con los elementos de arr desde el índice startIndex hasta endIndex-1.

s := arr[startIndex:] 

Si endIndex se omite, indica hasta el último elemento de arr.

s := arr[:endIndex] 

Si startIndex se omite, indica que comienza desde el primer elemento de arr.

s1 := s[startIndex:endIndex] 

Inicializa el slice s1 mediante el slice s.

s :=make([]int,len,cap) 

Mediante la función integradamake()inicializar el slices,[]intindica que es un slice cuyo tipo de elemento es int.


Funciones len() y cap()

Los slices se pueden indexar y su longitud se puede obtener con el método len().

Los slices proporcionan el método cap() para calcular la capacidad, que mide cuánto puede llegar a ser el slice como máximo.

A continuación se muestra un ejemplo concreto:

Ejemplo

package main

import "fmt"

func main() {
   var numbers = make([]int,3,5)

   printSlice(numbers)
}

func printSlice(x []int){
   fmt.Printf("len=%d cap=%d slice=%v\n",len(x),cap(x),x)
}

La salida del ejemplo anterior es:

len=3 cap=5 slice=[0 0 0]

Slice vacío (nil)

Un slice es nil por defecto antes de inicializarse, con longitud 0; el ejemplo es el siguiente:

Ejemplo

package main

import "fmt"

func main() {
   var numbers []int

   printSlice(numbers)

   if(numbers == nil){
      fmt.Printf("El slice está vacío")
   }
}

func printSlice(x []int){
   fmt.Printf("len=%d cap=%d slice=%v\n",len(x),cap(x),x)
}

La salida del ejemplo anterior es:

len=0 cap=0 slice=[]
切片是空的

Segmentación de slices

Se puede definir un sub-slice estableciendo el límite inferior y superior[lower-bound:upper-bound]; el ejemplo es el siguiente:

Ejemplo

package main

import "fmt"

func main() {
   /* Crear un slice */
   numbers := []int{0,1,2,3,4,5,6,7,8}  
   printSlice(numbers)

   /* Imprimir el slice original */
   fmt.Println("numbers ==", numbers)

   /* Imprimir el sub-slice del índice 1 (incluido) al índice 4 (excluido) */
   fmt.Println("numbers[1:4] ==", numbers[1:4])

   /* El límite inferior por defecto es 0 */
   fmt.Println("numbers[:3] ==", numbers[:3])

   /* El límite superior por defecto es len(s) */
   fmt.Println("numbers[4:] ==", numbers[4:])

   numbers1 := make([]int,0,5)
   printSlice(numbers1)

   /* Imprimir el sub-slice del índice 0 (incluido) al índice 2 (excluido) */
   number2 := numbers[:2]
   printSlice(number2)

   /* Imprimir el sub-slice del índice 2 (incluido) al índice 5 (excluido) */
   number3 := numbers[2:5]
   printSlice(number3)

}

func printSlice(x []int){
   fmt.Printf("len=%d cap=%d slice=%v\n",len(x),cap(x),x)
}

La salida del código anterior es:

len=9 cap=9 slice=[0 1 2 3 4 5 6 7 8]
numbers == [0 1 2 3 4 5 6 7 8]
numbers[1:4] == [1 2 3]
numbers[:3] == [0 1 2]
numbers[4:] == [4 5 6 7 8]
len=0 cap=5 slice=[]
len=2 cap=9 slice=[0 1]
len=3 cap=7 slice=[2 3 4]

Funciones append() y copy()

Si queremos aumentar la capacidad de un slice, debemos crear un slice nuevo más grande y copiar todo el contenido del slice original.

El siguiente código describe el método copy para copiar slices y el método append para añadir nuevos elementos a un slice.

Ejemplo

package main

import "fmt"

func main() {
   var numbers []int
   printSlice(numbers)

   /* Permite añadir a un slice vacío */
   numbers = append(numbers, 0)
   printSlice(numbers)

   /* Añade un elemento al slice */
   numbers = append(numbers, 1)
   printSlice(numbers)

   /* Añade varios elementos a la vez */
   numbers = append(numbers, 2,3,4)
   printSlice(numbers)

   /* Crea el slice numbers1 con el doble de capacidad que el slice anterior */
   numbers1 := make([]int, len(numbers), (cap(numbers))*2)

   /* Copia el contenido de numbers a numbers1 */
   copy(numbers1,numbers)
   printSlice(numbers1)  
}

func printSlice(x []int){
   fmt.Printf("len=%d cap=%d slice=%v\n",len(x),cap(x),x)
}

La salida del código anterior es:

len=0 cap=0 slice=[]
len=1 cap=1 slice=[0]
len=2 cap=2 slice=[0 1]
len=5 cap=6 slice=[0 1 2 3 4]
len=5 cap=12 slice=[0 1 2 3 4]
Otras extensiones