Contenido del curso
Fundamentos de POO
POO Avanzada
Asincronismo y consumo de APIs
Genéricos
Próximos pasos
Generics
Contenido del curso
Guillermo David Zevallos Escalante
Ronaldo Delgado
Christian Velázquez
Andrés Esteban Rodríguez Jiménez
Alex Guaman
Miguel Angel Reyes Moreno
Andrés Felipe Eslava Zuluaga
fabio andres zamora osorio
David Higuera
Andre Huaman Yovera
Eliecer Alejandro Molina Vergel
Rafael Livise Larico
Alex Guaman
Andrés Felipe Eslava Zuluaga
Antony Jose Cabeza Rauseo
Paolo Joaquin Pinto Perez
Diego Fagundez
Andre Huaman Yovera
Jean Paul Yepes
Kenny Jared Molina Murillo
Andre Huaman Yovera
Eden Josue Lazo Fuentes
David Higuera
Eminson Mendoza
Eminson Mendoza
Juan José Mamani Tarqui
Ronaldo Delgado
Gustavo Medina Limon
Por convención, se utiliza el nombre " T " para dar a conocer que es un generics, es muy común ver este tipo de nombre en otros repositorios, documentación y también es usado en otros lenguajes como java y C#. Otros nombres utilizados en los generics son:
Genial gracias
Variable de Tipo (<T>):
Esta lectura de aquí me ayudo mucho a entender sobre los generics :3
Excelente, amplía bastante el tema
Generics
Podemos enviar tipado como parámetro:
import { Dog } from "./8-herencia"; function getValue<T>(value: T) { //*Usar T es una convención para tus propios tipados return value; } getValue<number>(12).toFixed() getValue<string>('12').length getValue<boolean>(true).toString() const doggy = new Dog('doggy', 'Snoop dog') getValue<Dog>(doggy)
Es convencional usar camelCase para variables y nombres de métodos, UpperCamelCase para nombres de clases y UPPER_SNAKE_CASE para constantes; y es convencional usar T para un parámetro de tipo generics
Quiero confirmar si entendi bien para que sirve generics, osea si entendi cual es el problema que resuelve generics para lo cual doy el siguiente ejemplo: . "Si tenemos 3 funciones que tienen el mismo codigo pero reciben parametros de diferente tipo, osea, una recibe int, otra float y otra string. como se ve hay codigo repetido en las 3 funciones lo cual es una mala practica, entonces, lo ideal seria crear una sola funcion con el codigo que se repite y que dicha funcion pueda recibir un parametro que sea de multiples tipos a la vez. Ese es el problema que soluciona generics, osea, generics permite que las funciones tengan un parametro de multiples tipos"
¿lo anterior es correcto o no?
Coincido
Sí, has comprendido correctamente el propósito y la utilidad de los genéricos en el contexto que mencionas. Los genéricos en TypeScript (y en otros lenguajes) permiten crear funciones, clases o interfaces que pueden trabajar con diferentes tipos de datos sin tener que repetir código.
.
En el ejemplo que has dado, si tienes tres funciones que realizan la misma operación pero con diferentes tipos de parámetros (por ejemplo, una función que suma dos enteros, otra que suma dos números de punto flotante y otra que concatena dos cadenas de texto), puedes usar genéricos para crear una única función que acepte cualquier tipo de parámetro y reutilice el mismo código.
.
Los genéricos te permiten definir parámetros de tipo genérico T que luego pueden ser utilizados en la declaración de la función para indicar el tipo de los argumentos y el tipo de retorno. De esta manera, puedes crear una función más general y flexible que se adapte a diferentes tipos de datos sin duplicar código.
.
En resumen, los genéricos te permiten escribir código más genérico y reutilizable al proporcionar una forma de trabajar con múltiples tipos de datos de manera flexible. Esto ayuda a evitar la repetición de código y mejora la mantenibilidad de tu código.
El nombre T viene desde los genericos de JAVA, no por TS
Este tema lo toque con Java hace 4 años y es la primera ves que entiendo su uso, deje Java hace tiempo pero es una espina que recien puedo sacar.
// Otro ejemplo de uso genéricos
class Generica<T> { // Se define una propiedad de tipo función generica suma?: (x: T, y: T) => T; } // Se instancia y se le da la funcionalidad let instanciaArray = new Generica<(string | number)[]>(); instanciaArray.suma = function(x, y) { return [...x, ...y]; } let variableArray = instanciaArray.suma(['a','b','c'] , ['1','2','3']); console.log(variableArray);
Resultado:
[ 'a', 'b', 'c', '1', '2', '3' ]
esto me hizo entender mejor
Generics
Es una forma de delegar el tipado para pasarlo como argumento. Es decir, al momento de declarar la función se le coloca como parametro
import { Dog } from "./09-protected"; // Aqui lo declaramos como parametro function getValue<T>(value: T) { return value; } // Aqui lo pasamos como argumento getValue<number>(777).toFixed(); getValue<string>('loqsea'); getValue<number[]>([1, 2, 3, 4, 5, 6, 7]).forEach((item) => item + 1); const max = new Dog('Max', 'Antony') getValue<Dog>(max)
La ventaja que tiene es la flexibilidad de tener diferentes tipos de datos en un mismo método, sin necesidad de ponerlos uno a uno al momento de declarar la función
Porqué la T en generics?
Lo más probable es que la letra predeterminada a usar sea T porque significa "Tipo(Type en Inglés)", entonces, al igual que en matemáticas, es convencional usar letras consecutivas para múltiples variables que representan el mismo tipo de cosas, por lo que S, T, U, V son comunes. Además:
Fuente: https://stackoverflow.com/questions/68458146/why-do-we-use-the-letters-t-u-in-generics
Buenas, estoy probando genericos implementando una interface y me sale un error que no entiendo. Ayuda :(
Interface
export interface Bank { login<T, U>(data: T): Promise<U> | U; }
Clase Connector, que implementa la interface
public login = async <MainAccount, string>( data: MainAccount ): Promise<string> => { try { const oauthWire4 = new OAuthWire4( data.consumerKey, data.consumerSecret, Process.env.token ); return authorization; };
Error
Property 'login' in type 'Connector' is not assignable to the same property in base type 'Bank'. Type '<MainAccount, string>(data: MainAccount) => Promise<string>' is not assignable to type '<T, U>(data: T) => U | Promise<U>'. Type 'Promise<string>' is not assignable to type 'U | Promise<U>'. Type 'Promise<string>' is not assignable to type 'Promise<U>'. Type 'string' is not assignable to type 'U'. 'U' could be instantiated with an arbitrary type which could be unrelated to 'string'.ts(2416)
El error que estás experimentando está relacionado con la implementación incorrecta de la interfaz Bank en la clase Connector. El problema principal radica en cómo se definen y utilizan los parámetros genéricos en la clase. Aquí está el problema en tu código:
public login = async <MainAccount, string>( data: MainAccount ): Promise<string> => {
La declaración <MainAccount, string> dentro de los ángulos angulares está definiendo dos parámetros genéricos, uno llamado MainAccount y el otro llamado string. Sin embargo, parece que pretendías utilizar el tipo string como el tipo de retorno del método login, en lugar de un parámetro genérico adicional.
.
Para solucionar este problema, debes ajustar la definición de la función login para que utilice el parámetro genérico MainAccount y especifique string como el tipo de retorno. Aquí tienes la corrección:
public login = async <MainAccount>( data: MainAccount ): Promise<string> => {
Con este cambio, estás indicando que login es una función genérica que toma un parámetro data de tipo MainAccount y devuelve una promesa de tipo string, que coincide con la definición en la interfaz Bank.
.
Recuerda que los parámetros genéricos se definen entre los ángulos angulares (< >) y pueden utilizarse en toda la definición de la función para indicar los tipos de los argumentos y el tipo de retorno de manera genérica.
By CHATGPT
Un poco de humor
¿T de Troy?
realmente ya habia visto este tema en otro videos, pero hasta este video le entendi correctamente
El uso de la letra "T" en los métodos genéricos, como en TypeScript (TS) o C#, es una convención comúnmente utilizada para representar un parámetro de tipo genérico. La "T" se utiliza como un marcador o símbolo que representa un tipo desconocido o no específico que será determinado en tiempo de compilación o en el momento de uso del método.
La elección de la letra "T" es simplemente una convención y no está relacionada con una característica o función específica de los lenguajes de programación. Se eligió "T" debido a su proximidad en el alfabeto a las letras utilizadas para otros tipos genéricos, como "K" y "V" para clave y valor, respectivamente.
El uso de "T" facilita la legibilidad y comprensión del código, ya que se ha convertido en una práctica común y ampliamente reconocida en la comunidad de programadores. Sin embargo, es importante destacar que la elección de la letra "T" es arbitraria y se podría utilizar cualquier otra letra o incluso palabras más descriptivas según la convención establecida en cada lenguaje de programación en particular.
La "T" viene de Template ya que estos en ingles se conocen como Generic Templates
Los parámetros de tipado también puede ser opcionales:
function getValue<T, U = unknown>(value: T, value2?: U) { return { value, value2 }; } const fifi = new Dog("fifi"); getValue<Dog>(fifi);
Los generics en TypeScript permiten crear componentes y funciones que pueden trabajar con diferentes tipos de datos sin perder la información del tipo. Esto promueve la reutilización del código y mejora la seguridad al momento de compilar.
Ejemplos:
Función genérica:
function identidad<T>(arg: T): T { return arg; }
Clase genérica:
class Caja<T> { contenido: T; constructor(contenido: T) { this.contenido = contenido; } }
Interfaz genérica:
interface Respuesta<T> { datos: T; error: string | null; }
Los generics son esenciales para escribir código más flexible y mantenible en tus proyectos TypeScript.
Generics en TypeScript permiten crear funciones y clases que pueden trabajar con diferentes tipos de datos sin perder la información del tipo. Un ejemplo común es crear una función que retorna el primer elemento de un array:
function firstElement``<T>``(arr: T[]): T {
return arr[0];
}
const numberArray = [1, 2, 3];
const stringArray = ['a', 'b', 'c'];
const firstNumber = firstElement(numberArray); // retorna 1
const firstString = firstElement(stringArray); // retorna 'a'
Este enfoque maximiza la reutilización del código y la seguridad de tipos.
intersante
increíble estas funcionalidades para los typados me gusto mucho
Desde Java tenia la duda del tipado < > no comprendia para que funcionaba, ahora comprendo que es.