TypeScript classes: cómo definirlas y utilizarlas

Las clases de TypeScript proporcionan una forma clara y estructurada de organizar datos y comportamientos dentro de un objeto. De esta forma, es posible modelar entidades y conceptos en el código de una manera más fácil y comprensible.

¿Para qué se utilizan las clases de TypeScript?

Las clases son fundamentales en el lenguaje de programación TypeScript, que está basado en JavaScript. Proporcionan un método estructurado para definir objetos y aplicar la programación orientada a objetos (OOP). Las clases de TypeScript son como una especie de planos para la creación de objetos, que agrupan datos y métodos relacionados de manera lógica.

TypeScript contiene todas las funciones de JavaScript e incluye tipado estático, lo que permite especificar tipos de datos para funciones en TypeScript, variables y clases, así como detectar errores en tiempo de compilación. Además de la seguridad de tipos, las clases de TypeScript también soportan conceptos como la herencia y la abstracción, lo que facilita el desarrollo de aplicaciones complejas.

Las clases de TypeScript te permiten establecer una jerarquía clara de clases que heredan propiedades y métodos. Esto fomenta la reutilización de código y su estructuración. Los constructores en las clases posibilitan la inicialización de instancias y aseguran una creación de objetos coherente.

La sintaxis de las clases de TypeScript

La sintaxis de las clases en TypeScript se asemeja a la de ECMAScript 6 (ES6) y es una versión extendida de la sintaxis de clases de JavaScript. Una clase puede contener varios elementos para definir la estructura y el comportamiento de los objetos. Estos son sus componentes principales:

• Propiedades,
• constructor y
• métodos.

Propiedades

Las propiedades o properties determinan el estado de un objeto. Almacenan valores de datos y pueden anotarse con tipos de datos para garantizar que solo contengan valores válidos.

class ClassName {
    propertyName: propertyType;
}

• ClassName: el nombre de la clase.
• propertyName: el nombre de la propiedad que quieras definir.
• propertyType: el tipo de dato de la propiedad.

Fíjate en este ejemplo:

class Person {
    name: string;
}

Primero se define una clase llamada Person (persona) con una propiedad denominada name (nombre) del tipo string. Esto quiere decir que las instancias de la clase Person tienen una propiedad name que almacena cadenas de texto (strings).

Constructor

El constructor en TypeScript es un método especial que se llama al crear una instancia (un objeto) de una clase. Se utiliza para realizar la inicialización de las propiedades (properties) de un objeto. Básicamente, el constructor establece el estado inicial de una instancia. Puedes especificar parámetros en el constructor para pasar valores al instanciar clases de TypeScript.

La estructura básica de un constructor en TypeScript tiene el siguiente aspecto:

class ClassName {
    constructor(parameter1: Type1, parameter2: Type2, ...) {
    }
}

• constructor: cada clase puede tener solo un constructor. Si no se define ninguno, se crea un constructor vacío por defecto.
• parameter: Type: los parámetros pueden ser necesarios o no dependiendo de lo que la clase necesite hacer. Es útil indicar qué tipo de datos se espera para cada parámetro.

Aquí te mostramos un ejemplo de constructor:

class Person {
    firstName: string;
    lastName: string;
    constructor(firstName: string, lastName: string) {
        this.firstName = firstName;
        this.lastName = lastName;
    }
}

En el ejemplo anterior, la clase Person tiene un constructor que acepta dos parámetros: firstName (nombre) y lastName (apellido). Al crear una instancia de esta clase, se pasan estos parámetros y el constructor inicializa las propiedades firstName y lastName de la instancia con los valores correspondientes. La palabra clave this se refiere a la instancia actual de la clase en la que se está ejecutando el código.

Métodos

En TypeScript, los métodos son funciones que pueden definirse en las clases y aplicarse a sus instancias. Con ellos se pueden realizar ciertas acciones u operaciones en el contexto de una clase.

class ClassName {
    // ...
    methodName(parameter1: Type1, parameter2: Type2, ...): ReturnType {
    }
    // ...
}

• methodName: nombre del método.
• parameter: Type: parámetros opcionales que acepta el método.
• ReturnType: es el tipo de datos que determina qué valor devuelve el método. Si el método no devuelve nada, puedes especificar void.

Para llamar a una propiedad o a un método en una instancia de una clase, utiliza el operador punto . seguido del nombre del método y los argumentos necesarios si el método espera parámetros.

class Person {
    firstName: string;
    lastName: string;
    constructor(firstName: string, lastName: string) {
        this.firstName = firstName;
        this.lastName = lastName;
    }
    getFullName(): string {
        return this.firstName + " " + this.lastName;
    }
}
const person = new Person("John", "Doe");
const fullName = person.getFullName();

El método getFullName sirve para crear el nombre completo de la persona y devolverlo. Recurre a los valores de las propiedades firstName y lastName que se han definido en la clase e inicializado en el constructor. El objeto person se genera utilizando la palabra clave new seguida del nombre de la clase y de los parámetros correspondientes. Cuando se llama al método, concatena las dos cadenas y devuelve el nombre completo como una cadena o string. Por lo tanto, la salida para el objeto person es “John Doe”.

Ejemplos de aplicación de las clases de TypeScript

Las clases de TypeScript tienen varios mecanismos para organizar y controlar la estructura y el comportamiento de los objetos. A continuación, presentamos algunos conceptos para su uso.

Visibilidad

La visibilidad en las clases de TypeScript controla el acceso a las propiedades y métodos dentro y fuera de la clase. TypeScript proporciona tres modificadores de visibilidad: public, private y protected.

• public (estándar): las propiedades y los métodos marcados con public pueden llamarse desde cualquier lugar, tanto dentro como fuera de la clase.

• private: se refiere a propiedades y métodos que solo pueden llamarse dentro de la propia clase. Son inaccesibles para partes de código externas.

• protected: las propiedades y métodos marcados con protected pueden llamarse por la propia clase y por las clases derivadas (en herencia), pero no por código externo.

class Person {
    private socialSecurityNumber: string;
    constructor(ssn: string) {
        this.socialSecurityNumber = ssn;
    }
    greet() {
        console.log("Hello, I am a person with SSN: " + this.socialSecurityNumber);
    }
}
const person = new Person("123-45-6789");
person.greet();

En el ejemplo anterior, socialSecurityNumber (número de la Seguridad Social) es una propiedad privada a la que solo puede accederse dentro de la clase Person. En cambio, el método greet puede llamarse desde el exterior.

Herencia

La herencia es un concepto fundamental en la programación orientada a objetos (POO) que se utiliza en TypeScript y en muchos otros lenguajes de programación web. Permite crear una nueva clase a partir de una clase base o superclase existente. La clase derivada (subclase) hereda las propiedades y métodos de la clase base y puede ampliarlos o adaptarlos.

class Animal {
    name: string;
    constructor(name: string) {
        this.name = name;
    }
    makeSound() {
        console.log("Some generic sound");
    }
}
class Dog extends Animal {
    makeSound() {
        console.log(this.name + " barks");
    }
}
const myDog = new Dog("Buddy");
myDog.makeSound();

En el anterior código, la clase Dog (perro) hereda de la clase base Animal utilizando la palabra clave extends. La clase derivada Dog sobreescribe el método makeSound para añadir un comportamiento específico mientras asume la propiedad name de Animal.

Readonly

Al utilizar la palabra clave readonly, puedes declarar propiedades de las clases de TypeScript o los objetos como solo lectura. Esto supone que una vez que se inicializa una propiedad como de solo lectura, su valor no podrá modificarse después.

class Circle {
    readonly pi: number = 3.14159;
    radius: number;
    constructor(radius: number) {
        this.radius = radius;
    }
    getArea() {
        return this.pi    *this.radius*    this.radius;
    }
}
const myCircle = new Circle(5);
console.log(myCircle.getArea()); // Output: ≈ 78,54

En este ejemplo, la propiedad pi es de solo lectura y se inicializa en el constructor. Después de la inicialización, pi no puede modificarse. Si intentas modificar el valor de pi después de la inicialización, TypeScript generará un error de compilación.