Strukturen in Golang sind eine der am häufigsten verwendeten und eine Möglichkeit, benutzerdefinierte Typen zu erstellen.
In diesem Abschnitt werde ich alle Grundlagen zu Strukturen und deren Verwendung in Ihren Go-Programmen anhand einiger Beispiele behandeln.
Lass uns anfangen!
Inhaltsverzeichnis
Einführung
EIN Struktur ist eine Sammlung mehrerer Datenfelder, deren definierte Datentypen gruppiert sind. Sie sind nützlich, um Daten zu gruppieren, um benutzerdefinierte Datensätze zu bilden. Eine Struktur besteht sowohl aus integrierten als auch aus benutzerdefinierten Typen (Struktur selbst ist ein benutzerdefinierter Typ).
Strukturen in Golang sind veränderbar, dh sie können im gesamten Programm geändert werden.
Strukturen helfen bei der Verbesserung der allgemeinen Codequalität, indem sie es uns ermöglichen, komplexe Datenstrukturen über mehrere Module hinweg zu erstellen und zu übergeben. Stellen Sie sich vor, Sie übergeben 10 Parameter an eine Funktion, Sie werden bald vor dem Code davonlaufen. Genau aus diesem Grund sind Strukturen nützlich. Anstelle von 10 Parametern übergeben Sie jetzt einfach eine einzelne Struktur an diese Funktion.
Eine Struktur wird mit zwei Schlüsselwörtern deklariert – Typ und Struktur. Es ist mit geschweiften Klammern umschlossen (genau wie Klassen in Java) – die eine Reihe von Feldern enthalten, die einen definierten Typ und einen Bezeichner (Namen) haben. Wir besprechen die Implementierungsdetails im nächsten Abschnitt.
Wenn Sie aus dem Bereich der objektorientierten Programmierung (OOP) kommen, können Sie sich Struct als Klasse vorstellen, jedoch ohne Vererbung.
Strukturen deklarieren
Nachdem Sie nun verstanden haben, was eine Struktur ist und warum sie verwendet wird, ist es an der Zeit zu lernen, wie Strukturen deklariert werden. Das Grundgerüst einer Struktur sieht aus wie –
type name_of_struct struct {
field1 data_type_field1
field2 data_type_field2
}
Typ und Struktur sind hier Schlüsselwörter, während die Struktur mehrere Felder mit ihrem definierten Datentyp enthält.
Sehen wir uns ein Beispiel an –
package main
import (
"fmt"
)
type User struct {
name string
age int
bankBalance float32
}
func main() {
var user User
fmt.Println(user)
}
Hier definieren wir eine Benutzerstruktur, die aus String-, Int- und Float32-Feldern besteht. In main() deklarieren wir unser Struct als user und drucken es aus! Die Ausgabe, die wir erhalten, ist Null/leerer Wert von struct, da wir sie noch nicht initialisiert haben! Das Null Wert ist im Grunde Nullwerte jedes Feldes.
{ 0 0}
Strukturen initialisieren
Im vorherigen Abschnitt haben wir gelernt, wie man Strukturen deklariert. Jetzt möchten wir ihnen Werte initialisieren oder zuweisen. Sehen Sie sich den Code unten an, um zu erfahren, wie wir das machen –
package main
import (
"fmt"
)
type User struct {
name string
age int
bankBalance float32
}
func main() {
// With field names
user1 := User{
name: "Mohit",
age: 24,
bankBalance: 100.0,
}
// Without field names
user2 := User{"Nidhi", 21, 1000.0}
fmt.Println(user1)
fmt.Println(user2)
}
Der Code selbst erklärt, wie wir zwei Strukturen mit und ohne Feldnamen initialisieren. Hier wird die Ausgabe sein –
{Mohit 24 100}
{Nidhi 21 1000}
Wenn im obigen Fall eines der Felder nicht initialisiert ist, dann wird dieses Feld standardmäßig auf seinen Nullwert gesetzt.
user1 := User{
name: "Mohit",
age: 24,
}
// Output - { Mohit 24 0.0 }
Es gibt eine weitere Möglichkeit, Strukturen mit dem neuen Schlüsselwort zu erstellen. Wir werden uns im nächsten Abschnitt ansehen, wie man es verwendet.
Zugriff auf Felder einer Struktur
Jetzt wissen wir, wie man Strukturen erstellt und initialisiert, sehen wir uns an, wie man auf die Felder einer Struktur zugreift. Dafür stellt uns Golang den Punktoperator zur Verfügung. Um mit dem vorherigen Beispiel fortzufahren, greifen wir auf die Felder Name und Alter zu und drucken sie aus.
package main
import (
"fmt"
)
type User struct {
name string
age int
bankBalance float32
}
func main() {
// With field names
user := User{
name: "Mohit",
age: 24,
bankBalance: 100.0,
}
fmt.Println(user.name)
fmt.Println(user.age)
fmt.Println(user.bankBalance)
}
Hier verwenden wir struct_name.field_name, um auf Felder in einer Struktur zuzugreifen. Die Ausgabe des obigen Codes wird sein –
Mohit 24 100
Wie bereits erwähnt, können wir Strukturen mit dem neuen Schlüsselwort erstellen. Mal sehen wie –
user := new(User)
user.name = "Mohit"
user.age = 24
user.bankBalance = 100.0
fmt.Println(user)
// Output - &{Mohit 24 100}
Das Schlüsselwort new gibt den Zeiger auf die initialisierte Struktur zurück. In Golang müssen Sie den Zeiger nicht explizit dereferenzieren, aber fmt.Println(*user) würde zu derselben Ausgabe führen.
Verschachtelte Strukturen
Strukturen in golang können auch andere benutzerdefinierte Typen enthalten. Eine Struktur kann also andere verschachtelte Strukturen enthalten.
package main
import (
"fmt"
)
type User struct {
name string
age int
bankBalance float32
roleDetails RoleDetails
}
type RoleDetails struct {
position string
team string
}
func main() {
roleDetailForMohit := RoleDetails{
position: "Software Engineer",
team: "Transport",
}
user := User{
name: "Mohit",
age: 24,
bankBalance: 100.0,
roleDetails: roleDetailForMohit,
}
fmt.Println(user)
}
Im obigen Code haben wir die RoleDetails-Struktur als Teil der Benutzerstruktur. Die Ausgabe wird sein –
{Mohit 24 100 {Software Engineer Transport}}
Wenn Sie auf roleDetails zugreifen möchten, können Sie dies mit demselben Punktoperator tun –
user.roleDetails.position
Strukturgleichheit
Zwei Strukturen sind gleich, wenn jedes ihrer Felder gleich ist (sowohl eingebaute als auch benutzerdefinierte), aber nicht alle Datentypen vergleichbar sind. (Karte ist nicht direkt vergleichbar). Sehen wir uns ein Beispiel an, um die Gleichheit zu demonstrieren.
package main
import (
"fmt"
)
type User struct {
name string
age int
bankBalance float32
}
func main() {
user1 := User{
name: "Mohit",
age: 24,
bankBalance: 100.0,
}
user2 := User{
name: "Mohit",
age: 24,
bankBalance: 100.0,
}
user3 := User{
name: "Nidhi",
age: 21,
bankBalance: 1000.0,
}
if user1 == user2 {
fmt.Println("user1 and user2 are equal")
} else {
fmt.Println("user1 and user2 are not equal")
}
if user1 == user3 {
fmt.Println("user1 and user3 are equal")
} else {
fmt.Println("user1 and user3 are not equal")
}
}
Leere und nullwertige Strukturen sind gleich. Die Reihenfolge der Felder spielt keine Rolle, im Grunde sollte jedes Feld übereinstimmen, um Gleichheit zu gewährleisten. Die Ausgabe für den obigen Code ist –
user1 and user2 are equal user1 and user3 are not equal
Fazit
Genial!
Jetzt können Sie Strukturen in Golang verwenden. Wir haben alle Grundlagen wie Deklaration, Initialisierung und Zugriff auf Struct-Felder behandelt. Wir haben uns auch angesehen, wie man zwei Strukturen vergleicht und sogar eine verschachtelte Struktur implementiert. Hier sind einige Ressourcen, um mehr über Strukturen zu erfahren –
Es gibt noch viel mehr über Strukturen zu lernen, aber für den Moment ist es ein guter Anfang. Ich hoffe, Sie haben etwas Neues gelernt!
Erkunden Sie weiter. Lerne weiter!