Klasser i TypeScript

Denne artikel forklarer klasser i TypeScript.

YouTube Video

Klasser i TypeScript

Klasser i TypeScript er baseret på JavaScripts ES6-klasser og tilbyder yderligere funktioner som typeannoteringer og adgangsmodifikatorer. Dette giver dig mulighed for at udnytte koncepterne fra objektorienteret programmering og samtidig sikre stærkere og mere tydelig typesikkerhed.

Nedenfor forklares den grundlæggende brug og funktioner af klasser i TypeScript.

Grundlæggende klassedefinition

 1class Person {
 2    name: string;  // Member variable
 3    age: number;   // Member variable
 4
 5    // Constructor
 6    constructor(name: string, age: number) {
 7        this.name = name;
 8        this.age = age;
 9    }
10
11    // Method
12    greet(): void {
13        console.log(`Hello, my name is ${this.name} and I am ${this.age} years old.`);
14    }
15}
16
17const person = new Person("Alice", 25);
18person.greet();  // Hello, my name is Alice and I am 25 years old.

• name og age er egenskaber (medlemsvariabler) i klassen.
• constructor er en metode, der kaldes, når en instans af en klasse oprettes, som tager argumenter og tildeler værdier til egenskaber.
• greet er en metode i klassen, der angiver, at den ikke har nogen returværdi ved at være af typen void.

Adgangsmodifikatorer

I TypeScript kan du bruge adgangsmodifikatorer (public, private, protected) til at styre adgangen til klassens egenskaber og metoder.

public

Som standard er alle egenskaber og metoder public. Dette betyder, at de kan tilgås udefra klassen.

 1class Animal {
 2    public species: string;
 3
 4    constructor(species: string) {
 5        this.species = species;
 6    }
 7
 8    public makeSound(): void {
 9        console.log(`${this.species} makes a sound.`);
10    }
11}
12
13const animal = new Animal("Dog");
14console.log(animal.species);  // Dog
15animal.makeSound();           // Dog makes a sound.

• Egenskaben species og metoden makeSound er erklæret som public og kan tilgås udefra klassen.

private

Brugen af private-modifikatoren forhindrer adgang til egenskaber eller metoder udefra klassen.

 1class Car {
 2    private brand: string;
 3
 4    constructor(brand: string) {
 5        this.brand = brand;
 6    }
 7
 8    public getBrand(): string {
 9        return this.brand;
10    }
11}
12
13const car = new Car("Toyota");
14// console.log(car.brand);  // Error: 'brand' is private and cannot be accessed.
15console.log(car.getBrand());  // Toyota

• Egenskaben brand er erklæret som private, så den ikke kan tilgås udefra klassen.
• Indkapsling af data kan opnås ved at skjule egenskaber med private-modifikatoren.

protected

protected-modifikatoren begrænser adgang udefra klassen, men tillader det i underklasser (afledte klasser).

 1class Vehicle {
 2    protected model: string;
 3
 4    constructor(model: string) {
 5        this.model = model;
 6    }
 7}
 8
 9class Truck extends Vehicle {
10    public getModel(): string {
11        return this.model;
12    }
13}
14
15const truck = new Truck("Ford F-150");
16console.log(truck.getModel());  // Ford F-150
17
18// console.log(truck.model);
19// Error: Property 'model' is protected and only accessible within class 'Vehicle' and its subclasses.

• Egenskaben model er erklæret som protected, så den ikke kan tilgås udefra klassen, men kan tilgås fra underklasser.

Gettere og settere

I TypeScript kan du definere gettere og settere ved hjælp af nøgleordene get og set til at hente og indstille egenskabsværdier.

 1class Employee {
 2    private _salary: number;
 3
 4    constructor(salary: number) {
 5        this._salary = salary;
 6    }
 7
 8    // Getter
 9    get salary(): number {
10        return this._salary;
11    }
12
13    // Setter
14    set salary(newSalary: number) {
15        if (newSalary > 0) {
16            this._salary = newSalary;
17        } else {
18            console.log("Salary must be positive.");
19        }
20    }
21}
22
23const employee = new Employee(50000);
24console.log(employee.salary);  // 50000
25employee.salary = 60000;
26console.log(employee.salary);  // 60000
27employee.salary = -100;        // Salary must be positive.

• I dette eksempel bruges en getter og en setter for egenskaben salary for at kontrollere ekstern adgang og opdateringer. Setteren udfører validering for at forhindre negative værdier og viser en advarselsmeddelelse, hvis der gives en ugyldig værdi.

Arv

I TypeScript kan klasser arves. Ved hjælp af nøgleordet extends kan du arve funktionalitet fra en forælderklasse.

 1class Animal {
 2    constructor(public name: string) {}
 3
 4    public move(): void {
 5        console.log(`${this.name} is moving.`);
 6    }
 7}
 8
 9class Bird extends Animal {
10    public fly(): void {
11        console.log(`${this.name} is flying.`);
12    }
13}
14
15const bird = new Bird("Sparrow");
16bird.move();  // Sparrow is moving.
17bird.fly();   // Sparrow is flying.

• I dette eksempel arver klassen Bird fra klassen Animal, hvilket gør det muligt at bruge metoden move fra Animal. Derudover definerer den sin egen fly-metode og tilføjer ny funktionalitet, mens den arver egenskaber fra forældreklassen.

Abstrakte klasser

Abstrakte klasser (abstract) kan ikke instantieres direkte og bruges som skabeloner til at give konkrete implementeringer i underklasser.

 1abstract class Shape {
 2    abstract getArea(): number;
 3
 4    public describe(): void {
 5        console.log("This is a shape.");
 6    }
 7}
 8
 9class Circle extends Shape {
10    constructor(private radius: number) {
11        super();
12    }
13
14    public getArea(): number {
15        return Math.PI * this.radius * this.radius;
16    }
17}
18
19const circle = new Circle(5);
20console.log(circle.getArea());  // 78.53981633974483
21circle.describe();  // This is a shape.

• I dette eksempel er Shape defineret som en abstrakt klasse, og getArea er en abstrakt metode, der skal implementeres af underklasser. Klassen Circle arver denne abstrakte klasse og implementerer sin egen getArea-metode for at beregne arealet af en cirkel. Derudover arves konkrete metoder som describe som fælles funktionalitet og kan bruges som de er.

Forhold til interfaces

Klasser kan implementere interfaces, hvilket sikrer, at de har specifikke egenskaber og metoder.

 1interface Flyable {
 2    fly(): void;
 3}
 4
 5class Airplane implements Flyable {
 6    public fly(): void {
 7        console.log("The airplane is flying.");
 8    }
 9}
10
11const airplane: Flyable = new Airplane();
12airplane.fly();  // The airplane is flying.

• I dette eksempel definerer interfacet Flyable specifikationen for metoden fly, og klassen Airplane implementerer dette interface ved at give en konkret definition af metoden fly. Med dette garanteres det, at ethvert objekt, der kan behandles som en Flyable-type, har en fly-metode.

Statisk medlemmer

Når du definerer statisk medlemmer i en klasse, er disse metoder og egenskaber tilknyttet selve klassen. Statisk medlemmer kan kaldes uden at instantiere klassen.

 1class MathUtils {
 2    static PI: number = 3.14;
 3
 4    static add(a: number, b: number): number {
 5        return a + b;
 6    }
 7}
 8
 9console.log(MathUtils.add(10, 20)); // 30
10console.log(MathUtils.PI); // 3.14

• Du definerer statiske metoder ved at bruge nøgleordet static.
• I dette eksempel definerer klassen MathUtils en statisk metode add og en statisk egenskab PI.
• Statisk medlemmer tilhører ikke klasseinstanser, men kan kaldes direkte fra selve klassen.

Sammendrag

TypeScript-klasser tilføjer funktioner som typesikkerhed, adgangsmodifikatorer og abstrakte klasser til JavaScript-klassers funktionalitet. Dette muliggør mere effektiv og sikrere objektorienteret programmering.

Du kan følge med i ovenstående artikel ved hjælp af Visual Studio Code på vores YouTube-kanal. Husk også at tjekke YouTube-kanalen.

YouTube Video