Co ważniejsze, generyczne zachowują silne bezpieczeństwo typów Go, które umożliwia statyczne sprawdzanie typów w czasie kompilacji i zapewnia poprawność typów. Zapewniają znormalizowaną obsługę błędów w kodzie ogólnym, co poprawia przejrzystość i łatwość konserwacji. Ponadto zapewniają znormalizowaną obsługę błędów w kodzie ogólnym, co poprawia przejrzystość i łatwość konserwacji. W tym poście przyjrzymy się kilku rzeczywistym generycznym zastosowaniom Go i ich przykładom.
Przykład 1: Używanie funkcji ogólnej Golanga
Jednym z podstawowych przypadków użycia generycznych jest tworzenie funkcji, które mogą działać na różnych typach. Tutaj idziemy z jednym z przykładów, w których używana jest ogólna funkcja obwodu.
pakiet główny
import 'fmt'
funkcja obwód [ R int | pływak32 ]( promień r ) {
C := 3 * 2 * promień
fmt . Drukuj ln ( „Ogólny obwód to:” , C )
}
funkcja główny () {
był r1 int = 7
był r2 pływak32 = 7 . 5
obwód ( r1 )
obwód ( r2 )
}
Na początku poprzedniego kodu linia importuje pakiet „fmt”, który udostępnia funkcje dla sformatowanych operacji wejścia-wyjścia, w tym drukowania danych wyjściowych na konsoli. Następnie definiujemy ogólną funkcję o nazwie „obwód”, która przyjmuje promień parametru ogólnego typu „r”, którym może być „int” lub „float32”. Wewnątrz funkcji oblicza obwód, mnożąc promień przez stałą wartość „3”, a następnie mnożąc go przez „2”. Na koniec drukuje obliczony obwód za pomocą „fmt.Println”.
Następnie mamy główną funkcję, w której deklarowane są dwie zmienne r1 i r2, którym przypisuje się odpowiednio wartości 7 i 7,5. Następnie funkcja „obwód” jest wywoływana dwukrotnie, przekazując r1 i r2 jako argumenty.
Dane wyjściowe wyświetlają obliczenie poprzez wydrukowanie obwodów okręgów w następujący sposób:
Przykład 2: Korzystanie z ogólnego interfejsu Golang
Co więcej, leki generyczne Golang pomagają nam w swoich interfejsach. Interfejsy w Go są niezbędnym narzędziem ułatwiającym ponowne użycie kodu i polimorfizm. Umożliwiając im działanie z wieloma typami, typy ogólne zwiększają moc interfejsów. Poniżej znajduje się kod źródłowy ogólnego interfejsu Golang:
pakiet główny
import 'fmt'
typ EmpAge interfejs {
int64 | int32 | pływak32 | pływak64
}
funkcja nowaOgólnaFunkcja [ wiek Wiek ]( emp_Age wiek ) {
wartość := int ( emp_Wiek ) + 1
fmt . Drukuj ln ( wartość )
}
funkcja główny () {
fmt . Drukuj ln ( „Wiek pracowników” )
był Wiek1 int64 = 24
był Wiek2 pływak64 = 25 . 5
nowaOgólnaFunkcja ( Wiek1 )
nowaOgólnaFunkcja ( Wiek2 )
}
W poprzednim kodzie źródłowym zdefiniowaliśmy interfejs o nazwie „EmpAge”, który określa możliwe typy dla wieku pracownika. Interfejs zawiera typy int64, int32, float32 i float64. Ten interfejs umożliwia funkcji „rodzajowej” akceptowanie dowolnego z tych typów jako argumentu. Następnie stosujemy ogólną funkcję o nazwie newGenericFunc, która przyjmuje parametr emp_Age ogólnego typu wieku, który może być dowolnym typem spełniającym wymagania interfejsu EmpAge. Wewnątrz funkcji konwertuje emp_Age na int i zwiększa ją o 1, jak pokazano.
Następnie deklarujemy dwie zmienne, Wiek1 i Wiek2, i przypisujemy odpowiednio wartości 24 i 25,5 w funkcji main. Następnie Age1 i Age2 są przekazywane jako parametry do funkcji newGenericFunc, która jest dwukrotnie wykonywana. W ten sposób wiek jest podnoszony o 1 i generowane są zaktualizowane wartości.
Dane wyjściowe, które są uzyskiwane w następujący sposób, to wieki z funkcji ogólnej, która wykorzystuje interfejs:
Przykład 3: Korzystanie z ogólnej struktury danych Golang
Co więcej, generyczne Go dają nam również możliwość budowania ogólnych struktur danych, takich jak stosy, kolejki i połączone listy. Rozważ implementację ogólnego stosu w następujący sposób:
import 'fmt'typ Stos [ T dowolny ] [] T
funkcja ( ul * Stos [ T ]) Naciskać ( pozycja T ) {
ul = dodać ( * ul , przedmiot )
}
funkcja ( ul * Stos [ T ]) Muzyka pop () T {
Jeśli tylko ( * ul ) == 0 {
panika ( „Nic w stosie” )
}
indeks := tylko ( * ul ) - 1
przedmiot := ( * ul )[ indeks ]
* ul = ( * ul )[: indeks ]
powrót przedmiot
}
funkcja główny () {
stos := nowy ( Stos [ int ])
stos . Naciskać ( 1 )
stos . Naciskać ( 2 )
stos . Naciskać ( 3 )
fmt . Drukuj ln ( stos . Muzyka pop ())
fmt . Drukuj ln ( stos . Muzyka pop ())
fmt . Drukuj ln ( stos . Muzyka pop ())
}
W poprzednim kodzie zdefiniowano typ ogólny o nazwie „Stos”, który reprezentuje stos. Symbol zastępczy „T” pozwala stosowi przechowywać elementy dowolnego typu. Typ „Stack” jest zaimplementowany jako wycinek elementów typu „T”. Tutaj wdrożono dwie funkcje dla typu „Stos”: „Push” i „Pop”. Funkcja Push() odpowiada za dodawanie elementów do stosu. Pobiera element argumentu typu „T” i dołącza go do podstawowego wycinka za pomocą funkcji append().
Podczas gdy funkcja Pop() pobiera początkowy składnik ze stosu i zwraca go, najpierw określa, czy stos jest pusty, oceniając rozmiar leżącego pod nim wycinka. Powiadomienie o błędzie jest wysyłane, jeśli stos wydaje się być pusty, co powoduje panikę. W przeciwnym razie pobiera ostatni element z wycinka, usuwa go ze stosu, dzieląc wycinek do przedostatniego elementu i zwraca usunięty element.
Następnie tworzony jest nowy stos liczb całkowitych przy użyciu składni Stack[int] w głównej funkcji tego kodu. Następnie trzykrotnie wywoływana jest metoda „Push” w celu dodania liczb całkowitych 1, 2 i 3 do stosu. Jednak metoda „Pop” jest wywoływana trzy razy, aby pobrać i wydrukować elementy ze stosu.
Poniższe dane wyjściowe wskazują, że elementy są usuwane ze stosu w odwrotnej kolejności:
Przykład 4: Używanie ogólnych ograniczeń Golanga
Go oferuje również niestandardowe ograniczenia, które zapewniają dużą elastyczność i definiują specyficzne wymagania dla ogólnych konstrukcji w oparciu o potrzeby ich aplikacji. Kod niestandardowych ograniczeń ogólnych jest przedstawiony poniżej w celu zademonstrowania:
pakiet głównyimport 'fmt'
typ Liczby interfejs {
int64 | pływak64
}
funkcja główny () {
Wartość zmiennoprzecinkowa := [] pływak64 { 2 . 0 , 4 . 0 , 6 . 0 , 8 . 0 , 10 . 0 }
Wartość całkowita := [] int64 { 2 , 4 , 6 , 8 , 10 }
suma1 := ogólna suma ( Wartość zmiennoprzecinkowa )
suma2 := ogólna suma ( Wartość całkowita
fmt . Drukuj ln ( 'Suma liczby float64 :' , suma1 )
fmt . Drukuj ln ( 'Suma int64 :' , suma2 )
}
funkcja ogólna suma [ n Cyfry ]( liczby [] N ) N {
był Jestem n
Do _ , na jednego := zakres liczby {
suma += na jednego
}
powrót suma
}
We wcześniejszym kodzie źródłowym interfejs Numerics definiujemy metodą „Sum”. Następnie tworzymy dwa typy niestandardowe, „FloatValue” i „IntegerValue”, które implementują interfejs numeryczny, udostępniając odpowiednie metody „Sum”. Funkcja genericSum jest teraz w stanie akceptować wycinki dowolnego typu, który spełnia wymagania interfejsu numerycznego. Wewnątrz funkcji iterujemy elementy i wywołujemy metodę „Sum”, aby obliczyć sumę. Na koniec, w funkcji main, tworzymy wycinki FloatValue i IntegerValue i przekazujemy je do funkcji genericSum(), która prawidłowo oblicza sumę elementów w każdym plasterku.
Oczekiwany wynik jest teraz widoczny na następującym ekranie:
Wniosek
Przyjrzeliśmy się kilku praktycznym przykładom generycznych Go, które obejmują tworzenie generycznej struktury danych i generycznej funkcji, zdefiniowanie generycznego interfejsu i użycie niestandardowego ograniczenia typu. Te przykłady demonstrują moc i elastyczność, jakie typy generyczne wnoszą do języka programowania Go. Należy zauważyć, że generowanie kodu ogólnego podczas kompilacji zapewnia efektywny rozmiar pliku binarnego i czas kompilacji.