Struktury w Golang są jednym z najczęściej używanych i sposobem tworzenia typów zdefiniowanych przez użytkownika.
W tym artykule omówię wszystkie podstawy dotyczące struktur i sposobu ich używania w programach go z kilkoma przykładami.
Zacznijmy!
Spis treści:
Wstęp
A struktura jest zbiorem wielu pól danych z pogrupowanymi razem zdefiniowanymi typami danych. Są przydatne do grupowania danych w celu utworzenia niestandardowych rekordów. Struktura składa się zarówno z typów wbudowanych, jak i zdefiniowanych przez użytkownika (sama struktura jest typem zdefiniowanym przez użytkownika).
Struktury w Golang są zmienne, tzn. mogą być modyfikowane w całym programie.
Struktury pomagają w poprawie ogólnej jakości kodu, umożliwiając nam tworzenie i przekazywanie złożonych struktur danych w wielu modułach. Wyobraź sobie, że przekazujesz 10 parametrów do funkcji, a wkrótce uciekniesz od kodu. Właśnie dlatego struktury są przydatne, teraz zamiast 10 parametrów po prostu przekazujesz pojedynczą strukturę do tej funkcji.
Struktura jest deklarowana przy użyciu dwóch słów kluczowych – rodzaj i struktura. Jest opakowany w nawiasy klamrowe (podobnie jak klasy w Javie) – zawiera zestaw pól, które mają określony typ i identyfikator (nazwę). Szczegóły implementacji omówimy w następnej sekcji.
Jeśli wywodzisz się z programowania obiektowego (OOP), możesz myśleć o strukturze jako o klasie, ale bez dziedziczenia.
Deklarowanie struktur
Teraz, gdy już wiesz, czym jest struktura i dlaczego jest używana, nadszedł czas, aby nauczyć się deklarować struktury. Podstawowy szkielet struktury wygląda następująco –
type name_of_struct struct {
field1 data_type_field1
field2 data_type_field2
}
Tutaj typ i struktura to słowa kluczowe, podczas gdy struktura zawiera wiele pól ze zdefiniowanym typem danych.
Zobaczmy przykład –
package main
import (
"fmt"
)
type User struct {
name string
age int
bankBalance float32
}
func main() {
var user User
fmt.Println(user)
}
Tutaj definiujemy strukturę User, która składa się z pól string, int i float32. W funkcji main() deklarujemy naszą strukturę jako user i drukujemy ją! Dane wyjściowe, które otrzymujemy, to zero/pusta wartość struktury, ponieważ jeszcze jej nie zainicjowaliśmy! The wartość zerowa jest w zasadzie zerowymi wartościami każdego pola.
{ 0 0}
Inicjowanie struktur
W poprzedniej sekcji nauczyliśmy się, jak deklarować struktury. Teraz chcielibyśmy zainicjować lub przypisać im wartości. Sprawdź poniższy kod, jak to robimy –
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)
}
Sam kod wyjaśnia, w jaki sposób inicjujemy dwie struktury z nazwami pól i bez nich. Tutaj wyjście będzie –
{Mohit 24 100}
{Nidhi 21 1000}
W powyższym przypadku, jeśli jedno z pól nie zostanie zainicjowane, to pole domyślnie przyjmuje wartość zerową.
user1 := User{
name: "Mohit",
age: 24,
}
// Output - { Mohit 24 0.0 }
Istnieje jeszcze jeden sposób tworzenia struktur przy użyciu słowa kluczowego new. Przyjrzymy się, jak go używać w następnej sekcji.
Dostęp do pól struktury
Teraz wiemy, jak tworzyć i inicjować struktury, zobaczmy, jak uzyskać dostęp do pól struktury. W tym celu Golang udostępnia nam operator kropki. Kontynuując poprzedni przykład, uzyskajmy dostęp do pól imię i nazwisko oraz wiek i wydrukujmy je.
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)
}
Tutaj używamy struct_name.field_name, aby uzyskać dostęp do pól w strukturze. Wyjście powyższego kodu będzie –
Mohit 24 100
Jak wspomniano wcześniej, możemy tworzyć struktury za pomocą słowa kluczowego new. zobaczmy jak –
user := new(User)
user.name = "Mohit"
user.age = 24
user.bankBalance = 100.0
fmt.Println(user)
// Output - &{Mohit 24 100}
Słowo kluczowe new zwraca wskaźnik do zainicjowanej struktury. W Golang nie musisz jawnie wyłuskiwać wskaźnika, ale fmt.Println(*user) skutkowałoby tym samym wynikiem.
Struktury zagnieżdżone
Struktury w golangu mogą również zawierać inne typy zdefiniowane przez użytkownika. Tak więc struktura może zawierać inne struktury zagnieżdżone.
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)
}
W powyższym kodzie mamy strukturę RoleDetails jako część struktury User. Wyjściem będzie –
{Mohit 24 100 {Software Engineer Transport}}
Jeśli chcesz uzyskać dostęp do szczegółów roli, możesz to zrobić za pomocą tego samego operatora kropki –
użytkownik.rolaSzczegóły.pozycja
Równość struktury
Dwie struktury są równe, jeśli każde z ich pól jest równe (zarówno wbudowane, jak i zdefiniowane przez użytkownika), ale nie wszystkie typy danych są porównywalne. (mapa nie jest bezpośrednio porównywalna). Zobaczmy przykład demonstrujący równość.
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")
}
}
Puste i zerowe struktury wartości są równe. Kolejność pól nie ma znaczenia, w zasadzie każde pole powinno pasować dla równości. Dane wyjściowe dla powyższego kodu będą miały postać –
user1 and user2 are equal user1 and user3 are not equal
Wniosek
Wspaniały!
Teraz jesteś gotowy do użycia struktur w golangu. Omówiliśmy wszystkie podstawy, takie jak deklaracja, inicjalizacja i dostęp do pól struktury. Przyjrzeliśmy się również, jak porównać dwie struktury, a nawet zaimplementowaliśmy strukturę zagnieżdżoną. Oto kilka zasobów, aby dowiedzieć się więcej o strukturach –
Jest dużo więcej do nauczenia się o strukturach, ale na razie to dobry początek. Mam nadzieję, że nauczyłeś się czegoś nowego!
Eksploruj dalej. Ucz się!