Suche…
Einführung
Arrays sind bestimmte Datentypen, die eine geordnete Sammlung von Elementen eines anderen Typs darstellen.
In Go können Arrays einfach (manchmal "Listen" genannt) oder mehrdimensional sein (wie zum Beispiel 2-Dimentions-Arrays eine geordnete Sammlung von Arrays darstellen, die Elemente enthält)
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
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]