Slik bruker du TypeScript-klasser med enkle eksempler

TypeScript bringer kraftige funksjoner til JavaScript, inkludert konseptet med klasser, som tillater objektorientert programmering. Klasser gir en blåkopi for å lage objekter, innkapsle data og definere atferd. Denne veiledningen vil lede deg gjennom det grunnleggende om TypeScript-klasser med enkle eksempler.

Hva er en klasse?

En klasse er en blåkopi for å lage objekter med forhåndsdefinerte egenskaper og metoder. Det hjelper med å organisere kode, fremme gjenbrukbarhet og lage skalerbare applikasjoner. Klasser i TypeScript fungerer på samme måte som klasser i andre objektorienterte programmeringsspråk.

Definere en grunnleggende klasse

For å definere en klasse i TypeScript, bruk nøkkelordet class etterfulgt av klassenavnet og et sett med krøllete klammeparenteser som inneholder egenskaper og metoder.

Grunnleggende klasseeksempel

Nedenfor er et eksempel på en enkel Person-klasse med egenskaper 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 eksemplet har Person-klassen to egenskaper: navn og alder. Konstruktørmetoden initialiserer disse egenskapene, og greet-metoden sender ut en hilsen.

Tilgangsmodifikatorer

TypeScript gir tre tilgangsmodifikatorer for å kontrollere synligheten til klassemedlemmer:

• public: Medlemmer er tilgjengelige fra hvor som helst (standard).
• privat: Medlemmer er kun tilgjengelige innenfor klassen.
• beskyttet: Medlemmer er tilgjengelige innenfor klassen og dens underklasser.

Bruke tilgangsmodifikatorer

Slik kan du bruke tilgangsmodifikatorer 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 eksemplet er navn en offentlig eiendom, tilgjengelig fra utenfor klassen, mens alder er en privat eiendom, kun tilgjengelig innenfor klassen.

Arv i TypeScript

TypeScript støtter arv, som lar en klasse arve egenskaper og metoder fra en annen klasse. Dette hjelper med å gjenbruke kode og lage et hierarki av klasser.

Eksempel på arv

Nedenfor er et eksempel på en klasse Hund som arver fra en grunnklasse 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 eksemplet utvider Dog-klassen Animal-klassen og overstyrer makeSound-metoden.

Getters og Setters

TypeScript lar deg definere gettere og settere for egenskaper, og gir kontrollert tilgang 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 eksemplet er name-egenskapen åpnet og modifisert ved hjelp av getter- og setter-metoder.

Konklusjon

TypeScript-klasser er en kraftig måte å skrive objektorientert kode på en ren og effektiv måte. De gir en strukturert måte å definere egenskaper, metoder, tilgangsmodifikatorer, arv og mer. Ved å forstå hvordan du bruker TypeScript-klasser, kan du skrive mer robust og vedlikeholdbar kode for applikasjonene dine.