Go
fette

introduzione

Sintassi

• slice: = make ([] type, len, cap) // crea una nuova slice
• slice = append (slice, item) // aggiunge un elemento ad una slice
• slice = append (slice, items ...) // aggiunge una porzione di elementi a una slice
• len: = len (slice) // ottiene la lunghezza di una fetta
• cap: = cap (slice) // ottiene la capacità di una slice
• elNum: = copy (dst, slice) // copia un contenuto di una slice in un'altra slice

Aggiungendo alla fetta

slice = append(slice, "hello", "world")

Aggiunta di due fette insieme

slice1 := []string{"!"}
slice2 := []string{"Hello", "world"}
slice  := append(slice1, slice2...)

Esegui nel Go Playground

Rimozione elementi / fette "Affettare"

Se è necessario rimuovere uno o più elementi da una sezione o se è necessario lavorare con una sottosezione di un'altra esistente; puoi usare il seguente metodo.

Gli esempi seguenti utilizzano slice of int, ma questo funziona con tutti i tipi di slice.

Quindi, per quello, abbiamo bisogno di una fetta, da parte nostra rimuoveremo alcuni elementi:

slice := []int{1, 2, 3, 4, 5, 6} 
// > [1 2 3 4 5 6]

Abbiamo bisogno anche degli indici di elementi da rimuovere:

// index of first element to remove (corresponding to the '3' in the slice)
var first = 2

// index of last element to remove (corresponding to the '5' in the slice)
var last = 4 

E così possiamo "tagliare" la fetta, rimuovendo elementi indesiderati:

// keeping elements from start to 'first element to remove' (not keeping first to remove), 
// removing elements from 'first element to remove' to 'last element to remove'
// and keeping all others elements to the end of the slice
newSlice1 := append(slice[:first], slice[last+1:]...)
// > [1 2 6]

// you can do using directly numbers instead of variables
newSlice2 := append(slice[:2], slice[5:]...)
// > [1 2 6]

// Another way to do the same
newSlice3 := slice[:first + copy(slice[first:], slice[last+1:])]
// > [1 2 6]

// same that newSlice3 with hard coded indexes (without use of variables)
newSlice4 := slice[:2 + copy(slice[2:], slice[5:])]
// > [1 2 6]

Per rimuovere solo un elemento, devi solo mettere l'indice di questo elemento come primo E come ultimo indice da rimuovere, proprio così:

var indexToRemove = 3
newSlice5 := append(slice[:indexToRemove], slice[indexToRemove+1:]...)
// > [1 2 3 5 6]

// hard-coded version:
newSlice5 := append(slice[:3], slice[4:]...)
// > [1 2 3 5 6]

E puoi anche rimuovere elementi dall'inizio della sezione:

newSlice6 := append(slice[:0], slice[last+1:]...)
// > [6]

// That can be simplified into
newSlice6 := slice[last+1:]
// > [6]

Puoi anche rimuovere alcuni elementi dalla fine della sezione:

newSlice7 := append(slice[:first], slice[first+1:len(slice)-1]...)
// > [1 2]

// That can be simplified into
newSlice7 := slice[:first]
// > [1 2]

Se la nuova slice deve contenere esattamente gli stessi elementi della prima, puoi usare la stessa cosa ma con l' last := first-1 .
(Questo può essere utile nel caso in cui i tuoi indici siano precedentemente calcolati)

Lunghezza e capacità

Le fette hanno sia lunghezza che capacità. La lunghezza di una sezione è il numero di elementi attualmente nella sezione, mentre la capacità è il numero di elementi che la sezione può contenere prima di dover essere riallocata.

Quando si crea una sezione usando la funzione built-in make() , è possibile specificare la sua lunghezza e facoltativamente la sua capacità. Se la capacità non è specificata esplicitamente, sarà la lunghezza specificata.

var s = make([]int, 3, 5) // length 3, capacity 5

Puoi controllare la lunghezza di una sezione con la funzione len() integrata:

var n = len(s) // n == 3

Puoi verificare la capacità con la funzione cap() integrata:

var c = cap(s) // c == 5

Gli elementi creati da make() sono impostati sul valore zero per il tipo di elemento della slice:

for idx, val := range s {
    fmt.Println(idx, val)
}
// output:
// 0 0
// 1 0
// 2 0

Eseguilo su play.golang.org

Non è possibile accedere agli elementi oltre la lunghezza di una sezione, anche se l'indice è all'interno della capacità:

var x = s[3] // panic: runtime error: index out of range

Tuttavia, finché la capacità supera la lunghezza, è possibile aggiungere nuovi elementi senza riallocare:

var t = []int{3, 4}
s = append(s, t) // s is now []int{0, 0, 0, 3, 4}
n = len(s) // n == 5
c = cap(s) // c == 5

Se si aggiunge una porzione che non ha la capacità di accettare i nuovi elementi, l'array sottostante verrà riallocato per voi con una capacità sufficiente:

var u = []int{5, 6}
s = append(s, u) // s is now []int{0, 0, 0, 3, 4, 5, 6}
n = len(s) // n == 7
c = cap(s) // c > 5

Pertanto, è generalmente buona norma allocare una capacità sufficiente quando si crea una sezione, se si conosce lo spazio necessario per evitare riallocazioni non necessarie.

Copia dei contenuti da una sezione all'altra

Se si desidera copiare il contenuto di una sezione in una sezione inizialmente vuota, è possibile eseguire i seguenti passaggi per realizzarlo-

1. Crea la slice sorgente:

var sourceSlice []interface{} = []interface{}{"Hello",5.10,"World",true}

2. Crea la sezione di destinazione, con:

• Lunghezza = Lunghezza di sourceSlice

var destinationSlice []interface{} = make([]interface{},len(sourceSlice))

3. Ora che l'array sottostante della slice di destinazione è abbastanza grande da contenere tutti gli elementi della slice source, possiamo procedere a copiare gli elementi usando la copy integrata:

copy(destinationSlice,sourceSlice)

Creazione di fette

Le fette sono il modo tipico in cui i programmatori memorizzano gli elenchi di dati.

Per dichiarare una variabile slice usa []Type sintassi.

var a []int

Per dichiarare e inizializzare una variabile slice in una riga, utilizzare la sintassi []Type{values} .

var a []int = []int{3, 1, 4, 1, 5, 9}

Un altro modo per inizializzare una sezione è con la funzione make . Tre argomenti: il Type di sezione (o mappa ), la length e la capacity .

a := make([]int, 0, 5)

Puoi aggiungere elementi alla tua nuova sezione usando append .

a = append(a, 5)

Controlla il numero di elementi nella tua fetta usando len .

length := len(a)

Controlla la capacità della tua fetta usando cap . La capacità è il numero di elementi attualmente allocati in memoria per la sezione. È sempre possibile aggiungere una porzione alla capacità poiché Go creerà automaticamente una fetta più grande per te.

capacity := cap(a)

È possibile accedere agli elementi in una sezione utilizzando la tipica sintassi di indicizzazione.

a[0]  // Gets the first member of `a`

Puoi anche usare un ciclo for su loop con range . La prima variabile è l'indice nell'array specificato e la seconda variabile è il valore per l'indice.

for index, value := range a {
    fmt.Println("Index: " + index + " Value: " + value)  // Prints "Index: 0 Value: 5" (and continues until end of slice)
}

Vai al parco giochi

Filtrare una fetta

Per filtrare una porzione senza allocare una nuova matrice sottostante:

// Our base slice
slice := []int{ 1, 2, 3, 4 }
// Create a zero-length slice with the same underlying array
tmp := slice[:0]

for _, v := range slice {
  if v % 2 == 0 {
    // Append desired values to slice
    tmp = append(tmp, v)
  }
}

// (Optional) Reassign the slice
slice = tmp // [2, 4]

Valore zero della fetta

Il valore zero della slice è nil , che ha lunghezza e capacità 0 . Una slice nil non ha array sottostanti. Ma ci sono anche fette di lunghezza non nulla e capacità 0 , come []int{} o make([]int, 5)[5:] .

Qualsiasi tipo che ha valori nil può essere convertito in nil slice:

s = []int(nil)

Per verificare se una sezione è vuota, utilizzare:

if len(s) == 0　{
    fmt.Ptintf("s is empty.")
}