Golang Slice

Questo articolo si tufferà in profondità nel lavorare con le fette nel linguaggio di programmazione Go.

Conosciamo tutti gli array, in Go o in altri linguaggi di programmazione. Un array è una raccolta di elementi di un tipo di dati correlato (a seconda). In Go, un array può contenere solo elementi di un tipo simile. Gli array hanno una lunghezza fissa e non possono crescere o ridursi una volta definita la dimensione.

Una fetta è una visione di dimensioni dinamiche degli elementi di un array. Una fetta è molto flessibile, permettendoti di ridimensionarla. Tuttavia, il ridimensionamento deve rimanere sotto la capacità dell'array sottostante.

Dichiarare una fetta

Possiamo dichiarare una fetta usando una semplice sintassi come mostrato di seguito:

var slice_name [] dati _type

Nella sintassi sopra, iniziamo specificando la slice_name seguita da una coppia di parentesi quadrate e il tipo di dati per la fetta.

Noterai che la dichiarazione di fetta è molto simile a quella di un array. Tuttavia, non specifichiamo una dimensione per una fetta.

Crea fetta - Metodo 1

Ci sono due metodi per creare una fetta in Go. Il primo è usare il formato letterale. Questo è strettamente simile a quello mostrato nella sintassi sopra.

Ad esempio, il codice seguente crea una fetta chiamata my_slice:

Pacchetto principale
Importa "FMT"
funcmain ()
var my_slice = [] int 1, 2, 3, 4, 5, 6
fmt.Println (my_slice)

L'esempio sopra crea una fetta di tipo int con valori predefiniti. Se non si desidera utilizzare il metodo VAR di Dichiarazione variabile, è possibile utilizzare la sintassi di seguito:

my_slice: = [] int 1,2,3,4,5,6

Il metodo sopra è noto come fetta letterale.

Crea fetta - Metodo 2

Il secondo metodo per creare una fetta in GO è utilizzare la funzione Make.

La sintassi è come:

func make ([] t, len, cap) [] t

La funzione prende un tipo di dati, una lunghezza e una capacità in questo caso. La funzione allocherà un array con la dimensione specificata dal parametro di capacità. La funzione restituisce una fetta che fa riferimento a quell'array.

Per vederlo in pratica, vedi sotto:

slice_var: = make ([] int, 10)
fmt.Println (slice_var)

Questo esempio dichiara una fetta di dimensione 10 e tipo int. L'output risultante è una fetta di 0 valori.

[0 0 0 0 0 0 0 0 0 0 0]

È possibile assegnare i valori alla fetta usando la notazione indice.

Per assegnare un valore all'indice 1, possiamo fare:

slice_var [0] = 10
fmt.Println (slice_var)

Il codice sopra dovrebbe restituire:

[10 0 0 0 0 0 0 0 0 0 0 0]

NOTA L'elemento nell'indice 0 viene aggiornato per riflettere il nuovo valore.

Proprietà fetta

Esistono due importanti proprietà di una fetta con cui dovresti avere familiarità. La lunghezza e la capacità.

La lunghezza della fetta si riferisce al numero totale di elementi detenuti dalla fetta, mentre la capacità si riferisce al numero di elementi definiti dall'array sottostante. Questo è conteggiato dal primo elemento della fetta.

Per ottenere la lunghezza e la capacità di una fetta, è possibile utilizzare rispettivamente i metodi Len () e Cap ().

Un esempio è come dimostrato di seguito:

Pacchetto principale
Importa "FMT"
funcmain ()
Varmy_Slice = [] int 1, 2, 3, 4, 5, 6
fmt.Println ("lunghezza:", len (my_slice))
fmt.Println ("capacità:", cap (my_slice))

Il codice di esempio sopra dovrebbe restituire la lunghezza e la capacità della fetta come:

Ength: 6
Capacità: 6

Vai a tagliare l'indice

Sapevi che possiamo formare una fetta dalle fette esistenti?

Possiamo farlo specificando un indice limitato con un limite basso e alto. Ad esempio, per creare una nuova fetta con elementi dall'indice da 1 a 5:

new_slice: = my_slice [1: 5]
fmt.Println (new_slice)
La fetta risultante diventa:
[2 3 4 5]

Affettare l'iterazione

Possiamo iterare su un array usando il classico per un ciclo.

Per esempio:

Pacchetto principale
Importa "FMT"
funcmain ()
Varmy_Slice = [] String "Python", "JavaScript", "Go", "Rust", "Dart"
fori, articolo: = rangemy_slice
fmt.Println (i, articolo)

Nell'esempio sopra, utilizziamo un ciclo per loop e un'istruzione di intervallo per iterare l'indice e l'articolo della fetta. L'output risultante:

0 Python
1 JavaScript
2 Go
3 ruggine
4 dardo

Se non si desidera utilizzare l'istruzione Range per il tiro sulla fetta, è possibile utilizzare la lunghezza della fetta come:

per i: = 0; io < len(my_slice); i++
fmt.Println (my_slice [i])

L'esempio sopra restituirà un output simile all'utilizzo del costrutto dell'intervallo.

Vai a copiare l'elemento

Il metodo di copia consente di copiare elementi da una fetta a un'altra. Considera l'esempio seguente:

funccopy_slice ()
slice_1: = [] int 1, 2, 3, 4, 5
slice_2: = [] int 6, 7, 8, 9, 10
new_slice: = copy (slice_1, slice_2)
fmt.Printf ("%d elementi copiati", new_slice)

La funzione restituirà il numero totale di elementi copiati.

Fetta multidimensionale

Puoi anche creare una fetta multidimensionale. Fondamentalmente significa una fetta di fette. Un esempio è come mostrato:

funcmulti_slice ()
multi_slice: = [] [] int
1, 2,
3, 4,
5, 6,
7, 8,

fmt.Println (multi_slice)

L'esempio sopra dovrebbe stampare una fetta multidimensionale come:

[[1 2] [3 4] [5 6] [7 8]]

Per accedere agli elementi in un array multidimensionale, è possibile utilizzare gli indici come:

fmt.Println (multi_slice [0] [0])

La sintassi sopra restituisce il primo elemento nella prima fetta.

Conclusione

Questa guida ti aiuta con le basi del lavoro con le fette in Go. Sebbene non possiamo esaurire le fette nell'ambito di questo tutorial, dovrebbe iniziare.