TypeScript
Tipado de callbacks y funciones de orden superior, incluyendo parámetros, retornos, contexto, inferencia y contratos reutilizables entre APIs.
Una función de orden superior recibe funciones, retorna funciones o ambas. TypeScript relaciona las firmas para conservar información entre cada etapa.
function mapProducts<TOutput>(
products: readonly Product[],
transform: (product: Product) => TOutput,
): TOutput[] {
return products.map(transform);
}type ProductPredicate = (
product: Product,
index: number,
) => boolean;function filterProducts(
products: readonly Product[],
predicate: ProductPredicate,
): Product[] {
return products.filter(predicate);
}filterProducts(products, (product, index) => {
return product.stock > 0 && index < 10;
});Los parámetros se infieren desde el contexto. Anotarlos de nuevo suele ser innecesario.
Una callback puede ignorar argumentos que el llamador ofrece.
const names = products.map(
(product) => product.name,
);La firma de map ofrece también índice y array, pero la callback no tiene que declararlos.
function byMinimumPrice(
minimum: number,
): (product: Product) => boolean {
return (product) => product.price >= minimum;
}const premiumProducts = products.filter(
byMinimumPrice(500),
);function identity<T>(value: T): T {
return value;
}
function apply<TInput, TOutput>(
value: TInput,
operation: (value: TInput) => TOutput,
): TOutput {
return operation(value);
}const length = apply("TypeScript", (value) => value.length);
// numberfunction withLogging<TArgs extends unknown[], TResult>(
operation: (...args: TArgs) => TResult,
): (...args: TArgs) => TResult {
return (...args) => {
console.log("Arguments", args);
const result = operation(...args);
console.log("Result", result);
return result;
};
}La función conserva la lista de parámetros y el retorno originales.
Una arrow wrapper no conserva automáticamente el contrato de this de un método.
function withLogging<TThis, TArgs extends unknown[], TResult>(
operation: (this: TThis, ...args: TArgs) => TResult,
): (this: TThis, ...args: TArgs) => TResult {
return function (this: TThis, ...args: TArgs) {
console.log(args);
return operation.apply(this, args);
};
}type SyncHandler<T> = (value: T) => void;
type AsyncHandler<T> = (value: T) => Promise<void>;No los mezcles sin decidir quién espera la promesa.
async function notifyAll(
users: readonly User[],
notify: AsyncHandler<User>,
): Promise<void> {
await Promise.all(users.map(notify));
}type MaybePromise<T> = T | Promise<T>;
type Hook<T> = (value: T) => MaybePromise<void>;El llamador debe normalizar:
await hook(value);function registerHandler(
handler: (event: MouseEvent) => void,
): () => void {
window.addEventListener("click", handler);
return () => {
window.removeEventListener("click", handler);
};
}La API retorna cleanup y preserva la misma identidad del listener.
Estilo Node clásico:
type Callback<T> = (
error: Error | null,
value?: T,
) => void;Permite combinaciones ambiguas. Una unión discriminada o Promise suele ofrecer un contrato más claro en APIs nuevas.
type PricingStrategy = (
product: Product,
customer: Customer,
) => number;El tipo comunica el rol de la función, no solo sus parámetros.
type RequestContext = {
userId: string;
};
type Handler<TResult> = (
context: RequestContext,
) => Promise<TResult>;
function withAuthorization<TResult>(
handler: Handler<TResult>,
): Handler<TResult> {
return async (context) => {
await requirePermission(context.userId);
return handler(context);
};
}any.this.this cuando corresponde.¿Por qué forEach(async () => ...) no se vuelve esperable solo porque la callback está tipada como async?
Porque el contrato runtime de forEach ignora los retornos de sus callbacks. El tipo de la callback no cambia ese comportamiento de JavaScript.
Overloads modela APIs con varias formas de llamada relacionadas.