0Pricing
TypeScript Academy · Lección

Restricciones genéricas: reducción de parámetros de tipo

Utilice extends para exigir requisitos de estructura en los genéricos.

Restricciones genéricas: reducción de parámetros de tipo es una lección gratuita de TypeScript Academy en CoddyKit. Esta es la lección 2 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de TypeScript Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de TypeScript Academy incluye 4 lecciones en total.

Bienvenida

Las restricciones genéricas avanzadas permiten limitar los tipos que se pueden usar como argumentos de tipo, lo que posibilita operaciones con seguridad de tipos sobre estructuras complejas.

Recapitulación de restricciones

`T extends U` limita `T` a tipos que son subtipos de `U`. Esto proporciona a TypeScript información sobre la estructura de `T` dentro de la función.
function len<T extends { length: number }>(val: T): number {
  return val.length;
}

Restricción a métodos específicos

Exija que `T` tenga un método específico restringiéndolo a una interfaz que incluya dicho método.
interface Stringable { toString(): string; }
function stringify<T extends Stringable>(val: T): string {
  return val.toString();
}

Inferencia a partir de una restricción

Use `keyof` dentro de la restricción para crear accesores seguros.
function pluck<T, K extends keyof T>(items: T[], key: K): T[K][] {
  return items.map(item => item[key]);
}
const names = pluck(users, 'name'); // string[]

Restricciones de orden superior (simuladas)

TypeScript no admite tipos verdaderos de orden superior, pero puede simularlos con tipos condicionales y restricciones.

Restricción a tipos primitivos

Limite los parámetros de tipo a tipos primitivos específicos para crear funciones especializadas.
type Primitive = string | number | boolean | bigint | symbol | null | undefined;
function isPrimitive<T extends Primitive>(val: T): true { return true; }

Restricciones recursivas

Las restricciones pueden hacer referencia a sí mismas para implementar patrones recursivos.
interface Comparable<T> { compareTo(other: T): number; }
function sort<T extends Comparable<T>>(items: T[]): T[] {
  return [...items].sort((a, b) => a.compareTo(b));
}

Restricción con valor predeterminado

Un parámetro de tipo puede tener tanto una restricción como un valor predeterminado. El valor predeterminado debe satisfacer la restricción.
function process<T extends object = Record<string, unknown>>(data: T): void {
  console.log(Object.keys(data));
}

T extends Record<string, unknown>

Restrinja a un tipo de registro para habilitar el acceso dinámico a propiedades.
function getValue<T extends Record<string, unknown>>(obj: T, key: string): unknown {
  return obj[key];
}

Inferencia de restricciones en tipos de retorno

Cuando `T` está restringido, TypeScript usa la restricción para determinar las operaciones válidas sobre el tipo de retorno.
function firstKey<T extends object>(obj: T): keyof T {
  return Object.keys(obj)[0] as keyof T;
}

Utilidad NoInfer (TS 5.4)

TypeScript 5.4 introdujo `NoInfer` para evitar que un parámetro de tipo se infiera a partir de una posición de argumento específica.
function createState<T>(initial: T, fallback: NoInfer<T>): T {
  return initial ?? fallback;
}

Comprobación rápida

¿Qué añade `T extends { length: number }` a `T` dentro de una función genérica?

Recapitulación

Las restricciones avanzadas limitan los tipos genéricos a estructuras, métodos o uniones de tipos primitivos específicos. Combínelas con `keyof`, patrones recursivos y valores predeterminados para crear utilidades potentes con seguridad de tipos.

Preguntas frecuentes

¿La lección «Restricciones genéricas: reducción de parámetros de tipo» es gratis?

Sí — el texto completo de «Restricciones genéricas: reducción de parámetros de tipo» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de TypeScript Academy, actualiza a CoddyKit PRO. El curso de TypeScript Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Restricciones genéricas: reducción de parámetros de tipo»?

Utilice extends para exigir requisitos de estructura en los genéricos. Practicas TypeScript Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar TypeScript Academy?

No se requiere experiencia previa. TypeScript Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 2 de 4.

¿Cuánto tiempo toma la lección «Restricciones genéricas: reducción de parámetros de tipo»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de TypeScript Academy?

Sí. Cada lección de TypeScript Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

  1. keyof y tipos de acceso indexado
  2. Restricciones genéricas: reducción de parámetros de tipo
  3. Tipos condicionales: T extends U ? X : Y
  4. Tipos condicionales distributivos
← Volver a TypeScript Academy