# Hoe TypeScript-klassen definiëren en gebruiken TypeScript-klassen bieden een duidelijke en gestructureerde manier om gegevens en gedrag in een **object** te organiseren. Dit maakt het gemakkelijker om entiteiten en concepten in uw code te modelleren. ## Wat zijn TypeScript-klassen? Klassen zijn een belangrijk concept van TypeScript, een programmeertaal die is gebaseerd op JavaScript. Klassen vertegenwoordigen een **gestructureerde methode voor het definiëren van objecten** en voor het toepassen van objectgeoriënteerd programmeren (OOP). TypeScript-klassen zijn als blauwdrukken voor het maken van objecten die logisch gerelateerde gegevens en methoden bundelen. [TypeScript](https://www.ionos.com/nl-be/digitalguide/websites/webontwikkeling/wat-is-typescript/) bevat alle functies van JavaScript en omvat ook **statische typering**. Hierdoor kunt u gegevenstypen specificeren voor [TypeScript-functies](https://www.ionos.com/nl-be/digitalguide/websites/webontwikkeling/typescript-functies/), variabelen en klassen, zodat u fouten tijdens het compileren kunt opsporen. Naast typeveiligheid ondersteunen TypeScript-klassen ook concepten zoals overerving en abstractie, wat de ontwikkeling van complexe applicaties vergemakkelijkt. Met TypeScript-klassen kunt u een duidelijke **hiërarchie van klassen** creëren die eigenschappen en methoden erven. Dit bevordert hergebruik en structurering van code. Klassenconstructors maken het mogelijk om instanties te initialiseren en zorgen voor consistente objectcreatie. ## Wat is de syntaxis voor TypeScript-klassen? De notatie van TypeScript-klassen is vergelijkbaar met die van **ECMAScript 6 (ES6)** en is een uitgebreide versie van de JavaScript-klassensyntaxis. Een TypeScript-klasse kan verschillende elementen bevatten om de structuur en het gedrag van objecten te definiëren. De belangrijkste componenten zijn: - **Eigenschappen** - **Constructors** - **Methoden** ### Eigenschappen Eigenschappen bepalen de **status van een object**. Ze slaan gegevenswaarden op en kunnen worden geannoteerd met gegevenstypen, zodat ze alleen geldige waarden bevatten. ```typescript class ClassName { propertyName: propertyType; } ``` - **ClassName**: de naam van de klasse - **propertyName**: de naam van de eigenschap die u wilt definiëren - **propertyType**: het gegevenstype van de eigenschap Hier is een concreet voorbeeld: ```typescript class Person { name: string; } ``` Eerst wordt een klasse `Person` gedefinieerd met een eigenschap `name` van type `string`. Dit betekent dat instanties van de klasse `Person` een eigenschap `name` hebben die **strings** opslaat. ### Constructeur De constructor in TypeScript is een speciale methode die wordt aangeroepen wanneer een klasse-instantie (object) wordt aangemaakt. Je hebt deze nodig om **de eigenschappen van een object te initialiseren**. De constructor definieert in wezen de begintoestand van een instantie. Je kunt parameters specificeren in de constructor om waarden door te geven bij het instantiëren van TypeScript-klassen. De basissyntaxis van een constructor in TypeScript is: ```typescript class ClassName { constructor(parameter1: Type1, parameter2: Type2, ...) { } } ``` - **constructor**: elke klasse kan één constructor hebben. Als er geen constructor is gedefinieerd, wordt standaard een lege constructor aangemaakt. - **parameter: Type**: parameters zijn optioneel, afhankelijk van de klasse en de vereisten ervan. Parameters moeten worden gelabeld met hun gegevenstypen. Een voorbeeld van een constructor: ```typescript class Person { firstName: string; lastName: string; constructor(firstName: string, lastName: string) { this.firstName = firstName; this.lastName = lastName; } } ``` In het bovenstaande voorbeeld heeft de klasse `Person` een constructor die twee parameters `firstName` en `lastName` accepteert. Bij **het aanmaken van een instantie** van deze klasse worden deze parameters doorgegeven en initialiseert de constructor de eigenschappen `firstName` en `lastName` van de instantie met de overeenkomstige waarden. `this` verwijst naar de huidige instantie van de klasse waarop de code wordt uitgevoerd. ### Methoden In TypeScript zijn methoden functies die in klassen kunnen worden gedefinieerd en op hun instanties kunnen worden toegepast. Met methoden kunt u **bepaalde acties of bewerkingen** uitvoeren in de context van een klasse. ```typescript class ClassName { // ... methodName(parameter1: Type1, parameter2: Type2, ...): ReturnType { } // ... } ``` - **methodName**: naam van de methode - **parameter: Type**: optionele parameters die de methode accepteert - **ReturnType**: dit is het gegevenstype dat de waarde bepaalt die de methode retourneert. Als de methode niets retourneert, kunt u `void` opgeven. Om toegang te krijgen tot een eigenschap of een methode aan te roepen op een klasse-instantie, gebruikt u de puntoperator `.` gevolgd door de naam van de methode en de vereiste argumenten als de methode parameters verwacht. ```typescript 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 eigenschappen `firstName` en `lastName` die in de klasse zijn gedefinieerd en in de constructor zijn geïnitialiseerd. Het object `person` wordt aangemaakt door het sleutelwoord `new`, gevolgd door de klassenaam en de respectieve parameters. De methode **voegt de twee strings samen** wanneer deze wordt aangeroepen en retourneert de volledige naam als een string. De uitvoer voor het object `person` is daarom “John Doe”. ## Voorbeelden van TypeScript-klassen TypeScript-klassen beschikken over verschillende mechanismen om **de structuur en het gedrag van objecten** te organiseren en te controleren. Hieronder presenteren we enkele concepten voor het gebruik van TypeScript-klassen. ### Toegang TypeScript biedt drie toegangsmodificatoren: `public`, `private` en `protected` om de toegang tot eigenschappen en methoden binnen en buiten de klasse te regelen. - **openbaar (standaard)**: eigenschappen en methoden gemarkeerd met `public` kunnen overal worden aangeroepen, zowel binnen als buiten de klasse. - **privé**: `private` verwijst naar eigenschappen en methoden die alleen binnen de klasse zelf kunnen worden aangeroepen. Ze zijn niet toegankelijk voor externe codegedeelten. - **beschermd**: eigenschappen en methoden gemarkeerd met `protected` kunnen worden aangeroepen door de klasse zelf en door afgeleide klassen (in overerving), maar niet door externe code. ```typescript 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é-eigenschap die alleen toegankelijk is binnen de klasse `Person`. U kunt de methode `greet` echter wel buiten de klasse aanroepen. ### Erfenis Overerving is een fundamenteel concept in objectgeoriënteerd programmeren (OOP) dat wordt gebruikt in TypeScript en vele andere internetprogrammeertalen. Het maakt het mogelijk om een nieuwe klasse te creëren op basis van een bestaande **basisklasse of superklasse**. De afgeleide klasse (subklasse) erft de eigenschappen en methoden van de basisklasse en kan deze uitbreiden of aanpassen. ```typescript 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 sleutelwoord `extends` erft de onderliggende klasse `Dog` de eigenschappen en methoden van de bovenliggende klasse `Animal`. De klasse `Dog` overschrijft de methode `makeSound` om een specifiek gedrag toe te voegen, terwijl de eigenschap `name` van `Animal` wordt geërfd. ### Alleen-lezen Je kunt `readonly` gebruiken om eigenschappen van TypeScript-klassen of -objecten als **alleen-lezen** te declareren. Dit betekent dat zodra een alleen-lezen eigenschap is geïnitialiseerd, de waarde ervan niet meer kan worden gewijzigd. ```typescript 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 eigenschap `pi` is in ons voorbeeld alleen-lezen en wordt geïnitialiseerd in de constructor. Na initialisatie kan `pi` niet meer worden gewijzigd. Als u probeert de waarde van `pi` na initialisatie te wijzigen, genereert TypeScript een compilatiefout. This is a markdown version of: [https://www.ionos.com/nl-be/digitalguide/websites/webontwikkeling/typescript-klassen/](https://www.ionos.com/nl-be/digitalguide/websites/webontwikkeling/typescript-klassen/) for AI/LLM consumption.