Arrays in der Programmiersprache Golang oder Go sind anderen Programmiersprachen sehr ähnlich. Im Programm müssen wir manchmal eine Sammlung von Daten des gleichen Typs speichern, wie z. B. eine Liste von Schülernoten. Diese Art von Sammlung wird in einem Programm gespeichert, das ein Array verwendet. Ein Array ist eine Folge fester Länge, die verwendet wird, um homogene Elemente im Speicher zu speichern. Aufgrund ihrer Arrays mit fester Länge sind sie nicht so beliebt wie Slice in der Go-Sprache.
In einem Array dürfen Sie null oder mehr als null Elemente darin speichern. Die Elemente des Arrays werden mithilfe des Indexoperators [] mit ihrer nullbasierten Position indiziert, dh der Index des ersten Elements ist array[0] und der Index des letzten Elements ist array[len(array)-1] .

arrays-in-golang

Erstellen und Zugreifen auf ein Array

In der Go-Sprache werden Arrays auf zwei verschiedene Arten erstellt:

  1. Verwendung des Schlüsselworts var : In der Go-Sprache wird ein Array mit dem Schlüsselwort var eines bestimmten Typs mit Name, Größe und Elementen erstellt.

    Syntax:

    Var array_name[Länge]Typ
oder
var array_name[länge]Typ{Element1, Element2, Element3, ...ElementN}

    Wichtige Punkte:



    • In der Go-Sprache sind Arrays änderbar, sodass Sie die Syntax array[index] auf der linken Seite der Zuweisung verwenden können, um die Elemente des Arrays auf den angegebenen Index zu setzen.
      Var array_name[index] = element

    • Sie können auf die Elemente des Arrays zugreifen, indem Sie den Indexwert verwenden oder die for-Schleife verwenden.
    • In der Go-Sprache ist der Array-Typ eindimensional.
    • Die Länge des Arrays ist fest und unveränderlich.
    • Sie dürfen doppelte Elemente in einem Array speichern.

      Beispiel:




      // Go program to illustrate how to 
      // create an array using the var keyword 
      // and accessing the elements of the
      // array using their index value
      package main
        
      import "fmt"
        
      func main() {
        
      // Creating an array of string type 
      // Using var keyword
      var myarr[3]string
        
      // Elements are assigned using index
      myarr[0] = "GFG"
      myarr[1] = "GeeksforGeeks"
      myarr[2] = "Geek"
        
      // Accessing the elements of the array 
      // Using index value
      fmt.Println("Elements of Array:")
      fmt.Println("Element 1: ", myarr[0])
      fmt.Println("Element 2: ", myarr[1])
      fmt.Println("Element 3: ", myarr[2])
      }

      Ausgabe:

      Elemente des Arrays:
Element 1: GFG
Element 2: GeeksforGeeks
Element 3: Aussenseiter
  2. Kurzschrift-Deklaration verwenden: In der Go-Sprache können Arrays auch mit Kurzschrift-Deklaration deklariert werden. Sie ist flexibler als die obige Deklaration.

    Syntax:

    array_name:= [länge]Type{item1, item2, item3,...itemN}

    Beispiel:




    // Go program to illustrate how to create
    // an array using shorthand declaration 
    // and accessing the elements of the 
    // array using for loop
    package main
      
    import "fmt"
      
    func main() {
      
    // Shorthand declaration of array
    arr:= [4]string{"geek", "gfg", "Geeks1231", "GeeksforGeeks"}
      
    // Accessing the elements of 
    // the array Using for loop
    fmt.Println("Elements of the array:")
      
    for i:= 0; i < 3; i++{
    fmt.Println(arr[i])
    }
      
    }

    Ausgabe:

    Elemente des Arrays:
Aussenseiter
gfg
Geeks1231

Mehrdimensionales Array

Wie wir bereits wissen, sind Arrays 1-D, aber Sie dürfen ein mehrdimensionales Array erstellen. Mehrdimensionale Arrays sind die Arrays von Arrays des gleichen Typs . In der Go-Sprache können Sie mit der folgenden Syntax ein mehrdimensionales Array erstellen: 

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

Sie können ein mehrdimensionales Array mit dem Schlüsselwort Var oder mit einer Kurzdeklaration erstellen, wie im folgenden Beispiel gezeigt.

Hinweis: Wenn eine Zelle in einem mehrdimensionalen Array vom Benutzer nicht mit einem Wert initialisiert wird, wird sie vom Compiler automatisch mit Null initialisiert. Es gibt kein nicht initialisiertes Konzept im Golang.

Beispiel:

// Go program to illustrate the
// concept of multi-dimension array
package main
  
import "fmt"
  
func main() {
  
// Creating and initializing 
// 2-dimensional array 
// Using shorthand declaration
// Here the (,) Comma is necessary
arr:= [3][3]string{{"C#", "C", "Python"}, 
                   {"Java", "Scala", "Perl"},
                    {"C++", "Go", "HTML"},}
  
// Accessing the values of the 
// array Using for loop
fmt.Println("Elements of Array 1")
for x:= 0; x < 3; x++{
for y:= 0; y < 3; y++{
fmt.Println(arr[x][y])
}
}
  
// Creating a 2-dimensional
// array using var keyword
// and initializing a multi
// -dimensional array using index
var arr1 [2][2] int
arr1[0][0] = 100
arr1[0][1] = 200
arr1[1][0] = 300
arr1[1][1] = 400
  
// Accessing the values of the array
fmt.Println("Elements of array 2")
for p:= 0; p<2; p++{
for q:= 0; q<2; q++{
fmt.Println(arr1[p][q])
  
}
}
}

Ausgabe:

Elements of Array 1
C#
C
Python
Java
Scala
Perl
C++
Go
HTML
Elements of array 2
100
200
300
400

Wichtige Beobachtungen über Array

  1. Wenn in einem Array ein Array nicht explizit initialisiert wird, ist der Standardwert dieses Arrays 0 .

    Beispiel:




    // Go program to illustrate an array
    package main
      
    import "fmt"
      
    func main() {
      
    // Creating an array of int type
    // which stores, two elements
    // Here, we do not initialize the 
    // array so the value of the array
    // is zero
    var myarr[2]int 
    fmt.Println("Elements of the Array :", myarr)
      
    }

    Ausgabe:

    Elemente des Arrays: [0 0]
  2. In einem Array können Sie die Länge des Arrays mit der Methode len() finden, wie unten gezeigt:

    Beispiel:




    // Go program to illustrate how to find
    // the length of the array
    package main
      
    import "fmt"
      
    func main() {
      
    // Creating array
    // Using shorthand declaration    
    arr1:= [3]int{9,7,6}
    arr2:= [...]int{9,7,6,4,5,3,2,4}
    arr3:= [3]int{9,3,5}
      
    // Finding the length of the 
    // array using len method
    fmt.Println("Length of the array 1 is:", len(arr1))
    fmt.Println("Length of the array 2 is:", len(arr2))
    fmt.Println("Length of the array 3 is:", len(arr3))
    }

    Ausgabe:

    Länge des Arrays 1 ist: 3
Länge des Arrays 2 ist: 8
Länge des Arrays 3 ist: 3
  3. Wenn in einem Array Auslassungszeichen ''…'' an der Stelle der Länge sichtbar werden, dann wird die Länge des Arrays durch die initialisierten Elemente bestimmt. Wie im folgenden Beispiel gezeigt:

    Beispiel:




    // Go program to illustrate the
    // concept of ellipsis in an array
    package main
      
    import "fmt"
      
    func main() {
          
    // Creating an array whose size is determined 
    // by the number of elements present in it
    // Using ellipsis
    myarray:= [...]string{"GFG", "gfg", "geeks",
                        "GeeksforGeeks", "GEEK"}
      
    fmt.Println("Elements of the array: ", myarray)
      
    // Length of the array
    // is determine by 
    // Using len() method
    fmt.Println("Length of the array is:", len(myarray))
    }

    Ausgabe:

    Elemente des Arrays: [GFG gfg geeks GeeksforGeeks GEEK]
Länge des Arrays ist: 5
  4. In einem Array dürfen Sie über den Bereich der Elemente des Arrays iterieren . Wie im folgenden Beispiel gezeigt:

    Beispiel:




    // Go program to illustrate 
    // how to iterate the array
    package main
      
    import "fmt"
      
    func main() {
          
    // Creating an array whose size
    // is represented by the ellipsis
    myarray:= [...]int{29, 79, 49, 39,
                       20, 49, 48, 49}
      
    // Iterate array using for loop
    for x:=0; x < len(myarray); x++{
    fmt.Printf("%d\n", myarray[x])
    }
    }

    Ausgabe:

    29
79
49
39
20
49
48
49
  5. In der Go-Sprache ist ein Array vom Werttyp, nicht vom Referenztyp . Wenn also das Array einer neuen Variablen zugewiesen wird, wirken sich die an der neuen Variablen vorgenommenen Änderungen nicht auf das ursprüngliche Array aus. Wie im folgenden Beispiel gezeigt:

    Beispiel:




    // Go program to illustrate value type array
    package main
      
    import "fmt"
      
    func main() {
          
    // Creating an array whose size 
    // is represented by the ellipsis
    my_array:= [...]int{100, 200, 300, 400, 500}
    fmt.Println("Original array(Before):", my_array)
      
    // Creating a new variable 
    // and initialize with my_array
    new_array := my_array
      
    fmt.Println("New array(before):", new_array)
      
    // Change the value at index 0 to 500
    new_array[0] = 500
      
    fmt.Println("New array(After):", new_array)
      
    fmt.Println("Original array(After):", my_array)
    }

    Ausgabe:

    Ursprüngliches Array (vorher): [100 200 300 400 500]
Neues Array (vorher): [100 200 300 400 500]
Neues Array (nachher): [500 200 300 400 500]
Ursprüngliches Array (Nachher): [100 200 300 400 500]
  6. Wenn in einem Array der Elementtyp des Arrays vergleichbar ist, dann ist auch der Arraytyp vergleichbar. So können wir zwei Arrays direkt mit dem Operator == vergleichen . Wie im folgenden Beispiel gezeigt:

    Beispiel:




    // Go program to illustrate 
    // how to compare two arrays
    package main
      
    import "fmt"
      
    func main() {
      
    // Arrays    
    arr1:= [3]int{9,7,6}
    arr2:= [...]int{9,7,6}
    arr3:= [3]int{9,5,3}
      
    // Comparing arrays using == operator
    fmt.Println(arr1==arr2)
    fmt.Println(arr2==arr3)
    fmt.Println(arr1==arr3)
      
    // This will give and error because the 
    // type of arr1 and arr4 is a mismatch 
    /*
    arr4:= [4]int{9,7,6}
    fmt.Println(arr1==arr4)
    */
    }

    Ausgabe:

    wahr
falsch
falsch