Cómo utilizar clases TypeScript con ejemplos sencillos

TypeScript aporta potentes funciones a JavaScript, incluido el concepto de clases, que permite la programación orientada a objetos. Las clases proporcionan un modelo para crear objetos, encapsular datos y definir comportamientos. Esta guía le mostrará los conceptos básicos de las clases de TypeScript con ejemplos simples.

¿Qué es una clase?

Una clase es un modelo para crear objetos con propiedades y métodos predefinidos. Ayuda a organizar el código, promover la reutilización y crear aplicaciones escalables. Las clases en TypeScript funcionan de manera similar a las clases en otros lenguajes de programación orientados a objetos.

Definiendo una clase básica

Para definir una clase en TypeScript, utilice la palabra clave class seguida del nombre de la clase y un conjunto de llaves que contienen propiedades y métodos.

Ejemplo de clase básica

A continuación se muestra un ejemplo de una clase Person simple con propiedades y un método:

class Person {
  name: string;
  age: number;

  constructor(name: string, age: number) {
    this.name = name;
    this.age = age;
  }

  greet(): void {
    console.log(`Hello, my name is ${this.name} and I am ${this.age} years old.`);
  }
}

const person1 = new Person("Alice", 30);
person1.greet(); // Output: Hello, my name is Alice and I am 30 years old.

En este ejemplo, la clase Person tiene dos propiedades: name y age. El método constructor inicializa estas propiedades y el método greet genera un mensaje de saludo.

Modificadores de acceso

TypeScript proporciona tres modificadores de acceso para controlar la visibilidad de los miembros de la clase:

• public: Los miembros son accesibles desde cualquier lugar (predeterminado).
• private: Los miembros son accesibles solo dentro de la clase.
• protected: Los miembros son accesibles dentro de la clase y sus subclases.

Uso de modificadores de acceso

A continuación se explica cómo puede utilizar modificadores de acceso en una clase TypeScript:

class Animal {
  public name: string;
  private age: number;

  constructor(name: string, age: number) {
    this.name = name;
    this.age = age;
  }

  public getAge(): number {
    return this.age;
  }
}

const dog = new Animal("Buddy", 5);
console.log(dog.name); // Output: Buddy
console.log(dog.getAge()); // Output: 5
// console.log(dog.age); // Error: 'age' is private and only accessible within class 'Animal'.

En este ejemplo, name es una propiedad pública, accesible desde fuera de la clase, mientras que age es una propiedad privada, accesible solo dentro de la clase.

Herencia en TypeScript

TypeScript admite la herencia, lo que permite que una clase herede propiedades y métodos de otra clase. Esto ayuda a reutilizar el código y a crear una jerarquía de clases.

Ejemplo de herencia

A continuación se muestra un ejemplo de una clase Dog que hereda de una clase base Animal:

class Animal {
  constructor(public name: string) {}

  makeSound(): void {
    console.log(`${this.name} makes a sound.`);
  }
}

class Dog extends Animal {
  constructor(name: string) {
    super(name); // Call the constructor of the base class
  }

  makeSound(): void {
    console.log(`${this.name} barks.`);
  }
}

const dog = new Dog("Buddy");
dog.makeSound(); // Output: Buddy barks.

En este ejemplo, la clase Dog extiende la clase Animal y anula el método makeSound.

Captadores y definidores

TypeScript le permite definir métodos getters y setters para propiedades, proporcionando acceso controlado a los miembros de la clase.

Ejemplo de métodos getters y setters

class Person {
  private _name: string;

  constructor(name: string) {
    this._name = name;
  }

  get name(): string {
    return this._name;
  }

  set name(newName: string) {
    if (newName) {
      this._name = newName;
    } else {
      console.log("Name cannot be empty.");
    }
  }
}

const person = new Person("Alice");
console.log(person.name); // Output: Alice
person.name = "Bob";
console.log(person.name); // Output: Bob

En este ejemplo, se accede a la propiedad name y se modifica mediante métodos getter y setter.

Conclusión

Las clases TypeScript son una forma eficaz de escribir código orientado a objetos de forma clara y eficiente. Ofrecen una forma estructurada de definir propiedades, métodos, modificadores de acceso, herencia y más. Si comprende cómo usar las clases TypeScript, podrá escribir código más sólido y fácil de mantener para sus aplicaciones.