Struktury w Golang

Udostępnij teraz w social media:

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!

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.

  Jak ustawić limit czasu aplikacji na iPhonie i iPadzie

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.

  Wprowadzenie do SNMP dla początkujących

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!

  15 najlepszych motywów Shopify dla Twojej witryny e-commerce

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

x