Zoeken…


Invoering

Arrays zijn een specifiek gegevenstype en vertegenwoordigen een geordende verzameling elementen van een ander type.

In Go kunnen arrays eenvoudig zijn (soms "lijsten" genoemd) of multidimensionaal (zoals bijvoorbeeld een tweedimensionale arrays een geordende verzameling arrays vertegenwoordigt, die elementen bevat)

Syntaxis

  • var variableName [5] ArrayType // Declareren van een array met grootte 5.
  • var variableName [2] [3] ArrayType = {{Value1, Value2, Value3}, {Value4, Value5, Value6}} // Een multidimensionale array declareren
  • variableName: = [...] ArrayType {Value1, Value2, Value3} // Declareer een array met grootte 3 (de compiler telt de arrayelementen om de grootte te definiëren)
  • arrayName [2] // De waarde ophalen per index.
  • arrayName [5] = 0 // De waarde instellen op index.
  • arrayName [0] // Eerste waarde van de array
  • arrayName [len (arrayName) -1] // Laatste waarde van de array

Arrays maken

Een array in go is een geordende verzameling elementen van hetzelfde type.
De basisnotatie om arrays weer te geven is om [] te gebruiken met de variabelenaam.

Het maken van een nieuwe array ziet eruit als var array = [size]Type , waarbij size wordt vervangen door een nummer (bijvoorbeeld 42 om aan te geven dat het een lijst met 42 elementen zal zijn) en Type vervangen door het type elementen dat de array kan bevatten (voor voorbeeld int of string )

Net daaronder is een codevoorbeeld dat de verschillende manier toont om een array in Go te maken.

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

speel het op speelplaats

Multidimensionale array

Multidimensionale arrays zijn in feite arrays die andere arrays als elementen bevatten.
Het wordt weergegeven als het type [sizeDim1][sizeDim2]..[sizeLastDim]type , waarbij sizeDim wordt vervangen door getallen die overeenkomen met de lengte van de dimensie, en type door het type gegevens in de multidimensionale array.

[2][3]int vertegenwoordigt bijvoorbeeld een array die bestaat uit 2 subarrays van 3 int getypte elementen .
Het kan in feite de weergave zijn van een matrix van 2 lijnen en 3 kolommen .

Dus we kunnen enorme dimensies maken van een reeks zoals var values := [2017][12][31][24][60]int bijvoorbeeld als u een nummer voor elke minuten wilt opslaan sinds Jaar 0.

Om toegang te krijgen tot dit soort array, voor het laatste voorbeeld, op zoek naar de waarde van 2016-01-31 om 19:42, hebt u toegang tot values[2016][0][30][19][42] (omdat arrayindexen begint bij 0 en niet bij 1 zoals dagen en maanden)

Enkele voorbeelden hiervan:

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

Matrixindexen

Arrays-waarden moeten worden benaderd met behulp van een nummer dat de locatie van de gewenste waarde in de array opgeeft. Dit nummer wordt Index genoemd.

Indexen beginnen bij 0 en eindigen bij matrixlengte -1 .

Om toegang te krijgen tot een waarde, moet u iets als dit doen: arrayName[index] , waarbij "index" wordt vervangen door het nummer dat overeenkomt met de rangorde van de waarde in uw array.

Bijvoorbeeld:

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)

Om een waarde in de array in te stellen of te wijzigen, is de manier hetzelfde.
Voorbeeld:

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
Licentie onder CC BY-SA 3.0
Niet aangesloten bij Stack Overflow