Go
Arrays

Einführung

Syntax

• var variableName [5] ArrayType // Deklarieren eines Arrays der Größe 5.
• var variableName [2] [3] ArrayType = {{Value1, Value2, Value3}, {Value4, Value5, Value6}} // Deklaration eines mehrdimensionalen Arrays
• variableName: = [...] ArrayType {Value1, Value2, Value3} // Deklarieren Sie ein Array der Größe 3 (Der Compiler zählt die Array-Elemente, um die Größe zu bestimmen)
• arrayName [2] // Den Wert anhand des Index abrufen.
• arrayName [5] = 0 // Wert am Index setzen.
• arrayName [0] // Erster Wert des Arrays
• arrayName [len (arrayName) -1] // Letzter Wert des Arrays

Arrays erstellen

Ein Array in go ist eine geordnete Sammlung gleichartiger Elemente.
Die grundlegende Notation zur Darstellung von Arrays ist die Verwendung von [] mit dem Variablennamen.

Das Erstellen eines neuen Arrays sieht wie var array = [size]Type , wobei size durch eine Zahl ersetzt wird (zum Beispiel 42 um anzugeben, dass es eine Liste von 42 Elementen ist) und Type durch den Typ der Elemente ersetzt, die das Array enthalten kann (z Beispiel int oder string )

Direkt darunter sehen Sie ein Codebeispiel, das zeigt, wie ein Array in Go anders erstellt wird.

// 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

spiele es auf dem Spielplatz

Mehrdimensionales Array

Mehrdimensionale Arrays sind im Grunde Arrays, die andere Arrays als Elemente enthalten.
Es wird als [sizeDim1][sizeDim2]..[sizeLastDim]type , wobei sizeDim durch Zahlen ersetzt wird, die der Länge der Dimension entsprechen, und type durch den Datentyp im mehrdimensionalen Array.

Zum Beispiel repräsentiert [2][3]int ein Array, das aus 2 Unterarrays von 3 int typisierten Elementen besteht .
Es kann grundsätzlich die Darstellung einer Matrix aus 2 Zeilen und 3 Spalten sein .

Wir können also ein Array mit großen Dimensionswerten wie var values := [2017][12][31][24][60]int wenn Sie beispielsweise seit Jahr 0 eine Zahl für jede Minute speichern müssen.

Um auf diese Art von Array zuzugreifen, suchen Sie für das letzte Beispiel bei der Suche nach dem Wert von 2016-01-31 um 19:42 auf die values[2016][0][30][19][42] (weil Array indiziert beginnt um 0 und nicht um 1 wie Tage und Monate)

Einige Beispiele folgen:

// 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"]]]]

Array-Indizes

Auf Array-Werte sollte mit einer Nummer zugegriffen werden, die die Position des gewünschten Werts im Array angibt. Diese Nummer wird als Index bezeichnet.

Der Index beginnt bei 0 und endet bei der Arraylänge -1 .

Um auf einen Wert zuzugreifen, müssen Sie arrayName[index] tun: arrayName[index] . Ersetzen Sie "index" durch die Zahl, die dem Rang des Werts in Ihrem Array entspricht.

Zum Beispiel:

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)

Um einen Wert im Array festzulegen oder zu ändern, ist der Weg derselbe.
Beispiel:

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]