Sådan bruges TypeScript-klasser med simple eksempler

TypeScript bringer kraftfulde funktioner til JavaScript, herunder begrebet klasser, som giver mulighed for objektorienteret programmering. Klasser giver en blueprint til at skabe objekter, indkapsle data og definere adfærd. Denne guide vil lede dig gennem det grundlæggende i TypeScript-klasser med enkle eksempler.

Hvad er en klasse?

En klasse er en blueprint til at skabe objekter med foruddefinerede egenskaber og metoder. Det hjælper med at organisere kode, fremme genbrugelighed og skabe skalerbare applikationer. Klasser i TypeScript fungerer på samme måde som klasser i andre objektorienterede programmeringssprog.

Definition af en basisklasse

For at definere en klasse i TypeScript skal du bruge nøgleordet class efterfulgt af klassenavnet og et sæt krøllede klammer, der indeholder egenskaber og metoder.

Grundlæggende klasseeksempel

Nedenfor er et eksempel på en simpel Person klasse med egenskaber og en metode:

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.

I dette eksempel har Person-klassen to egenskaber: navn og alder. Konstruktørmetoden initialiserer disse egenskaber, og greet-metoden udsender en hilsen.

Adgangsmodifikatorer

TypeScript giver tre adgangsmodifikatorer til at kontrollere synligheden af ​​klassemedlemmer:

• public: Medlemmer er tilgængelige fra hvor som helst (standard).
• privat: Medlemmer er kun tilgængelige inden for klassen.
• beskyttet: Medlemmer er tilgængelige inden for klassen og dens underklasser.

Brug af adgangsmodifikatorer

Sådan kan du bruge adgangsmodifikatorer i en TypeScript-klasse:

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

I dette eksempel er navn en offentlig ejendom, der er tilgængelig uden for klassen, mens alder er en privat ejendom, der kun er tilgængelig inden for klassen.

Arv i TypeScript

TypeScript understøtter arv, som tillader en klasse at arve egenskaber og metoder fra en anden klasse. Dette hjælper med at genbruge kode og skabe et hierarki af klasser.

Eksempel på arv

Nedenfor er et eksempel på en klasse Hund, der arver fra en basisklasse Dyr:

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.

I dette eksempel udvider Dog-klassen Animal-klassen og tilsidesætter makeSound-metoden.

Getters og Settere

TypeScript giver dig mulighed for at definere gettere og sættere for egenskaber, hvilket giver kontrolleret adgang til klassemedlemmer.

Getters og Setters Eksempel

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

I dette eksempel er egenskaben navn tilgået og ændret ved hjælp af getter- og setter-metoder.

Konklusion

TypeScript-klasser er en effektiv måde at skrive objektorienteret kode på på en ren og effektiv måde. De giver en struktureret måde at definere egenskaber, metoder, adgangsmodifikatorer, arv og mere på. Ved at forstå, hvordan man bruger TypeScript-klasser, kan du skrive mere robust og vedligeholdelig kode til dine applikationer.