Hur man använder TypeScript-klasser med enkla exempel

TypeScript ger kraftfulla funktioner till JavaScript, inklusive konceptet med klasser, som möjliggör objektorienterad programmering. Klasser ger en ritning för att skapa objekt, kapsla in data och definiera beteenden. Den här guiden går igenom grunderna i TypeScript-klasser med enkla exempel.

Vad är en klass?

En klass är en ritning för att skapa objekt med fördefinierade egenskaper och metoder. Det hjälper till att organisera kod, främja återanvändbarhet och skapa skalbara applikationer. Klasser i TypeScript fungerar på samma sätt som klasser i andra objektorienterade programmeringsspråk.

Definiera en grundläggande klass

För att definiera en klass i TypeScript, använd nyckelordet class följt av klassnamnet och en uppsättning hängslen som innehåller egenskaper och metoder.

Exempel på grundläggande klass

Nedan är ett exempel på en enkel klass Person med egenskaper och en 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.

I det här exemplet har klassen Person två egenskaper: namn och ålder. Konstruktormetoden initierar dessa egenskaper och metoden greet matar ut ett hälsningsmeddelande.

Åtkomstmodifierare

TypeScript tillhandahåller tre åtkomstmodifierare för att kontrollera synligheten för klassmedlemmar:

• public: Medlemmar är tillgängliga från var som helst (standard).
• privat: Medlemmar är endast tillgängliga inom klassen.
• protected: Medlemmar är tillgängliga inom klassen och dess underklasser.

Använda åtkomstmodifierare

Så här kan du använda åtkomstmodifierare i en TypeScript-klass:

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 det här exemplet är namn en allmän egendom som är tillgänglig utanför klassen, medan ålder är en privat egendom, endast tillgänglig inom klassen.

Arv i TypeScript

TypeScript stöder arv, vilket gör att en klass kan ärva egenskaper och metoder från en annan klass. Detta hjälper till att återanvända kod och skapa en hierarki av klasser.

Arvsexempel

Nedan är ett exempel på en klass Hund som ärver från en basklass Djur:

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 det här exemplet utökar klassen Dog klassen Animal och åsidosätter metoden makeSound.

Getters och Setters

TypeScript låter dig definiera getters och seters för egenskaper, vilket ger kontrollerad åtkomst till klassmedlemmar.

Getters och Setters Exempel

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 det här exemplet nås och ändras egenskapen name med getter- och settermetoder.

Slutsats

TypeScript-klasser är ett kraftfullt sätt att skriva objektorienterad kod på ett rent och effektivt sätt. De tillhandahåller ett strukturerat sätt att definiera egenskaper, metoder, åtkomstmodifierare, arv och mer. Genom att förstå hur man använder TypeScript-klasser kan du skriva mer robust och underhållbar kod för dina applikationer.