Introduktion till strukturer i Golang
En struktur i Golang är en sammansatt datatyp som grupperar flera variabler, var och en med sin egen datatyp, under ett enda namn. De fungerar som ett verktyg för att skapa skräddarsydda datarepresentationer genom att kombinera relaterade datafält. En struktur kan innehålla både grundläggande datatyper och andra strukturer, vilket gör det möjligt att bygga komplexa datamodeller.
Strukturer i Golang är föränderliga, vilket innebär att deras innehåll kan justeras efter att de skapats. Detta ger flexibilitet i hanteringen av data inom programmet.
Genom att använda strukturer kan du förbättra din kods struktur och läsbarhet. Istället för att skicka en mängd separata parametrar till funktioner, kan du kapsla in dem i en struktur och skicka ett enda objekt, vilket förenklar koden avsevärt. Tänk dig att hantera 10 parametrar i en funktion – med en struktur kan du reducera det till ett enda, sammanhållet dataobjekt.
En struktur definieras med hjälp av nyckelorden type och struct. Definitionen av en struktur omges av klammerparenteser, inom vilka datafält (med namn och datatyp) deklareras. Detta liknar hur klasser definieras i andra objektorienterade språk som Java. Vi kommer att utforska detaljerna i implementeringen i kommande avsnitt.
För dem med erfarenhet av objektorienterad programmering, kan man se en struktur som en klass utan arv, men med möjligheten att gruppera och hantera data på ett effektivt sätt.
Deklaration av strukturer
Efter att ha bekantat oss med konceptet och nyttan med strukturer, är det dags att lära sig hur man definierar dem. Den grundläggande strukturen för en struktur ser ut som följer:
type struct_namn struct {
fält1 data_typ_fält1
fält2 data_typ_fält2
}
Här utgör type och struct de nödvändiga nyckelorden. Inuti struct, specificeras en eller flera fält med deras respektive datatyper.
Låt oss exemplifiera detta med ett konkret exempel:
package main
import (
"fmt"
)
type Anvandare struct {
namn string
alder int
saldo float32
}
func main() {
var anvandare Anvandare
fmt.Println(anvandare)
}
I exemplet ovan definieras en struktur vid namn Anvandare. Den innehåller fält för användarens namn (string), ålder (int) och bankbalans (float32). I main-funktionen deklareras en variabel av typen Anvandare och dess tomma värde skrivs ut. Eftersom vi inte tilldelat några värden till strukturen ännu kommer utskriften visa strukturernas nollvärden.
Det tomma värdet är det fördefinierade standardvärdet för varje fälts datatyp.
{ 0 0}
Initialisering av strukturer
Nu när vi har lärt oss hur man deklarerar strukturer, ska vi utforska hur man tilldelar värden till dem. Nedan följer ett exempel på hur vi kan initialisera en struktur:
package main
import (
"fmt"
)
type Anvandare struct {
namn string
alder int
saldo float32
}
func main() {
// Med fältnamn
anvandare1 := Anvandare{
namn: "Mohit",
alder: 24,
saldo: 100.0,
}
// Utan fältnamn
anvandare2 := Anvandare{"Nidhi", 21, 1000.0}
fmt.Println(anvandare1)
fmt.Println(anvandare2)
}
Koden ovan visar två sätt att initialisera en struktur: med och utan explicita fältnamn. Resultatet av utskriften kommer att vara:
{Mohit 24 100}
{Nidhi 21 1000}
Om ett av fälten inte initieras, kommer det att anta sitt standardvärde, så kallat nollvärde.
anvandare1 := Anvandare{
namn: "Mohit",
alder: 24,
}
// Output - { Mohit 24 0.0 }
Det finns även ett alternativt sätt att skapa strukturer med nyckelordet new, vilket vi kommer att titta närmare på i nästa avsnitt.
Åtkomst till fält i en struktur
Efter att ha gått igenom hur man skapar och initierar strukturer, låt oss nu undersöka hur man får tillgång till deras fält. Golang tillhandahåller punktoperatorn för detta ändamål. Med utgångspunkt i det tidigare exemplet, låt oss komma åt och skriva ut fälten namn och ålder:
package main
import (
"fmt"
)
type Anvandare struct {
namn string
alder int
saldo float32
}
func main() {
// Med fältnamn
anvandare := Anvandare{
namn: "Mohit",
alder: 24,
saldo: 100.0,
}
fmt.Println(anvandare.namn)
fmt.Println(anvandare.alder)
fmt.Println(anvandare.saldo)
}
Här använder vi notationen struktur_namn.fält_namn för att komma åt specifika fält i strukturen. Resultatet av körningen blir:
Mohit 24 100
Som tidigare nämnts kan strukturer också skapas med hjälp av nyckelordet new. Låt oss se hur det fungerar:
anvandare := new(Anvandare)
anvandare.namn = "Mohit"
anvandare.alder = 24
anvandare.saldo = 100.0
fmt.Println(anvandare)
// Output - &{Mohit 24 100}
Nyckelordet new returnerar en pekare till den nyligen initierade strukturen. I Golang behöver du inte uttryckligen dereferera pekaren, men fmt.Println(*anvandare) skulle ge samma resultat.
Kapslade strukturer
I Golang kan strukturer även innehålla andra användardefinierade typer, vilket gör det möjligt att kapsla strukturer inuti andra strukturer:
package main
import (
"fmt"
)
type Anvandare struct {
namn string
alder int
saldo float32
rollDetaljer RollDetaljer
}
type RollDetaljer struct {
position string
team string
}
func main() {
rollDetaljerForMohit := RollDetaljer{
position: "Mjukvaruingenjor",
team: "Transport",
}
anvandare := Anvandare{
namn: "Mohit",
alder: 24,
saldo: 100.0,
rollDetaljer: rollDetaljerForMohit,
}
fmt.Println(anvandare)
}
I koden ovan ser vi RollDetaljer-strukturen som en del av Anvandare-strukturen. Resultatet av utskriften kommer att vara:
{Mohit 24 100 {Mjukvaruingenjor Transport}}
För att komma åt information om rollen, kan vi använda punktoperatorn enligt följande: anvandare.rollDetaljer.position.
Jämlikhet mellan strukturer
Två strukturer anses vara lika om samtliga motsvarande fält har identiska värden. Detta gäller både för inbyggda och användardefinierade datatyper. Dock är inte alla datatyper jämförbara direkt (exempelvis maps). Låt oss demonstrera detta med ett exempel:
package main
import (
"fmt"
)
type Anvandare struct {
namn string
alder int
saldo float32
}
func main() {
anvandare1 := Anvandare{
namn: "Mohit",
alder: 24,
saldo: 100.0,
}
anvandare2 := Anvandare{
namn: "Mohit",
alder: 24,
saldo: 100.0,
}
anvandare3 := Anvandare{
namn: "Nidhi",
alder: 21,
saldo: 1000.0,
}
if anvandare1 == anvandare2 {
fmt.Println("anvandare1 och anvandare2 är lika")
} else {
fmt.Println("anvandare1 och anvandare2 är inte lika")
}
if anvandare1 == anvandare3 {
fmt.Println("anvandare1 och anvandare3 är lika")
} else {
fmt.Println("anvandare1 och anvandare3 är inte lika")
}
}
Tomma strukturer och strukturer som enbart innehåller nollvärden är lika. Fältens ordning spelar ingen roll, det avgörande är att varje fält har ett matchande värde för att strukturen ska betraktas som likadan. Resultatet av ovanstående kod kommer att vara:
anvandare1 och anvandare2 är lika anvandare1 och anvandare3 är inte lika
Sammanfattning
Utmärkt!
Nu är du rustad att använda strukturer i Golang. Vi har gått igenom grunderna, från deklaration och initialisering till åtkomst av fält. Vi har även utforskat hur man jämför två strukturer och hur man använder kapslade strukturer. Det finns mycket mer att upptäcka om strukturer, men detta ger dig en bra grund att stå på.
Här är några resurser för vidare studier:
Fortsätt utforska och lära!