Lo que es más importante, los genéricos mantienen la sólida seguridad de tipo de Go, que permite la verificación de tipo estático en tiempo de compilación y garantiza la corrección del tipo. Proporcionan un manejo de errores estandarizado dentro del código genérico que mejora la claridad y la capacidad de mantenimiento. Además, proporcionan un manejo de errores estandarizado dentro del código genérico que mejora la claridad y la facilidad de mantenimiento. En esta publicación, examinaremos las diversas aplicaciones y ejemplos de genéricos Go del mundo real.
Ejemplo 1: uso de la función genérica de Golang
Uno de los principales casos de uso de los genéricos es la creación de funciones que pueden operar en distintos tipos. Aquí vamos con uno de los ejemplos donde se usa la función de circunferencia genérica.
paquete principal
importar 'fmt'
función circunferencia [ r En t | flotar32 ]( radio r ) {
C := 3 * 2 * radio
fmt . Imprimir ( 'La circunferencia genérica es: ' , C )
}
función principal () {
era r1 En t = 7
era r2 flotar32 = 7 . 5
circunferencia ( r1 )
circunferencia ( r2 )
}
Al comienzo del código anterior, la línea importa el paquete 'fmt' que proporciona funciones para E/S formateadas, incluida la impresión de la salida en la consola. Luego, definimos una función genérica llamada 'circunferencia' que toma un radio de parámetro de tipo genérico 'r' que puede ser 'int' o 'float32'. Dentro de la función, calcula la circunferencia multiplicando el radio por el valor constante de '3' y luego multiplicándolo por '2'. Finalmente, imprime la circunferencia calculada mediante “fmt.Println”.
A continuación, tenemos la función principal donde se declaran dos variables, r1 y r2, y se les asignan los valores de 7 y 7,5, respectivamente. Después de eso, la función 'circunferencia' se invoca dos veces, pasando r1 y r2 como argumentos.
La salida muestra el cálculo imprimiendo las circunferencias de los círculos de la siguiente manera:
Ejemplo 2: uso de la interfaz genérica de Golang
Además, los genéricos de Golang nos ayudan con sus interfaces. Las interfaces en Go son una herramienta vital para facilitar la reutilización de código y el polimorfismo. Al permitirles funcionar con muchos tipos, los genéricos aumentan el poder de las interfaces. El siguiente es el código fuente de la interfaz de genéricos de Golang:
paquete principal
importar 'fmt'
tipo empage interfaz {
int64 | int32 | flotar32 | flotar64
}
función newGenericFunc [ edad Edad ]( emp_Age edad ) {
valor := En t ( emp_Edad ) + 1
fmt . Imprimir ( valor )
}
función principal () {
fmt . Imprimir ( 'Edad de los empleados' )
era Edad1 int64 = 24
era Edad2 flotar64 = 25 . 5
newGenericFunc ( Edad1 )
newGenericFunc ( Edad2 )
}
En el código fuente anterior, definimos una interfaz llamada 'EmpAge' que especifica los tipos posibles para la edad de un empleado. La interfaz incluye los tipos int64, int32, float32 y float64. Esta interfaz permite que la función 'genérica' acepte cualquiera de estos tipos como argumento. Después de eso, empleamos una función genérica llamada newGenericFunc que toma el parámetro emp_Age de un tipo genérico de edad que puede ser cualquier tipo que satisfaga la interfaz EmpAge. Dentro de la función, convierte emp_Age en un int y lo incrementa en 1 como se muestra.
A continuación, declaramos las dos variables, Edad1 y Edad2, y asignamos los valores de 24 y 25,5, respectivamente, en la función principal. A partir de entonces, Age1 y Age2 se pasan como parámetros a la función newGenericFunc, que se ejecuta dos veces. Con esto, las edades se elevan en 1 y generan los valores actualizados.
El resultado que se obtiene a continuación son las edades de la función genérica que utiliza la interfaz:
Ejemplo 3: uso de la estructura de datos genérica de Golang
Además, Go generics también nos brinda la capacidad de construir estructuras de datos genéricas como pilas, colas y listas vinculadas. Considere la implementación de la pila genérica en lo siguiente:
importar 'fmt'tipo Pila [ T cualquier ] [] T
función ( calle * Pila [ T ]) Empujar ( elemento T ) {
calle = adjuntar ( * calle , artículo )
}
función ( calle * Pila [ T ]) Estallido () T {
si solo ( * calle ) == 0 {
pánico ( 'Nada en la pila' )
}
índice := solo ( * calle ) - 1
artículo := ( * calle )[ índice ]
* calle = ( * calle )[: índice ]
devolver artículo
}
función principal () {
pila := nuevo ( Pila [ En t ])
pila . Empujar ( 1 )
pila . Empujar ( 2 )
pila . Empujar ( 3 )
fmt . Imprimir ( pila . Estallido ())
fmt . Imprimir ( pila . Estallido ())
fmt . Imprimir ( pila . Estallido ())
}
En el código anterior se define un tipo genérico denominado “Stack” que representa la pila. El marcador de posición 'T' permite que la pila contenga elementos de cualquier tipo. El tipo 'Pila' se implementa como una porción de elementos de tipo 'T'. Aquí, se implementan dos funciones para el tipo 'Pila': 'Push' y 'Pop'. La función Push() es responsable de agregar los elementos a la pila. Toma un elemento de argumento de tipo 'T' y lo agrega a la porción subyacente usando la función append().
Mientras que la función Pop() toma el componente inicial de la pila y lo devuelve, primero determina si la pila está vacía evaluando el tamaño del segmento subyacente. Se envía una notificación de error si la pila parece estar vacía, lo que provoca un pánico. De lo contrario, recupera el último elemento del segmento, lo elimina de la pila dividiendo el segmento hasta el penúltimo elemento y devuelve el elemento eliminado.
A continuación, la nueva pila de enteros se crea utilizando la sintaxis Stack[int] dentro de la función principal de este código. Después de eso, el método 'Push' se llama tres veces para agregar los números enteros 1, 2 y 3 a la pila. Sin embargo, el método 'Pop' se llama tres veces posteriormente para recuperar e imprimir los elementos de la pila.
El siguiente resultado indica que los elementos se eliminan de la pila en orden inverso:
Ejemplo 4: uso de las restricciones genéricas de Golang
Go también ofrece restricciones personalizadas que permiten una gran flexibilidad y definen requisitos específicos para construcciones genéricas en función de las necesidades de su aplicación. El código de las restricciones genéricas personalizadas se proporciona a continuación para demostración:
paquete principalimportar 'fmt'
tipo numericos interfaz {
int64 | flotar64
}
función principal () {
valor flotante := [] flotar64 { 2 . 0 , 4 . 0 , 6 . 0 , 8 . 0 , 10 . 0 }
Valor entero := [] int64 { 2 , 4 , 6 , 8 , 10 }
suma1 := suma genérica ( valor flotante )
suma2 := suma genérica ( Valor entero
fmt . Imprimir ( 'Suma de float64:' , suma1 )
fmt . Imprimir ( 'Suma de int64:' , suma2 )
}
función suma genérica [ n numéricos ]( números [] norte ) norte {
era Yo soy n
para _ , en uno := rango números {
suma += en uno
}
devolver suma
}
En el código fuente anterior, definimos la interfaz numérica con el método 'Suma'. Luego, creamos dos tipos personalizados, 'FloatValue' y 'IntegerValue', que implementan la interfaz Numerics proporcionando sus respectivos métodos 'Sum'. La función genericSum ahora puede aceptar porciones de cualquier tipo que satisfaga la interfaz de Numerics. Dentro de la función, iteramos sobre los elementos y llamamos al método 'Suma' para calcular la suma. Finalmente, en la función principal, creamos los segmentos de FloatValue e IntegerValue y los pasamos a la función genericSum() que calcula correctamente la suma de los elementos en cada segmento.
El resultado esperado ahora es visible en la siguiente pantalla:
Conclusión
Exploramos algunos ejemplos prácticos de genéricos de Go que incluyen la creación de una estructura de datos genérica y una función genérica, la definición de una interfaz genérica y el uso de la restricción de tipo personalizado. Estos ejemplos demuestran el poder y la flexibilidad que los genéricos aportan al lenguaje de programación Go. Tenga en cuenta que la generación de código genérico durante la compilación garantiza el tamaño binario y los tiempos de compilación eficientes.