Klasser i TypeScript

Denne artikkelen forklarer klasser i TypeScript.

YouTube Video

Klasser i TypeScript

Klasser i TypeScript er basert på JavaScript sine ES6-klasser og tilbyr tilleggsegenskaper som typeannotasjoner og tilgangsmodifikatorer. Dette lar deg utnytte konseptene i objektorientert programmering samtidig som du sikrer robust og tydelig typesikkerhet.

Nedenfor finner du forklaringer på grunnleggende bruk og egenskaper til klasser i TypeScript.

Grunnleggende klassedefinisjon

 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 egenskaper (medlemsvariabler) av klassen.
• constructor er en metode som kalles når man oppretter en instans av en klasse, og som tar argumenter og tildeler verdier til egenskaper.
• greet er en metode i klassen, som angir at den ikke har noen returverdi ved å være av typen void.

Tilgangsmodifikatorer

I TypeScript kan du bruke tilgangsmodifikatorer (public, private, protected) for å kontrollere tilgangen til klasseegenskaper og metoder.

public

Som standard er alle egenskaper og metoder public. Dette betyr at de kan nås fra utsiden av 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.

• species-egenskapen og makeSound-metoden er deklarert som public og kan nås fra utsiden av klassen.

private

Ved å bruke private-modifikatoren forhindrer du tilgang til egenskapene eller metodene fra utsiden av 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

• brand-egenskapen er deklarert som private, så den kan ikke nås fra utsiden av klassen.
• Innkapsling av data kan oppnås ved å skjule egenskaper med private-modifikatoren.

protected

protected-modifikatoren begrenser tilgang fra utsiden av klassen, men tillater det i underklasser (avledede 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.

• model-egenskapen er deklarert som protected, så den kan ikke nås fra utsiden av klassen, men kan nås fra subklasser.

Gettere og settere

I TypeScript kan du definere gettere og settere ved å bruke nøkkelordene get og set for å hente og angi verdier for egenskaper.

 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 eksemplet brukes en getter og setter for salary-egenskapen for å kontrollere ekstern tilgang og oppdateringer. Setteren utfører validering for å forhindre negative verdier, og viser en advarsel hvis en ugyldig verdi angis.

Arv

I TypeScript kan klasser arves. Ved å bruke nøkkelordet extends kan du arve funksjonalitet fra en overordnet klasse.

 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 eksemplet arver Bird-klassen fra Animal-klassen, noe som lar den bruke move-metoden til Animal. Videre definerer den sin egen fly-metode og legger til ny funksjonalitet samtidig som den arver egenskaper fra superklassen.

Abstrakte klasser

Abstrakte klasser (abstract) kan ikke instanseres direkte og brukes som maler for å tilby konkrete implementasjoner 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 eksemplet er Shape definert som en abstrakt klasse, og getArea er en abstrakt metode som må implementeres av subklasser. Circle-klassen arver denne abstrakte klassen og implementerer sin egen getArea-metode for å beregne arealet til en sirkel. I tillegg arves konkrete metoder som describe som felles funksjonalitet og kan brukes som de er.

Forhold til grensesnitt

Klasser kan implementere grensesnitt, noe som sikrer at de har spesifikke egenskaper 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 eksemplet definerer Flyable-grensesnittet spesifikasjonen for fly-metoden, og Airplane-klassen implementerer dette grensesnittet ved å gi en konkret definisjon av fly-metoden. Med dette er det garantert at alle objekter som kan behandles som Flyable-typen har en fly-metode.

Statisk medlemmer

Når du definerer statisk medlemmer i en klasse, er disse metodene og egenskapene tilknyttet selve klassen. Statisk medlemmer kan kalles uten å instansiere 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 å bruke nøkkelordet static.
• I dette eksemplet definerer MathUtils-klassen en statisk metode add og en statisk egenskap PI.
• Statisk medlemmer tilhører ikke klasseinstanser, men kan kalles direkte fra selve klassen.

Sammendrag

TypeScript-klasser legger til funksjoner som typesikkerhet, tilgangsmodifikatorer og abstrakte klasser til JavaScript-klassefunksjonalitet. Dette muliggjør mer kraftig og sikker objektorientert programmering.

Du kan følge med på artikkelen ovenfor ved å bruke Visual Studio Code på vår YouTube-kanal. Vennligst sjekk ut YouTube-kanalen.

YouTube Video