Příklady generických léků Golang

Priklady Generickych Leku Golang



Generická funkce Golang umožňuje vytvořit opakovaně použitelný kód, který je typově bezpečný a kompatibilní s širokou škálou typů. Naštěstí přidání generik do Go otevírá nové cesty pro opětovné použití kódu a flexibilitu. Nejnovější verze Golang s sebou přináší vysoce očekávanou podporu pro generika.

Ještě důležitější je, že generika zachovávají silnou typovou bezpečnost Go, která umožňuje statickou kontrolu typu v době kompilace a zajišťuje správnost typu. Poskytují standardizované zpracování chyb v rámci generického kódu, což zlepšuje přehlednost a udržovatelnost. Navíc poskytují standardizované zpracování chyb v rámci generického kódu, což zlepšuje přehlednost a udržovatelnost. V tomto příspěvku prozkoumáme několik generických aplikací a příkladů Go v reálném světě.

Příklad 1: Použití obecné funkce Golang

Jedním z primárních případů použití pro generika je vytváření funkcí, které mohou fungovat na různých typech. Zde uvádíme jeden z příkladů, kde je použita obecná obvodová funkce.







balík hlavní
import 'fmt'
func obvod [ r int | plovák32 ]( poloměr r ) {
C := 3 * 2 * poloměr
fmt . Println ( 'Obecný obvod je:' , C )
}
func hlavní () {
byl r1 int = 7
byl r2 plovák32 = 7 . 5
obvod ( r1 )
obvod ( r2 )
}

Na začátku předchozího kódu řádek importuje balíček „fmt“, který poskytuje funkce pro formátované I/O, včetně tisku výstupu na konzolu. Poté definujeme obecnou funkci s názvem „obvod“, která přebírá poloměr parametru obecného typu „r“, což může být buď „int“ nebo „float32“. Uvnitř funkce vypočítá obvod vynásobením poloměru konstantní hodnotou „3“ a následným vynásobením „2“. Nakonec vytiskne vypočítaný obvod pomocí „fmt.Println“.



Dále máme hlavní funkci, kde jsou dvě proměnné, r1 a r2, deklarovány a přiřazeny s hodnotami 7 a 7,5. Poté je funkce „obvod“ vyvolána dvakrát a jako argumenty se předají r1 a r2.



Výstup zobrazí výpočet vytištěním obvodů kruhů v následujícím formátu:





Příklad 2:  Použití obecného rozhraní Golang

Navíc nám generika Golang pomáhají s jejich rozhraními. Rozhraní v Go jsou zásadním nástrojem pro usnadnění opětovného použití kódu a polymorfismu. Tím, že jim generika umožňují fungovat s mnoha typy, zvyšují výkon rozhraní. Níže je uveden zdrojový kód generického rozhraní Golang:



balík hlavní
import 'fmt'
typ EmpAge rozhraní {
int64 | int32 | plovák32 | plovák64
}
func newGenericFunc [ věk Věk ]( emp_Age age ) {
val := int ( emp_Age ) + 1
fmt . Println ( val )
}
func hlavní () {
fmt . Println ( 'Věk zaměstnanců' )
byl Věk1 int64 = 24
byl Věk 2 plovák64 = 25 . 5
newGenericFunc ( Věk1 )
newGenericFunc ( Věk 2 )
}

V předchozím zdrojovém kódu jsme definovali rozhraní s názvem „EmpAge“, které specifikuje možné typy pro věk zaměstnance. Rozhraní zahrnuje typy int64, int32, float32 a float64. Toto rozhraní umožňuje „obecné“ funkci přijmout kterýkoli z těchto typů jako argument. Poté použijeme generickou funkci nazvanou newGenericFunc, která přebírá parametr emp_Age obecného typu věku, což může být jakýkoli typ, který vyhovuje rozhraní EmpAge. Uvnitř funkce převede emp_Age na int a zvýší jej o 1, jak je znázorněno.

Dále deklarujeme dvě proměnné, Věk1 a Věk2, a přiřadíme jim hodnoty 24 a 25,5 v hlavní funkci. Poté jsou Age1 a Age2 předány jako parametry funkci newGenericFunc, která se provede dvakrát. Tím se věk zvýší o 1 a vygenerují se aktualizované hodnoty.

Výstup, který je získán v následujícím textu, jsou věky z obecné funkce, která využívá rozhraní:

Příklad 3: Použití obecné datové struktury Golang

Kromě toho nám Go generics také dává možnost vytvářet obecné datové struktury, jako jsou zásobníky, fronty a propojené seznamy. Zvažte implementaci generického zásobníku v následujícím:

import 'fmt'
typ Zásobník [ T žádné ] [] T
func ( Svatý * Zásobník [ T ]) TAM ( položka T ) {
Svatý = připojit ( * Svatý , položka )
}
func ( Svatý * Zásobník [ T ]) Pop () T {
-li jen ( * Svatý ) == 0 {
panika ( 'Nic v zásobníku' )
}
index := jen ( * Svatý ) - 1
položka := ( * Svatý )[ index ]
* Svatý = ( * Svatý )[: index ]
vrátit se položka
}
func hlavní () {
zásobník := Nový ( Zásobník [ int ])
zásobník . TAM ( 1 )
zásobník . TAM ( 2 )
zásobník . TAM ( 3 )
fmt . Println ( zásobník . Pop ())
fmt . Println ( zásobník . Pop ())
fmt . Println ( zásobník . Pop ())
}

V předchozím kódu je definován obecný typ s názvem „Zásobník“, který představuje zásobník. Zástupný symbol „T“ umožňuje, aby stoh obsahoval prvky jakéhokoli typu. Typ „Stack“ je implementován jako řez prvků typu „T“. Zde jsou pro typ „Stack“ nasazeny dvě funkce: „Push“ a „Pop“. Funkce Push() je zodpovědná za přidávání prvků do zásobníku. Vezme položku argumentu typu „T“ a připojí ji k základnímu řezu pomocí funkce append().

Zatímco funkce Pop() vezme počáteční komponentu ze zásobníku a vrátí ji, nejprve určí, zda je zásobník prázdný, vyhodnocením velikosti spodního řezu. Pokud se zásobník zdá být prázdný, dojde k panice a odešle se upozornění o chybě. V opačném případě načte poslední prvek z řezu, odstraní jej ze zásobníku rozříznutím řezu až k předposlednímu prvku a vrátí odstraněnou položku.

Dále je vytvořen nový zásobník celých čísel pomocí syntaxe Stack[int] v rámci hlavní funkce tohoto kódu. Poté se třikrát zavolá metoda „Push“, aby se do zásobníku přidala celá čísla 1, 2 a 3. Metoda „Pop“ je však následně zavolána třikrát, aby se prvky načetly a vytiskly ze zásobníku.

Následující výstup indikuje, že prvky jsou odstraněny ze zásobníku v opačném pořadí:

Příklad 4: Použití obecných omezení Golang

Go také nabízí vlastní omezení, která umožňují velkou flexibilitu a definují specifické požadavky na generické konstrukce na základě jejich aplikačních potřeb. Kód vlastních obecných omezení je pro ukázku uveden v následujícím textu:

balík hlavní
import 'fmt'
typ Číslice rozhraní {
int64 | plovák64
}
func hlavní () {
FloatValue := [] plovák64 { 2 . 0 , 4 . 0 , 6 . 0 , 8 . 0 , 10 . 0 }
IntegerValue := [] int64 { 2 , 4 , 6 , 8 , 10 }
součet1 := genericSum ( FloatValue )
součet2 := genericSum ( IntegerValue
fmt . Println ( 'Součet float64:' , součet1 )
fmt . Println ( 'Součet int64:' , součet2 )

}
func genericSum [ n Číslice ]( čísla [] n ) n {
byl jsem n
pro _ , na jednom := rozsah čísla {
součet += na jednom
}
vrátit se součet
}

V předchozím zdrojovém kódu definujeme rozhraní Numerics pomocí metody „Sum“. Poté vytvoříme dva vlastní typy, „FloatValue“ a „IntegerValue“, které implementují rozhraní Numerics poskytnutím příslušných metod „Sum“. Funkce genericSum je nyní schopna přijímat řezy jakéhokoli typu, který vyhovuje rozhraní Numerics. Uvnitř funkce iterujeme přes prvky a zavoláme metodu „Sum“ pro výpočet součtu. Nakonec v hlavní funkci vytvoříme řezy FloatValue a IntegerValue a předáme je funkci genericSum(), která správně vypočítá součet prvků v každém řezu.

Očekávaný výstup je nyní viditelný na následující obrazovce:

Závěr

Prozkoumali jsme některé praktické příklady generik Go, které zahrnují vytvoření obecné datové struktury a generické funkce, definování generického rozhraní a použití omezení vlastního typu. Tyto příklady demonstrují sílu a flexibilitu, kterou generika přinášejí do programovacího jazyka Go. Všimněte si, že generování generického kódu během kompilace zajišťuje efektivní binární velikost a dobu kompilace.