Generics

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:

• E - Elemento (elementos en una colección)
• K - Llave
• N - Número
• V - Valor

Esta lectura de aquí me ayudo mucho a entender sobre los generics :3

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

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' ]

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:

• K se usa a menudo para un tipo de clave genérica
• V para un tipo de valor asociado.
• en algunos casos, E se usa para el tipo de “elementos” en una colección.

Fuente: https://stackoverflow.com/questions/68458146/why-do-we-use-the-letters-t-u-in-generics

realmente ya habia visto este tema en otro videos, pero hasta este video le entendi correctamente

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);

Desde Java tenia la duda del tipado < > no comprendia para que funcionaba, ahora comprendo que es.

Recomiendo leer esto. Corto, simple y te hace entender muy rápido para que sirven los generics: aqui

Un poco de humor

¿T de Troy?

Podemos entender los genéricos como una especie de “plantilla” de código, mediante la cual podemos aplicar un tipo de datos determinado a varios puntos de nuestro código. Sirven para aprovechar código, sin tener que duplicarlo por causa de cambios de tipo y evitando la necesidad de usar el tipo “any”.