Go Academy · Lezione

Slice: liste dinamiche

make, append, copy, len e cap

Slice: liste dinamiche è una lezione Go Academy gratuita su CoddyKit. Questa è la lezione 2 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Go Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Go Academy include 4 lezioni in totale.

Che cos'è uno slice

Uno slice è una vista di dimensione dinamica su un array sottostante. Ha tre componenti: un puntatore all'array, una lunghezza e una capacità.

Gli slice sono tipi riferimento: più slice possono condividere lo stesso array di supporto
La maggior parte delle operazioni simili a quelle sulle liste in Go utilizza slice, non array

Literal di slice e make

Crei gli slice con un literal o con make:

package main
import "fmt"

func main() {
    nums := []int{1, 2, 3, 4, 5}      // literal
    strs := make([]string, 3)          // len=3, cap=3, zero values
    buf  := make([]byte, 0, 64)        // len=0, cap=64
    fmt.Println(nums, strs, len(buf), cap(buf))
}

len e cap

len restituisce il numero di elementi attualmente presenti nello slice. cap restituisce la capacità dell'array sottostante a partire dal puntatore iniziale dello slice.

package main
import "fmt"

func main() {
    s := make([]int, 3, 8)
    fmt.Println(len(s)) // 3
    fmt.Println(cap(s)) // 8
}

append: far crescere uno slice

append aggiunge elementi a uno slice e alloca un nuovo array di supporto quando la capacità viene superata:

package main
import "fmt"

func main() {
    s := []int{1, 2, 3}
    s = append(s, 4, 5)
    s = append(s, []int{6, 7, 8}...)
    fmt.Println(s) // [1 2 3 4 5 6 7 8]
}

Suddividere uno slice

Utilizzi la sintassi [low:high] per creare un sotto-slice (che condivide l'array di supporto):

package main
import "fmt"

func main() {
    a := []int{0, 1, 2, 3, 4, 5}
    b := a[1:4]   // [1 2 3]
    c := a[:3]    // [0 1 2]
    d := a[3:]    // [3 4 5]
    fmt.Println(b, c, d)
}

copy: slice indipendenti

copy copia elementi tra slice e restituisce il numero di elementi copiati. La destinazione e l'origine non condividono la memoria:

package main
import "fmt"

func main() {
    src := []int{1, 2, 3}
    dst := make([]int, len(src))
    n := copy(dst, src)
    dst[0] = 99
    fmt.Println(src, dst, n) // [1 2 3] [99 2 3] 3
}

Slice nil e slice vuoto

Uno slice nil non ha un array di supporto. Uno slice vuoto ha un array di supporto, ma lunghezza 0. Entrambi hanno len == 0:

package main
import "fmt"

func main() {
    var nilSlice []int
    emptySlice  := []int{}
    fmt.Println(nilSlice  == nil) // true
    fmt.Println(emptySlice == nil) // false
    fmt.Println(len(nilSlice), len(emptySlice)) // 0 0
    nilSlice = append(nilSlice, 1) // safe!
}

Eliminare un elemento

Go non dispone di una funzione integrata per eliminare elementi dagli slice. L'approccio idiomatico utilizza append:

package main
import "fmt"

func main() {
    s := []int{1, 2, 3, 4, 5}
    i := 2 // delete index 2
    s = append(s[:i], s[i+1:]...)
    fmt.Println(s) // [1 2 4 5]
}

Inserire un elemento

Inserisca un elemento nella posizione i combinando append e lo slicing:

package main
import "fmt"

func main() {
    s := []int{1, 2, 4, 5}
    i := 2
    s = append(s[:i+1], s[i:]...)
    s[i] = 3
    fmt.Println(s) // [1 2 3 4 5]
}

Insidia degli slice: array di supporto condiviso

I sotto-slice condividono l'array di supporto: modificare uno influisce sull'altro finché non avviene una riallocazione:

package main
import "fmt"

func main() {
    a := []int{1, 2, 3, 4}
    b := a[:2]   // shares backing array
    b[0] = 99
    fmt.Println(a) // [99 2 3 4] — a is changed!
}

Verifica rapida

Che cosa restituisce append?

Riepilogo: slice

Punti chiave:

Gli slice sono composti da puntatore + len + cap e racchiudono gli array
Utilizzi make per preallocare la capacità
Assegni sempre il risultato di append
copy crea slice indipendenti
Presti attenzione agli array di supporto condivisi con i sotto-slice

Esercizio

Crei con make uno slice di 5 int, aggiunga altri tre valori con append, quindi lo copi in un nuovo slice e modifichi la copia senza influire sull'originale. Stampi entrambi.

Domande Frequenti

La lezione «Slice: liste dinamiche» è gratuita?

Sì — il testo completo di «Slice: liste dinamiche» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Go Academy, passa a CoddyKit PRO. Il corso Go Academy include 4 lezioni in totale.

Cosa imparerò in «Slice: liste dinamiche»?

make, append, copy, len e cap Eserciti Go Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Go Academy?

Non è richiesta alcuna esperienza precedente. Go Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 2 di 4.

Quanto tempo richiede la lezione «Slice: liste dinamiche»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Go Academy?

Sì. Ogni lezione Go Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

← Torna a Go Academy