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ę!