TypeScript ofrece soporte completo para la palabra clave class introducida en ES2015.
Al igual que con otras características de JavaScript, TypeScript agrega anotaciones de tipo y otra sintaxis para expresar relaciones entre clases y otros tipos.
La clase más básica es una vacía:
class Punto {}
Esta clase no es muy útil aún, así que comencemos a agregar algunos miembros.
Una declaración de campo crea una propiedad pública y escribible en una clase:
class Punto {
x: number;
y: number;
}
const pt = new Punto();
pt.x = 0;
pt.y = 0;
Al igual que en otras ubicaciones, la anotación de tipo es opcional, pero será any implícito si no se especifica.
Los campos también pueden tener inicializadores; estos se ejecutarán automáticamente cuando se instancie la clase:
class Punto {
x = 0;
y = 0;
}
const pt = new Punto();
// Imprime 0, 0
console.log(`${pt.x}, ${pt.y}`);
Al igual que con const, let y var, el inicializador de una propiedad de clase se utilizará para inferir su tipo.
La configuración strictPropertyInitialization controla si los campos de la clase necesitan ser inicializados en el constructor.
class MalSaludo {
nombre: string;
// Error: La propiedad 'nombre' no tiene inicializador y no está definitivamente asignada en el constructor.
}
class BuenSaludo {
nombre: string;
constructor() {
this.nombre = "hola";
}
}
Ten en cuenta que el campo debe inicializarse en el propio constructor. TypeScript no analiza los métodos que invoca desde el constructor para detectar inicializaciones, porque una clase derivada podría sobrescribir esos métodos y no inicializar los miembros.
Si tienes la intención de inicializar definitivamente un campo a través de medios distintos al constructor (por ejemplo, tal vez una biblioteca externa esté completando parte de su clase por usted), puedes usar el operador de aserción de asignación definitiva, `!`:
class OKSaludo {
// No inicializado, pero sin error
nombre!: string;
}
Los campos pueden estar precedidos con el modificador readonly. Esto evita asignaciones al campo fuera del constructor.
class Saludo {
readonly nombre: string = "mundo";
constructor(otroNombre?: string) {
if (otroNombre !== undefined) {
this.nombre = otroNombre;
}
}
err() {
this.nombre = "no está bien"; // Error: No se puede asignar a 'nombre' porque es una propiedad de solo lectura.
}
}
const g = new Saludo();
g.nombre = "tampoco está bien"; // Error: No se puede asignar a 'nombre' porque es una propiedad de solo lectura.
Los constructores de clase son muy similares a las funciones. Puede agregar parámetros con anotaciones de tipo, valores predeterminados y sobrecargas:
class Punto {
x: number;
y: number;
// Firma normal con valores predeterminados
constructor(x = 0, y = 0) {
this.x = x;
this.y = y;
}
}
Hay solo algunas diferencias entre las firmas de constructor de clase y las firmas de función:
- Los constructores no pueden tener parámetros de tipo; estos pertenecen a la declaración externa de la clase.
- Los constructores no pueden tener anotaciones de tipo de retorno; el tipo de instancia de la clase es siempre lo que se devuelve.
Al igual que en JavaScript, si tiene una clase base, deberá llamar a super(); en el cuerpo de su constructor antes de usar cualquier miembro this.
class Base {
k = 4;
}
class Derivada extends Base {
constructor() {
// Imprime un valor incorrecto en ES5; lanza una excepción en ES6
console.log(this.k); // Error: 'super' debe ser llamado antes de acceder a 'this' en el constructor de una clase derivada.
super();
}
}
Olvidar llamar a super es un error fácil de cometer en JavaScript, pero TypeScript le informará cuándo es necesario.
Una propiedad de función en una clase se llama método. Los métodos pueden usar todas las mismas anotaciones de tipo que las funciones y los constructores:
class Punto {
x = 10;
y = 10;
escalar(n: number): void {
this.x *= n;
this.y *= n;
}
}
Aparte de las anotaciones de tipo estándar, TypeScript no agrega nada más nuevo a los métodos. Tenga en cuenta que dentro de un cuerpo de método, aún es obligatorio acceder a los campos y otros métodos a través de this.
Las clases también pueden tener accesores:
class C {
_longitud = 0;
get longitud() {
return this._longitud;
}
set longitud(valor) {
this._longitud = valor;
}
}
Tenga en cuenta que un par get/set respaldado por un campo sin lógica adicional es muy raramente útil en JavaScript. Está bien exponer campos públicos si no necesita agregar lógica adicional durante las operaciones get/set.
TypeScript tiene algunas reglas de inferencia especiales para los accesores:
- Si existe get pero no set, la propiedad es automáticamente de solo lectura.
- Si no se especifica el tipo del parámetro del setter, se infiere del tipo de retorno del getter.
Desde TypeScript 4.3, es posible tener accesores