Jak używać klas TypeScript z prostymi przykładami

TypeScript wprowadza potężne funkcje do JavaScript, w tym koncepcję klas, która umożliwia programowanie obiektowe. Klasy zapewniają plan tworzenia obiektów, hermetyzowania danych i definiowania zachowań. Ten przewodnik przeprowadzi Cię przez podstawy klas TypeScript za pomocą prostych przykładów.

Czym jest klasa?

Klasa to plan tworzenia obiektów z predefiniowanymi właściwościami i metodami. Pomaga w organizowaniu kodu, promowaniu możliwości ponownego użycia i tworzeniu skalowalnych aplikacji. Klasy w TypeScript działają podobnie do klas w innych obiektowych językach programowania.

Definiowanie klasy podstawowej

Aby zdefiniować klasę w TypeScript, należy użyć słowa kluczowego class, po którym należy podać nazwę klasy i zestaw nawiasów klamrowych zawierający właściwości i metody.

Przykład podstawowej klasy

Poniżej znajduje się przykład prostej klasy Person z właściwościami i 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.

W tym przykładzie klasa Person ma dwie właściwości: name i age. Metoda konstruktora inicjuje te właściwości, a metoda greet wyprowadza wiadomość powitalną.

Modyfikatory dostępu

TypeScript udostępnia trzy modyfikatory dostępu umożliwiające kontrolę widoczności elementów klasy:

• public: Dostęp do członków jest możliwy z dowolnego miejsca (domyślnie).
• private: Członkowie są dostępni tylko w obrębie klasy.
• protected: Elementy są dostępne w obrębie klasy i jej podklas.

Korzystanie z modyfikatorów dostępu

Oto jak można używać modyfikatorów dostępu w klasie 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'.

W tym przykładzie name jest właściwością publiczną, dostępną spoza klasy, natomiast age jest właściwością prywatną, dostępną tylko w obrębie klasy.

Dziedziczenie w TypeScript

TypeScript obsługuje dziedziczenie, co pozwala klasie dziedziczyć właściwości i metody z innej klasy. Pomaga to w ponownym użyciu kodu i tworzeniu hierarchii klas.

Przykład dziedziczenia

Poniżej znajduje się przykład klasy Dog dziedziczącej po klasie bazowej 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.

W tym przykładzie klasa Dog rozszerza klasę Animal i nadpisuje metodę makeSound.

Gettery i settery

TypeScript umożliwia definiowanie metod getter i setter dla właściwości, zapewniając kontrolowany dostęp do elementów klasy.

Przykład getterów i setterów

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

W tym przykładzie do właściwości name uzyskuje się dostęp i ją modyfikuje za pomocą metod getter i setter.

Wniosek

Klasy TypeScript to potężny sposób pisania kodu obiektowego w czysty i wydajny sposób. Zapewniają ustrukturyzowany sposób definiowania właściwości, metod, modyfikatorów dostępu, dziedziczenia i innych. Rozumiejąc, jak używać klas TypeScript, możesz pisać bardziej solidny i łatwiejszy w utrzymaniu kod dla swoich aplikacji.