Hoe Ty­pe­Script-klassen de­fi­ni­ë­ren en gebruiken

Ty­pe­Script-klassen bieden een dui­de­lij­ke en ge­struc­tu­reer­de manier om gegevens en gedrag in een object te or­ga­ni­se­ren. Dit maakt het ge­mak­ke­lij­ker om en­ti­tei­ten en concepten in uw code te mo­del­le­ren.

Wat zijn Ty­pe­Script-klassen?

Klassen zijn een be­lang­rijk concept van Ty­pe­Script, een pro­gram­meer­taal die is gebaseerd op Ja­vaScript. Klassen ver­te­gen­woor­di­gen een ge­struc­tu­reer­de methode voor het de­fi­ni­ë­ren van objecten en voor het toepassen van ob­ject­ge­o­ri­ën­teerd pro­gram­me­ren (OOP). Ty­pe­Script-klassen zijn als blauw­druk­ken voor het maken van objecten die logisch ge­re­la­teer­de gegevens en methoden bundelen.

Ty­pe­Script bevat alle functies van Ja­vaScript en omvat ook statische typering. Hierdoor kunt u ge­ge­vens­ty­pen spe­ci­fi­ce­ren voor Ty­pe­Script-functies, va­ri­a­be­len en klassen, zodat u fouten tijdens het com­pi­le­ren kunt opsporen. Naast ty­pe­vei­lig­heid on­der­steu­nen Ty­pe­Script-klassen ook concepten zoals over­er­ving en ab­strac­tie, wat de ont­wik­ke­ling van complexe ap­pli­ca­ties ver­ge­mak­ke­lijkt.

Met Ty­pe­Script-klassen kunt u een dui­de­lij­ke hi­ë­rar­chie van klassen creëren die ei­gen­schap­pen en methoden erven. Dit bevordert her­ge­bruik en struc­tu­re­ring van code. Klas­sen­con­struc­tors maken het mogelijk om in­stan­ties te ini­ti­a­li­se­ren en zorgen voor con­sis­ten­te ob­ject­cre­a­tie.

Wat is de syntaxis voor Ty­pe­Script-klassen?

De notatie van Ty­pe­Script-klassen is ver­ge­lijk­baar met die van EC­MAScript 6 (ES6) en is een uit­ge­brei­de versie van de Ja­vaScript-klas­sen­syn­taxis. Een Ty­pe­Script-klasse kan ver­schil­len­de elementen bevatten om de structuur en het gedrag van objecten te de­fi­ni­ë­ren. De be­lang­rijk­ste com­po­nen­ten zijn:

• Ei­gen­schap­pen
• Con­struc­tors
• Methoden

Ei­gen­schap­pen

Ei­gen­schap­pen bepalen de status van een object. Ze slaan ge­ge­vens­waar­den op en kunnen worden ge­an­no­teerd met ge­ge­vens­ty­pen, zodat ze alleen geldige waarden bevatten.

class ClassName {
    propertyName: propertyType;
}

• ClassName: de naam van de klasse
• pro­per­ty­Na­me: de naam van de ei­gen­schap die u wilt de­fi­ni­ë­ren
• pro­per­ty­Ty­pe: het ge­ge­vens­ty­pe van de ei­gen­schap

Hier is een concreet voorbeeld:

class Person {
    name: string;
}

Eerst wordt een klasse Person ge­de­fi­ni­eerd met een ei­gen­schap name van type string. Dit betekent dat in­stan­ties van de klasse Person een ei­gen­schap name hebben die strings opslaat.

Con­struc­teur

De con­struc­tor in Ty­pe­Script is een speciale methode die wordt aan­ge­roe­pen wanneer een klasse-instantie (object) wordt aan­ge­maakt. Je hebt deze nodig om de ei­gen­schap­pen van een object te ini­ti­a­li­se­ren. De con­struc­tor de­fi­ni­eert in wezen de be­gin­toe­stand van een instantie. Je kunt pa­ra­me­ters spe­ci­fi­ce­ren in de con­struc­tor om waarden door te geven bij het in­stan­ti­ë­ren van Ty­pe­Script-klassen.

De ba­sis­syn­taxis van een con­struc­tor in Ty­pe­Script is:

class ClassName {
    constructor(parameter1: Type1, parameter2: Type2, ...) {
    }
}

• con­struc­tor: elke klasse kan één con­struc­tor hebben. Als er geen con­struc­tor is ge­de­fi­ni­eerd, wordt standaard een lege con­struc­tor aan­ge­maakt.
• parameter: Type: pa­ra­me­ters zijn optioneel, af­han­ke­lijk van de klasse en de vereisten ervan. Pa­ra­me­ters moeten worden gelabeld met hun ge­ge­vens­ty­pen.

Een voorbeeld van een con­struc­tor:

class Person {
    firstName: string;
    lastName: string;
    constructor(firstName: string, lastName: string) {
        this.firstName = firstName;
        this.lastName = lastName;
    }
}

In het bo­ven­staan­de voorbeeld heeft de klasse Person een con­struc­tor die twee pa­ra­me­ters firstName en lastName ac­cep­teert. Bij het aanmaken van een instantie van deze klasse worden deze pa­ra­me­ters door­ge­ge­ven en ini­ti­a­li­seert de con­struc­tor de ei­gen­schap­pen firstName en lastName van de instantie met de over­een­kom­sti­ge waarden. this verwijst naar de huidige instantie van de klasse waarop de code wordt uit­ge­voerd.

Methoden

In Ty­pe­Script zijn methoden functies die in klassen kunnen worden ge­de­fi­ni­eerd en op hun in­stan­ties kunnen worden toegepast. Met methoden kunt u bepaalde acties of be­wer­kin­gen uitvoeren in de context van een klasse.

class ClassName {
    // ...
    methodName(parameter1: Type1, parameter2: Type2, ...): ReturnType {
    }
    // ...
}

• me­thod­Na­me: naam van de methode
• parameter: Type: optionele pa­ra­me­ters die de methode ac­cep­teert
• Re­turn­Ty­pe: dit is het ge­ge­vens­ty­pe dat de waarde bepaalt die de methode re­tour­neert. Als de methode niets re­tour­neert, kunt u void opgeven.

Om toegang te krijgen tot een ei­gen­schap of een methode aan te roepen op een klasse-instantie, gebruikt u de punt­ope­ra­tor . gevolgd door de naam van de methode en de vereiste ar­gu­men­ten als de methode pa­ra­me­ters verwacht.

class Person {
    firstName: string;
    lastName: string;
    constructor(firstName: string, lastName: string) {
        this.firstName = firstName;
        this.lastName = lastName;
    }
    getFullName(): string {
        return this.firstName + " " + this.lastName;
    }
}
const person = new Person("John", "Doe");
const fullName = person.getFullName();

De methode getFullName wordt gebruikt om de volledige naam van de persoon te creëren en terug te geven. Deze methode heeft toegang tot de waarden van de ei­gen­schap­pen firstName en lastName die in de klasse zijn ge­de­fi­ni­eerd en in de con­struc­tor zijn ge­ï­ni­ti­a­li­seerd. Het object person wordt aan­ge­maakt door het sleu­tel­woord new, gevolgd door de klas­se­naam en de res­pec­tie­ve pa­ra­me­ters. De methode voegt de twee strings samen wanneer deze wordt aan­ge­roe­pen en re­tour­neert de volledige naam als een string. De uitvoer voor het object person is daarom “John Doe”.

Voor­beel­den van Ty­pe­Script-klassen

Ty­pe­Script-klassen be­schik­ken over ver­schil­len­de me­cha­nis­men om de structuur en het gedrag van objecten te or­ga­ni­se­ren en te con­tro­le­ren. Hieronder pre­sen­te­ren we enkele concepten voor het gebruik van Ty­pe­Script-klassen.

Toegang

Ty­pe­Script biedt drie toe­gangs­mo­di­fi­ca­to­ren: public, private en protected om de toegang tot ei­gen­schap­pen en methoden binnen en buiten de klasse te regelen.

• openbaar (standaard): ei­gen­schap­pen en methoden ge­mar­keerd met public kunnen overal worden aan­ge­roe­pen, zowel binnen als buiten de klasse.
• privé: private verwijst naar ei­gen­schap­pen en methoden die alleen binnen de klasse zelf kunnen worden aan­ge­roe­pen. Ze zijn niet toe­gan­ke­lijk voor externe co­de­ge­deel­ten.
• beschermd: ei­gen­schap­pen en methoden ge­mar­keerd met protected kunnen worden aan­ge­roe­pen door de klasse zelf en door afgeleide klassen (in over­er­ving), maar niet door externe code.

class Person {
    private socialSecurityNumber: string;
    constructor(ssn: string) {
        this.socialSecurityNumber = ssn;
    }
    greet() {
        console.log("Hello, I am a person with SSN: " + this.socialSecurityNumber);
    }
}
const person = new Person("123-45-6789");
person.greet();

In dit voorbeeld is socialSecurityNumber een privé-ei­gen­schap die alleen toe­gan­ke­lijk is binnen de klasse Person. U kunt de methode greet echter wel buiten de klasse aanroepen.

Erfenis

Over­er­ving is een fun­da­men­teel concept in ob­ject­ge­o­ri­ën­teerd pro­gram­me­ren (OOP) dat wordt gebruikt in Ty­pe­Script en vele andere in­ter­net­pro­gram­meer­ta­len. Het maakt het mogelijk om een nieuwe klasse te creëren op basis van een bestaande ba­sis­klas­se of su­per­klas­se. De afgeleide klasse (subklasse) erft de ei­gen­schap­pen en methoden van de ba­sis­klas­se en kan deze uit­brei­den of aanpassen.

class Animal {
    name: string;
    constructor(name: string) {
        this.name = name;
    }
    makeSound() {
        console.log("Some generic sound");
    }
}
class Dog extends Animal {
    makeSound() {
        console.log(this.name + " barks");
    }
}
const myDog = new Dog("Buddy");
myDog.makeSound();

Met behulp van het sleu­tel­woord extends erft de on­der­lig­gen­de klasse Dog de ei­gen­schap­pen en methoden van de bo­ven­lig­gen­de klasse Animal. De klasse Dog over­schrijft de methode makeSound om een specifiek gedrag toe te voegen, terwijl de ei­gen­schap name van Animal wordt geërfd.

Alleen-lezen

Je kunt readonly gebruiken om ei­gen­schap­pen van Ty­pe­Script-klassen of -objecten als alleen-lezen te de­cla­re­ren. Dit betekent dat zodra een alleen-lezen ei­gen­schap is ge­ï­ni­ti­a­li­seerd, de waarde ervan niet meer kan worden gewijzigd.

class Circle {
    readonly pi: number = 3.14159;
    radius: number;
    constructor(radius: number) {
        this.radius = radius;
    }
    getArea() {
        return this.pi    *this.radius*    this.radius;
    }
}
const myCircle = new Circle(5);
console.log(myCircle.getArea()); // Output: ≈ 78,54

De ei­gen­schap pi is in ons voorbeeld alleen-lezen en wordt ge­ï­ni­ti­a­li­seerd in de con­struc­tor. Na ini­ti­a­li­sa­tie kan pi niet meer worden gewijzigd. Als u probeert de waarde van pi na ini­ti­a­li­sa­tie te wijzigen, genereert Ty­pe­Script een com­pi­la­tie­fout.