Struktūras Golangā

Struktūras Golangā ir viens no visbiežāk izmantotajiem un veids, kā izveidot lietotāja definētus veidus.

Šeit es apskatīšu visus pamatus par struktūrām un to izmantošanu savās programmās ar dažiem piemēriem.

Sāksim!

Ievads

A struktūra ir vairāku datu lauku kolekcija ar definētajiem datu tipiem, kas sagrupēti kopā. Tie ir noderīgi datu grupēšanai kopā, veidojot pielāgotus ierakstus. Struktūra sastāv gan no iebūvētiem, gan no lietotāja definētiem tipiem (pati struktūra ir lietotāja definēts tips).

Golang struktūras ir mainīgas, ti, tās var mainīt visā programmā.

Struktūras palīdz uzlabot vispārējo koda kvalitāti, ļaujot mums izveidot un nodot sarežģītas datu struktūras vairākos moduļos. Iedomājieties, ka nododat funkcijai 10 parametrus, un jūs drīz aizbēgsit no koda. Tieši tāpēc struktūras ir noderīgas, tagad 10 parametru vietā šai funkcijai vienkārši nododat vienu struktūru.

Struktūra tiek deklarēta, izmantojot divus atslēgvārdus – veids un struktūra. Tas ir iesaiņots ar krokainajām iekavām (tāpat kā java klasēm), kas satur lauku kopu, kam ir noteikts tips un identifikators (nosaukums). Ieviešanas detaļas mēs apspriedīsim nākamajā sadaļā.

Ja jums ir objektorientētas programmēšanas (OOP) fons, struct varat uzskatīt par klasi, bet bez mantojuma.

Struktūru deklarēšana

Tagad, kad jūs saprotat, kas ir struktūra un kāpēc tā tiek izmantota, ir pienācis laiks uzzināt, kā deklarēt struktūras. Struktūras pamata skelets izskatās šādi –

type name_of_struct struct { 
     field1 data_type_field1 
     field2 data_type_field2 
 }

Šeit tips un struktūra ir atslēgvārdi, savukārt struktūrā ir vairāki lauki ar to noteikto datu tipu.

  Virtru ļauj sūtīt drošus e-pasta ziņojumus no Gmail, Outlook un Yahoo Mail

Apskatīsim piemēru –

package main

import (
	"fmt"
)

type User struct {
	name        string
	age         int
	bankBalance float32
}

func main() {
	var user User
	fmt.Println(user)
}

Šeit mēs definējam lietotāja struktūru, kas sastāv no laukiem virknes, int un float32. Main () mēs deklarējam savu struktūru kā lietotāju un izdrukājam to! Izvade, ko mēs iegūstam, ir nulles/tukša struktūras vērtība, jo mēs to vēl neesam inicializējuši! The nulles vērtība būtībā ir nulle katra lauka vērtības.

{ 0 0}

Struktūru inicializācija

Iepriekšējā sadaļā mēs uzzinājām, kā deklarēt struktūras. Tagad mēs vēlamies inicializēt vai piešķirt tām vērtības. Pārbaudiet tālāk norādīto kodu, kā mēs to darām –

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)
}

Pats kods izskaidro, kā inicializēt divas struktūras ar lauku nosaukumiem un bez tiem. Šeit iznākums būs –

{Mohit 24 100}
 {Nidhi 21 1000}

Iepriekš minētajā gadījumā, ja kāds no laukiem nav inicializēts, šim laukam pēc noklusējuma tiek iestatīta nulles vērtība.

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

 // Output - { Mohit 24 0.0 }

Ir vēl viens veids, kā izveidot struktūras, izmantojot jaunu atslēgvārdu. Kā to izmantot, mēs apskatīsim nākamajā sadaļā.

  Kā iespējot īpaši zema latentuma režīmu NVIDIA grafikai

Piekļuve struktūras laukiem

Tagad mēs zinām, kā izveidot un inicializēt struktūras, redzēsim, kā piekļūt struktūras laukiem. Šim nolūkam Golang mums nodrošina punktu operatoru. Turpinot ar iepriekšējo piemēru, piekļūsim vārda un vecuma laukiem un izdrukāsim tos.

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)
}

Šeit mēs izmantojam struct_name.field_name, lai piekļūtu struktūras laukiem. Iepriekš minētā koda izvade būs –

Mohit
 24
 100

Kā minēts iepriekš, mēs varam izveidot struktūras ar jaunu atslēgvārdu. Paskatīsimies, kā –

user := new(User)
 user.name = "Mohit"
 user.age = 24
 user.bankBalance = 100.0

 fmt.Println(user)

 // Output - &{Mohit 24 100}

Jaunais atslēgvārds atgriež rādītāju uz inicializēto struktūru. Programmā Golang jums nav skaidri jānorāda rādītāja atsauce, taču fmt.Println(*user) rezultātā tiks iegūta tāda pati izvade.

Ligzdotas struktūras

Struktūras golangā var saturēt arī citus lietotāja definētus veidus. Tātad struktūra var saturēt citas ligzdotas struktūras.

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)
}

Iepriekš minētajā kodā mums ir RoleDetails struktūra kā User struct daļa. Rezultāts būs –

{Mohit 24 100 {Software Engineer Transport}}

Ja vēlaties piekļūt roleDetails, varat to izdarīt, izmantojot to pašu punktu operatoru –

  Kas ir kritiskie brīdinājumi iPhone un iPad ierīcēs un kā tos iespējot?

user.roleDetails.position

Struktūras vienlīdzība

Divas struktūras ir vienādas, ja katrs no tām esošajiem laukiem ir vienāds (gan iebūvēts, gan lietotāja definēts), bet ne visi datu tipi ir salīdzināmi. (karte nav tieši salīdzināma). Apskatīsim piemēru, lai parādītu vienlīdzību.

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")
	}
}

Tukšas un nulles vērtības struktūras ir vienādas. Lauku secībai nav nozīmes, būtībā katram laukam ir jāatbilst vienlīdzības labad. Iepriekš norādītā koda izvade būs –

user1 and user2 are equal
user1 and user3 are not equal

Secinājums

Satriecošs!

Tagad esat gatavs izmantot struktūras golangā. Mēs aptvērām visus pamatus, piemēram, deklarāciju, inicializāciju un piekļuvi struct laukiem. Mēs arī apskatījām, kā salīdzināt divas struktūras, un pat ieviesām ligzdotu struktūru. Šeit ir daži resursi, lai uzzinātu vairāk par struktūrām –

Ir vēl daudz ko uzzināt par struktūrām, taču pagaidām tas ir labs sākums. Ceru, ka uzzinājāt ko jaunu!

Turpiniet izpēti. Turpini mācīties!