Cum să utilizați clase TypeScript cu exemple simple

TypeScript aduce caracteristici puternice JavaScript, inclusiv conceptul de clase, care permite programarea orientată pe obiecte. Clasele oferă un plan pentru crearea de obiecte, încapsularea datelor și definirea comportamentelor. Acest ghid vă va ghida prin elementele de bază ale claselor TypeScript cu exemple simple.

Ce este o clasă?

O clasă este un plan pentru crearea de obiecte cu proprietăți și metode predefinite. Ajută la organizarea codului, promovarea reutilizabilității și crearea de aplicații scalabile. Clasele din TypeScript funcționează în mod similar cu clasele din alte limbaje de programare orientate pe obiecte.

Definirea unei clase de bază

Pentru a defini o clasă în TypeScript, utilizați cuvântul cheie class urmat de numele clasei și un set de acolade care conțin proprietăți și metode.

Exemplu de clasă de bază

Mai jos este un exemplu de clasă simplă Person cu proprietăți și o metodă:

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.

În acest exemplu, clasa Persoană are două proprietăți: nume și vârsta. Metoda constructorului inițializează aceste proprietăți, iar metoda greet scoate un mesaj de salut.

Modificatori de acces

TypeScript oferă trei modificatori de acces pentru a controla vizibilitatea membrilor clasei:

• public: Membrii sunt accesibili de oriunde (implicit).
• private: Membrii sunt accesibili numai în cadrul clasei.
• protected: Membrii sunt accesibili în cadrul clasei și subclaselor acesteia.

Utilizarea modificatorilor de acces

Iată cum puteți utiliza modificatorii de acces într-o clasă 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'.

În acest exemplu, name este o proprietate publică, accesibilă din afara clasei, în timp ce age este o proprietate privată, accesibilă numai în cadrul clasei.

Moștenirea în TypeScript

TypeScript acceptă moștenirea, ceea ce permite unei clase să moștenească proprietăți și metode de la o altă clasă. Acest lucru ajută la reutilizarea codului și la crearea unei ierarhii de clase.

Exemplu de moștenire

Mai jos este un exemplu de clasă Dog care moștenește dintr-o clasă de bază 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.

În acest exemplu, clasa Dog extinde clasa Animal și suprascrie metoda makeSound.

Getters și Setters

TypeScript vă permite să definiți getters și setters pentru proprietăți, oferind acces controlat membrilor clasei.

Exemplu de getters și 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

În acest exemplu, proprietatea name este accesată și modificată folosind metode getter și setter.

Concluzie

Clasele TypeScript sunt o modalitate puternică de a scrie cod orientat pe obiecte într-o manieră curată și eficientă. Ele oferă o modalitate structurată de a defini proprietăți, metode, modificatori de acces, moștenire și multe altele. Înțelegând cum să utilizați clasele TypeScript, puteți scrie cod mai robust și mai ușor de întreținut pentru aplicațiile dvs.