Concatena due Slice in Go

1. Dichiarazione di Slice
2. Concatenazione di fette
3. Funzionamento della funzione append() di Go

In Go, una slice è la struttura dati dinamica che memorizza più elementi dello stesso tipo di dati. Possono anche essere pensati come array di dimensioni variabili che hanno l’indicizzazione come array ma la loro dimensione non è fissa in quanto possono essere ridimensionati. Poiché le sezioni sono di natura dinamica, possiamo aggiungere un nuovo elemento per affettare o concatenare due o più sezioni utilizzando la funzione append.

Dichiarazione di Slice

La dichiarazione di una Slice è simile alla dichiarazione di array, ma la dimensione non è specificata.

package main

import "fmt"

func main() {
    var Slice1 = []int{1, 2, 3, 4}
    fmt.Printf("Length of Slice: %v\n",len(Slice1))
    fmt.Printf("First Element: %v\n",Slice1[0])
    fmt.Printf("Second Element: %v\n",Slice1[1])
    fmt.Printf("Third Element: %v\n",Slice1[2])
    fmt.Printf("Fourth Element: %v\n",Slice1[3])

}

Produzione:

Length of Slice: 4
First Element: 1
Second Element: 2
Third Element: 3
Fourth Element: 4

Concatenazione di fette

Usiamo la funzione incorporata append() per aggiungere elementi all’lista o concatenare due o più sezioni insieme. Se la capacità è sufficiente, la destinazione viene nuovamente affettata per accogliere i nuovi elementi. Se non è disponibile una capacità sufficiente, viene allocato un nuovo sottostante e il contenuto viene copiato. Infine, la funzione append restituisce la slice aggiornata.

Aggiungi un singolo elemento a Slice

package main

import "fmt"

func main() {
    var slice_1 = []int{1, 2}
    slice_2 := append(slice_1, 3)  
    fmt.Printf("slice_1: %v\n", slice_1)
    fmt.Printf("slice_2: %v\n", slice_2)

}

Produzione:

slice_1: [1 2]
slice_2: [1 2 3]

Aggiungi più elementi a una sezione

package main

import "fmt"

func main() {
    var slice_1 = []int{1, 2}
    slice_2 := append(slice_1, 3)
    slice_3 := append(slice_2, 4,5,6)   
    fmt.Printf("slice_3: %v\n", slice_3)

}

Produzione:

slice_3: [1 2 3 4 5 6]

Concatena due fette

package main

import "fmt"

func main() {
    var slice_3 = []int{1, 2, 3, 4, 5, 6}
    var slice_4 = []int{7,8}
    
    slice_5 := append(slice_3,slice_4...) 
    fmt.Printf("slice_4: %v\n", slice_4)
    fmt.Printf("slice_5: %v\n", slice_5)

}

Produzione:

slice_4: [7 8]
slice_5: [1 2 3 4 5 6 7 8]

Un punto importante da notare durante la concatenazione di due sezioni in una volta è che ... è essenziale dopo slice_4 poiché append() è una funzione variadica, proprio come altre funzioni variadiche. ... ti consente di passare più argomenti a una funzione da uno slice. Qui la funzione append viene chiamata ricorsivamente per ogni elemento in slice_4.

Aggiungi una stringa a una porzione di byte

var slice []byte = append([]byte("abc "), "def"...)
fmt.Printf("slice: %v\n", slice)

Produzione:

slice: [97 98 99 32 100 101 102]

Qui i caratteri sono codificati in UTF-8 utilizzando 3 byte che rappresentano il valore ASCII dei caratteri. Lo slice byte può essere riconvertito in stringa come:

slice_str := string(slice)
fmt.Printf("String: %v\n", slice_str)

Produzione:

Slice: abc def

Funzionamento della funzione append() di Go

La funzione incorporata append() prende uno slice, aggiunge tutti gli elementi alla fine di uno slice in input e infine restituisce lo slice concatenato. Se la sezione di destinazione ha una capacità sufficiente, la sezione viene nuovamente affettata per accogliere i nuovi elementi aggiunti. Ma se la destinazione non ha una capacità sufficiente, viene creato un nuovo array e gli elementi presenti nelle slice esistenti vengono copiati nel nuovo array e, infine, viene restituito un nuovo array dalla funzione.

package main

import "fmt"

func main() {

    slice_1 := []int{0, 1, 2}
    fmt.Println("slice_1 : ", slice_1)
    fmt.Println("Capacity of slice_1: ", cap(slice_1))

    res_1 := append(slice_1, 3)
    fmt.Println("res_1 : ", res_1)
    fmt.Println("Capacity of res_1: ", cap(res_1))

    slice_2 := make([]int, 3, 5)  //Create slice_1 with length 3 and capacity 5
    copy(slice_2, []int{0, 1, 2}) //Copy elements into slice_1
    fmt.Println("slice_2 : ", slice_2)
    fmt.Println("Capacity of slice_2: ", cap(slice_2))

    res_2 := append(slice_2, 3)
    fmt.Println("res_2 : ", res_2)
    fmt.Println("Capacity of res_2: ", cap(res_2))

}

Produzione:

slice_1 :  [0 1 2]
Capacity of slice_1:  3
res_1 :  [0 1 2 3]
Capacity of res_1:  6
slice_2 :  [0 1 2]
Capacity of slice_2:  5
res_2 :  [0 1 2 3]
Capacity of res_2:  5

Qui slice_1 non ha una capacità sufficiente per aggiungere nuovi elementi, quindi viene creata una nuova slice di capacità 6 e tutti gli elementi nelle slice esistenti vengono copiati nella slice appena creata.

Tuttavia, slice_2 ha una capacità sufficiente per aggiungere nuovi elementi e quindi gli elementi vengono aggiunti allo slice esistente.