In Go sind Strukturen ein fundamentales Werkzeug zur Erstellung benutzerdefinierter Datentypen. Sie sind ein wesentlicher Bestandteil der Sprache und ermöglichen es, Daten auf strukturierte Weise zu organisieren.
In diesem Beitrag werden wir die Grundlagen von Strukturen in Go erkunden und anhand von Beispielen veranschaulichen, wie sie in Ihren Programmen verwendet werden können.
Legen wir los!
Einführung in Strukturen
Eine Struktur ist eine Zusammenfassung von Datenfeldern unterschiedlicher Datentypen. Sie dienen dazu, Daten logisch zu gruppieren und eigene, komplexe Datensätze zu erstellen. Strukturen können sowohl primitive als auch benutzerdefinierte Datentypen enthalten, wobei die Struktur selbst wiederum ein benutzerdefinierter Typ ist.
In Golang sind Strukturen veränderlich, d.h., ihre Werte können im Laufe der Programmausführung angepasst werden.
Der Einsatz von Strukturen steigert die Codequalität, indem er uns die Möglichkeit gibt, komplexe Datenstrukturen zu modellieren und diese einfach zwischen verschiedenen Modulen zu übergeben. Stellen Sie sich vor, Sie müssten einer Funktion zehn Parameter übergeben – dies würde schnell unübersichtlich. Strukturen lösen dieses Problem, indem sie ermöglichen, statt vieler Parameter eine einzige Struktur zu übergeben.
Eine Struktur wird mit den Schlüsselwörtern type und struct deklariert und durch geschweifte Klammern begrenzt, ähnlich wie Klassen in Java. Innerhalb der Klammern werden die einzelnen Felder mit ihrem jeweiligen Datentyp und einem Bezeichner (Namen) definiert. Die genaue Implementierung wird im nächsten Abschnitt detaillierter betrachtet.
Wenn Sie aus der objektorientierten Programmierung (OOP) kommen, können Sie sich Strukturen als Klassen ohne Vererbung vorstellen.
Deklaration von Strukturen
Nachdem wir nun die Bedeutung und Anwendung von Strukturen verstanden haben, ist es an der Zeit, zu lernen, wie man sie deklariert. Das Grundgerüst einer Struktur sieht wie folgt aus:
type NameDerStruktur struct {
Feld1 DatentypFeld1
Feld2 DatentypFeld2
}
Hier sind type und struct Schlüsselwörter, und die Struktur enthält mehrere Felder, die jeweils ihren eigenen Datentyp haben.
Betrachten wir ein konkretes Beispiel:
package main
import (
"fmt"
)
type Benutzer struct {
name string
alter int
kontostand float32
}
func main() {
var benutzer Benutzer
fmt.Println(benutzer)
}
In diesem Beispiel definieren wir eine Struktur namens Benutzer, die aus den Feldern name (string), alter (int) und kontostand (float32) besteht. In der main()-Funktion deklarieren wir eine Variable vom Typ Benutzer namens benutzer und geben diese aus. Da wir die Struktur noch nicht initialisiert haben, wird ihr Nullwert ausgegeben. Der Nullwert entspricht den jeweiligen Nullwerten der Felder.
{ 0 0}
Initialisierung von Strukturen
Im vorangegangenen Abschnitt haben wir gelernt, wie man Strukturen deklariert. Nun wollen wir ihnen Werte zuweisen. Das folgende Codebeispiel zeigt, wie dies funktioniert:
package main
import (
"fmt"
)
type Benutzer struct {
name string
alter int
kontostand float32
}
func main() {
// Mit Feldnamen
benutzer1 := Benutzer{
name: "Mohit",
alter: 24,
kontostand: 100.0,
}
// Ohne Feldnamen
benutzer2 := Benutzer{"Nidhi", 21, 1000.0}
fmt.Println(benutzer1)
fmt.Println(benutzer2)
}
Der Code demonstriert die Initialisierung von zwei Strukturen – einmal mit und einmal ohne explizite Feldnamen. Die Ausgabe lautet:
{Mohit 24 100}
{Nidhi 21 1000}
Wenn ein Feld nicht explizit initialisiert wird, nimmt es den Standard-Nullwert seines Datentyps an.
benutzer1 := Benutzer{
name: "Mohit",
alter: 24,
}
// Ausgabe - { Mohit 24 0.0 }
Es gibt eine weitere Möglichkeit, Strukturen mit dem Schlüsselwort new zu erstellen. Wir werden dies im nächsten Abschnitt genauer betrachten.
Zugriff auf Felder einer Struktur
Nun da wir wissen, wie man Strukturen erstellt und initialisiert, wollen wir sehen, wie man auf die Felder einer Struktur zugreift. In Golang verwenden wir hierfür den Punktoperator. Wir setzen das vorherige Beispiel fort, indem wir auf die Felder name und alter zugreifen und diese ausgeben.
package main
import (
"fmt"
)
type Benutzer struct {
name string
alter int
kontostand float32
}
func main() {
// Mit Feldnamen
benutzer := Benutzer{
name: "Mohit",
alter: 24,
kontostand: 100.0,
}
fmt.Println(benutzer.name)
fmt.Println(benutzer.alter)
fmt.Println(benutzer.kontostand)
}
Hier verwenden wir struktur_name.feld_name, um auf die Felder zuzugreifen. Die Ausgabe des obigen Codes lautet:
Mohit 24 100
Wie bereits erwähnt, können wir Strukturen auch mit dem new-Schlüsselwort erstellen. Hier ist ein Beispiel dafür:
benutzer := new(Benutzer)
benutzer.name = "Mohit"
benutzer.alter = 24
benutzer.kontostand = 100.0
fmt.Println(benutzer)
// Ausgabe - &{Mohit 24 100}
Das new-Schlüsselwort gibt einen Zeiger auf die neu erstellte Struktur zurück. In Golang ist es nicht notwendig, den Zeiger explizit zu dereferenzieren. fmt.Println(*benutzer) würde zum gleichen Ergebnis führen.
Verschachtelte Strukturen
Strukturen in Golang können auch andere benutzerdefinierte Typen enthalten, einschließlich anderer verschachtelter Strukturen.
package main
import (
"fmt"
)
type Benutzer struct {
name string
alter int
kontostand float32
rollendetails Rollendetails
}
type Rollendetails struct {
position string
team string
}
func main() {
rollendetailsFürMohit := Rollendetails{
position: "Software Engineer",
team: "Transport",
}
benutzer := Benutzer{
name: "Mohit",
alter: 24,
kontostand: 100.0,
rollendetails: rollendetailsFürMohit,
}
fmt.Println(benutzer)
}
Im obigen Code ist die Rollendetails-Struktur in der Benutzer-Struktur eingebettet. Die Ausgabe lautet:
{Mohit 24 100 {Software Engineer Transport}}
Auf die Felder der verschachtelten Struktur kann man ebenfalls mit dem Punktoperator zugreifen:
benutzer.rollendetails.position
Strukturgleichheit
Zwei Strukturen sind dann gleich, wenn jedes ihrer Felder (sowohl primitive als auch benutzerdefinierte Typen) gleich sind. Allerdings sind nicht alle Datentypen direkt vergleichbar (z.B. Maps). Betrachten wir ein Beispiel zur Demonstration der Gleichheit von Strukturen:
package main
import (
"fmt"
)
type Benutzer struct {
name string
alter int
kontostand float32
}
func main() {
benutzer1 := Benutzer{
name: "Mohit",
alter: 24,
kontostand: 100.0,
}
benutzer2 := Benutzer{
name: "Mohit",
alter: 24,
kontostand: 100.0,
}
benutzer3 := Benutzer{
name: "Nidhi",
alter: 21,
kontostand: 1000.0,
}
if benutzer1 == benutzer2 {
fmt.Println("benutzer1 und benutzer2 sind gleich")
} else {
fmt.Println("benutzer1 und benutzer2 sind nicht gleich")
}
if benutzer1 == benutzer3 {
fmt.Println("benutzer1 und benutzer3 sind gleich")
} else {
fmt.Println("benutzer1 und benutzer3 sind nicht gleich")
}
}
Leere und Nullwertstrukturen sind ebenfalls gleich. Die Reihenfolge der Felder ist irrelevant, es müssen lediglich die Werte aller Felder übereinstimmen. Die Ausgabe des obigen Codes lautet:
benutzer1 und benutzer2 sind gleich benutzer1 und benutzer3 sind nicht gleich
Fazit
Ausgezeichnet!
Sie können nun Strukturen in Golang verwenden. Wir haben die Grundlagen der Deklaration, Initialisierung und des Zugriffs auf Felder behandelt. Wir haben uns auch die Gleichheit von Strukturen und die Verwendung verschachtelter Strukturen angeschaut. Hier sind einige Ressourcen, um mehr über Strukturen zu lernen:
Es gibt noch viel mehr über Strukturen zu lernen, aber dies ist ein guter Ausgangspunkt. Ich hoffe, Sie haben etwas Neues gelernt!
Entdecken Sie weiter. Lernen Sie weiter!