Vai - Fette

Go Slice è un'astrazione su Go Array. Go Array consente di definire variabili che possono contenere diversi elementi di dati dello stesso tipo ma non fornisce alcun metodo integrato per aumentare le sue dimensioni dinamicamente o ottenere un proprio sotto-array. Le fette superano questa limitazione. Fornisce molte funzioni di utilità richieste su Array ed è ampiamente utilizzato nella programmazione Go.

Definizione di una fetta

Per definire una fetta, puoi dichiararla come un array senza specificarne la dimensione. In alternativa, puoi usaremake funzione per creare una fetta.

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*/

funzioni len () e cap ()

Una fetta è un'astrazione su un array. In realtà utilizza gli array come struttura sottostante. Illen() funzione restituisce gli elementi presenti nello slice dove cap()restituisce la capacità dello slice (cioè quanti elementi può contenere). L'esempio seguente spiega l'utilizzo di 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)
}

Quando il codice precedente viene compilato ed eseguito, produce il seguente risultato:

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

Fetta nulla

Se una slice viene dichiarata senza input, per impostazione predefinita viene inizializzata come nil. La sua lunghezza e capacità sono pari a zero. Ad esempio:

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

Quando il codice precedente viene compilato ed eseguito, produce il seguente risultato:

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

Subslicing

Slice consente di specificare il limite inferiore e il limite superiore per ottenere la sottosezione di esso utilizzando[lower-bound:upper-bound]. Ad esempio:

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

Quando il codice precedente viene compilato ed eseguito, produce il seguente risultato:

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]

Funzioni append () e copy ()

Si può aumentare la capacità di una fetta usando il append()funzione. Utilizzandocopy()funzione, il contenuto di una slice di origine viene copiato in una slice di destinazione. Ad esempio:

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

Quando il codice precedente viene compilato ed eseguito, produce il seguente risultato:

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]