TypeScript Academy · Lección

Restricciones genéricas con extends

Restrinja los parámetros de tipo a estructuras específicas.

Restricciones genéricas con extends es una lección gratuita de TypeScript Academy en CoddyKit. Esta es la lección 3 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 limitan los tipos que se pueden pasar como argumentos de tipo. Utilice `extends` para exigir que T tenga determinadas propiedades o coincida con una forma concreta.

El problema sin restricciones

Sin restricciones, TypeScript no sabe qué operaciones son válidas sobre T, por lo que solo permite las operaciones comunes a todos los tipos.

function getLength<T>(val: T): number {
  // return val.length; // Error — T might not have .length
}

Añadir una restricción

Utilice `T extends Shape` para exigir que T tenga, como mínimo, las propiedades de Shape.

function getLength<T extends { length: number }>(val: T): number {
  return val.length;
}
getLength('hello');  // OK — string has .length
getLength([1, 2]);   // OK — array has .length
// getLength(42);   // Error — number has no .length

Restringir a una interfaz

Restrinja T para que implemente una interfaz específica.

interface Named { name: string; }
function greet<T extends Named>(person: T): string {
  return 'Hello, ' + person.name;
}

Restricción con keyof

Utilice `K extends keyof T` para restringir K a las claves de T. Esto permite acceder a las propiedades de forma segura.

function getProperty<T, K extends keyof T>(obj: T, key: K): T[K] {
  return obj[key];
}
const age = getProperty({ name: 'Alice', age: 30 }, 'age'); // number

Extender una unión

T puede restringirse a un tipo unión, lo que limita el argumento de tipo a valores específicos.

type Status = 'active' | 'inactive' | 'banned';
function setStatus<T extends Status>(status: T): void {
  console.log('Setting status:', status);
}

Restringir a un constructor

Restrinja T para que sea una clase (que tenga un constructor), de modo que pueda crear instancias dentro de la función.

function create<T>(ctor: new () => T): T {
  return new ctor();
}

Varias restricciones con intersecciones

Restrinja T para que cumpla varias interfaces mediante una intersección.

interface Serializable { serialize(): string; }
interface Loggable { log(): void; }
function process<T extends Serializable & Loggable>(item: T): void {
  item.log();
  console.log(item.serialize());
}

Herencia de restricciones

Las restricciones funcionan con la herencia. Si T extiende una clase base, puede llamar a todos los métodos de la clase base.

class Animal { breathe() { return 'breathing'; } }
function care<T extends Animal>(a: T): string { return a.breathe(); }

T se extiende a sí mismo (recursivo)

Las restricciones pueden ser autorreferenciales para estructuras de datos recursivas.

interface Comparable<T> { compareTo(other: T): number; }
function max<T extends Comparable<T>>(a: T, b: T): T {
  return a.compareTo(b) >= 0 ? a : b;
}

Mensajes de error de las restricciones

Cuando un argumento de tipo no cumple una restricción, TypeScript muestra un error claro que identifica tanto el argumento como la restricción.

Comprobación rápida

¿A qué restringe `K extends keyof T` el parámetro K?

Resumen

Utilice `T extends SomeType` para restringir los parámetros de tipo genéricos. Esto permite llamar a métodos específicos sobre T, usar keyof para acceder a propiedades de forma segura y crear utilidades con seguridad de tipos.

Preguntas frecuentes

¿La lección «Restricciones genéricas con extends» es gratis?

Sí — el texto completo de «Restricciones genéricas con extends» 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 con extends»?

Restrinja los parámetros de tipo a estructuras específicas. 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 3 de 4.

¿Cuánto tiempo toma la lección «Restricciones genéricas con extends»?

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

← Volver a TypeScript Academy