Strukturer i Golang

Strukturer i Golang er en af ​​de mest brugte og en måde at skabe brugerdefinerede typer på.

I dette vil jeg dække alt det grundlæggende om strukturer og hvordan du bruger dem i dine go-programmer med et par eksempler.

Lad os komme igang!

Introduktion

EN struktur er en samling af flere datafelter med deres definerede datatyper grupperet sammen. De er nyttige til at gruppere data sammen for at danne brugerdefinerede poster. En struct består af både indbyggede og brugerdefinerede typer (struct i sig selv er en brugerdefineret type).

Strukturer i Golang kan ændres, dvs. de kan ændres gennem hele programmet.

Strukturer hjælper med at forbedre den overordnede kodekvalitet ved at give os mulighed for at skabe og videregive komplekse datastrukturer på tværs af flere moduler. Forestil dig, at du sender 10 parametre ind i en funktion, du vil snart løbe væk fra kode. Det er præcis derfor structs er nyttige, nu i stedet for 10 parametre sender du blot en enkelt struct til den funktion.

En struct erklæres ved hjælp af to nøgleord – type og struktur. Det er pakket med krøllede parenteser (ligesom klasser i java) – som indeholder et sæt felter, der har en defineret type og en identifikator(navn). Vi diskuterer implementeringsdetaljerne i næste afsnit.

Hvis du kommer fra en objektorienteret programmering (OOP) baggrund, kan du tænke på struct som en klasse, men uden arv.

Erklæring af strukturer

Nu, hvor du forstår, hvad en struktur er, og hvorfor den bruges, er det tid til at lære at erklære strukturer. Det grundlæggende skelet af en struktur ser ud som –

type name_of_struct struct { 
     field1 data_type_field1 
     field2 data_type_field2 
 }

Her er type og struct nøgleord, hvorimod struct indeholder flere felter med deres definerede datatype.

Lad os 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 brugerstruktur, som består af string, int og float32 felter. I main() erklærer vi vores struct som bruger og udskriver den! Det output, vi får, er nul/tom værdi af struct, da vi ikke har initialiseret det endnu! Det nul værdi er dybest set nul værdier for hvert felt.

{ 0 0}

Initialisering af strukturer

I det foregående afsnit lærte vi, hvordan man erklærer strukturer. Nu ønsker vi at initialisere eller tildele dem værdier. Tjek koden nedenfor om, hvordan 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)
}

Selve koden forklarer, hvordan vi initialiserer to strukturer med og uden feltnavne. Her vil outputtet være –

{Mohit 24 100}
 {Nidhi 21 1000}

I ovenstående tilfælde, hvis et af felterne ikke er initialiseret, vil dette felt som standard have værdien nul.

user1 := User{
	name:        "Mohit",
	age:         24,
}

 // Output - { Mohit 24 0.0 }

Der er endnu en måde at oprette strukturer ved hjælp af nye søgeord. Vi vil se på, hvordan du bruger det i næste afsnit.

Adgang til felter i en struktur

Nu ved vi, hvordan man opretter og initialiserer strukturer, lad os se, hvordan man får adgang til felterne i en struktur. Til dette giver Golang os prikoperatoren. Lad os fortsætte med det forrige eksempel, få adgang til navne- og aldersfelter og udskrive 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)
}

Her bruger vi struct_name.field_name til at få adgang til felter i en struct. Outputtet af ovenstående kode vil være –

Mohit
 24
 100

Som tidligere nævnt kan vi oprette strukturer med nyt søgeord. Lad os 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øgleord returnerer markøren til den initialiserede struktur. I Golang behøver du ikke eksplicit at dereferere markøren, men fmt.Println(*user) ville resultere i det samme output.

Indlejrede strukturer

Strukturer i golang kan også indeholde andre brugerdefinerede typer. Så en struktur kan indeholde andre indlejrede 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 af User struct. Outputtet bliver –

{Mohit 24 100 {Software Engineer Transport}}

Hvis du vil have adgang til roleDetails, kan du gøre det ved at bruge den samme prikoperator –

bruger.rolleDetails.position

Strukturer ligestilling

To strukturer er ens, hvis hvert af felterne, de har, er ens (både indbygget og brugerdefineret), men ikke alle datatyper er sammenlignelige. (kortet er ikke direkte sammenligneligt). Lad os se et eksempel for at demonstrere lighed.

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 nulværdistrukturer er ens. Rækkefølgen af ​​felter er ligegyldig, dybest set bør hvert felt matche for lighed. Output for kode ovenfor vil være –

user1 and user2 are equal
user1 and user3 are not equal

Konklusion

Fantastisk!

Nu er du klar til at bruge structs i golang. Vi dækkede alt det grundlæggende som erklæring, initialisering og adgang til struct-felter. Vi så også på, hvordan man sammenligner to strukturer og implementerede endda en indlejret struktur. Her er nogle ressourcer til at lære mere om strukturer –

Der er meget mere at lære om strukturer, men det er en god start for nu. Jeg håber du har lært noget nyt!

Fortsæt med at udforske. Fortsæt med at lære!