Ty­pe­S­cri­pt classes: cómo de­fi­ni­r­las y uti­li­zar­las

Las clases de Ty­pe­S­cri­pt pro­po­r­cio­nan una forma clara y es­tru­c­tu­ra­da de organizar datos y co­m­po­r­ta­mie­n­tos 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 co­m­pre­n­si­ble.

¿Para qué se utilizan las clases de Ty­pe­S­cri­pt?

Las clases son fu­n­da­me­n­ta­les en el lenguaje de pro­gra­ma­ción Ty­pe­S­cri­pt, que está basado en Ja­va­S­cri­pt. Pro­po­r­cio­nan un método es­tru­c­tu­ra­do para definir objetos y aplicar la pro­gra­ma­ción orientada a objetos (OOP). Las clases de Ty­pe­S­cri­pt son como una especie de planos para la creación de objetos, que agrupan datos y métodos re­la­cio­na­dos de manera lógica.

Ty­pe­S­cri­pt contiene todas las funciones de Ja­va­S­cri­pt e incluye tipado estático, lo que permite es­pe­ci­fi­car tipos de datos para funciones en Ty­pe­S­cri­pt, variables y clases, así como detectar errores en tiempo de co­m­pi­la­ción. Además de la seguridad de tipos, las clases de Ty­pe­S­cri­pt también soportan conceptos como la herencia y la ab­s­tra­c­ción, lo que facilita el de­sa­rro­llo de apli­ca­cio­nes complejas.

Las clases de Ty­pe­S­cri­pt te permiten es­ta­ble­cer una jerarquía clara de clases que heredan pro­pie­da­des y métodos. Esto fomenta la re­uti­li­za­ción de código y su es­tru­c­tu­ra­ción. Los co­n­s­tru­c­to­res en las clases po­si­bi­li­tan la ini­cia­li­za­ción de in­s­ta­n­cias y aseguran una creación de objetos coherente.

La sintaxis de las clases de Ty­pe­S­cri­pt

La sintaxis de las clases en Ty­pe­S­cri­pt se asemeja a la de EC­MA­S­cri­pt 6 (ES6) y es una versión extendida de la sintaxis de clases de Ja­va­S­cri­pt. Una clase puede contener varios elementos para definir la es­tru­c­tu­ra y el co­m­po­r­ta­mie­n­to de los objetos. Estos son sus co­m­po­ne­n­tes pri­n­ci­pa­les:

• Pro­pie­da­des,
• co­n­s­tru­c­tor y
• métodos.

Pro­pie­da­des

Las pro­pie­da­des o pro­pe­r­ties de­te­r­mi­nan el estado de un objeto. Almacenan valores de datos y pueden anotarse con tipos de datos para ga­ra­n­ti­zar que solo contengan valores válidos.

class ClassName {
    propertyName: propertyType;
}

• ClassName: el nombre de la clase.
• pro­pe­r­t­y­Na­me: el nombre de la propiedad que quieras definir.
• pro­pe­r­t­y­T­y­pe: 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 de­no­mi­na­da name (nombre) del tipo string. Esto quiere decir que las in­s­ta­n­cias de la clase Person tienen una propiedad name que almacena cadenas de texto (strings).

Co­n­s­tru­c­tor

El co­n­s­tru­c­tor en Ty­pe­S­cri­pt es un método especial que se llama al crear una instancia (un objeto) de una clase. Se utiliza para realizar la ini­cia­li­za­ción de las pro­pie­da­des (pro­pe­r­ties) de un objeto. Bá­si­ca­me­n­te, el co­n­s­tru­c­tor establece el estado inicial de una instancia. Puedes es­pe­ci­fi­car pa­rá­me­tros en el co­n­s­tru­c­tor para pasar valores al in­s­ta­n­ciar clases de Ty­pe­S­cri­pt.

La es­tru­c­tu­ra básica de un co­n­s­tru­c­tor en Ty­pe­S­cri­pt tiene el siguiente aspecto:

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

• co­n­s­tru­c­tor: cada clase puede tener solo un co­n­s­tru­c­tor. Si no se define ninguno, se crea un co­n­s­tru­c­tor vacío por defecto.
• parameter: Type: los pa­rá­me­tros pueden ser ne­ce­sa­rios o no de­pe­n­die­n­do 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 co­n­s­tru­c­tor:

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 co­n­s­tru­c­tor que acepta dos pa­rá­me­tros: firstName (nombre) y lastName (apellido). Al crear una instancia de esta clase, se pasan estos pa­rá­me­tros y el co­n­s­tru­c­tor ini­cia­li­za las pro­pie­da­des firstName y lastName de la instancia con los valores co­rre­s­po­n­die­n­tes. La palabra clave this se refiere a la instancia actual de la clase en la que se está eje­cu­ta­n­do el código.

Métodos

En Ty­pe­S­cri­pt, los métodos son funciones que pueden definirse en las clases y aplicarse a sus in­s­ta­n­cias. Con ellos se pueden realizar ciertas acciones u ope­ra­cio­nes en el contexto de una clase.

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

• me­tho­d­Na­me: nombre del método.
• parameter: Type: pa­rá­me­tros op­cio­na­les que acepta el método.
• Re­tu­r­n­T­y­pe: es el tipo de datos que determina qué valor devuelve el método. Si el método no devuelve nada, puedes es­pe­ci­fi­car 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 ar­gu­me­n­tos ne­ce­sa­rios si el método espera pa­rá­me­tros.

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 de­vo­l­ve­r­lo. Recurre a los valores de las pro­pie­da­des firstName y lastName que se han definido en la clase e ini­cia­li­za­do en el co­n­s­tru­c­tor. El objeto person se genera uti­li­za­n­do la palabra clave new seguida del nombre de la clase y de los pa­rá­me­tros co­rre­s­po­n­die­n­tes. 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 apli­ca­ción de las clases de Ty­pe­S­cri­pt

Las clases de Ty­pe­S­cri­pt tienen varios me­ca­ni­s­mos para organizar y controlar la es­tru­c­tu­ra y el co­m­po­r­ta­mie­n­to de los objetos. A co­n­ti­nua­ción, pre­se­n­ta­mos algunos conceptos para su uso.

Vi­si­bi­li­dad

La vi­si­bi­li­dad en las clases de Ty­pe­S­cri­pt controla el acceso a las pro­pie­da­des y métodos dentro y fuera de la clase. Ty­pe­S­cri­pt pro­po­r­cio­na tres mo­di­fi­ca­do­res de vi­si­bi­li­dad: public, private y protected.

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

• private: se refiere a pro­pie­da­des y métodos que solo pueden llamarse dentro de la propia clase. Son inac­ce­si­bles para partes de código externas.

• protected: las pro­pie­da­des 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 fu­n­da­me­n­tal en la pro­gra­ma­ción orientada a objetos (POO) que se utiliza en Ty­pe­S­cri­pt y en muchos otros lenguajes de pro­gra­ma­ción web. Permite crear una nueva clase a partir de una clase base o su­pe­r­cla­se existente. La clase derivada (subclase) hereda las pro­pie­da­des y métodos de la clase base y puede am­pliar­los o ada­p­tar­los.

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 uti­li­za­n­do la palabra clave extends. La clase derivada Dog so­bree­s­cri­be el método makeSound para añadir un co­m­po­r­ta­mie­n­to es­pe­cí­fi­co mientras asume la propiedad name de Animal.

Readonly

Al utilizar la palabra clave readonly, puedes declarar pro­pie­da­des de las clases de Ty­pe­S­cri­pt o los objetos como solo lectura. Esto supone que una vez que se ini­cia­li­za una propiedad como de solo lectura, su valor no podrá mo­di­fi­car­se 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 ini­cia­li­za en el co­n­s­tru­c­tor. Después de la ini­cia­li­za­ción, pi no puede mo­di­fi­car­se. Si intentas modificar el valor de pi después de la ini­cia­li­za­ción, Ty­pe­S­cri­pt generará un error de co­m­pi­la­ción.