TypeScript
Modelado de funciones con firmas de llamada, parámetros, retornos y propiedades asociadas para describir APIs invocables de forma precisa.
TypeScript puede describir una función como un contrato entre entradas, retorno y forma de invocación.
type CalculateTotal = (
subtotal: number,
taxRate: number,
) => number;function calculateTotal(
subtotal: number,
taxRate: number,
): number {
return subtotal * (1 + taxRate);
}TypeScript comprueba:
number.function calculateSubtotal(
price: number,
quantity: number,
) {
return price * quantity;
}El retorno se infiere como number.
No necesitas anotar cada función privada. Una anotación explícita aporta especialmente cuando:
type Formatter = (value: number) => string;
const formatPrice: Formatter = (value) => {
return `$${value.toFixed(2)}`;
};La implementación recibe contextual typing: value ya se conoce como number.
type ProductLoader = (
productId: string,
) => Promise<Product>;Varias implementaciones pueden cumplir la misma firma:
const loadFromApi: ProductLoader = async (productId) => {
return api.getProduct(productId);
};
const loadFromCache: ProductLoader = async (productId) => {
return cache.require(productId);
};El consumidor depende del contrato, no del origen del dato.
type Compare = (
first: Product,
second: Product,
) => number;Los nombres documentan, pero no forman parte de la compatibilidad.
const compareByPrice: Compare = (a, b) => {
return a.price - b.price;
};Una función también puede tener propiedades.
type Validator = {
(value: unknown): boolean;
description: string;
};const isString: Validator = Object.assign(
(value: unknown) => typeof value === "string",
{
description: "Checks whether a value is a string",
},
);La sintaxis con : describe una call signature dentro de una forma de objeto.
type Cart = {
add(product: Product): void;
calculateTotal(): number;
};La firma de método describe una función invocada como miembro del objeto.
También puede escribirse como propiedad función:
type Cart = {
add: (product: Product) => void;
};Ambas formas se parecen, pero tienen diferencias de variance en ciertos contextos. La nota de compatibilidad de funciones profundiza en ello.
const operations: Array<(value: number) => number> = [
(value) => value * 2,
(value) => value + 10,
];TypeScript conserva el hecho de que una función puede:
El comportamiento runtime sigue siendo JavaScript; TypeScript solo describe el contrato.
function createMultiplier(
factor: number,
): (value: number) => number {
return (value) => value * factor;
}const double = createMultiplier(2);
double(5); // numberEl closure pertenece a JavaScript. TypeScript relaciona el parámetro capturado con la firma retornada.
const products = [
{ id: "p1", price: 100 },
{ id: "p2", price: 80 },
];
products.map((product) => product.price);product se conoce por la firma de map. No necesitas anotarlo manualmente.
products.map((product: Product) => product.price);Puede ser válido, pero repite información y a veces vuelve la callback menos compatible de lo necesario.
type CreateProduct = () => Product;
const createProduct: CreateProduct = () => ({
id: "product-1",
price: 100,
});El objeto retornado se comprueba contra Product.
function report(message: string): void {
console.log(message);
}void expresa que el consumidor no debe depender del retorno. No significa necesariamente que en JavaScript sea imposible devolver algo en todos los contextos.
function fail(message: string): never {
throw new Error(message);
}never indica que no existe una finalización normal con un valor.
No elijas la sintaxis por TypeScript, sino por el comportamiento de JavaScript:
this y no son constructibles.this según la llamada.El tipo puede ser similar, pero el runtime no es idéntico.
type DiscountPolicy = (
order: Order,
customer: Customer,
) => number;
function calculateFinalTotal(
order: Order,
customer: Customer,
discountPolicy: DiscountPolicy,
): number {
const discount = discountPolicy(order, customer);
return Math.max(0, order.total - discount);
}La política puede sustituirse sin cambiar la función principal.
Function en lugar de una firma concreta.any para aceptar funciones con firmas diferentes.void cuando el retorno sí forma parte del contrato.Function es demasiado amplio para APIs útiles.void y never representan situaciones distintas.¿Por qué type Handler = Function ofrece menos seguridad que (event: Event) => void?
Porque Function no describe qué argumentos acepta ni qué retorna. La firma concreta permite comprobar tanto la implementación como cada llamada.
Parámetros y tipos de retorno profundiza en opcionales, defaults, rest, destructuring y contratos de salida.