English | 简体中文 | 繁體中文 | Русский язык | Français | Español | Português | Deutsch | 日本語 | 한국어 | Italiano | بالعربية

Tutorial di base Golang

Istruzioni di controllo Golang

Funzione & Metodo Golang

Struttura (Struct) Golang

Taglio (Slice) & Array Golang

Stringa (String) Golang

Puntatore Golang

Interfaccia Golang

Concordanza Golang

Eccezioni (Error) Golang

Altri argomenti Golang

Array del linguaggio Go

Il linguaggio di programmazione Go utilizza array che sono molto simili agli altri linguaggi di programmazione. Nei programmi, a volte è necessario memorizzare un insieme di dati dello stesso tipo, ad esempio una lista di punteggi degli studenti. Questo tipo di insieme viene memorizzato nell'array del programma. Gli array sono sequenze di lunghezza fissa utilizzati per memorizzare elementi dello stesso tipo nella memoria. Poiché la loro lunghezza fissa non è così popolare come il Slice (taglio) nel linguaggio Go.
In un array, è permesso memorizzare zero o più elementi. Questo significa che l'indice degli elementi dell'array è indicizzato utilizzando l'operatore di indagine [] e la sua posizione di partenza a zero, il che significa che l'indice del primo elemento èarray [0], l'indice dell'ultimo elemento èarray [len(array)-1]。

Creazione e accesso agli array

In Go, gli array vengono creati in due modi diversi:

  • Utilizzo della parola chiave var:In Go, gli array vengono creati utilizzando la parola chiave var con nome, dimensione ed elementi di tipo specifico.

    Sintassi:

    Var array_name[length]Type
o
var array_name[lunghezza]Typle{item1, item2, item3, ...itemN}

    Punti importanti:

    • In Go, gli array sono mutabili, quindi puoi impostare l'elemento dell'array a una posizione data utilizzando la sintassi array [index] sulla parte sinistra dell'assegnazione.

      Var array_name[index] = element[oggetto Oggetto]

    • Puoi accedere agli elementi dell'array utilizzando un valore di indice o un ciclo for.

    • In Go, il tipo di array è uno solo.

    • La lunghezza dell'array è fissa e non può essere modificata.

    • Puoi memorizzare elementi duplicati nell'array.

      • //Creazione di un array utilizzando la parola chiave var
//Accesso agli elementi dell'array utilizzando il suo indice
package main
import "fmt"
func main() {
　　　　//Creazione di un array di tipo stringa utilizzando la parola chiave var
　　　　var myarr [3]string
　　　　//Assegnazione degli elementi utilizzando l'indice
　　　　myarr[0] = "GFG"
　　　　myarr[1] = "it.oldtoolbag.com"
　　　　myarr[2] = "w3codebox"
　　　　//Accesso agli elementi dell'array
　　　　//Uso dell'indice
　　　　fmt.Println("Elemento dell'array:")
　　　　fmt.Println("Elemento 1: ", myarr[0])
　　　　fmt.Println("Elemento 2: ", myarr[1])
　　　　fmt.Println("Elemento 3: ", myarr[2])
{}

      Output:

      Elemento dell'array:
Elemento 1: GFG
Elemento 2: it.oldtoolbag.com
Elemento 3: w3codebox

  • Dichiarazione abbreviata:In Go, gli array possono essere dichiarati anche con dichiarazioni abbreviate. Sono più flessibili di quella sopra.

    Sintassi:

    array_name:= [lunghezza]Type{item1, item2, item3,...itemN}[oggetto Oggetto]
    //Array utilizzando la dichiarazione abbreviata
//Accesso all'array utilizzando un ciclo for
package main
import "fmt"
func main() {
　　　　//Dichiarazione abbreviata dell'array
　　　　arr := [4]string{"w3codebox", "gfg", "w3codeboxs1231", "it.oldtoolbag.com"}
　　　　//Elemento dell'array, utilizzando l'array con un ciclo for
　　　　fmt.Println("Elemento dell'array:")
　　　　for i := 0; i < 3; i++ {
　　　　　　　　fmt.Println(arr[i])
　　　　{}
{}

    Output:

    Elemento dell'array:
w3codebox
gfg
w3codeboxs1231

    • Array multidimensionale

    Sappiamo già che gli array sono unidimensionali, ma è possibile creare array multidimensionali. Gli array multidimensionali sono array di array dello stesso tipo. In Go è possibile creare array multidimensionali utilizzando la seguente sintassi:

    Array_name[Length1][Length2]..[LengthN]Type

    PuoiUtilizzando la parola chiave VaroUtilizzando la dichiarazione abbreviataPer creare array multidimensionali, come nell'esempio seguente.

    Attenzione:In un array multidimensionale, se l'utente non inizializza una cella con un valore, il compilatore la inizializzerà automaticamente a zero. In Golang non c'è il concetto di valore non inizializzato.

    package main
import "fmt"
func main() {
　　　　//创建和初始化
　　　　//二维数组
　　　　//使用简写声明
　　　　//这里需要用（，）逗号
　　　　arr := [3][3]string{{"C#", "C", "Python"},
　　　　　　　　{"Java", "Scala", "Perl"},
　　　　　　　　{"C++", "Go", "HTML"}
　　　　//访问的值
　　　　//数组使用for循环
　　　　fmt.Println("数组的元素 1")
　　　　for x := 0; x < 3; x++ {
　　　　　　　　for y := 0; y < 3; y++ {
　　　　　　　　　　　　fmt.Println(arr[x][y])
　　　　　　　　{}
　　　　{}
　　　　//创建二维数组
　　　　//使用var关键字的数组
　　　　//并初始化一个
　　　　//使用索引的维数组
　　　　var arr1 [2][2]int
　　　　arr1[0][0] = 100
　　　　arr1[0][1] = 200
　　　　arr1[1][0] = 300
　　　　arr1[1][1] = 400
　　　　//访问数组的值
　　　　fmt.Println("数组的元素 2")
　　　　for p := 0; p < 2; p++ {
　　　　　　　　for q := 0; q < 2; q++ {
　　　　　　　　　　　　fmt.Println(arr1[p][q])
　　　　　　　　{}
　　　　{}
{}

    Output:

    数组的元素　1
C#
C
Python
Java
Scala
Perl
C++
Go
HTML
数组的元素　2
100
200
300
400

    关于数组的注意事项

  • 在数组中，如果未显式初始化数组，则此数组的默认值为0。

    package main　
　　
import "fmt"
　　
func main() {　
　　
//创建一个int类型的数组,存储两个元素
//在这里，我们不初始化数组，所以数组的值为零
var　myarr[2]int　
fmt.Println("数组元素　:",　myarr)　
　　
{}

    Output:

    数组元素　:　[0　0]

  • 在数组中，您可以使用len()方法获取数组的长度，如下所示：

    package main
import "fmt"
func main() {
　　　　//创建数组
　　　　//使用简写声明
　　　　arr1 := [3]int{9, 7, 6}
　　　　arr2　:=　[...]int{9,　7,　6,　4,　5,　3,　2,　4}
　　　　arr3　:=　[3]int{9,　3,　5}
　　　　//　使用len方法计算数组大小
　　　　fmt.Println("数组1的长度是:",　len(arr1))
　　　　fmt.Println("数组2的长度是:",　len(arr2))
　　　　fmt.Println("数组3的长度是:",　len(arr3))
{}

    Output:

    数组1的长度是:　3
数组2的长度是:　8
数组3的长度是:　3

  • 在数组中，如果省略号“ ...”在长度位置处可见，则数组的长度由初始化的元素确定。如下例所示：

    //数组中省略号的使用方法
package main
import "fmt"
func main() {
　　　　//创建大小已确定的数组
　　　　//根据其中元素的数量
　　　　//使用省略号
　　　　myarray　:=　[...]string{"GFG",　"gfg",　"w3codeboxs",　"it.oldtoolbag.com",　"w3codebox"}
　　　　fmt.Println("数组元素:　",　myarray)
　　　　//数组的长度
　　　　//由...决定
　　　　//使用len()方法
　　　　fmt.Println("数组的长度为:",　len(myarray))
{}

    Output:

    数组元素:　　[GFG　gfg　w3codeboxs　it.oldtoolbag.com　w3codebox]
数组的长度为:　5

  • 在数组中，允许您在array 的元素范围内进行迭代。Ecco un esempio:

    //如何迭代数组
package main
import "fmt"
func main() {
　　　　// Creare un array di una determinata dimensione
　　　　// Utilizzare i puntini di sospensione per rappresentare
　　　　myarray　:=　[...]int{29,　79,　49,　39,　20,　49,　48,　49}
　　　　//使用for循环迭代数组
　　　　for x := 0; x < len(myarray); x++ {
　　　　　　　　fmt.Printf("%d\n", myarray[x])
　　　　{}
{}

    Output:

    29
79
49
39
20
49
48
49

  • In Go语言中，Il tipo di valore dell'array non è di tipo riferimento。Quindi, quando assegniamo un array a una nuova variabile, le modifiche apportate nella nuova variabile non influenzeranno l'array originale. Ecco un esempio:

    package main
import "fmt"
func main() {
　　　　// Creare un array di una determinata dimensione
　　　　// Utilizzare i puntini di sospensione per rappresentare
　　　　my_array := [...]int{100, 200, 300, 400, 500}
　　　　fmt.Println("Array originale (prima delle modifiche):", my_array)
　　　　// Creare una nuova variabile
　　　　// E inizializzare con my_array
　　　　new_array := my_array
　　　　fmt.Println("Nuovo array (prima delle modifiche):", new_array)
　　　　// Modificare il valore all'indice 0 a 500
　　　　new_array[0] = 500
　　　　fmt.Println("Nuovo array (dopo le modifiche):", new_array)
　　　　fmt.Println("Array originale (dopo le modifiche):", my_array)
{}

    Output:

    Array originale (prima delle modifiche): [100 200 300 400 500]
Nuovo array (prima delle modifiche): [100 200 300 400 500]
Nuovo array (dopo le modifiche): [500 200 300 400 500]
Array originale (dopo le modifiche): [100 200 300 400 500]

  • In un array, se il tipo degli elementi dell'array è comparabile, il tipo dell'array è anche comparabile. Pertanto,Possiamo utilizzare direttamente l'operatore == per confrontare due array。Ecco un esempio:

    // Come confrontare due array
package main
import "fmt"
func main() {
　　　　arr1 := [3]int{9, 7, 6}
　　　　arr2 := [...]int{9, 7, 6}
　　　　arr3 := [3]int{9, 5, 3}
　　　　// Utilizzare l'operatore == per confrontare gli array
　　　　fmt.Println(arr1 == arr2)
　　　　fmt.Println(arr2 == arr3)
　　　　fmt.Println(arr1 == arr3)
　　　　// Questo produrrà un errore perché
　　　　// arr1 e arr4 non hanno lo stesso tipo
　　　　/*
　　　　　　　arr4:= [4]int{9,7,6}
　　　　　　　fmt.Println(arr1==arr4)
　　　　*/
{}

    Output:

    true
false
false
Copia dell'array GoFunzione utilizzata come campo della struttura Go