Przykłady interfejsów Golang

Przyklady Interfejsow Golang



W Go zestaw sygnatur metod składa się z interfejsu. Określa grupę działań, które typ musi wykonać, aby określić, czy spełnia ten interfejs. Innymi słowy, interfejs określa metody, które musi mieć typ, ale nie dostarcza informacji o implementacji. Chociaż interfejsy Go zapewniają potężny mechanizm do osiągnięcia zachowania polimorficznego i napisania kodu wielokrotnego użytku. W tym poście przyjrzymy się idei interfejsów w Go i przedstawimy rzeczywiste przykłady pokazujące, jak z nich korzystać.

Przykład 1: Pusty interfejs Golanga

Rozpocznij od pustego interfejsu{}, który w Go jest nazywany interfejsem. Wskazuje typ, który może przechowywać dowolny rodzaj wartości. Poniżej znajduje się kod źródłowy pustego interfejsu w Go:

pakiet główny
import 'fmt'
typ Kalkulator znaków interfejs {}
funkcja główny () {
był m Marks Calculator
fmt . Drukuj ln ( M )
}

Tutaj podajemy kod, w którym interfejs „MarksCalculator” nie ma żadnych określonych sygnatur metod, ponieważ jest pusty. W rezultacie nie zapewnia żadnej funkcjonalności. Następnie mamy funkcję main() tego pustego interfejsu, w którym zadeklarowana jest zmienna „m” typu MarksCalculator. Ponieważ interfejs jest pusty, „m” może przechowywać dowolną wartość dowolnego typu. W tym przypadku „m” jest niezainicjowane, więc ma wartość zerową dla swojego typu, czyli „zero” dla interfejsów. Kiedy „m” jest drukowane za pomocą „fmt.Println”, wysyła „nil” do konsoli.







Pobrane dane wyjściowe są „zerowe”, zgodnie z oczekiwaniami z poprzedniego kodu źródłowego:





Przykład 2:  Implementacja interfejsu Golang

Ta sekcja demonstruje implementację interfejsu Golang. Typ musi oferować implementację dla każdej określonej metody w interfejsie, aby można było ją zaimplementować w Go. Poniżej podano kod źródłowy implementacji interfejsu:





pakiet główny
import (
'fmt'
)
typ samogłoski interfejs {
Wyszukaj samogłoski () [] runa
}
typ MojaStr strunowy
funkcja ( st MojaStr ) Wyszukaj samogłoski () [] runa {
był samogłoski [] runa
Do _ , runa := zakres ul {
Jeśli runa == 'A' || runa == 'To jest' || runa == 'I' || runa == „O” || runa == 'W' {
samogłoski = dodać ( samogłoski , runa )
}
}
powrót samogłoski
}

funkcja główny () {
Nowy ciąg := MojaStr ( „Interfejsy GoLang” )
był v1 Samogłoski
v1 = Nowy ciąg
fmt . Drukuj ( „Samogłoski to %c” , v1 . Wyszukaj samogłoski ())
}

Tutaj kod definiuje interfejs o nazwie „Vowels”, który określa pojedynczą metodę SearchVowels() zwracającą wycinek runy (typ int32). Interfejs umożliwia przypisanie dowolnego typu, który implementuje tę sygnaturę metody, do zmiennej typu interfejsu. Następnie deklarowany jest nowy typ „MyStr”, który jest aliasem dla podstawowego ciągu typu. Oznacza to, że „MyStr” dziedziczy wszystkie metody łańcucha, ale jest odrębnym typem.

Następnie implementujemy metodę SearchVowels() dla typu „MyStr”. Ta metoda skanuje ciąg znaków wejściowych znak po znaku i sprawdza, czy każdy znak jest samogłoską („a”, „e”, „i”, „o” lub „u”). Jeśli znak jest samogłoską, jest dołączany do wycinka samogłoski.



Wewnątrz funkcji main() tworzona jest zmienna „NewString” typu „MyStr” z wartością „GoLang Interfaces”. Następnie deklarowana jest zmienna „v1” typu „Vowels”. Ponieważ „MyStr” implementuje metodę SearchVowels() zdefiniowaną w interfejsie „Vowels”, „NewString” można przypisać do „v1”.

Dane wyjściowe wyświetlają całą tablicę samogłosek, które znajdują się w określonym łańcuchu:

Przykład 3: Interfejs Golang Stringer

Dodatkowo Golang posiada predefiniowany interfejs „Stringer” w pakiecie „fmt”. Pozwala niestandardowemu typowi kontrolować swoją reprezentację łańcuchową, gdy jest sformatowany za pomocą czasownika „%v” w funkcjach drukowania pakietu „fmt”. Poniżej znajduje się przykładowy kod interfejsu stringer w Go:

pakiet główny
import (
'fmt'
)
typ Student struktura {
Nazwa strunowy
Stopień strunowy
}
funkcja ( s Student ) Strunowy () strunowy {
powrót fmt . Sprintf ( '%s to (n) %s' , S . Nazwa , S . Stopień )
}
funkcja główny () {
s1 := Student { „Elena Gilbert” , 'Informatyka' }
s2 := Student { „Karolina Candice” , „BBA” }
fmt . Drukuj ln ( s1 )
fmt . Drukuj ln ( s2 )
}

Tutaj kod najpierw importuje niezbędny pakiet, którym jest „fmt”, aby wydrukować go na konsoli. Następnie definiujemy strukturę typu „Student” z dwoma polami: „Nazwa” i „Stopień”. Ta struktura reprezentuje informacje o uczniu. Ponadto tworzona jest metoda String() dla typu „Student”. Ta metoda ma odbiornik typu „Student” i zwraca ciąg znaków. Metoda „String()” to specjalna metoda w Go, która służy do dostosowywania reprezentacji łańcuchowej obiektu podczas jego drukowania. W tym przypadku metoda „String()” formatuje i zwraca ciąg zawierający imię i nazwisko studenta oraz stopień naukowy.

Następnie mamy funkcję main(), w której dwie zmienne, s1 i s2 typu „Student”, są deklarowane i inicjowane informacjami o uczniu. Na koniec kod używa funkcji fmt.Println() do drukowania wartości s1 i s2. Ponieważ metoda String() jest zdefiniowana dla typu „Student”, Go automatycznie wywołuje tę metodę podczas drukowania obiektu „Student”. Metoda String() formatuje informacje ucznia za pomocą funkcji „fmt.Sprintf()” i zwraca sformatowany ciąg znaków.

Poniższe wyjście drukuje obiekt typu „Student” interfejsu stringer:

Przykład 4: Interfejs przełącznika typu Golang

Następnie pojawia się interfejs przełącznika typu Go. Przełącznik typu to struktura kontrolna, która pozwala nam sprawdzić dynamiczny typ wartości interfejsu. Postępuj zgodnie z kodem źródłowym interfejsu przełącznika typu:

pakiet główny
import 'fmt
func MojaFunkcja(interfejs F1{}) {
przełącznik F1.(typ) {
przypadek int:
fmt.Println('
Typ : int , Wartość : ', F1.(ty))
ciąg przypadków:
fmt.Println('
\nWpisz : strunowy , Wartość : ', F1.(ciąg znaków))
przypadek float64:
fmt.Println('
\nWpisz : pływak64 , Wartość : ', F1.(float64))
domyślny:
fmt.Println('
\nTyp jest nieprawidłowy ')
}
}
func main() {
MojaFunkcja('
Samouczek dotyczący interfejsów Golang ')
MojaFunkcja(89.7)
MojaFunkcja(prawda)
}

Tutaj podany kod definiuje funkcję „MyFunction”, która przyjmuje parametr „F1” typu „interfejs{}”. Oznacza to, że „F1” może przyjąć wartość dowolnego typu. Wewnątrz funkcji używana jest instrukcja switch z „F1.(type)” w celu sprawdzenia typu wartości przekazywanej do „MyFunction”. Składnia „.(typ)” jest używana w przełączniku typu, aby uzyskać bazowy typ dynamiczny wartości interfejsu. Zwróć uwagę, że przypadki przełączników tutaj obsługują trzy określone typy: „int”, „string” i „float64”. Jeśli typ „F1” pasuje do jednego z tych przypadków. Drukuje odpowiedni typ i wartość przy użyciu asercji typu (F1.(int), F1.(string), F1.(float64)). Jeśli typ „F1” nie pasuje do żadnego ze zdefiniowanych przypadków, wykonywany jest przypadek domyślny, który wyświetla „Typ jest nieprawidłowy”.

Następnie w ramach funkcji main() trzykrotnie wywoływana jest funkcja „MyFunction” z różnymi wartościami: ciąg znaków, liczba zmiennoprzecinkowa64 i wartość logiczna (która nie jest obsługiwana w instrukcji switch).

Dane wyjściowe wyświetlają demonstrację interfejsu przełącznika z asercjami typu:

Przykład 5: Wiele interfejsów Golang

Co więcej, Go oferuje wiele interfejsów, które umożliwiają dostarczanie różnych zestawów zachowań w zależności od kontekstu. Ta funkcja jest nazywana „wieloma interfejsami” lub „kompozycją interfejsu”. Poniższy kod ilustruje implementację wielu interfejsów:

pakiet główny
import 'fmt'
typ ptaki interfejs {
oddychać ()
latać ()
}

typ ptaki interfejs {
karmić ()
}
typ Gdzie struktura {
wiek int
}
funkcja ( gdzie ) oddychać () {
fmt . Drukuj ln ( „Gołąb oddycha” )
}
funkcja ( gdzie ) latać () {
fmt . Drukuj ln ( „Gołąb latający” )
}
funkcja ( gdzie ) karmić () {
fmt . Drukuj ln ( „Gołębie wychowują dzieci” )
}
funkcja główny () {
był b ptaki
D := Gdzie {}
B = D
B . oddychać ()
B . latać ()
był ptactwo
A = D
A . karmić ()
}

Tutaj definiujemy dwa interfejsy: „ptaki” i „ptaki”. Interfejs „birds” deklaruje dwie metody: Breath() i fly(). Natomiast interfejs „avians” deklaruje metodę feed(). Następnie struktura „dove” implementuje wszystkie metody interfejsów „birds” i „avians”. Zapewnia implementacje funkcji Breath(), Fly() i Feed().

Następnie deklarujemy zmienną „b” typu „birds” w funkcji main(). Instancja „gołębicy” jest tworzona i przypisywana do „b” za pomocą przypisania b = d. Ponieważ „gołąb” implementuje wszystkie metody interfejsu „ptaki”, to przypisanie jest prawidłowe.

Następnie metody Breath() i Fly() są wywoływane na „b”, które jest typu „birds”. Podobnie, zmienna „a” typu „avians” jest deklarowana i przypisywana z instancją „d” „gołąb”. Ponieważ „dove” implementuje metodę feed() zdefiniowaną w interfejsie „avians”, to przypisanie jest również poprawne. Metoda feed() jest wywoływana na „a”, który jest typu „avians”. Ponieważ „a” przechowuje instancję „dove”, wykonywana jest metoda feed() zaimplementowana przez „dove”.

Dane wyjściowe pokazują, że metody interfejsów są wykonywane poprawnie:

Wniosek

Poznaliśmy podstawy interfejsów Go i przedstawiliśmy praktyczne przykłady ilustrujące ich użycie. Definiując interfejsy i implementując je różnymi typami, możemy tworzyć elastyczne i rozszerzalne programy.