Halimbawa 1: Golang Empty Interface
Magsimula sa walang laman na interface{} na tinutukoy bilang interface sa Go. Ito ay nagpapahiwatig ng isang uri na maaaring mag-imbak ng anumang uri ng halaga. Ang sumusunod ay ang source code para sa walang laman na interface sa Go:
pakete pangunahingangkat 'fmt'
uri MarksCalculator interface {}
func pangunahing () {
ay m MarksCalculator
fmt . Println ( m )
}
Dito, ibinibigay namin ang code kung saan ang interface ng 'MarksCalculator' ay walang anumang tinukoy na mga lagda ng pamamaraan dahil ito ay walang laman. Bilang resulta, hindi ito nagbibigay ng anumang functionality. Susunod, mayroon kaming pangunahing() function ng walang laman na interface na ito kung saan ang isang variable na 'm' ng uri ng MarksCalculator ay idineklara. Dahil ang interface ay walang laman, ang 'm' ay maaaring magkaroon ng anumang halaga ng anumang uri. Sa kasong ito, ang 'm' ay hindi nasimulan, kaya ito ay may zero na halaga para sa uri nito na 'nil' para sa mga interface. Kapag na-print ang 'm' gamit ang 'fmt.Println' naglalabas ito ng 'nil' sa console.
Ang output na nakuha ay 'nil' tulad ng inaasahan mula sa nakaraang source code:
Halimbawa 2: Pagpapatupad ng Interface ng Golang
Ipinapakita ng seksyong ito ang pagpapatupad ng interface ng Golang. Ang isang uri ay dapat mag-alok ng pagpapatupad para sa bawat isa sa tinukoy na paraan sa isang interface upang maipatupad ito sa Go. Ang sumusunod ay ang ibinigay na source code para sa pagpapatupad ng interface:
pakete pangunahing
angkat (
'fmt'
)
uri Mga patinig interface {
SearchVowels () [] rune
}
uri MyStr string
func ( st MyStr ) SearchVowels () [] rune {
ay mga patinig [] rune
para sa _ , rune := saklaw st {
kung rune == 'a' || rune == 'Ito ay' || rune == 'ako' || rune == 'O' || rune == 'sa' {
mga patinig = dugtungan ( mga patinig , rune )
}
}
bumalik mga patinig
}
func pangunahing () {
BagongString := MyStr ( 'Mga Interface ng GoLang' )
ay v1 Mga Patinig
v1 = BagongString
fmt . Printf ( 'Ang mga patinig ay %c' , v1 . SearchVowels ())
}
Dito, tinutukoy ng code ang isang interface na pinangalanang 'Vowels' na tumutukoy sa isang paraan SearchVowels() na nagbabalik ng slice ng rune(type int32). Ang isang interface ay nagbibigay-daan sa anumang uri na nagpapatupad ng pamamaraang ito na lagda upang maitalaga sa isang variable ng uri ng interface. Pagkatapos, idineklara ang isang bagong uri ng 'MyStr' na isang alias para sa pinagbabatayan na uri ng string. Nangangahulugan ito na ang 'MyStr' ay nagmamana ng lahat ng mga pamamaraan ng string ngunit isang natatanging uri.
Pagkatapos nito, ipinatupad namin ang paraan ng SearchVowels() para sa uri ng 'MyStr'. Ini-scan ng pamamaraang ito ang input string na character ayon sa karakter at sinusuri kung ang bawat karakter ay isang patinig (“a”, “e”, “i”, “o”, o “u”). Kung ang isang karakter ay isang patinig, ito ay idinagdag sa hiwa ng patinig.
Sa loob ng main() function, isang variable na “NewString” ng uri ng “MyStr” ang ginawa gamit ang value ng “GoLang Interfaces”. Susunod, idineklara ang isang variable na 'v1' ng uri ng 'Vowels'. Dahil ipinapatupad ng 'MyStr' ang paraan ng SearchVowels() na tinukoy sa interface ng 'Vowels', ang 'NewString' ay maaaring italaga sa 'v1'.
Ipinapakita ng output ang lahat ng hanay ng mga patinig na matatagpuan sa tinukoy na string:
Halimbawa 3: Golang Stringer Interface
Bukod pa rito, ang Golang ay may paunang natukoy na interface na 'Stringer' sa package na 'fmt'. Nagbibigay-daan ito sa isang custom na uri na kontrolin ang representasyon ng string nito kapag na-format gamit ang '%v' na pandiwa sa mga function ng pag-print ng package na 'fmt'. Ang sumusunod ay ang halimbawang code para sa stringer interface ng Go:
pakete pangunahingangkat (
'fmt'
)
uri Mag-aaral struct {
Pangalan string
Degree string
}
func ( s Mag-aaral ) String () string {
bumalik fmt . Sprintf ( 'Ang %s ay isang(n) %s' , s . Pangalan , s . Degree )
}
func pangunahing () {
s1 := Mag-aaral { 'Elena Gilbert' , 'Computer science' }
s2 := Mag-aaral { 'Caroline Candice' , 'BBA' }
fmt . Println ( s1 )
fmt . Println ( s2 )
}
Dito, unang ini-import ng code ang kinakailangang package na 'fmt' para i-print sa console. Pagkatapos, tinukoy namin ang isang uri ng istruktura na 'Mag-aaral' na may dalawang patlang: 'Pangalan' at 'Degree'. Ang istrukturang ito ay kumakatawan sa impormasyon ng isang mag-aaral. Dagdag pa, ang isang String() na pamamaraan para sa uri ng 'Mag-aaral' ay nilikha. Ang pamamaraang ito ay may tatanggap ng uri ng 'Mag-aaral' at nagbabalik ng isang string. Ang pamamaraang 'String()' ay isang espesyal na paraan sa Go na ginagamit upang i-customize ang representasyon ng string ng isang bagay kapag ito ay naka-print. Sa kasong ito, ang paraan ng 'String()' ay nag-format at nagbabalik ng string na kinabibilangan ng pangalan at degree ng mag-aaral.
Susunod, mayroon kaming main() function kung saan ang dalawang variable, s1 at s2 ng uri ng 'Mag-aaral', ay idineklara at sinisimulan sa impormasyon ng mag-aaral. Panghuli, ginagamit ng code ang function na fmt.Println() para i-print ang mga value ng s1 at s2. Dahil ang String() na paraan ay tinukoy para sa uri ng 'Mag-aaral', awtomatikong tinatawagan ni Go ang pamamaraang ito kapag nagpi-print ng bagay na 'Mag-aaral'. Ang String() method ay nagfo-format ng impormasyon ng mag-aaral gamit ang 'fmt.Sprintf()' function at ibinabalik ang na-format na string.
Ang sumusunod na output ay nagpi-print ng object ng 'Mag-aaral' na uri ng stringer interface:
Halimbawa 4: Golang Type Switch Interface
Pagkatapos ay darating ang uri ng switch interface ng Go. Ang type switch ay isang control structure na nagbibigay-daan sa amin na siyasatin ang dynamic na uri ng isang interface value. Sundin ang source code ng type switch interface:
pakete pangunahingangkat 'fmt
func MyFunction(F1 interface{}) {
switch F1.(uri) {
case int:
fmt.Println(' Uri : int , Halaga : ', F1.(ikaw))
string ng kaso:
fmt.Println(' \nI-type : string , Halaga : ', F1.(string))
kaso float64:
fmt.Println(' \nI-type : lumutang64 , Halaga : ', F1.(float64))
default:
fmt.Println(' \nHindi wasto ang uri ')
}
}
func main() {
MyFunction(' Tutorial sa Mga Interface ng Golang ')
MyFunction(89.7)
MyFunction(totoo)
}
Dito, tinutukoy ng ibinigay na code ang isang function na 'MyFunction' na kumukuha ng parameter na 'F1' ng uri ng 'interface{}'. Ito ay nagpapahiwatig na ang 'F1' ay maaaring tumanggap ng isang halaga ng anumang uri. Sa loob ng function, ginagamit ang switch statement na may 'F1.(type)' upang suriin ang uri ng value na ipinapasa sa 'MyFunction'. Ang '.(type)' na syntax ay ginagamit sa isang uri ng switch upang makuha ang pinagbabatayan na dynamic na uri ng isang halaga ng interface. Tandaan na ang mga switch case dito ay humahawak ng tatlong partikular na uri: 'int', 'string', at 'float64'. Kung ang uri ng 'F1' ay tumutugma sa isa sa mga kasong ito. Ito ay nagpi-print ng kaukulang uri at halaga gamit ang mga uri ng assertion (F1.(int), F1.(string), F1.(float64)). Kung ang uri ng 'F1' ay hindi tumutugma sa alinman sa mga tinukoy na kaso, ang default na kaso ay isasagawa na nagpi-print ng 'Uri ay hindi wasto.'
Pagkatapos noon, sa loob ng main() function, ang 'MyFunction' ay tinatawag na tatlong beses na may iba't ibang value: isang string, isang float64, at isang Boolean (na hindi pinangangasiwaan sa switch statement).
Ang output ay nagpapakita ng pagpapakita ng switch interface na may mga uri ng assertion:
Halimbawa 5: Golang Maramihang Interface
Bukod dito, nag-aalok ang Go ng maraming interface na nagbibigay-daan dito na magbigay ng iba't ibang hanay ng mga pag-uugali depende sa konteksto. Ang feature na ito ay tinatawag na 'multiple interfaces' o 'interface composition'. Ipinapakita ng sumusunod na code ang pagpapatupad ng maramihang mga interface:
pakete pangunahingangkat 'fmt'
uri mga ibon interface {
huminga ()
lumipad ()
}
uri mga ibon interface {
magpakain ()
}
uri saan struct {
edad int
}
func ( d saan ) huminga () {
fmt . Println ( 'huminga ang kalapati' )
}
func ( d saan ) lumipad () {
fmt . Println ( 'Lumipad ang kalapati' )
}
func ( d saan ) magpakain () {
fmt . Println ( 'Ang kalapati ay nag-aalaga ng mga sanggol' )
}
func pangunahing () {
ay b mga ibon
d := saan {}
b = d
b . huminga ()
b . lumipad ()
ay isang ibon
a = d
a . magpakain ()
}
Dito, tinukoy namin ang dalawang interface: 'mga ibon' at 'mga avian'. Ang interface ng 'birds' ay nagdedeklara ng dalawang pamamaraan: breathe() at fly(). Habang ang 'avians' na interface ay nagdedeklara ng feed() na paraan. Pagkatapos, ang istraktura ng 'kalapati' ay nagpapatupad ng lahat ng mga pamamaraan ng parehong 'mga ibon' at 'mga avian' na mga interface. Nagbibigay ito ng mga pagpapatupad para sa breathe(), fly(), at feed().
Susunod, ipinapahayag namin ang variable na 'b' ng uri ng 'mga ibon' sa loob ng pangunahing() function. Ang isang halimbawa ng 'kalapati' ay ginawa at itinalaga sa 'b' gamit ang b = d na takdang-aralin. Habang ipinapatupad ng 'kalapati' ang lahat ng mga pamamaraan ng interface ng 'mga ibon', ang takdang-aralin na ito ay wasto.
Pagkatapos, ang breathe() at fly() na mga pamamaraan ay tinatawag sa 'b' na nasa 'birds' type. Katulad nito, ang isang variable na 'a' ng uri ng 'mga avian' ay idineklara at itinalaga kasama ang 'kalapati' na halimbawa ng 'd'. Dahil ipinapatupad ng 'dove' ang paraan ng feed() na tinukoy sa interface ng 'mga avian', valid din ang takdang-aralin na ito. Ang feed() na paraan ay tinatawag sa 'a' na 'avians' na uri. Habang hawak ng 'a' ang instance na 'dove', ang feed() method na ipinapatupad ng 'dove' ay isinasagawa.
Ipinapakita ng output na ang mga pamamaraan ng mga interface ay naisakatuparan nang tama:
Konklusyon
Natutunan namin ang mga pangunahing kaalaman ng mga interface ng Go at nagbigay kami ng mga praktikal na halimbawa upang ilarawan ang kanilang paggamit. Sa pamamagitan ng pagtukoy sa mga interface at pagpapatupad ng mga ito sa iba't ibang uri, maaari tayong lumikha ng mga nababaluktot at napapalawak na mga programa.