Structurile din Golang sunt una dintre cele mai utilizate și o modalitate de a crea tipuri definite de utilizator.
În aceasta, voi acoperi toate elementele de bază despre structuri și cum să le utilizez în programele dvs. go cu câteva exemple.
Să începem!
Cuprins
Introducere
A struct este o colecție de câmpuri de date multiple cu tipurile de date definite grupate împreună. Sunt utile pentru gruparea datelor împreună pentru a forma înregistrări personalizate. O structură constă din tipuri atât încorporate, cât și definite de utilizator (structul în sine este un tip definit de utilizator).
Structurile din Golang sunt mutabile, adică pot fi modificate pe tot parcursul programului.
Structurile ajută la îmbunătățirea calității generale a codului, permițându-ne să creăm și să transmitem structuri complexe de date peste mai multe module. Imaginați-vă că treceți 10 parametri într-o funcție, în curând veți fugi de cod. Acesta este exact motivul pentru care structurile sunt utile, acum, în loc de 10 parametri, pur și simplu treceți un singur struct acelei funcții.
O structură este declarată folosind două cuvinte cheie – tip și struct. Este împachetat cu paranteze (la fel ca clasele în java) – care conține un set de câmpuri care au un tip definit și un identificator (nume). Discutăm detaliile implementării în secțiunea următoare.
Dacă veniți dintr-un mediu de programare orientată pe obiecte (OOP), vă puteți gândi la struct ca la o clasă, dar fără moștenire.
Declararea structurilor
Acum, că înțelegi ce este o structură și de ce este folosită, este timpul să înveți cum să declari structuri. Scheletul de bază al unei structuri arată ca –
type name_of_struct struct {
field1 data_type_field1
field2 data_type_field2
}
Aici, tipul și structura sunt cuvinte cheie, în timp ce structura conține mai multe câmpuri cu tipul lor de date definit.
Să vedem un exemplu –
package main
import (
"fmt"
)
type User struct {
name string
age int
bankBalance float32
}
func main() {
var user User
fmt.Println(user)
}
Aici definim o structură User care constă din câmpuri string, int și float32. În main() declarăm structura noastră ca utilizator și o imprimăm! Ieșirea pe care o obținem este valoarea zero/vide a structului, deoarece nu l-am inițializat încă! The valoare zero este practic zero valori ale fiecărui câmp.
{ 0 0}
Inițializarea structurilor
În secțiunea anterioară, am învățat cum să declarăm structuri. Acum, am dori să le inițializam sau să le atribuim valori. Verificați codul de mai jos despre cum facem asta –
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)
}
Codul în sine explică modul în care inițializam două structuri cu și fără nume de câmp. Aici, rezultatul va fi –
{Mohit 24 100}
{Nidhi 21 1000}
În cazul de mai sus, dacă unul dintre câmpuri nu este inițializat, atunci acel câmp va reveni la valoarea sa zero.
user1 := User{
name: "Mohit",
age: 24,
}
// Output - { Mohit 24 0.0 }
Mai există o modalitate de a crea structuri folosind un cuvânt cheie nou. Vom vedea cum să-l folosim în secțiunea următoare.
Accesarea câmpurilor unei structuri
Acum știm cum să creăm și să inițializam structuri, să vedem cum să accesăm câmpurile unei structuri. Pentru aceasta, Golang ne pune la dispoziție operatorul punct. Continuând cu exemplul anterior, să accesăm câmpurile de nume și vârstă și să le tipărim.
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)
}
Aici, folosim struct_name.field_name pentru a accesa câmpurile dintr-o struct. Ieșirea codului de mai sus va fi –
Mohit 24 100
După cum am menționat mai devreme, putem crea structuri cu un cuvânt cheie nou. Să vedem cum –
user := new(User)
user.name = "Mohit"
user.age = 24
user.bankBalance = 100.0
fmt.Println(user)
// Output - &{Mohit 24 100}
Noul cuvânt cheie returnează indicatorul la structura inițializată. În Golang, nu trebuie să dereferiți în mod explicit indicatorul, dar fmt.Println(*user) ar avea ca rezultat aceeași ieșire.
Structuri imbricate
Structurile din golang pot conține și alte tipuri definite de utilizator. Deci, un struct poate conține alte structuri imbricate.
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)
}
În codul de mai sus, avem RoleDetails struct ca parte a User struct. Ieșirea va fi –
{Mohit 24 100 {Software Engineer Transport}}
Dacă doriți să accesați roleDetails, puteți face asta folosind același operator de punct –
user.roleDetails.position
Structura Egalitatea
Două structuri sunt egale dacă fiecare dintre câmpurile pe care le au este egal (atât încorporat, cât și definit de utilizator), dar nu toate tipurile de date sunt comparabile. (harta nu este comparabilă direct). Să vedem un exemplu pentru a demonstra egalitatea.
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")
}
}
Structurile goale și zero sunt egale. Ordinea câmpurilor nu contează, practic, fiecare câmp ar trebui să se potrivească pentru egalitate. Ieșirea pentru codul de mai sus va fi –
user1 and user2 are equal user1 and user3 are not equal
Concluzie
Minunat!
Acum sunteți gata să utilizați structuri în golang. Am acoperit toate elementele de bază, cum ar fi declararea, inițializarea și accesarea câmpurilor struct. De asemenea, ne-am uitat la cum să comparăm două structuri și chiar am implementat un struct imbricat. Iată câteva resurse pentru a afla mai multe despre structuri –
Mai sunt multe de învățat despre structuri, dar este un început bun pentru moment. Sper că ai învățat ceva nou!
Continuați să explorați. Continua sa inveti!