Strukturer i Golang är en av de mest använda och ett sätt att skapa användardefinierade typer.
I detta kommer jag att täcka alla grunderna om strukturer och hur du använder dem i dina go-program med ett par exempel.
Låt oss börja!
Introduktion
A struktur är en samling av flera datafält med deras definierade datatyper grupperade tillsammans. De är användbara för att gruppera data tillsammans för att bilda anpassade poster. En struct består av både inbyggda och användardefinierade typer (struct i sig är en användardefinierad typ).
Strukturer i Golang är föränderliga, dvs de kan modifieras genom hela programmet.
Strukturer hjälper till att förbättra den övergripande kodkvaliteten genom att tillåta oss att skapa och skicka komplexa datastrukturer över flera moduler. Föreställ dig att skicka 10 parametrar till en funktion, du kommer snart att fly från kod. Det är precis därför structs är användbara, nu istället för 10 parametrar skickar du helt enkelt en enda struct till den funktionen.
En struct deklareras med två nyckelord – typ och struktur. Det är insvept med krulliga parenteser (precis som klasser i java) – som innehåller en uppsättning fält som har en definierad typ och en identifierare (namn). Vi diskuterar implementeringsdetaljerna i nästa avsnitt.
Om du kommer från en bakgrund med objektorienterad programmering (OOP) kan du tänka på struct som en klass men utan arv.
Deklarerar strukturer
Nu när du förstår vad en struktur är och varför den används, är det dags att lära dig hur man deklarerar strukturer. Det grundläggande skelettet i en struktur ser ut som –
type name_of_struct struct {
field1 data_type_field1
field2 data_type_field2
}
Här är typ och struct nyckelord, medan struct innehåller flera fält med deras definierade datatyp.
Låt oss se ett exempel –
package main
import (
"fmt"
)
type User struct {
name string
age int
bankBalance float32
}
func main() {
var user User
fmt.Println(user)
}
Här definierar vi en användarstruktur som består av sträng-, int- och float32-fält. I main() deklarerar vi vår struct som användare och skriver ut den! Utdata vi får är noll/tomt värde av struct eftersom vi inte har initierat det ännu! De noll värde är i princip noll värden för varje fält.
{ 0 0}
Initialisering av strukturer
I föregående avsnitt lärde vi oss hur man deklarerar strukturer. Nu skulle vi vilja initiera eller tilldela dem värden. Kontrollera koden nedan om hur vi gör det –
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)
}
Själva koden förklarar hur vi initierar två strukturer med och utan fältnamn. Här blir utgången –
{Mohit 24 100}
{Nidhi 21 1000}
I ovanstående fall, om ett av fälten inte initieras, kommer det fältet att ha sitt nollvärde som standard.
user1 := User{
name: "Mohit",
age: 24,
}
// Output - { Mohit 24 0.0 }
Det finns ytterligare ett sätt att skapa strukturer med nya nyckelord. Vi kommer att titta på hur man använder det i nästa avsnitt.
Åtkomst till fält i en struktur
Nu vet vi hur man skapar och initierar strukturer, låt oss se hur man kommer åt fälten i en struktur. För detta förser Golang oss med punktoperatorn. Fortsätt med föregående exempel, låt oss komma åt namn- och åldersfält och skriva ut dem.
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)
}
Här använder vi struct_name.field_name för att komma åt fält i en struct. Utdata från ovanstående kod kommer att vara –
Mohit 24 100
Som nämnts tidigare kan vi skapa strukturer med nya nyckelord. Låt oss se hur –
user := new(User)
user.name = "Mohit"
user.age = 24
user.bankBalance = 100.0
fmt.Println(user)
// Output - &{Mohit 24 100}
Det nya nyckelordet returnerar pekaren till den initierade strukturen. I Golang behöver du inte uttryckligen avreferera pekaren men fmt.Println(*user) skulle resultera i samma utdata.
Kapslade strukturer
Strukturer i golang kan också innehålla andra användardefinierade typer. Så en struktur kan innehålla andra kapslade strukturer.
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)
}
I koden ovan har vi RoleDetails struct som en del av User struct. Utgången blir –
{Mohit 24 100 {Software Engineer Transport}}
Om du vill komma åt roleDetails kan du göra det med samma punktoperator –
user.roleDetails.position
Strukturera jämställdhet
Två strukturer är lika om vart och ett av fälten de har är lika (både inbyggda och användardefinierade) men inte alla datatyper är jämförbara. (karta är inte direkt jämförbar). Låt oss se ett exempel för att visa jämlikhet.
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")
}
}
Tomma och nollvärdesstrukturer är lika. Fältordningen spelar ingen roll, i grund och botten bör varje fält matcha för jämlikhet. Utdata för koden ovan blir –
user1 and user2 are equal user1 and user3 are not equal
Slutsats
Grymt bra!
Nu är du redo att använda strukturer i golang. Vi täckte alla grunderna som deklaration, initiering och åtkomst till struct-fält. Vi tittade också på hur man jämför två strukturer och implementerade till och med en kapslad struktur. Här är några resurser för att lära dig mer om strukturer –
Det finns mycket mer att lära sig om strukturer, men det är en bra början för nu. Jag hoppas att du lärde dig något nytt!
Fortsätt utforska. Fortsätt lära!
