# Wat is TypeScript? Een beginnershandleiding voor de superset van JavaScript

TypeScript heeft een aantal belangrijke functies die **de ontwikkeling van webapplicaties** fundamenteel verbeteren. Deze TypeScript-tutorial geeft u een inleiding tot de programmeertaal en legt enkele van de belangrijkste functies en toepassingen uit, evenals de voor- en nadelen ervan.

## Wat is TypeScript?

TypeScript is ontwikkeld door Microsoft en bouwt voort op de programmeertaal JavaScript, die veel wordt gebruikt bij webontwikkeling. Een opvallende eigenschap van TypeScript is **statische typering**. In tegenstelling tot JavaScript, dat dynamische typering heeft, kunt u in TypeScript datatypes voor variabelen, functies en parameters declareren. Hierdoor kunnen codefouten vroegtijdig worden opgespoord, waardoor fouten kunnen worden geïdentificeerd nog voordat de code is uitgevoerd. Statische typering verbetert niet alleen de kwaliteit van de code aanzienlijk, maar ook de leesbaarheid ervan.

De syntaxis van TypeScript is vrijwel identiek aan die van JavaScript, waardoor het veel eenvoudiger is om het te integreren in bestaande JavaScript-projecten. **TypeScript is** zelfs **een superset van JavaScript**, wat betekent dat alle correcte JavaScript-code ook geldige TypeScript-code is. Hierdoor kunt u geleidelijk migreren naar TypeScript en profiteren van de voordelen van statische typering en andere functies, zonder dat u uw bestaande codebase volledig hoeft te herschrijven.

Hier is een eenvoudig JavaScript-voorbeeld:

```javascript
function greet(name) {
    return "Hello, " + name;
}
console.log(greet(123)); // Output: "Hello, 123"
```

In de bovenstaande code is de functie `greet` niet beperkt tot een specifiek gegevenstype voor de parameter `name`. Dit betekent dat de functie nog steeds werkt, zelfs als we een getal als argument doorgeven.

In TypeScript kan de code er als volgt uitzien:

```typescript
function greet(name: string): string {
    return "Hello, " + name;
}
console.log(greet(123)); // Error in TypeScript
```

Hier hebben we de parameter `name` als een tekenreeks gedeclareerd. Als we de functie met een getal proberen te gebruiken, geeft TypeScript een foutmelding weer omdat het doorgegeven gegevenstype niet overeenkomt met het verwachte gegevenstype.

Dit voorbeeld laat zien hoe TypeScript helpt om fouten in een vroeg stadium op te sporen, waardoor de kwaliteit van de code wordt verbeterd door **onjuist gebruik van datatypes** te voorkomen. Het is belangrijk om op te merken dat TypeScript uiteindelijk wordt gecompileerd naar JavaScript, waardoor het in elke JavaScript-omgeving kan worden uitgevoerd. Dit betekent echter dat u alleen tijdens de ontwikkelingsfase profiteert van de voordelen van typeveiligheid.

## Waarvoor wordt TypeScript gebruikt?

TypeScript is essentieel voor verschillende aspecten van softwareontwikkeling, vooral in situaties waarin **typeveiligheid** en codekwaliteit van cruciaal belang zijn.

Een prominent gebruiksscenario voor TypeScript is webontwikkeling. Hier zorgt TypeScript ervoor dat JavaScript-code op een manier wordt geschreven die deze veiliger en gemakkelijker te onderhouden maakt. Dit is gunstig bij uitgebreide frontend-projecten met complexe codebases. TypeScript kan echter ook aan de **serverzijde (backend) in Node.js-toepassingen** worden geïmplementeerd om een extra beveiligingslaag te bieden. In serverloze architecturen zoals AWS Lambda en Azure Functions helpt TypeScript om fouten te minimaliseren en een betrouwbare uitvoering te garanderen.

Cross-platformontwikkeling is nog een ander gebied waarop TypeScript zijn sterke punten laat zien. Het kan **cross-platformtoepassingen en de ontwikkeling van mobiele apps** aanzienlijk optimaliseren. Frameworks zoals NativeScript en React Native bieden ondersteuning voor TypeScript als het gaat om het programmeren van mobiele apps voor verschillende platforms. Bij de ontwikkeling van games wordt TypeScript gebruikt in projecten die gebruikmaken van WebGL of game-engines zoals Phaser of Babylon.js. De typeveiligheid van TypeScript helpt de kwaliteit en onderhoudbaarheid van games te verbeteren.

TypeScript wordt ook gebruikt voor **datavisualisatie- en analyseprojecten**. Bibliotheken zoals D3.js bieden ondersteuning voor TypeScript en maken het mogelijk om geavanceerde dashboards en visualisaties te creëren.

## Hoe TypeScript te installeren

Het installeren van TypeScript is eenvoudig en kost slechts een paar stappen. Als u **Node.js** op uw computer hebt, kunt u TypeScript installeren met `npm` (Node Package Manager).

### Stap 1: Node.js downloaden

Controleer of Node.js op uw computer is geïnstalleerd. Als u Node.js nog niet hebt geïnstalleerd, kunt u het downloaden en installeren vanaf de officiële website.

### Stap 2: Installeer TypeScript in de terminal

Open uw **opdrachtprompt** (bijvoorbeeld Opdrachtprompt in Windows of de terminal op macOS of Linux) en voer de volgende opdracht in om TypeScript globaal te installeren:

```bash
npm install -g typescript
```

De vlag `-g` (global) installeert TypeScript op uw hele systeem, zodat u het overal kunt gebruiken.

### Stap 3: Controleer de geïnstalleerde versie

U kunt controleren of de installatie succesvol was door het volgende commando uit te voeren:

```bash
tsc -v
```

Dit commando laat zien welke versie van TypeScript is geïnstalleerd. Als er een **versienummer** wordt weergegeven, betekent dit dat de installatie is geslaagd.

Na de installatie kunt u **JavaScript-bestanden** genereren door TypeScript-bestanden (met de extensie *.ts*) aan te maken en deze te compileren met de TypeScript-compiler `tsc`.

### Stap 4: Maak een TypeScript-bestand aan

Maak een TypeScript-bestand aan, bijvoorbeeld *app.ts*, en voeg uw TypeScript-code toe.

```typescript
type Person = { name: string, age: number };
const alice: Person = { name: "Alice", age: 30 };
console.log(`Hello, I am ${alice.name} and I am ${alice.age} years old.`);
```

### Stap 5: Compileer het bestand

Compileer het TypeScript-bestand door de volgende opdracht in te voeren:

```bash
tsc app.ts
```

Hierdoor wordt *app.ts* gecompileerd tot een JavaScript-bestand met de naam *app.js*. Vervolgens kunt u het JavaScript-bestand uitvoeren.

## Welke functies heeft TypeScript?

Webontwikkeling heeft de afgelopen jaren aanzienlijke vooruitgang geboekt en TypeScript is naar voren gekomen als een uiterst **efficiënt alternatief voor JavaScript**. Hieronder hebben we de belangrijkste kenmerken van deze taal samengevat.

### Statische typering

Statische typering is een essentiële functie van TypeScript waarmee u gegevenstypen kunt specificeren voor variabelen, parameters, functies en andere elementen in uw code. In tegenstelling tot **dynamische typering in JavaScript**, waarbij gegevenstypen tijdens de uitvoering worden bepaald, worden gegevenstypen in TypeScript tijdens de ontwikkeling toegewezen, voordat de code wordt uitgevoerd. Deze methode helpt om fouten en logische problemen in een vroeg stadium op te sporen.

```typescript
function add(a: number, b: number): number {
    return a + b;
}
const result = add(5, 3); // valid
const result = add(5, "3"); // Type Error
```

In dit voorbeeld hebben we statische typering gebruikt voor de functie `add`. De twee parameters `a` en `b` worden gedeclareerd als getallen (`number`) en de functie retourneert een waarde van het type `number`. Elke poging om deze functie te gebruiken met een ander gegevenstype zal ervoor zorgen dat TypeScript dit als een fout identificeert.

### Optioneel typen

Met optionele typering kunt u gegevenstypen voor bepaalde variabelen en parameters specificeren, terwijl u andere variabelen en parameters zonder gedefinieerd gegevenstype laat.

```typescript
function sayHello(name: string, age: any): string {
    if (age) {
        return `Hello, ${name}, you are ${age} years old.`;
    } else {
        return `Hello, ${name}.`;
    }
}
```

De functie `sayHello` wordt gedefinieerd met de parameters `name` en `age`. De aanduiding `any` geeft aan dat de parameter `age` elk gegevenstype kan zijn.

### ES6+-functies

TypeScript ondersteunt moderne JavaScript-functies, waaronder ES6 en nieuwere functies zoals **pijlfuncties en sjabloonstrings**.

```typescript
const multiply = (a: number, b: number): number => a * b;
const greeting = (name: string) => `Hello, ${name}!`;
```

De pijlfuncties leiden tot een kortere en beknoptere syntaxis.

### Code-organisatie

TypeScript biedt een betere organisatie van de code en zorgt ervoor dat de code wordt opgedeeld in herbruikbare delen. Dit wordt mogelijk gemaakt door modules en naamruimten.

```typescript
// Math.ts
export function add(a: number, b: number): number {
    return a + b;
}
// Main.ts
import { add } from './Math';
const result = add(5, 3);
```

Hier laten we zien hoe je code met modules kunt structureren en `import` en `export` kunt gebruiken voor organisatie. De functie add wordt gedefinieerd in een aparte module met de naam `Math.ts` en vervolgens geïmporteerd en geïntegreerd in een andere module, `Main.ts`.

### Objectgeoriënteerd programmeren (OOP)

TypeScript vergemakkelijkt objectgeoriënteerd programmeren door middel van [TypeScript-klassen](https://www.ionos.com/nl-be/digitalguide/websites/webontwikkeling/typescript-klassen/), interfaces en overerving:

```typescript
class Person {
    constructor(public name: string, public age: number) {}
    greet() {
        console.log(`Hello, my name is ${this.name} and I'm ${this.age} years old.`);
    }
}
const person = new Person("Alice", 30);
person.greet();
```

Dit voorbeeld toont het gebruik van klassen en objectgeoriënteerd programmeren (OOP) in TypeScript. De klasse `Person` heeft de eigenschappen `name`, `age` en een methode `greet`, die wordt gebruikt om de persoon voor te stellen en informatie over hem of haar te verstrekken.

### Uitgebreid typesysteem

Het TypeScript-typesysteem is flexibel en uitgebreid. U kunt **door de gebruiker gedefinieerde types en interfaces** maken en zelfs bestaande types uitbreiden.

```typescript
interface Animal {
    name: string;
}
 
interface Dog extends Animal {
    breed: string;
}
const myDog: Dog = { name: "Buddy", breed: "Labrador" };
```

De interface `Animal` definieert een eigenschap `name`, terwijl de interface `Dog` erft van `Animal` en een extra eigenschap `breed` toevoegt. Het object `myDog` heeft de kenmerken van beide interfaces.

### Compatibiliteit met JavaScript

TypeScript is compatibel met JavaScript, waardoor het in elke JavaScript-omgeving kan worden uitgevoerd. Deze compatibiliteit maakt het gemakkelijker om TypeScript geleidelijk in bestaande JavaScript-projecten te integreren.

```typescript
// JavaScript-Code
function greet(name) {
    return "Hello, " + name;
}
// TypeScript-Code
function greet(name: string): string {
    return "Hello, " + name;
}
```

De bovenstaande JavaScript-code (zonder typificatie) kan zonder problemen worden gebruikt in een TypeScript-code (met typificatie).

## Wat zijn de voor- en nadelen van TypeScript?

Hoewel TypeScript een aantal voordelen biedt, heeft het ook enkele nadelen. Hier volgt een overzicht:

### Voordelen

TypeScript heeft een uitgebreid ecosysteem van typedefinities voor veel JavaScript-bibliotheken en -frameworks. Hierdoor verloopt de integratie van code van derden in TypeScript-projecten naadloos en eenvoudig. Dit is handig in de huidige wereld van webgebaseerde applicaties, die vaak afhankelijk zijn van meerdere bibliotheken en frameworks.

Naast statische typering biedt TypeScript een schat aan ontwikkelingsfuncties, waaronder interfaces, klassen, modules en **ondersteuning voor de huidige ECMAScript-standaarden**. Deze functies verbeteren de structurering van de code, vergemakkelijken het onderhoud en de schaalbaarheid van projecten en bevorderen de productiviteit bij de ontwikkeling. Veel geïntegreerde ontwikkelomgevingen (IDE’s), zoals Visual Studio Code, bieden uitstekende ondersteuning voor TypeScript.

### Nadelen

**Het kost tijd om aan** TypeScript **te wennen**, vooral voor ontwikkelaars die voorheen alleen met JavaScript hebben gewerkt. TypeScript-code moet eerst in JavaScript worden gecompileerd voordat deze in browsers of Node.js-omgevingen kan worden uitgevoerd. Dit zorgt voor een extra stap in het ontwikkelingsproces.

Bij kleinere projecten kan TypeScript als te complex worden ervaren, omdat de voordelen van typeveiligheid misschien niet zo duidelijk zijn. TypeScript-projecten kunnen **meer middelen** vereisen **vanwege extra type-informatie en compilatiestappen**.

## Wat zijn enkele alternatieven voor TypeScript?

Er zijn verschillende webprogrammeertalen die een goed alternatief kunnen zijn voor TypeScript, afhankelijk van de specifieke vereisten van een project en de voorkeur van de ontwikkelaar(s).

- **Flow**: Flow is een statische typechecker voor JavaScript die is ontwikkeld door Facebook. Hiermee kunt u typen toevoegen aan JavaScript-code zonder volledig over te stappen op TypeScript. Flow is een goede keuze als u typen geleidelijk wilt integreren in uw JavaScript-projecten.
- **Dart**: dit is een door Google ontwikkelde programmeertaal die kan worden gebruikt om webapplicaties en mobiele apps te maken. Het biedt typeveiligheid en goede prestaties. Dart wordt vaak gebruikt in combinatie met het Flutter-framework voor de ontwikkeling van mobiele apps.
- **PureScript**: PureScript is een sterk getypeerde functionele programmeertaal die sterke typeveiligheid en een puur functionele programmeerstijl biedt. Het maakt het mogelijk om JavaScript-bibliotheken te importeren.
- **Elm**: Elm is een functionele, sterk getypeerde taal die is ontworpen voor de ontwikkeling van webbapplicaties. Elm promoot het principe van Elm Architecture en heeft een hoge mate van typeveiligheid.
- **ReasonML (BuckleScript)**: deze taal is ontwikkeld door Facebook en is gebaseerd op OCaml. BuckleScript is een compiler die ReasonML compileert naar JavaScript. Het biedt ook typeveiligheid en is eenvoudig te integreren met React voor frontend-ontwikkeling.

Tip In andere artikelen in onze digitale gids gaan we dieper in op andere onderwerpen, zoals [TypeScript-functies](https://www.ionos.com/nl-be/digitalguide/websites/webontwikkeling/typescript-functies/) en [TypeScript-arrays](https://www.ionos.com/nl-be/digitalguide/websites/webontwikkeling/typescript-arrays/).


This is a markdown version of: [https://www.ionos.com/nl-be/digitalguide/websites/webontwikkeling/wat-is-typescript/](https://www.ionos.com/nl-be/digitalguide/websites/webontwikkeling/wat-is-typescript/) for AI/LLM consumption.