TypeScript
Fundamentos de clases en TypeScript: campos, constructores, métodos, instancias, miembros estáticos, herencia y diferencias entre tipo y valor.
TypeScript añade comprobaciones estáticas sobre las clases de JavaScript: tipos de propiedades, visibilidad, contratos abstractos, , y generics.
implementsoverrideclass Product {
constructor(
readonly id: string,
public name: string,
public price: number,
) {}
}class Product {
id: string;
name: string;
price: number;
constructor(
id: string,
name: string,
price: number,
) {
this.id = id;
this.name = name;
this.price = price;
}
}Con strictPropertyInitialization, cada propiedad debe:
class Cart {
items: CartItem[] = [];
}El initializer se ejecuta por instancia según las reglas de clases de JavaScript.
class Product {
constructor(
readonly id: string,
public name: string,
public price: number,
) {}
}El modificador convierte el parámetro en una propiedad y genera la asignación runtime correspondiente.
Es una sintaxis de TypeScript, no una característica nativa de JavaScript.
class Product {
applyDiscount(percentage: number): void {
this.price *= 1 - percentage / 100;
}
getLabel(): string {
return `${this.name}: ${this.price}`;
}
}class Account {
#balance = 0;
get balance(): number {
return this.#balance;
}
set balance(value: number) {
if (value < 0) {
throw new RangeError("Balance cannot be negative");
}
this.#balance = value;
}
}TypeScript comprueba que getter y setter representen un contrato compatible.
class ProductService {
static version = 1;
constructor(
readonly repository: ProductRepository,
) {}
}type Instance = ProductService;
type Constructor = typeof ProductService;El nombre de clase en posición de tipo representa instancias. typeof representa el constructor y miembros static.
class Point2D {
constructor(
public x: number,
public y: number,
) {}
}
type Coordinate = {
x: number;
y: number;
};
const coordinate: Coordinate = new Point2D(1, 2);Las instancias siguen siendo compatibles estructuralmente.
Cuando una clase contiene un miembro private o protected de TypeScript, dos clases solo son compatibles si ese miembro proviene de la misma declaración de clase.
class First {
private value = 0;
}
class Second {
private value = 0;
}Aunque las formas visibles se parezcan, First y Second no son compatibles.
Esto introduce un componente nominal dentro del sistema estructural.
class Service {
private token: string;
}private es una restricción del checker. Dependiendo del target, la propiedad puede existir con un nombre normal en JavaScript.
class Service {
#token: string;
}#token es privacidad runtime de JavaScript.
Usa # cuando la privacidad debe existir al ejecutar; usa private cuando el contrato estático y compatibilidad con tooling son suficientes o el proyecto lo requiere.
class Product {
name: string;
}Los miembros son public por defecto. Escribirlo puede formar parte de la convención, pero no cambia el acceso.
class Product {
constructor(readonly id: string) {}
}Impide reasignar mediante el tipo después de la inicialización. No congela objetos anidados.
const Constructor = Product;
const product = new Constructor("p1", "Keyboard", 100);La clase existe en runtime, a diferencia de interfaces y type aliases.
const ProductModel = class Product {
constructor(readonly id: string) {}
};TypeScript puede inferir el tipo constructor e instancia.
interface Identifiable {
id: string;
}
class Product implements Identifiable {
constructor(readonly id: string) {}
}implements solo comprueba el lado de instancia. No añade propiedades ni métodos.
interface Cacheable {
cacheKey?(): string;
}Una clase que implementa la interface no recibe el método opcional automáticamente.
function createEntityClass<const TType extends string>(
type: TType,
) {
return class Entity {
readonly type = type;
constructor(readonly id: string) {}
};
}TypeScript conserva el literal capturado en el tipo retornado.
class Controller {
declare context: RequestContext;
}declare indica que otro mecanismo inicializa la propiedad y evita emitir un field. Debe corresponder con una garantía runtime, por ejemplo un framework o decorator.
No es una inicialización.
Esta opción alinea la emisión de fields con la semántica moderna de JavaScript usando definición de propiedades. Puede afectar clases heredadas y setters cuando se migra código antiguo.
La configuración debe coincidir con el target y el runtime esperado.
class Order {
#status: OrderStatus = "pending";
constructor(
readonly id: OrderId,
readonly items: readonly OrderItem[],
) {}
get status(): OrderStatus {
return this.#status;
}
complete(): void {
if (this.#status !== "pending") {
throw new InvalidOrderStateError();
}
this.#status = "completed";
}
}El tipo protege la API; la clase protege también la invariante durante ejecución.
private con privacidad runtime universal.readonly congela objetos.implements copia miembros.typeof Class.declare como si inicializara una propiedad.typeof representa el constructor.private y protected afectan compatibilidad estática.#private existe en runtime.readonly es estático y superficial.implements solo verifica un contrato.¿Por qué dos clases con una propiedad privada idéntica pueden ser incompatibles?
Porque TypeScript exige que los miembros private o protected provengan de la misma declaración para considerar compatibles las instancias, introduciendo identidad nominal.
Modificadores, parameter properties y readonly profundiza en acceso, emisión y estado de las instancias.