Strukturer i Golang er en av de mest brukte og en måte å lage brukerdefinerte typer på.
I dette vil jeg dekke alt det grunnleggende om strukturer og hvordan du bruker dem i go-programmene dine med et par eksempler.
La oss komme i gang!
Innholdsfortegnelse
Introduksjon
EN struktur er en samling av flere datafelt med deres definerte datatyper gruppert sammen. De er nyttige for å gruppere data sammen for å danne tilpassede poster. En struct består av både innebygde og brukerdefinerte typer (struct i seg selv er en brukerdefinert type).
Strukturer i Golang er mutable, dvs. de kan endres gjennom hele programmet.
Strukturer hjelper til med å forbedre den generelle kodekvaliteten ved å tillate oss å lage og sende komplekse datastrukturer på tvers av flere moduler. Tenk deg å overføre 10 parametere til en funksjon, du vil snart løpe fra kode. Det er nettopp derfor strukturer er nyttige, nå i stedet for 10 parametere sender du bare en enkelt struktur til den funksjonen.
En struktur er deklarert ved å bruke to nøkkelord – type og struktur. Den er pakket med krøllede parenteser (akkurat som klasser i java) – som inneholder et sett med felt som har en definert type og en identifikator (navn). Vi diskuterer implementeringsdetaljene i neste avsnitt.
Hvis du kommer fra en objektorientert programmeringsbakgrunn (OOP), kan du tenke på struct som en klasse, men uten arv.
Erklærer strukturer
Nå, som du forstår hva en struktur er og hvorfor den brukes, er det på tide å lære å erklære strukturer. Det grunnleggende skjelettet til en struktur ser ut som –
type name_of_struct struct {
field1 data_type_field1
field2 data_type_field2
}
Her er type og struct nøkkelord, mens struct inneholder flere felt med deres definerte datatype.
La oss se et eksempel –
package main
import (
"fmt"
)
type User struct {
name string
age int
bankBalance float32
}
func main() {
var user User
fmt.Println(user)
}
Her definerer vi en brukerstruktur som består av streng-, int- og float32-felt. I main() erklærer vi strukturen vår som bruker og skriver den ut! Utdataene vi får er null/tom verdi av struct siden vi ikke har initialisert den ennå! De null verdi er i utgangspunktet null verdier for hvert felt.
{ 0 0}
Initialisering av strukturer
I forrige seksjon lærte vi hvordan vi deklarerer strukturer. Nå ønsker vi å initialisere eller tildele dem verdier. Sjekk koden nedenfor for hvordan vi gjø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)
}
Selve koden forklarer hvordan vi initialiserer to strukturer med og uten feltnavn. Her vil utgangen være –
{Mohit 24 100}
{Nidhi 21 1000}
I tilfellet ovenfor, hvis ett av feltene ikke er initialisert, vil feltet som standard ha nullverdien.
user1 := User{
name: "Mohit",
age: 24,
}
// Output - { Mohit 24 0.0 }
Det er en annen måte å lage strukturer ved å bruke nye søkeord. Vi vil se på hvordan du bruker det i neste avsnitt.
Tilgang til felt i en struktur
Nå vet vi hvordan vi oppretter og initialiserer strukturer, la oss se hvordan du får tilgang til feltene til en struktur. For dette gir Golang oss punktoperatøren. Fortsetter med forrige eksempel, la oss få tilgang til navn og aldersfelt og skrive dem ut.
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)
}
Her bruker vi struct_name.field_name for å få tilgang til felt i en struct. Utgangen av koden ovenfor vil være –
Mohit 24 100
Som nevnt tidligere kan vi lage strukturer med nytt nøkkelord. La oss se hvordan –
user := new(User)
user.name = "Mohit"
user.age = 24
user.bankBalance = 100.0
fmt.Println(user)
// Output - &{Mohit 24 100}
Det nye nøkkelordet returnerer pekeren til den initialiserte strukturen. I Golang trenger du ikke eksplisitt å referere til pekeren, men fmt.Println(*user) vil resultere i samme utgang.
Nestede strukturer
Strukturer i golang kan også inneholde andre brukerdefinerte typer. Så en struktur kan inneholde andre nestede 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 ovenfor har vi RoleDetails struct som en del av User struct. Utgangen vil være –
{Mohit 24 100 {Software Engineer Transport}}
Hvis du vil ha tilgang til roleDetails, kan du gjøre det ved å bruke samme punktoperator –
user.roleDetails.position
Strukturer likestilling
To strukturer er like hvis hvert av feltene de har er like (både innebygd og brukerdefinert), men ikke alle datatyper er sammenlignbare. (kartet er ikke sammenlignbart direkte). La oss se et eksempel for å demonstrere likhet.
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")
}
}
Tomme og nullverdistrukturer er like. Rekkefølgen på feltene spiller ingen rolle, i utgangspunktet bør hvert felt matche for likhet. Utdata for koden ovenfor vil være –
user1 and user2 are equal user1 and user3 are not equal
Konklusjon
Rått!
Nå er du klar til å bruke strukturer i golang. Vi dekket alt det grunnleggende som erklæring, initialisering og tilgang til struct-felt. Vi så også på hvordan man sammenligner to strukturer og implementerte til og med en nestet struktur. Her er noen ressurser for å lære mer om strukturer –
Det er mye mer å lære om strukturer, men det er en god start for nå. Jeg håper du har lært noe nytt!
Fortsett å utforske. Fortsett å lære!