Tutorial di base di Golang

Istruzioni di controllo di Golang

Funzione & Metodo di Golang

Struttura di Golang

Slice & Array di Golang

Stringa (String) di Golang

Puntatore di Golang

Interfaccia di Golang

Concordanza di Golang

Eccezioni (Error) di Golang

Altri argomenti di Golang

Copia del slice Go Array come parametro della funzione Go

Slice (Slice) del linguaggio Go

In Go, la slice è piùArrayPiù potente, flessibile, conveniente e leggera, la slice è una sequenza a lunghezza variabile utilizzata per memorizzare elementi dello stesso tipo, non consentendo di memorizzare elementi di tipo diverso nella stessa slice. Come un array con valori di indice e lunghezza, ma la dimensione della slice può essere regolata, la slice non è come l'array di dimensione fissa. Sotto il coperchio, la slice e l'array sono collegati, la slice è un riferimento all'array di base. Permette di memorizzare elementi ripetuti nella slice.La prima posizione dell'indice nella slice è sempre 0, mentre l'ultima posizione dell'indice sarà (lunghezza della slice - 1).

Dichiarazione della slice

La dichiarazione della slice è simile all'array, ma non include la dimensione della slice. Pertanto, può crescere o ridursi secondo necessità.

Sintassi:

[]T
O
[]T{}
O
[]T{value1, value2, value3, ...value n}

In questo caso, T è il tipo dell'elemento. Ad esempio:

var my_slice[]int

Composizione della slice

Una slice contiene tre componenti:

Puntatore:Il puntatore serve a puntare al primo elemento dell'array accessibile tramite la slice. In questo caso, l'elemento puntato non deve essere il primo elemento dell'array.
Lunghezza:La lunghezza è il numero totale di elementi presenti nell'array.
Capacità:La capacità rappresenta la dimensione massima estendibile.

Discutiamo tutti questi componenti con un esempio:

Esempio

//Slice
package main
import "fmt"
func main() {
　　　　//创建一个数组
　　　　arr := [7]string{"Questo", "è", "Golang", "di", "base", "online", "it.oldtoolbag.com"}
　　　　//Mostra l'array
　　　　fmt.Println("Array:", arr)
　　　　//Creazione delle fette
　　　　myslice := arr[1:6]
　　　　//Mostra la slice
　　　　fmt.Println("Slice:", myslice)
　　　　//Mostra la lunghezza della slice
　　　　fmt.Printf("Lunghezza della slice: %d", len(myslice))
　　　　//Mostra la capacità della slice
　　　　fmt.Printf("\nCapacità della slice: %d", cap(myslice))
}

Output:

Array: [Questo è il tutorial di base di Golang online it.oldtoolbag.com]
切片: [是 Golang 基础 教程 在线]
切片长度: 5
切片容量: 6

用法解释：在上面的实例中，我们从给定的数组中创建一个切片。这里，切片的指针指向索引1，因为切片的下界被设置为1，所以它开始访问来自索引1的元素。切片的长度为5，表示切片中元素的总数为5，而切片的容量表示最多可以存储6个元素。

如何创建和初始化切片？

在Go语言中，可以使用以下方式创建和初始化切片：

使用切片字面量：您可以，使用切片字面量创建切片。切片字面量的创建就像数组字面量一样，但是有一个区别，即不允许您在方括号[]中指定切片的大小。如下例所示，该表达式的右侧是切片字面量。

var my_slice_1 = []string{"w3codeboxs", "for", "w3codeboxs"}

注意：请注意，当您使用字符串文字创建切片时，它首先创建一个数组，然后返回对其的切片引用。

Esempio

//使用切片创建切片字面量
package main
import "fmt"
func main() {
　　　　//使用var关键字创建切片
　　　　var my_slice_1 = []string{"w3codeboxs", "for", "w3codeboxs"}
　　　　fmt.Println("My Slice 1:", my_slice_1)
　　　　//Creazione delle fette
　　　　//使用简写声明
　　　　my_slice_2 := []int{12, 45, 67, 56, 43, 34, 45}
　　　　fmt.Println("My Slice 2:", my_slice_2)
}

Output:

My Slice 1: [w3codeboxs for w3codeboxs]
My Slice 2: [12 45 67 56 43 34 45]

使用数组：我们已经知道，切片是数组的引用，因此，您可以根据给定的数组创建切片。要从给定数组创建切片，首先需要指定下限和上限，这意味着切片可以从下限到上限开始获取数组中的元素。它不包括从上限开始的元素。如下例所示：
Sintassi:
```
array_name[low:high]
```
Questa sintassi restituirà un nuovo taglio.
注意：默认情况下，下限为0，上限为给定数组中存在的元素总数。

Esempio

//从数组创建切片
package main　
　　
import "fmt"
　　
func main() {　
　　
　　　　//创建一个数组
　　　　arr := [4]string{"w3codeboxs", "for", "w3codeboxs", "GFG"}　
　　
　　　　//从给定数组创建切片　
　　　　var my_slice_1 = arr[1:2]　
　　　　my_slice_2 := arr[0:]　
　　　　my_slice_3 := arr[:2]　
　　　　my_slice_4 := arr[:]　
　　
　　　　//Mostra il risultato
　　　　fmt.Println("Il mio array:", arr)　
　　　　fmt.Println("My Slice 1:", my_slice_1)　
　　　　fmt.Println("My Slice 2:", my_slice_2)　
　　　　fmt.Println("My Slice 3:", my_slice_3)　
　　　　fmt.Println("My Slice 4:", my_slice_4)　
}

Output:

Il mio array:     [w3codeboxs for w3codeboxs GFG]
My Slice 1:     [for]
My Slice 2:     [w3codeboxs for w3codeboxs GFG]
My Slice 3:     [w3codeboxs for]
My Slice 4:     [w3codeboxs for w3codeboxs GFG]

Usa il taglio esistente:Puoi anche creare un taglio da un taglio dato. Per creare un taglio da un taglio dato, è necessario specificare il limite inferiore e il limite superiore, il che significa che il taglio può iniziare a prendere gli elementi dal limite inferiore al limite superiore. Non include l'elemento che inizia dall'indice superiore. Come nell'esempio seguente:

Sintassi:

slice_name[low:high]

Questa sintassi restituirà un nuovo taglio.

注意：Il valore predefinito per il limite inferiore è 0, il valore predefinito per il limite superiore è il numero totale di elementi presenti nel taglio dato.

Esempio

//Crea un taglio da un taglio
package main
import "fmt"
func main() {
　　　　//Creazione delle fette
　　　　oRignAl_slice := []int{90, 60, 40, 50, 34, 49, 30}
　　　　//Crea un taglio da un taglio dato
　　　　var my_slice_1 = oRignAl_slice[1:5]
　　　　my_slice_2 := oRignAl_slice[0:]
　　　　my_slice_3 := oRignAl_slice[:6]
　　　　my_slice_4 := oRignAl_slice[:]
　　　　my_slice_5 := my_slice_3[2:4]
　　　　//Mostra il risultato
　　　　fmt.Println("Taglio originale:", oRignAl_slice)
　　　　fmt.Println("Nuovo taglio 1:", my_slice_1)
　　　　fmt.Println("Nuovo taglio 2:", my_slice_2)
　　　　fmt.Println("Nuovo taglio 3:", my_slice_3)
　　　　fmt.Println("Nuova sezione 4:", my_slice_4)
　　　　fmt.Println("Nuova sezione 5:", my_slice_5)
}

Output:

Sezione originale: [90 60 40 50 34 49 30]
Nuova sezione 1: [60 40 50 34]
Nuova sezione 2: [90 60 40 50 34 49 30]
Nuova sezione 3: [90 60 40 50 34 49]
Nuova sezione 4: [90 60 40 50 34 49 30]
Nuova sezione 5: [40 50]

Utilizza la funzione make():Puoi anche utilizzare le librerie fornite da gofunzione make()Crea una sezione. Questa funzione accetta tre parametri, ovvero il tipo, la lunghezza e la capacità. In questo caso, il valore della capacità è opzionale. La dimensione dell'array di livello inferiore assegnata è uguale alla capacità fornita e restituisce una sezione che punta all'array di livello inferiore. Di solito, la funzione make() viene utilizzata per creare una sezione vuota. In questo caso, la sezione vuota è costituita da quelle sezioni che contengono riferimenti a array vuoti.

Sintassi:

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

Esempio

// Utilizza la funzione make
package main
import "fmt"
func main() {
　　　　// Crea un array di dimensione 7
　　　　// Taglia questo array in 4
　　　　// E restituisce un riferimento alla sezione
　　　　// Utilizza la funzione make
　　　　var my_slice_1 = make([]int, 4, 7)
　　　　fmt.Printf("Slice 1 = %v, \nlength = %d, \ncapacity = %d\n",my_slice_1, len(my_slice_1), cap(my_slice_1))
　　　　// Crea un altro array di dimensione 7
　　　　// E restituisce un riferimento alla sezione
　　　　// Utilizza la funzione make
　　　　var my_slice_2 = make([]int, 7)
　　　　fmt.Printf("Slice 2 = %v, \nlength = %d, \ncapacity = %d\n",my_slice_2, len(my_slice_2), cap(my_slice_2))
}

Output:

Slice 1 = [0 0 0 0],　
length = 4,　
capacity = 7
Slice 2 = [0 0 0 0 0 0 0],　
length = 7,　
capacity = 7

Come esplorare una sezione?

Puoi esplorare la sezione in questo modo:

Utilizza un ciclo for:Questo è il metodo più semplice per iterare una sezione, come mostrato negli esempi seguenti:

Esempio

// Iterazione del ciclo for sulla sezione
package main　
　　
import "fmt"
　　
func main() {　
　　
　　　　//Creazione delle fette
　　　　myslice := []string{"This", "is", "the", "tutorial", "of", "Go", "language"}　
　　
　　　　// Esegui un ciclo for per l'iterazione
　　　　per e := 0; e < len(myslice); e++ {　
　　　　　　　　fmt.Println(myslice[e])　
　　　　}　
}

Output:

This
is
the
tutorial
of
Go
language

Uso di range nel ciclo for:È possibile usare un ciclo for con range per iterare attraverso un array. Utilizzando range nel ciclo for, è possibile ottenere l'indice e il valore dell'elemento, come mostrato negli esempi:

Esempio

// Uso di range nel ciclo for
package main　
　　
import "fmt"
　　
func main() {　
　　
　　　　//Creazione delle fette
　　　　myslice := []string{"This", "is", "the", "tutorial", "of", "Go", "language"}　
　　
　　　　　　　　// Iterazione dell'array
　　　　　　　　// Uso di range nel ciclo for
　　　　for index, ele := range myslice {　
　　　　　　　　fmt.Printf("Indice = %d e elemento = %s\n", index+3, ele)　
　　　　}　
}

Output:

Indice = 3 e elemento = This
Indice = 4 e elemento = is
Indice = 5 e elemento = the
Indice = 6 e elemento = tutorial
Indice = 7 e elemento = of
Indice = 8 e elemento = Go
Indice = 9 e elemento = language

Uso di identificatore vuoto nel ciclo for: nel ciclo forAll'interno del ciclo for, se non si desidera ottenere il valore dell'indice dell'elemento, si può usare uno spazio vuoto (_ come variabile di indice, come mostrato negli esempi seguenti:

Esempio

// Uso di range nel ciclo for senza indice　
package main　
　　
import "fmt"
　　
func main() {　
　　
　　　　//Creazione delle fette　
　　　　myslice := []string{"This", "is", "the", "tutorial", "of", "Go", "language"}　
　　
　　　　　　　　// Iterazione dell'array
　　　　　　　　// Uso di range nel ciclo for
　　　　　　　　// Senza indice
　　　　for _, ele := range myslice {　
　　　　　　　　fmt.Printf("Elemento = %s\n", ele)　
　　　　}　
}

Output:

Elemento = This
Elemento = is
Elemento = the
Elemento = tutorial
Elemento = of
Elemento = Go
Elemento = language

Punti chiave sui tagli

Array vuoto:In Go è permesso creare un array vuoto che non contiene alcun elemento. Pertanto, la capacità e la lunghezza di questo array sono 0. Gli array vuoti non contengono riferimenti a array, come mostrato negli esempi seguenti:

Esempio

package main　
　　
import "fmt"
　　
func main() {　
　　
　　　　// Creazione di un'array di zero valori
　　　　var myslice []string　
　　　　fmt.Printf("Lunghezza = %d\n", len(myslice))　
　　　　fmt.Printf("Capacity = %d ", cap(myslice))　
　　
}

Output:

Length = 0
Capacity = 0

修改Slice：正如我们已经知道slice是引用类型一样，它可以引用基础数组。因此，如果我们更改切片中的某些元素，则更改也应发生在引用数组中。换句话说，如果您对切片进行了任何更改，则切片也会反映在数组中，如以下示例所示：

Esempio

//如何修改切片
package main　
　　
import "fmt"
　　
func main() {　
　　
　　　　//创建零值切片
　　　　arr := [6]int{55, 66, 77, 88, 99, 22}　
　　　　slc := arr[0:4]　
　　
　　　　//修改前
　　
　　　　fmt.Println("Original_Array: ", arr)　
　　　　fmt.Println("Original_Slice: ", slc)　
　　
　　　　//修改后　
　　　　slc[0] = 100　
　　　　slc[1] = 1000　
　　　　slc[2] = 1000　
　　
　　　　fmt.Println("\nNew_Array: ", arr)　
　　　　fmt.Println("New_Slice: ", slc)　
}

Output:

Original_Array: [55 66 77 88 99 22]
Original_Slice: [55 66 77 88]
New_Array: [100 1000 1000 88 99 22]
New_Slice: [100 1000 1000 88]

切片的比较：在切片中，您只能使用==运算符检查给定切片是否存在。==运算符的帮助下比较两个切片，则会抛出错误，如下例所示：

Esempio

//判断切片是否为零
package main　
　　
import "fmt"
　　
func main() {　
　　
　　　　//Creazione delle fette
　　　　s1 := []int{12, 34, 56}　
　　　　var s2 []int
　　
　　　　　　　　//如果你尝试运行这个注释
　　　　　　　　//代码编译器将给出一个错误
　　　　/*s3:= []int{23, 45, 66}*/　
　　　　　　fmt.Println(s1==s3)　
　　　　*/
　　
　　　　//检查给定的片是否为nil
　　　　fmt.Println(s1 == nil)　
　　　　fmt.Println(s2 == nil)　
}

Output:

false
true

注意：如果要比较两个切片，请使用循环范围匹配每个元素，或者可以使用DeepEqual函数。

多维切片：多维切片与多维数组一样，只是切片不包含大小。

Esempio

package main　
　　
import "fmt"
　　
func main() {　
　　
　　　　//Creazione delle fette multidimensionali
　　　　s1 := [][]int{{12, 34},}}　
　　　　　　　　{56, 47},　
　　　　　　　　{29, 40},　
　　　　　　　　{46, 78},　
　　　　}　
　　
　　　　//Accesso alle fette multidimensionali
　　　　fmt.Println("Slice 1: ", s1)　
　　
　　　　//Creazione delle fette multidimensionali　
　　　　s2 := [][]string{　
　　　　　　　　[]string{"w3codeboxs", "for"},　
　　　　　　　　[]string{"w3codeboxs", "GFG"},　
　　　　　　　　[]string{"gfg", "w3codebox"},　
　　　　}　
　　
　　　　//Accesso alle fette multidimensionali
　　　　fmt.Println("Slice 2: ", s2)　
　　
}

Output:

Slice 1: [[12 34] [56 47] [29 40] [46 78]]
Slice 2: [[w3codeboxs for] [w3codeboxs GFG] [gfg w3codebox]]

Ordinamento delle fette:Nel linguaggio Go, è possibile ordinare gli elementi presenti nelle fette. Il linguaggio Go fornisce la libreria standard sort, che contiene diversi tipi di funzioni di ordinamento per le fette di int, float64 e stringhe. Queste funzioni ordinano sempre gli elementi disponibili nelle fette in ordine crescente.

Esempio

//Elementi presenti nelle fette
package main　
　　
import (　
　　　　"fmt"
　　　　"sort"
)　
　　
func main() {　
　　
　　　　//Creazione delle fette
　　　　slc1 := []string{"Python", "Java", "C#", "Go", "Ruby"}　
　　　　slc2 := []int{45, 67, 23, 90, 33, 21, 56, 78, 89}　
　　
　　　　fmt.Println("Prima della sortatura:")　
　　　　fmt.Println("Slice 1: ", slc1)　
　　　　fmt.Println("Slice 2: ", slc2)　
　　
　　　　//L'uso delle funzioni di ordinamento delle fette
　　　　sort.Strings(slc1)　
　　　　sort.Ints(slc2)　
　　
　　　　fmt.Println("
Sortato:")　
　　　　fmt.Println("Slice 1: ", slc1)　
　　　　fmt.Println("Slice 2: ", slc2)　
　　
}

Output:

Prima della sortatura:
Slice 1: [Python Java C# Go Ruby]
Slice 2: [45 67 23 90 33 21 56 78 89]
Sortato:
Slice 1: [C# Go Java Python Ruby]
Slice 2: [21 23 33 45 56 67 78 89 90]

Copia del slice Go Array come parametro della funzione Go