Ir - Rebanadas

Go Slice es una abstracción de Go Array. Go Array le permite definir variables que pueden contener varios elementos de datos del mismo tipo, pero no proporciona ningún método incorporado para aumentar su tamaño dinámicamente u obtener una submatriz propia. Las rebanadas superan esta limitación. Proporciona muchas funciones de utilidad requeridas en Array y se usa ampliamente en la programación Go.

Definiendo una rebanada

Para definir un sector, puede declararlo como una matriz sin especificar su tamaño. Alternativamente, puede usarmake función para crear una rebanada.

var numbers []int /* a slice of unspecified size */
/* numbers == []int{0,0,0,0,0}*/
numbers = make([]int,5,5) /* a slice of length 5 and capacity 5*/

funciones len () y cap ()

Un segmento es una abstracción sobre una matriz. En realidad, utiliza matrices como estructura subyacente. loslen() La función devuelve los elementos presentes en el segmento donde cap()La función devuelve la capacidad del segmento (es decir, cuántos elementos puede acomodar). El siguiente ejemplo explica el uso de slice:

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)
}

Cuando el código anterior se compila y ejecuta, produce el siguiente resultado:

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

Rebanada nula

Si un segmento se declara sin entradas, de forma predeterminada, se inicializa como nil. Su longitud y capacidad son cero. Por ejemplo

package main

import "fmt"

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

Cuando el código anterior se compila y ejecuta, produce el siguiente resultado:

len = 0 cap = 0 slice = []
slice is nil

Subslicing

Slice permite especificar el límite inferior y el límite superior para obtener su sublicencia usando[lower-bound:upper-bound]. Por ejemplo

package main

import "fmt"

func main() {
   /* create a slice */
   numbers := []int{0,1,2,3,4,5,6,7,8}   
   printSlice(numbers)
   
   /* print the original slice */
   fmt.Println("numbers ==", numbers)
   
   /* print the sub slice starting from index 1(included) to index 4(excluded)*/
   fmt.Println("numbers[1:4] ==", numbers[1:4])
   
   /* missing lower bound implies 0*/
   fmt.Println("numbers[:3] ==", numbers[:3])
   
   /* missing upper bound implies len(s)*/
   fmt.Println("numbers[4:] ==", numbers[4:])
   
   numbers1 := make([]int,0,5)
   printSlice(numbers1)
   
   /* print the sub slice starting from index 0(included) to index 2(excluded) */
   number2 := numbers[:2]
   printSlice(number2)
   
   /* print the sub slice starting from index 2(included) to index 5(excluded) */
   number3 := numbers[2:5]
   printSlice(number3)
   
}
func printSlice(x []int){
   fmt.Printf("len = %d cap = %d slice = %v\n", len(x), cap(x),x)
}

Cuando el código anterior se compila y ejecuta, produce el siguiente resultado:

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 ()

Uno puede aumentar la capacidad de una rebanada usando el append()función. Utilizandocopy()función, el contenido de un segmento de origen se copia en un segmento de destino. Por ejemplo

package main

import "fmt"

func main() {
   var numbers []int
   printSlice(numbers)
   
   /* append allows nil slice */
   numbers = append(numbers, 0)
   printSlice(numbers)
   
   /* add one element to slice*/
   numbers = append(numbers, 1)
   printSlice(numbers)
   
   /* add more than one element at a time*/
   numbers = append(numbers, 2,3,4)
   printSlice(numbers)
   
   /* create a slice numbers1 with double the capacity of earlier slice*/
   numbers1 := make([]int, len(numbers), (cap(numbers))*2)
   
   /* copy content of numbers to numbers1 */
   copy(numbers1,numbers)
   printSlice(numbers1)   
}
func printSlice(x []int){
   fmt.Printf("len=%d cap=%d slice=%v\n",len(x),cap(x),x)
}

Cuando el código anterior se compila y ejecuta, produce el siguiente resultado:

len = 0 cap = 0 slice = []
len = 1 cap = 2 slice = [0]
len = 2 cap = 2 slice = [0 1]
len = 5 cap = 8 slice = [0 1 2 3 4]
len = 5 cap = 16 slice = [0 1 2 3 4]