TypeScript
Tipado de this, call signatures y construct signatures para modelar funciones, métodos, objetos invocables y valores que pueden construirse con new.
function describe(
this: Product,
prefix: string,
): string {
return `${prefix}: ${this.name}`;
}this aparece en el tipo, pero no es un argumento runtime adicional.
describe.call(product, "Product");Con noImplicitThis, TypeScript detecta contextos donde this no tiene un tipo claro.
const object = {
value: 10,
getValue() {
return this.value;
},
};El método recibe contextual typing desde el objeto.
ThisType<T> puede proporcionar tipo contextual de this dentro de object literals usados como DSL.
type ObjectDescriptor<D, M> = {
data: D;
methods: M & ThisType<D & M>;
};No genera nada en runtime; funciona como marcador para el checker.
type Method = (
this: ProductService,
id: string,
) => Product;
type BoundMethod = OmitThisParameter<Method>;Es útil cuando bind produce una función que ya no necesita receptor explícito.
type Receiver = ThisParameterType<Method>;
// ProductServicetype Counter = {
(step?: number): number;
reset(): void;
};function createCounter(): Counter {
let value = 0;
const counter = (step = 1) => {
value += step;
return value;
};
counter.reset = () => {
value = 0;
};
return counter;
}type ProductConstructor = new (
id: string,
name: string,
) => Product;function createInstance(
Constructor: ProductConstructor,
): Product {
return new Constructor("p1", "Keyboard");
}type AbstractConstructor<T> = abstract new (
...args: never[]
) => T;Permite aceptar clases abstractas en utilidades que trabajan con herencia, aunque no puedan instanciarse directamente.
Algunas APIs históricas pueden invocarse con o sin new.
type DateLike = {
(): string;
new (): Date;
};No diseñes una API híbrida nueva sin una razón clara; es más difícil de entender y tipar.
class ProductService {
static version = 1;
constructor(
readonly repository: ProductRepository,
) {}
}
type ProductServiceInstance = ProductService;
type ProductServiceClass = typeof ProductService;ProductService en posición de tipo representa la instancia.typeof ProductService representa el constructor y miembros estáticos.type Args = ConstructorParameters<
typeof ProductService
>;
type Instance = InstanceType<
typeof ProductService
>;interface UIElement {
addClickListener(
handler: (this: void, event: Event) => void,
): void;
}this: void comunica que la callback no debe depender de un receptor proporcionado por la API.
Una arrow no declara su propio this.
class Controller {
value = 10;
handler = () => {
console.log(this.value);
};
}El tipo no cambia el costo runtime: cada instancia crea su propia arrow field.
type AdapterConstructor<TAdapter> = new (
configuration: AdapterConfiguration,
) => TAdapter;
function createAdapter<TAdapter>(
Constructor: AdapterConstructor<TAdapter>,
configuration: AdapterConfiguration,
): TAdapter {
return new Constructor(configuration);
}this en la firma se pasa como argumento normal.typeof Class.() => T.call o bind cambien su this.any en construct signatures.ThisType existe en runtime.this solo describe el receptor.new.typeof Class representa el lado estático y constructor.this de JavaScript.¿Por qué ProductService y typeof ProductService representan tipos distintos?
ProductService representa las instancias creadas; typeof ProductService representa el valor constructor, sus miembros estáticos y su firma new.
Funciones asíncronas y Promises tipadas modela resultados futuros sin cambiar el comportamiento del Event Loop.