Struktury v Golangu

Struktury v Golangu jsou jedním z nejpoužívanějších a způsobem, jak vytvářet uživatelsky definované typy.

V tomto budu pokrývat všechny základy o strukturách a jejich použití ve vašich go programech na několika příkladech.

Začněme!

Úvod

A strukturovat je kolekce více datových polí s jejich definovanými datovými typy seskupenými dohromady. Jsou užitečné pro seskupování dat do vlastních záznamů. Struktura se skládá z vestavěných i uživatelem definovaných typů (samotná struktura je typ definovaný uživatelem).

Struktury v Golangu jsou proměnlivé, tj. mohou být modifikovány v průběhu programu.

Struktury pomáhají zlepšit celkovou kvalitu kódu tím, že nám umožňují vytvářet a předávat složité datové struktury napříč více moduly. Představte si předání 10 parametrů do funkce, brzy vám uteče kód. To je přesně důvod, proč jsou struktury užitečné, nyní místo 10 parametrů jednoduše předáte této funkci jedinou strukturu.

Struktura je deklarována pomocí dvou klíčových slov – typ a strukturovat. Je zabalena do složených závorek (stejně jako třídy v jazyce Java) – která obsahuje sadu polí, která mají definovaný typ a identifikátor (název). Podrobnosti implementace probereme v další části.

Pokud pocházíte z objektově orientovaného programování (OOP), můžete si struct představit jako třídu, ale bez dědičnosti.

Deklarace struktur

Nyní, když chápete, co je struktura a proč se používá, je čas naučit se deklarovat struktury. Základní kostra struktury vypadá takto –

type name_of_struct struct { 
     field1 data_type_field1 
     field2 data_type_field2 
 }

Zde jsou typ a struktura klíčová slova, zatímco struktura obsahuje více polí s jejich definovaným datovým typem.

  Jak se připravit na Halloween v 'Animal Crossing: New Horizons'

Podívejme se na příklad –

package main

import (
	"fmt"
)

type User struct {
	name        string
	age         int
	bankBalance float32
}

func main() {
	var user User
	fmt.Println(user)
}

Zde definujeme uživatelskou strukturu, která se skládá z polí string, int a float32. V main() deklarujeme naši strukturu jako uživatelskou a vytiskneme ji! Výstup, který dostáváme, je nulová/prázdná hodnota struct, protože jsme ji ještě neinicializovali! The nulová hodnota je v podstatě nulová hodnota každého pole.

{ 0 0}

Inicializace struktur

V předchozí části jsme se naučili, jak deklarovat struktury. Nyní bychom jim chtěli inicializovat nebo přiřadit hodnoty. Podívejte se na kód níže, jak to děláme –

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)
}

Samotný kód vysvětluje, jak inicializujeme dvě struktury s názvy polí a bez nich. Zde bude výstupem –

{Mohit 24 100}
 {Nidhi 21 1000}

Pokud ve výše uvedeném případě není jedno z polí inicializováno, má toto pole výchozí hodnotu nula.

user1 := User{
	name:        "Mohit",
	age:         24,
}

 // Output - { Mohit 24 0.0 }

Existuje ještě jeden způsob, jak vytvořit struktury pomocí nového klíčového slova. Na to, jak jej používat, se podíváme v další části.

Přístup k polím struktury

Nyní víme, jak vytvářet a inicializovat struktury, podívejme se, jak přistupovat k polím struktury. Za tímto účelem nám Golang poskytuje operátor tečky. Pokračujeme v předchozím příkladu, zpřístupníme pole jména a věku a vytiskneme 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)
}

Zde používáme struct_name.field_name pro přístup k polím ve struktuře. Výstupem výše uvedeného kódu bude –

Mohit
 24
 100

Jak již bylo zmíněno dříve, můžeme vytvářet struktury s novým klíčovým slovem. Podívejme se jak –

user := new(User)
 user.name = "Mohit"
 user.age = 24
 user.bankBalance = 100.0

 fmt.Println(user)

 // Output - &{Mohit 24 100}

Klíčové slovo new vrátí ukazatel na inicializovanou strukturu. V Golangu nemusíte explicitně dereferencovat ukazatel, ale fmt.Println(*user) by vedl ke stejnému výstupu.

  Vytvářejte kurzy založené na kohortách na těchto 11 platformách

Vnořené struktury

Struktury v golangu mohou obsahovat i další uživatelem definované typy. Struktura tedy může obsahovat další vnořené struktury.

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)
}

Ve výše uvedeném kódu máme strukturu RoleDetails jako součást uživatelské struktury. Výstupem bude –

{Mohit 24 100 {Software Engineer Transport}}

Pokud chcete získat přístup k detailům role, můžete to udělat pomocí stejného operátoru tečky –

user.roleDetails.position

Rovnost struktury

Dvě struktury jsou stejné, pokud je každé z polí, které mají, stejné (vestavěné i uživatelem definované), ale ne všechny datové typy jsou srovnatelné. (mapa není přímo srovnatelná). Podívejme se na příklad pro demonstraci rovnosti.

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")
	}
}

Prázdné a nulové struktury jsou stejné. Na pořadí polí nezáleží, v zásadě by každé pole mělo odpovídat rovnosti. Výstup pro kód výše bude –

user1 and user2 are equal
user1 and user3 are not equal

Závěr

Úžasný!

  Samsung Galaxy S20: Jak úplně zakázat Bixby

Nyní jste připraveni používat struktury v golangu. Pokryli jsme všechny základy, jako je deklarace, inicializace a přístup k polím struct. Podívali jsme se také na to, jak porovnat dvě struktury, a dokonce jsme implementovali vnořenou strukturu. Zde je několik zdrojů, kde se dozvíte více o strukturách –

O strukturách se lze dozvědět mnohem více, ale prozatím je to dobrý začátek. Doufám, že jste se naučili něco nového!

Pokračujte ve zkoumání. Stále se uč!

x