Ricerca…


introduzione

Le matrici sono tipi di dati specifici, che rappresentano una raccolta ordinata di elementi di un altro tipo.

In Go, gli array possono essere semplici (a volte chiamati "elenchi") o multidimensionali (ad esempio, un array di 2 dimensioni rappresenta una raccolta ordinata di matrici, che contiene elementi)

Sintassi

  • var variableName [5] ArrayType // Dichiarazione di una matrice di dimensione 5.
  • var variableName [2] [3] ArrayType = {{Valore1, Valore2, Valore3}, {Valore4, Valore5, Valore6}} // Dichiarazione di un array multidimensionale
  • variableName: = [...] ArrayType {Value1, Value2, Value3} // Dichiara una matrice di dimensione 3 (Il compilatore conterà gli elementi dell'array per definire la dimensione)
  • arrayName [2] // Ottenere il valore per indice.
  • arrayName [5] = 0 // Impostazione del valore all'indice.
  • arrayName [0] // Primo valore della matrice
  • arrayName [len (arrayName) -1] // Ultimo valore della matrice

Creare matrici

Un array in go è una raccolta ordinata di elementi dello stesso tipo.
La notazione di base per rappresentare gli array è usare [] con il nome della variabile.

La creazione di un nuovo array assomiglia a var array = [size]Type , sostituendo le size con un numero (ad esempio 42 per specificare che sarà un elenco di 42 elementi) e sostituendo Type base al tipo di elementi che l'array può contenere (per esempio int o string )

Subito sotto è un esempio di codice che mostra il diverso modo di creare un array in Go.

// Creating arrays of 6 elements of type int,
// and put elements 1, 2, 3, 4, 5 and 6 inside it, in this exact order:
var array1 [6]int = [6]int {1, 2, 3, 4, 5, 6} // classical way
var array2 = [6]int {1, 2, 3, 4, 5, 6} // a less verbose way
var array3 = [...]int {1, 2, 3, 4, 5, 6} // the compiler will count the array elements by itself

fmt.Println("array1:", array1) // > [1 2 3 4 5 6]
fmt.Println("array2:", array2) // > [1 2 3 4 5 6]
fmt.Println("array3:", array3) // > [1 2 3 4 5 6]


// Creating arrays with default values inside:
zeros := [8]int{}               // Create a list of 8 int filled with 0
ptrs := [8]*int{}               // a list of int pointers, filled with 8 nil references ( <nil> )
emptystr := [8]string{}         // a list of string filled with 8 times ""

fmt.Println("zeroes:", zeros)      // > [0 0 0 0 0 0 0 0]
fmt.Println("ptrs:", ptrs)         // > [<nil> <nil> <nil> <nil> <nil> <nil> <nil> <nil>]
fmt.Println("emptystr:", emptystr) // > [       ]  
// values are empty strings, separated by spaces,
// so we can just see separating spaces


// Arrays are also working with a personalized type
type Data struct {
    Number int
    Text   string
}

// Creating an array with 8 'Data' elements
// All the 8 elements will be like {0, ""} (Number = 0, Text = "")
structs := [8]Data{}  

fmt.Println("structs:", structs) // > [{0 } {0 } {0 } {0 } {0 } {0 } {0 } {0 }] 
// prints {0 } because Number are 0 and Text are empty; separated by a space

giocarci sul campo da gioco

Matrice multidimensionale

Gli array multidimensionali sono fondamentalmente array che contengono altri array come elementi.
È rappresentato come [sizeDim1][sizeDim2]..[sizeLastDim]type , sostituendo sizeDim base ai numeri corrispondenti alla lunghezza della dimensione e type il tipo di dati nell'array multidimensionale.

Ad esempio, [2][3]int rappresenta una matrice composta da 2 sottoarray di 3 elementi tipizzati int .
Può essere fondamentalmente la rappresentazione di una matrice di 2 righe e 3 colonne .

Quindi possiamo creare array di numeri di dimensioni enormi come var values := [2017][12][31][24][60]int per esempio se è necessario memorizzare un numero per ogni minuto dall'anno 0.

Per accedere a questo tipo di array, per l'ultimo esempio, cercando il valore di 2016-01-31 alle 19:42, si accede ai values[2016][0][30][19][42] (perché gli indici di array inizia da 0 e non a 1 come giorni e mesi)

Alcuni esempi seguenti:

// Defining a 2d Array to represent a matrix like
// 1 2 3     So with 2 lines and 3 columns;
// 4 5 6     
var multiDimArray := [2/*lines*/][3/*columns*/]int{ [3]int{1, 2, 3}, [3]int{4, 5, 6} }

// That can be simplified like this:
var simplified := [2][3]int{{1, 2, 3}, {4, 5, 6}}

// What does it looks like ?
fmt.Println(multiDimArray)
// > [[1 2 3] [4 5 6]]

fmt.Println(multiDimArray[0]) 
// > [1 2 3]    (first line of the array)

fmt.Println(multiDimArray[0][1])
// > 2          (cell of line 0 (the first one), column 1 (the 2nd one))
// We can also define array with as much dimensions as we need
// here, initialized with all zeros
var multiDimArray := [2][4][3][2]string{} 

fmt.Println(multiDimArray);
// Yeah, many dimensions stores many data
// > [[[["" ""] ["" ""]] [["" ""] ["" ""]] [["" ""] ["" ""]]]
//    [[["" ""] ["" ""]] [["" ""] ["" ""]] [["" ""] ["" ""]]]
//    [[["" ""] ["" ""]] [["" ""] ["" ""]] [["" ""] ["" ""]]]
//    [[["" ""] ["" ""]] [["" ""] ["" ""]] [["" ""] ["" ""]]]]
//   [[[["" ""] ["" ""]] [["" ""] ["" ""]] [["" ""] ["" ""]]]
//    [[["" ""] ["" ""]] [["" ""] ["" ""]] [["" ""] ["" ""]]]
//    [[["" ""] ["" ""]] [["" ""] ["" ""]] [["" ""] ["" ""]]]
//    [[["" ""] ["" ""]] [["" ""] ["" ""]] [["" ""] ["" ""]]]]
// We can set some values in the array's cells
multiDimArray[0][0][0][0] := "All zero indexes"  // Setting the first value
multiDimArray[1][3][2][1] := "All indexes to max"  // Setting the value at extreme location

fmt.Println(multiDimArray);
// If we could see in 4 dimensions, maybe we could see the result as a simple format
    
// > [[[["All zero indexes" ""] ["" ""]] [["" ""] ["" ""]] [["" ""] ["" ""]]]
//    [[["" ""] ["" ""]] [["" ""] ["" ""]] [["" ""] ["" ""]]]
//    [[["" ""] ["" ""]] [["" ""] ["" ""]] [["" ""] ["" ""]]]
//    [[["" ""] ["" ""]] [["" ""] ["" ""]] [["" ""] ["" ""]]]]
//   [[[["" ""] ["" ""]] [["" ""] ["" ""]] [["" ""] ["" ""]]]
//    [[["" ""] ["" ""]] [["" ""] ["" ""]] [["" ""] ["" ""]]]
//    [[["" ""] ["" ""]] [["" ""] ["" ""]] [["" ""] ["" ""]]]
//    [[["" ""] ["" ""]] [["" ""] ["" ""]] [["" ""] ["" "All indexes to max"]]]]

Indici di matrice

È necessario accedere ai valori delle matrici utilizzando un numero che specifica la posizione del valore desiderato nell'array. Questo numero è chiamato Indice.

Gli indici iniziano da 0 e finiscono con la lunghezza dell'array -1 .

Per accedere a un valore, devi fare qualcosa del genere: arrayName[index] , sostituendo "index" con il numero corrispondente al rank del valore dell'array.

Per esempio:

var array = [6]int {1, 2, 3, 4, 5, 6}

fmt.Println(array[-42]) // invalid array index -1 (index must be non-negative)
fmt.Println(array[-1]) // invalid array index -1 (index must be non-negative)
fmt.Println(array[0]) // > 1
fmt.Println(array[1]) // > 2
fmt.Println(array[2]) // > 3
fmt.Println(array[3]) // > 4
fmt.Println(array[4]) // > 5
fmt.Println(array[5]) // > 6
fmt.Println(array[6]) // invalid array index 6 (out of bounds for 6-element array)
fmt.Println(array[42]) // invalid array index 42 (out of bounds for 6-element array)

Per impostare o modificare un valore nella matrice, il modo è lo stesso.
Esempio:

var array = [6]int {1, 2, 3, 4, 5, 6}

fmt.Println(array) // > [1 2 3 4 5 6]

array[0] := 6
fmt.Println(array) // > [6 2 3 4 5 6]

array[1] := 5
fmt.Println(array) // > [6 5 3 4 5 6]

array[2] := 4
fmt.Println(array) // > [6 5 4 4 5 6]

array[3] := 3
fmt.Println(array) // > [6 5 4 3 5 6]

array[4] := 2
fmt.Println(array) // > [6 5 4 3 2 6]

array[5] := 1
fmt.Println(array) // > [6 5 4 3 2 1]


Modified text is an extract of the original Stack Overflow Documentation
Autorizzato sotto CC BY-SA 3.0
Non affiliato con Stack Overflow