I Go, er strukturer en svært anvendt metode for å skape egendefinerte datatyper.
Denne artikkelen vil utforske de fundamentale aspektene ved strukturer og demonstrere hvordan de kan implementeres i dine Go-programmer, inkludert noen praktiske eksempler.
La oss dykke inn!
Introduksjon
En struktur er i bunn og grunn en samling av ulike datafelt, hver med sin spesifikke datatype, som er gruppert sammen. Disse strukturene er nyttige for å organisere relaterte data i tilpassede oppføringer. En struktur kan bestå av både innebygde og brukerdefinerte typer, og selve strukturen er også en brukerdefinert type.
Strukturer i Go er fleksible og kan endres i løpet av programmets kjøretid.
Ved å tillate opprettelse og overføring av komplekse datastrukturer mellom moduler, bidrar strukturer til å forbedre den overordnede kodekvaliteten. Istedenfor å sende et stort antall parametere til en funksjon, kan du nå sende en enkelt struktur, noe som gjør koden mer oversiktlig og lett å vedlikeholde.
En struktur deklareres ved hjelp av nøkkelordene type og struct. Den er definert innenfor krøllparenteser, på samme måte som klasser i Java, og inneholder en rekke felt med definerte datatyper og identifikatorer. Vi vil se nærmere på implementeringsdetaljene i neste avsnitt.
Dersom du har bakgrunn innen objektorientert programmering (OOP), kan du tenke på en struktur som en klasse, men uten arv.
Deklarasjon av strukturer
Nå som du har en forståelse av hva en struktur er og hvorfor den er nyttig, er det på tide å lære hvordan du deklarerer en struktur. Den grunnleggende malen for en struktur er som følger:
type struct_navn struct {
felt1 datatype_felt1
felt2 datatype_felt2
}
Her er `type` og `struct` nøkkelord, og selve strukturen inneholder flere felt med tilhørende datatyper.
La oss se på et konkret eksempel:
package main
import (
"fmt"
)
type Bruker struct {
navn string
alder int
bankSaldo float32
}
func main() {
var bruker Bruker
fmt.Println(bruker)
}
I dette eksemplet definerer vi en brukerstruktur som inkluderer streng-, int- og float32-felter. I `main()` deklarerer vi strukturen som `bruker` og printer den ut. Utskriften vil vise null- eller tomme verdier siden strukturen ennå ikke er initialisert. Nullverdier representerer standardverdiene for hver datatype.
{ 0 0}
Initialisering av strukturer
I forrige avsnitt så vi hvordan vi deklarerer strukturer. Nå skal vi lære hvordan vi initialiserer dem med faktiske verdier. Koden under viser hvordan vi gjør dette:
package main
import (
"fmt"
)
type Bruker struct {
navn string
alder int
bankSaldo float32
}
func main() {
// Med feltnavn
bruker1 := Bruker{
navn: "Mohit",
alder: 24,
bankSaldo: 100.0,
}
// Uten feltnavn
bruker2 := Bruker{"Nidhi", 21, 1000.0}
fmt.Println(bruker1)
fmt.Println(bruker2)
}
Koden illustrerer hvordan vi initialiserer to strukturer, både med og uten eksplisitte feltnavn. Utskriften vil være:
{Mohit 24 100}
{Nidhi 21 1000}
Hvis et felt ikke er initialisert, vil det automatisk bli satt til sin standard nullverdi.
bruker1 := Bruker{
navn: "Mohit",
alder: 24,
}
// Output - { Mohit 24 0.0 }
Det finnes også en annen måte å opprette strukturer på, ved bruk av nøkkelordet `new`. Vi skal utforske dette i neste avsnitt.
Tilgang til felt i en struktur
Nå som vi vet hvordan vi oppretter og initialiserer strukturer, skal vi se hvordan vi får tilgang til feltene i en struktur. I Go benytter vi punktoperatoren (.). La oss fortsette med det forrige eksemplet og se hvordan vi aksesserer og skriver ut navn- og alder-feltene:
package main
import (
"fmt"
)
type Bruker struct {
navn string
alder int
bankSaldo float32
}
func main() {
// Med feltnavn
bruker := Bruker{
navn: "Mohit",
alder: 24,
bankSaldo: 100.0,
}
fmt.Println(bruker.navn)
fmt.Println(bruker.alder)
fmt.Println(bruker.bankSaldo)
}
Vi bruker `struktur_navn.felt_navn` for å få tilgang til feltene i strukturen. Utskriften for koden ovenfor vil være:
Mohit 24 100
Som nevnt tidligere kan vi også opprette strukturer med `new`-nøkkelordet. La oss se hvordan:
bruker := new(Bruker)
bruker.navn = "Mohit"
bruker.alder = 24
bruker.bankSaldo = 100.0
fmt.Println(bruker)
// Output - &{Mohit 24 100}
`new`-nøkkelordet returnerer en peker til den initialiserte strukturen. I Go trenger du ikke eksplisitt dereferere pekeren, men `fmt.Println(*bruker)` vil gi samme utskrift.
Nøstede strukturer
Strukturer i Go kan også inneholde andre brukerdefinerte datatyper, noe som betyr at en struktur kan inneholde andre nøstede strukturer:
package main
import (
"fmt"
)
type Bruker struct {
navn string
alder int
bankSaldo float32
rolleDetaljer RolleDetaljer
}
type RolleDetaljer struct {
stilling string
team string
}
func main() {
rolleDetaljerForMohit := RolleDetaljer{
stilling: "Programvareingeniør",
team: "Transport",
}
bruker := Bruker{
navn: "Mohit",
alder: 24,
bankSaldo: 100.0,
rolleDetaljer: rolleDetaljerForMohit,
}
fmt.Println(bruker)
}
I koden ovenfor har vi `RolleDetaljer` som en del av `Bruker`-strukturen. Utskriften vil være:
{Mohit 24 100 {Programvareingeniør Transport}}
For å få tilgang til feltene i `rolleDetaljer` kan du bruke samme punktoperator:
`bruker.rolleDetaljer.stilling`
Strukturell likhet
To strukturer er ansett som like hvis hvert av feltene deres er identiske (både innebygde og brukerdefinerte), men ikke alle datatyper er direkte sammenlignbare (kart er ikke sammenlignbart). La oss se på et eksempel for å demonstrere likhet:
package main
import (
"fmt"
)
type Bruker struct {
navn string
alder int
bankSaldo float32
}
func main() {
bruker1 := Bruker{
navn: "Mohit",
alder: 24,
bankSaldo: 100.0,
}
bruker2 := Bruker{
navn: "Mohit",
alder: 24,
bankSaldo: 100.0,
}
bruker3 := Bruker{
navn: "Nidhi",
alder: 21,
bankSaldo: 1000.0,
}
if bruker1 == bruker2 {
fmt.Println("bruker1 og bruker2 er like")
} else {
fmt.Println("bruker1 og bruker2 er ikke like")
}
if bruker1 == bruker3 {
fmt.Println("bruker1 og bruker3 er like")
} else {
fmt.Println("bruker1 og bruker3 er ikke like")
}
}
Tomme og nullverdistrukturer er også ansett som like. Rekkefølgen på feltene spiller ingen rolle, det som teller er at verdiene i hvert felt stemmer overens. Utdata for koden ovenfor vil være:
bruker1 og bruker2 er like bruker1 og bruker3 er ikke like
Konklusjon
Flott!
Nå er du godt rustet til å bruke strukturer i Go. Vi har dekket grunnleggende konsepter som deklarasjon, initialisering og tilgang til strukturfelt. Vi har også sett på hvordan vi sammenligner to strukturer og implementert en nøstet struktur. Her er noen ressurser for å lære mer om strukturer:
Det er mye mer å utforske om strukturer, men dette er en god start. Jeg håper du har lært noe nytt i dag!
Fortsett å utforske og lære!