Ejemplos de interfaces de Golang

Ejemplo 1: interfaz vacía de Golang

Comience con la interfaz vacía{} a la que se hace referencia como la interfaz en Go. Indica un tipo que puede almacenar cualquier tipo de valor. El siguiente es el código fuente de la interfaz vacía en Go:

Aquí, proporcionamos el código donde la interfaz 'MarksCalculator' no tiene ninguna firma de método especificada porque está vacía. Como resultado, no proporciona ninguna funcionalidad. A continuación tenemos la función main() de esta interfaz vacía donde se declara una variable “m” de tipo MarksCalculator. Dado que la interfaz está vacía, 'm' puede contener cualquier valor de cualquier tipo. En este caso, 'm' no está inicializado, por lo que tiene un valor cero para su tipo que es 'nil' para las interfaces. Cuando se imprime 'm' usando 'fmt.Println', se envía 'nil' a la consola.

La salida que se recupera es 'nula' como se esperaba del código fuente anterior:

Ejemplo 2: Implementación de la interfaz de Golang

Esta sección demuestra la implementación de la interfaz de Golang. Un tipo debe ofrecer la implementación de cada uno de los métodos especificados en una interfaz para poder implementarlo en Go. El siguiente es el código fuente dado para la implementación de la interfaz:

Aquí, el código define una interfaz llamada 'Vocales' que especifica un único método SearchVowels() que devuelve una porción de la runa (tipo int32). Una interfaz permite que cualquier tipo que implemente esta firma de método se asigne a una variable del tipo de interfaz. Luego, se declara un nuevo tipo 'MyStr' que es un alias para la cadena de tipo subyacente. Esto significa que 'MyStr' hereda todos los métodos de cadena pero es un tipo distinto.

Después de eso, implementamos el método SearchVowels() para el tipo “MyStr”. Este método escanea la cadena de entrada carácter por carácter y verifica si cada carácter es una vocal ('a', 'e', 'i', 'o' o 'u'). Si un carácter es una vocal, se agrega a la porción de vocal.

Dentro de la función main(), se crea una variable 'NewString' de tipo 'MyStr' con el valor 'GoLang Interfaces'. A continuación se declara una variable “v1” de tipo “Vocales”. Dado que 'MyStr' implementa el método SearchVowels() que se define en la interfaz 'Vowels', la 'NewString' se puede asignar a 'v1'.

La salida muestra toda la matriz de vocales que se encuentran en la cadena especificada:

Ejemplo 3: interfaz de larguero de Golang

Además, Golang tiene la interfaz 'Stringer' predefinida en el paquete 'fmt'. Permite que un tipo personalizado controle su representación de cadena cuando se formatea con el verbo '%v' en las funciones de impresión del paquete 'fmt'. El siguiente es el código de ejemplo para la interfaz de stringer de Go:

Aquí, el código primero importa el paquete necesario que es 'fmt' para imprimir en la consola. Luego, definimos una estructura tipo 'Estudiante' con dos campos: 'Nombre' y 'Título'. Esta estructura representa la información de un estudiante. Además, se crea un método String() para el tipo 'Estudiante'. Este método tiene un receptor de tipo 'Estudiante' y devuelve una cadena. El método 'String()' es un método especial en Go que se utiliza para personalizar la representación de cadena de un objeto cuando se imprime. En este caso, el método 'String()' formatea y devuelve una cadena que incluye el nombre y el título del estudiante.

A continuación tenemos la función main() donde dos variables, s1 y s2 de tipo “Estudiante”, son declaradas e inicializadas con información del estudiante. Por último, el código usa la función fmt.Println() para imprimir los valores de s1 y s2. Dado que el método String() está definido para el tipo 'Estudiante', Go automáticamente llama a este método cuando imprime el objeto 'Estudiante'. El método String() formatea la información del estudiante usando la función 'fmt.Sprintf()' y devuelve la cadena formateada.

El siguiente resultado imprime el objeto del tipo 'Estudiante' de la interfaz de stringer:

Ejemplo 4: Interfaz de interruptor de tipo Golang

Luego viene la interfaz de cambio de tipo de Go. Un cambio de tipo es una estructura de control que nos permite inspeccionar el tipo dinámico de un valor de interfaz. Siga el código fuente de la interfaz de cambio de tipo:

Aquí, el código proporcionado define una función 'MyFunction' que toma un parámetro 'F1' de tipo 'interface{}'. Esto indica que “F1” puede aceptar un valor de cualquier tipo. Dentro de la función, se usa una declaración de cambio con 'F1.(tipo)' para verificar el tipo del valor que se pasa a 'MiFunción'. La sintaxis “.(tipo)” se usa en un cambio de tipo para obtener el tipo dinámico subyacente de un valor de interfaz. Tenga en cuenta que los casos de cambio aquí manejan tres tipos específicos: 'int', 'string' y 'float64'. Si el tipo “F1” coincide con uno de estos casos. Imprime el tipo y el valor correspondiente utilizando las aserciones de tipo (F1.(int), F1.(string), F1.(float64)). Si el tipo 'F1' no coincide con ninguno de los casos definidos, se ejecuta el caso predeterminado que imprime 'El tipo no es válido'.

A partir de entonces, dentro de la función main(), se llama a 'MyFunction' tres veces con diferentes valores: una cadena, un float64 y un booleano (que no se maneja en la instrucción switch).

El resultado muestra la demostración de la interfaz del conmutador con las aserciones de tipo:

Ejemplo 5: interfaces múltiples de Golang

Además, Go ofrece múltiples interfaces que le permiten proporcionar diferentes conjuntos de comportamientos según el contexto. Esta función se denomina 'interfaces múltiples' o 'composición de interfaz'. El siguiente código demuestra la implementación de múltiples interfaces:

Aquí, definimos dos interfaces: 'pájaros' y 'aves'. La interfaz de 'pájaros' declara dos métodos: respirar () y volar (). Mientras que la interfaz 'avians' declara el método feed(). Luego, la estructura 'dove' implementa todos los métodos de las interfaces 'birds' y 'avians'. Proporciona las implementaciones para respirar(), volar() y alimentar().

A continuación, declaramos la variable “b” de tipo “pájaros” dentro de la función main(). Se crea una instancia de una 'paloma' y se asigna a 'b' usando la asignación b = d. Como “dove” implementa todos los métodos de la interfaz “birds”, esta asignación es válida.

Luego, los métodos respirar() y volar() se llaman en 'b', que es del tipo 'pájaros'. De manera similar, una variable “a” de tipo “avians” es declarada y asignada con la instancia “dove” de “d”. Dado que “dove” implementa el método feed() que se define en la interfaz “avians”, esta asignación también es válida. El método feed() se llama en 'a', que es de tipo 'avians'. Como “a” contiene la instancia de “paloma”, se ejecuta el método feed() que implementa la “paloma”.

El resultado muestra que los métodos de las interfaces se ejecutan correctamente:

Conclusión

Aprendimos los conceptos básicos de las interfaces de Go y brindamos ejemplos prácticos para ilustrar su uso. Al definir interfaces e implementarlas con diferentes tipos, podemos crear programas flexibles y extensibles.