Hoe TypeScript-klassen te gebruiken met eenvoudige voorbeelden

TypeScript brengt krachtige functies naar JavaScript, waaronder het concept van klassen, wat objectgeoriënteerd programmeren mogelijk maakt. Klassen bieden een blauwdruk voor het maken van objecten, het inkapselen van gegevens en het definiëren van gedragingen. Deze gids leidt u door de basisprincipes van TypeScript-klassen met eenvoudige voorbeelden.

Wat is een klasse?

Een klasse is een blauwdruk voor het maken van objecten met vooraf gedefinieerde eigenschappen en methoden. Het helpt bij het organiseren van code, het bevorderen van herbruikbaarheid en het maken van schaalbare applicaties. Klassen in TypeScript werken op een vergelijkbare manier als klassen in andere objectgeoriënteerde programmeertalen.

Een basisklasse definiëren

Om een ​​klasse in TypeScript te definiëren, gebruikt u het trefwoord class gevolgd door de klassenaam en een set accolades met eigenschappen en methoden.

Basisklasse voorbeeld

Hieronder ziet u een voorbeeld van een eenvoudige Person-klasse met eigenschappen en een methode:

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.

In dit voorbeeld heeft de klasse Person twee eigenschappen: name en age. De constructormethode initialiseert deze eigenschappen en de methode greet geeft een begroetingsbericht weer.

Toegangsmodifiers

TypeScript biedt drie toegangsmodifiers om de zichtbaarheid van klasseleden te beheren:

• public: Leden zijn overal toegankelijk (standaard).
• private: Leden zijn alleen toegankelijk binnen de klasse.
• protected: Leden zijn toegankelijk binnen de klasse en haar subklassen.

Toegangsmodifiers gebruiken

Hier ziet u hoe u toegangsmodifiers in een TypeScript-klasse kunt gebruiken:

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'.

In dit voorbeeld is naam een openbare eigenschap die toegankelijk is van buiten de klasse, terwijl leeftijd een privé-eigenschap is die alleen binnen de klasse toegankelijk is.

Overerving in TypeScript

TypeScript ondersteunt overerving, wat een klasse toestaat eigenschappen en methoden van een andere klasse over te erven. Dit helpt bij het hergebruiken van code en het creëren van een hiërarchie van klassen.

Erfenis voorbeeld

Hieronder ziet u een voorbeeld van een klasse Dog die erft van de basisklasse 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.

In dit voorbeeld breidt de klasse Dog de klasse Animal uit en overschrijft de methode makeSound.

Getters en Setters

Met TypeScript kunt u getters en setters voor eigenschappen definiëren, waardoor u gecontroleerde toegang tot klasseleden krijgt.

Getters en Setters Voorbeeld

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

In dit voorbeeld wordt de eigenschap name benaderd en gewijzigd met behulp van de getter- en settermethoden.

Conclusie

TypeScript-klassen zijn een krachtige manier om objectgeoriënteerde code op een schone en efficiënte manier te schrijven. Ze bieden een gestructureerde manier om eigenschappen, methoden, toegangsmodifiers, overerving en meer te definiëren. Door te begrijpen hoe u TypeScript-klassen gebruikt, kunt u robuustere en onderhoudbare code voor uw toepassingen schrijven.