Lección 3 de 20 · Lectura y práctica
Ejercicio: Crear un Sistema de Filtros Tipado
Tipo de lección: VideoConcepto claveLos sistemas de filtros tipados en TypeScript avanzado permiten crear abstracciones que procesan datos manteniendo la seguridad de tipos en tiempo de compilación. En arquitecturas complejas,.
Del concepto a la práctica
Taller de esta lección
Un filtro reutilizable puede recibir una función predicado y preservar el tipo de sus registros. El valor está en componer reglas sin convertir la colección en unknown[].
Ejemplo resuelto
type Product = { sku: string; price: number; stock: number };
const products: Product[] = [
{ sku: "A1", price: 12, stock: 4 },
{ sku: "B2", price: 8, stock: 0 },
{ sku: "C3", price: 15, stock: 2 }
];
function filterBy<T>(items: readonly T[], predicate: (item: T) => boolean): T[] {
return items.filter(predicate);
}
const available = filterBy(products, p => p.stock > 0 && p.price >= 10);
console.log(available.map(p => p.sku)); // ["A1", "C3"]Pruébalo
Escribe
filterBy<T>(items, predicate).Combina precio mínimo 10 y stock positivo.
Devuelve los SKU en el orden original.
Sobre available, añade un filtro que busque
sku === "B2".
Comprueba tu resultado
El resultado inicial debe ser A1,C3; el segundo debe ser una lista vacía.
Error frecuente: mutar products con splice. Corrígelo devolviendo filter, que crea una colección nueva y mantiene intactos los tres registros.
Aplicar la búsqueda B2 directamente a products devuelve un producto sin stock; aplicarla a available devuelve cero porque B2 ya fue excluido. Deja explícita esa composición y conserva tres entradas originales. filter copia el contenedor, pero comparte las referencias de los objetos: no cambies stock dentro del predicado. Añade los casos arreglo vacío y precio exactamente10 para comprobar el límite inclusivo y el orden A1,C3.

Mapa de prácticaUna condición decide qué camino ejecuta el programa. Un bucle repite una operación mientras queden elementos, y termina cuando la lista se agota. Separar ambas ideas ayuda a seguir el flujo y comprobar casos límite.
Ver la infografía en tamaño completo ↗Fuentes para profundizar
Tipo de lección: Video
Concepto clave
Los sistemas de filtros tipados en TypeScript avanzado permiten crear abstracciones que procesan datos manteniendo la seguridad de tipos en tiempo de compilación. En arquitecturas complejas, esto es crucial para evitar errores en runtime y garantizar que las transformaciones de datos sean predecibles y mantenibles.
Imagina un sistema de recomendación de productos donde necesitas filtrar por múltiples criterios (precio, categoría, disponibilidad). Un sistema tipado te asegura que cada filtro reciba exactamente los datos que espera, y que el resultado mantenga la estructura correcta. Esto es similar a una línea de ensamblaje industrial donde cada estación solo acepta piezas específicas y produce componentes validados.
Cómo funciona en la práctica
Vamos a construir un filtro genérico paso a paso. Primero, definimos una interfaz base para nuestros filtros:
interface Filter {
apply(data: T[]): T[];
getDescription(): string;
} Luego, implementamos filtros específicos usando genéricos con restricciones:
class PriceFilter implements Filter {
constructor(private minPrice: number, private maxPrice: number) {}
apply(data: T[]): T[] {
return data.filter(item => item.price >= this.minPrice && item.price <= this.maxPrice);
}
getDescription(): string {
return `Filtro de precio: ${this.minPrice} - ${this.maxPrice}`;
}
} Finalmente, creamos un sistema que compone múltiples filtros:
class FilterSystem {
private filters: Filter[] = [];
addFilter(filter: Filter): void {
this.filters.push(filter);
}
applyAll(data: T[]): T[] {
return this.filters.reduce((result, filter) => filter.apply(result), data);
}
} Caso de estudio
En una aplicación de e-commerce, necesitamos filtrar productos para una página de ofertas. Definimos nuestro tipo de producto:
interface Product {
id: string;
name: string;
price: number;
category: 'electronics' | 'clothing' | 'home';
inStock: boolean;
discount?: number;
}Creamos filtros específicos:
class CategoryFilter implements Filter {
constructor(private category: Product['category']) {}
apply(data: Product[]): Product[] {
return data.filter(item => item.category === this.category);
}
getDescription(): string {
return `Filtro de categoría: ${this.category}`;
}
}
class InStockFilter implements Filter {
apply(data: Product[]): Product[] {
return data.filter(item => item.inStock);
}
getDescription(): string {
return 'Filtro de disponibilidad: solo en stock';
}
} Implementamos el sistema:
const productFilterSystem = new FilterSystem();
productFilterSystem.addFilter(new PriceFilter(50, 200));
productFilterSystem.addFilter(new CategoryFilter('electronics'));
productFilterSystem.addFilter(new InStockFilter());
const filteredProducts = productFilterSystem.applyAll(allProducts); El sistema tipado garantiza que solo productos válidos pasen cada filtro, y el resultado final mantiene el tipo Product[] con todas sus propiedades.
Errores comunes
- No usar restricciones en genéricos: Permitir cualquier tipo en filtros puede llevar a errores en runtime. Siempre usa
T extendspara definir qué propiedades necesita el filtro. - Olvidar la inmutabilidad: Los filtros no deben modificar los datos originales. Siempre retorna nuevos arrays usando métodos como
filter(). - Tipos demasiado amplios: Evita usar
anyounknownen sistemas de filtros. Define interfaces específicas para cada contexto. - No validar datos de entrada: Aunque TypeScript valida en compilación, en runtime podrías recibir datos mal formados. Considera validaciones adicionales para APIs externas.
- Complejidad innecesaria: No crees filtros hiper-especializados para casos de uso únicos. Busca equilibrio entre reutilización y simplicidad.
Checklist de dominio
- Puedo crear una interfaz genérica
Filter<T>con métodos tipados correctamente - Sé implementar filtros específicos usando restricciones de tipos (
T extends) - Puedo componer múltiples filtros en un sistema que mantiene la seguridad de tipos
- Entiendo cómo inferir tipos automáticamente en cadenas de filtros
- Puedo crear filtros que trabajen con tipos condicionales y mapeados
- Sé optimizar filtros para performance manteniendo la seguridad de tipos
- Puedo documentar un sistema de filtros para que otros desarrolladores lo usen correctamente
Implementa un sistema de filtros para una biblioteca de medios
Objetivo
Crea un sistema tipado de filtros para una aplicación que gestiona una biblioteca de medios (libros, películas, música).
Pasos
- Define una interfaz
MediaItemcon propiedades comunes:id(string),title(string),year(number),rating(number del 1 al 5), y un discriminadortype('book' | 'movie' | 'music'). - Crea una interfaz genérica
Filter<T>con métodosapply(items: T[]): T[]ygetName(): string. - Implementa tres filtros específicos:
YearRangeFilter: Filtra por rango de años (ej: 2000-2020)MinRatingFilter: Filtra por rating mínimo (ej: 4 estrellas o más)TypeFilter: Filtra por tipo específico de medio
- Crea una clase
MediaFilterSystemque pueda agregar y aplicar múltiples filtros en secuencia. - Implementa un filtro avanzado
SearchFilterque busque en título usando una cadena (case-insensitive). - Escribe tests que verifiquen que el sistema mantiene los tipos correctamente en cada paso.
Requisitos técnicos
- Usa TypeScript estricto (
strict: true) - No uses
anyo aserciones de tipo innecesarias - Mantén la inmutabilidad en todos los filtros
- Documenta cada filtro con comentarios JSDoc
Pistas
- Usa tipos condicionales para crear filtros que funcionen solo con ciertos subtipos de MediaItem
- Considera crear una función utilitaria para combinar filtros de forma más eficiente
- Para el SearchFilter, explora el tipo Template Literal de TypeScript para búsquedas más seguras
Evalua tu comprension
Completa el quiz interactivo de arriba para ganar XP.
Sigue con TypeScript Avanzado: Patrones Genéricos y Tipado Profundo para Arquitecturas Complejas
Esta lección forma parte de un curso de Cursalo. Revisa su programa y elige entre la compra individual o el acceso a toda la escuela.
Si ya tenías acceso a este curso, entra con tu cuenta: tus derechos y tu progreso se conservan. No necesitas comprarlo de nuevo.