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!
Tartalomjegyzék
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.
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.
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!
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!