Exemple 1: interfície buida Golang
Comenceu amb la interfície buida{} que es coneix com a interfície a Go. Indica un tipus que pot emmagatzemar qualsevol tipus de valor. El següent és el codi font de la interfície buida a Go:
paquet principalimportar 'fmt'
tipus Calculadora de marques interfície {}
func principal () {
era m MarksCalculator
fmt . Println ( m )
}
Aquí, proporcionem el codi on la interfície 'MarksCalculator' no té cap signatura de mètode especificada perquè està buida. Com a resultat, no ofereix cap funcionalitat. A continuació, tenim la funció main() d'aquesta interfície buida on es declara una variable 'm' de tipus MarksCalculator. Com que la interfície està buida, 'm' pot contenir qualsevol valor de qualsevol tipus. En aquest cas, 'm' no està inicialitzat, de manera que té un valor zero per al seu tipus, que és 'nul' per a les interfícies. Quan s'imprimeix 'm' amb 'fmt.Println', mostra 'nil' a la consola.
La sortida que es recupera és 'nul' com s'esperava del codi font anterior:
Exemple 2: Implementació de la interfície Golang
Aquesta secció demostra la implementació de la interfície Golang. Un tipus ha d'oferir la implementació de cadascun dels mètodes especificats en una interfície per implementar-lo a Go. El següent és el codi font per a la implementació de la interfície:
paquet principal
importar (
'fmt'
)
tipus Vocals interfície {
Cerca vocals () [] runa
}
tipus MyStr corda
func ( st MyStr ) Cerca vocals () [] runa {
era vocals [] runa
per _ , runa := rang st {
si runa == 'a' || runa == 'És' || runa == 'jo' || runa == 'O' || runa == 'en' {
vocals = adjuntar ( vocals , runa )
}
}
tornar vocals
}
func principal () {
NewString := MyStr ( 'Interfícies de GoLang' )
era v1 Vocals
v1 = NewString
fmt . Printf ( 'Les vocals són %c' , v1 . Cerca vocals ())
}
Aquí, el codi defineix una interfície anomenada 'Vowels' que especifica un únic mètode SearchVowels() que retorna una porció de la runa (tipus int32). Una interfície permet que qualsevol tipus que implementi aquesta signatura de mètode s'assigni a una variable del tipus d'interfície. A continuació, es declara un nou tipus 'MyStr' que és un àlies per a la cadena de tipus subjacent. Això vol dir que 'MyStr' hereta tots els mètodes de cadena però és un tipus diferent.
Després d'això, implementem el mètode SearchVowels() per al tipus 'MyStr'. Aquest mètode explora la cadena d'entrada caràcter per caràcter i comprova si cada caràcter és una vocal ('a', 'e', 'i', 'o' o 'u'). Si un caràcter és una vocal, s'afegeix a la secció vocal.
Dins de la funció main(), es crea una variable 'NewString' del tipus 'MyStr' amb el valor 'GoLang Interfaces'. A continuació, es declara una variable 'v1' de tipus 'Vocals'. Com que 'MyStr' implementa el mètode SearchVowels() que es defineix a la interfície 'Vowels', el 'NewString' es pot assignar a 'v1'.
La sortida mostra tota la matriu de vocals que es troben a la cadena especificada:
Exemple 3: interfície Golang Stringer
A més, Golang té la interfície 'Stringer' predefinida al paquet 'fmt'. Permet que un tipus personalitzat controli la seva representació de cadena quan es formatea amb el verb '%v' a les funcions d'impressió del paquet 'fmt'. El següent és el codi d'exemple per a la interfície stringer de Go:
paquet principalimportar (
'fmt'
)
tipus Estudiant estructura {
Nom corda
Grau corda
}
func ( s Estudiant ) Corda () corda {
tornar fmt . Sprintf ( '%s és un (n) %s' , s . Nom , s . Grau )
}
func principal () {
s1 := Estudiant { 'Elena Gilbert' , 'Ciències de la Computació' }
s2 := Estudiant { 'Caroline Candice' , 'BBA' }
fmt . Println ( s1 )
fmt . Println ( s2 )
}
Aquí, el codi importa primer el paquet necessari que és 'fmt' per imprimir a la consola. A continuació, definim un tipus d'estructura 'Estudiant' amb dos camps: 'Nom' i 'Grau'. Aquesta estructura representa la informació d'un estudiant. A més, es crea un mètode String() per al tipus 'Estudiant'. Aquest mètode té un receptor de tipus 'Estudiant' i retorna una cadena. El mètode 'String()' és un mètode especial a Go que s'utilitza per personalitzar la representació de cadena d'un objecte quan s'imprimeix. En aquest cas, el mètode 'String()' formatea i retorna una cadena que inclou el nom i la titulació de l'estudiant.
A continuació, tenim la funció main() on dues variables, s1 i s2 de tipus 'Estudiant', es declaren i s'inicialitzen amb la informació de l'estudiant. Finalment, el codi utilitza la funció fmt.Println() per imprimir els valors de s1 i s2. Com que el mètode String() està definit per al tipus 'Estudiant', Go crida automàticament aquest mètode quan imprimeix l'objecte 'Estudiant'. El mètode String() formatea la informació de l'estudiant mitjançant la funció 'fmt.Sprintf()' i retorna la cadena formatada.
La sortida següent imprimeix l'objecte del tipus 'Estudiant' de la interfície de cadena:
Exemple 4: Interfície d'interruptor tipus Golang
Després ve la interfície de canvi de tipus de Go. Un interruptor de tipus és una estructura de control que ens permet inspeccionar el tipus dinàmic d'un valor d'interfície. Seguiu el codi font del tipus d'interfície de commutació:
paquet principalimportar 'fmt
func La meva funció (interfície F1{}) {
interruptor F1.(tipus) {
cas int:
fmt.Println(' Tipus : int , Valor : ', F1.(tu))
cadena de majúscules:
fmt.Println(' \nEscriu : corda , Valor : ', F1.(cadena))
cas float64:
fmt.Println(' \nEscriu : flotar64 , Valor : ', F1.(float64))
per defecte:
fmt.Println(' \nEl tipus no és vàlid ')
}
}
funció principal() {
La meva funció(' Tutorial d'interfícies de Golang ')
La meva funció (89,7)
La meva funció (true)
}
Aquí, el codi proporcionat defineix una funció 'MyFunction' que pren un paràmetre 'F1' de tipus 'interfície{}'. Això indica que 'F1' pot acceptar un valor de qualsevol tipus. Dins de la funció, s'utilitza una instrucció switch amb 'F1.(tipus)' per comprovar el tipus del valor que es passa a 'MyFunction'. La sintaxi '.(tipus)' s'utilitza en un canvi de tipus per obtenir el tipus dinàmic subjacent d'un valor d'interfície. Tingueu en compte que els casos de commutació aquí gestionen tres tipus específics: 'int', 'string' i 'float64'. Si el tipus 'F1' coincideix amb un d'aquests casos. Imprimeix el tipus i el valor corresponents utilitzant les assercions de tipus (F1.(int), F1.(cadena), F1.(float64)). Si el tipus 'F1' no coincideix amb cap dels casos definits, s'executa el cas per defecte que imprimeix 'El tipus no és vàlid'.
Després, dins de la funció main(), 'MyFunction' es crida tres vegades amb valors diferents: una cadena, un float64 i un booleà (que no es gestiona a la instrucció switch).
La sortida mostra la demostració de la interfície del commutador amb les afirmacions de tipus:
Exemple 5: interfícies múltiples de Golang
A més, Go ofereix múltiples interfícies que li permeten proporcionar diferents conjunts de comportaments segons el context. Aquesta característica s'anomena 'interfícies múltiples' o 'composició de la interfície'. El codi següent mostra la implementació de múltiples interfícies:
paquet principalimportar 'fmt'
tipus ocells interfície {
respirar ()
volar ()
}
tipus aviars interfície {
alimentar ()
}
tipus On estructura {
edat int
}
func ( d on ) respirar () {
fmt . Println ( 'La coloma respira' )
}
func ( d on ) volar () {
fmt . Println ( 'Mosca de la coloma' )
}
func ( d on ) alimentar () {
fmt . Println ( 'La coloma alimenta els nadons' )
}
func principal () {
era b ocells
d := On {}
b = d
b . respirar ()
b . volar ()
era un aviar
a = d
a . alimentar ()
}
Aquí, definim dues interfícies: 'ocells' i 'aviaris'. La interfície 'ocells' declara dos mètodes: respirar () i volar (). Mentre que la interfície 'avians' declara el mètode feed(). Aleshores, l'estructura 'dove' implementa tots els mètodes de les interfícies 'ocells' i 'aviaris'. Proporciona les implementacions de breathe(), fly() i feed().
A continuació, declarem la variable 'b' del tipus 'ocells' dins de la funció main(). Es crea una instància d'una 'coloma' i s'assigna a 'b' mitjançant l'assignació b = d. Com que 'dove' implementa tots els mètodes de la interfície 'ocells', aquesta assignació és vàlida.
Aleshores, els mètodes breathe() i fly() s'anomenen a 'b', que és de tipus 'ocells'. De la mateixa manera, una variable “a” de tipus “aviaris” es declara i s'assigna amb la instància “dove” de “d”. Com que 'dove' implementa el mètode feed() que es defineix a la interfície 'avians', aquesta assignació també és vàlida. El mètode feed() es crida a 'a', que és de tipus 'avians'. Com que 'a' conté la instància 'dove', s'executa el mètode feed() que implementa el 'dove'.
La sortida mostra que els mètodes de les interfícies s'executen correctament:
Conclusió
Hem après els conceptes bàsics de les interfícies Go i hem proporcionat exemples pràctics per il·lustrar-ne l'ús. En definir interfícies i implementar-les amb diferents tipus, podem crear programes flexibles i extensibles.