Struktúrák Golangban

A Golang struktúrái az egyik leggyakrabban használt és a felhasználó által definiált típusok létrehozásának egyik módja.

Ebben egy pár példával bemutatom a struktúrák alapjait és azok használatát a go programokban.

Kezdjük el!

Bevezetés

A struct több adatmező gyűjteménye, amelyek meghatározott adattípusai vannak csoportosítva. Hasznosak az adatok csoportosításához egyéni rekordok létrehozásához. A struktúra beépített és felhasználó által definiált típusokból is áll (maga a struktúra egy felhasználó által definiált típus).

A Golang struktúrái változtathatók, azaz a program során módosíthatók.

A struktúrák segítenek az általános kódminőség javításában, mivel lehetővé teszik számunkra, hogy összetett adatstruktúrákat hozzunk létre és továbbítsunk több modulon keresztül. Képzelje el, hogy 10 paramétert ad át egy függvénynek, és hamarosan elmenekül a kód elől. Pontosan ezért hasznosak a struktúrák, most 10 paraméter helyett egyszerűen csak egyetlen struktúrát adunk át a függvénynek.

Egy struktúrát két kulcsszóval deklarálunk – típus és szerkezet. Kapcsos zárójelbe van burkolva (akárcsak a java osztályai) – amely meghatározott típusú és azonosítóval (névvel) rendelkező mezőket tartalmaz. A megvalósítás részleteit a következő részben tárgyaljuk.

Ha objektum-orientált programozási (OOP) háttérrel rendelkezik, akkor a struct-ot osztálynak tekintheti, de öröklődés nélkül.

Struktúrák deklarálása

Most, hogy megértette, mi az a struktúra, és miért használják, ideje megtanulni, hogyan deklarálhat struktúrákat. A struktúra alapváza így néz ki:

type name_of_struct struct { 
     field1 data_type_field1 
     field2 data_type_field2 
 }

Itt a típus és a struktúra kulcsszavak, míg a struktúra több mezőt tartalmaz meghatározott adattípusokkal.

  Az 5 legjobb legördülő terminálalkalmazás Linuxhoz

Lássunk egy példát –

package main

import (
	"fmt"
)

type User struct {
	name        string
	age         int
	bankBalance float32
}

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

Itt definiálunk egy felhasználói struktúrát, amely string, int és float32 mezőkből áll. A main()-ban felhasználóiként deklaráljuk a struct-unkat, és kinyomtatjuk! A kapott kimenet a struct nulla/üres értéke, mivel még nem inicializáltuk! Az nulla érték alapvetően minden mező nulla értéke.

{ 0 0}

Struktúrák inicializálása

Az előző részben megtanultuk a struktúrák deklarálását. Most szeretnénk inicializálni vagy értékeket rendelni hozzájuk. Tekintse meg az alábbi kódot, hogy ezt hogyan tesszük –

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

Maga a kód elmagyarázza, hogyan inicializálunk két struktúrát mezőnévvel és anélkül. Itt a kimenet a következő lesz:

{Mohit 24 100}
 {Nidhi 21 1000}

A fenti esetben, ha az egyik mező nincs inicializálva, akkor a mező alapértelmezett értéke nulla.

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

 // Output - { Mohit 24 0.0 }

Van még egy módja a struktúrák létrehozásának új kulcsszó használatával. A következő részben megvizsgáljuk, hogyan kell használni.

Hozzáférés egy struktúra mezőihez

Most már tudjuk, hogyan kell struktúrákat létrehozni és inicializálni, lássuk, hogyan lehet elérni egy struktúra mezőit. Ehhez Golang biztosítja számunkra a pont operátort. Folytatva az előző példát, érjük el a név és életkor mezőket, és nyomtassuk ki őket.

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

Itt a struct_name.field_name paramétert használjuk a struktúra mezőinek eléréséhez. A fenti kód kimenete a következő lesz:

Mohit
 24
 100

Mint korábban említettük, új kulcsszóval is létrehozhatunk struktúrákat. Lássuk hogyan –

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

 fmt.Println(user)

 // Output - &{Mohit 24 100}

Az új kulcsszó visszaadja a mutatót az inicializált struktúrára. A Golangban nem kell kifejezetten a mutató hivatkozását megszüntetni, de az fmt.Println(*user) ugyanazt a kimenetet eredményezi.

  HDMI 2.1: Újdonságok, és szükség van-e frissítésre?

Beágyazott szerkezetek

A golang struktúrái más, felhasználó által definiált típusokat is tartalmazhatnak. Tehát egy struktúra tartalmazhat más beágyazott struktúrákat.

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

A fenti kódban a RoleDetails struktúra a User struct részeként szerepel. A kimenet a következő lesz:

{Mohit 24 100 {Software Engineer Transport}}

Ha hozzá szeretne férni a roleDetails-hez, ezt ugyanazzal a pontoperátorral teheti meg –

user.roleDetails.position

Strukturális egyenlőség

Két struktúra akkor egyenlő, ha mindegyik mezőjük egyenlő (beépített és felhasználó által meghatározott), de nem minden adattípus összehasonlítható. (a térkép közvetlenül nem hasonlítható össze). Nézzünk egy példát az egyenlőség bizonyítására.

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

Az üres és a nulla értékű struktúrák egyenlőek. A mezők sorrendje nem számít, alapvetően minden mezőnek egyeznie kell az egyenlőség érdekében. A fenti kód kimenete:

user1 and user2 are equal
user1 and user3 are not equal

Következtetés

Fantasztikus!

  Készítsen gyönyörű KPI-irányítópultokat ezzel a 10 eszközzel

Most már készen áll a struktúrák használatára a golangban. Minden alapelvvel foglalkoztunk, mint például a deklaráció, az inicializálás és a struct mezők elérése. Azt is megvizsgáltuk, hogyan lehet két struktúrát összehasonlítani, és még egy beágyazott struktúrát is megvalósítottunk. Íme néhány forrás, amelyből többet megtudhat a struktúrákról –

Sokat kell még tanulni a struktúrákról, de ez most jó kezdet. Remélem tanultál valami újat!

Folytassa a felfedezést. Tanulj tovább!