Introduction

We hebben in het begin van deze tutorial kort gesproken over het feit dat JavaScript een dynamisch getypeerde taal is, maar in dit artikel, evenals de volgende, zullen we de verschillende gegevenstypen bespreken die je tegenkomt bij het werken met JavaScript . Maar waarom zou u zich druk maken om gegevenstypen als de programmeertaal dynamische typen gebruikt?

Nou, ook al is JavaScript niet strikt als het gaat om types, er zullen nog steeds situaties zijn waarin types ertoe doen. Wat gebeurt er bijvoorbeeld als je "42" (een tekststring met het getal 42) vermenigvuldigt met 2 (het getal 2)? Een strikt getypeerde taal zou hier waarschijnlijk over klagen, maar JavaScript geeft er niet echt om.

Dynamische types

Maar laten we het eens hebben over wat een dynamisch type is en hoe je het kunt gebruiken. In een sterk getypeerde programmeertaal moet je een variabele meestal declareren als een specifiek type, bijvoorbeeld een string of een geheel getal, en als je de variabele eenmaal hebt gedeclareerd, kun je het type niet meer veranderen en als je iets van een ander type aan de variabele probeert toe te wijzen, zal de compiler klagen. In JavaScript hoef je geen type te definiëren en kun je er achteraf eenvoudig een ander type aan toekennen. Hier is een voorbeeld:

let answer = 42;
answer = "The answer to everything: 42";
alert(answer);

Merk op dat ik een variabele met de naam "antwoord" declareer en er vervolgens een nummer (42) aan toewijs. In de volgende regel bedenk ik me en wijs ik er een string aan toe, en dan presenteer ik het antwoord. JavaScript zal helemaal niet klagen over deze wijziging - u bent vrij om te doen wat u wilt, omdat er niet wordt verwacht dat de variabele van een specifiek type is.

Types zijn nog steeds belangrijk

Maar zoals ik al zei, betekent het feit dat de types dynamisch zijn niet dat ze niet bestaan. Op de achtergrond doet JavaScript veel voor je, zodat je je geen zorgen hoeft te maken over types. Laten we ter illustratie teruggaan naar mijn voorbeeld van het vermenigvuldigen van twee getallen, waarbij een van de twee toevallig een tekststring is die het getal bevat:

let n1 = "42", n2 = 2;
alert(n1 * n2);

In dit geval raadt JavaScript dat je waarschijnlijk twee getallen probeert te vermenigvuldigen, dus ook al is een van de getallen eigenlijk een tekststring, het resultaat is nog steeds 84. Maar wat als we de getallen proberen op te tellen in plaats van te vermenigvuldigen?

let n1 = "42", n2 = 2;
alert(n1 + n2);

Misschien verwacht je dat het resultaat 44 is, maar in plaats daarvan krijg je "422". Waarom? Omdat JavaScript in dit geval niet meer weet dat je wiskunde probeert te doen - in plaats daarvan behandelt het beide variabelen als tekststrings en voegt ze toe. Dit is een goed voorbeeld van waarom types nog steeds belangrijk zijn in een dynamisch getypeerde taal, omdat je geen waarschuwingen of klachten krijgt over het bovenstaande voorbeeld, ook al is het resultaat misschien niet wat je verwachtte.

Primitieve types

De meeste programmeertalen maken onderscheid tussen primitieve types en complexe/referente types. JavaScript doet hetzelfde, waarbij we verschillende primitieve types aan de ene kant hebben en objecten aan de andere kant. Ter referentie, dit zijn de primitieve gegevenstypen die worden ondersteund door de JavaScript-taal:

• bigint
• boolean
• null
• number
• string
• symbol
• undefined

Dit hoofdstuk gaat helemaal over de primitieve types en we zullen ze allemaal doornemen in de volgende artikelen. Daarna zullen we kijken naar enkele ingebouwde objecten en hoe je je eigen complexe types kunt definiëren.

Samenvatting

JavaScript maakt gebruik van een dynamisch type systeem, waardoor je variabelen kunt declareren en gebruiken zonder dat je een type hoeft op te geven. Zoals in dit artikel wordt aangetoond, moet u echter opletten hoe je variabelen van verschillende typen samen gebruikt.

In de volgende artikelen gaan we dieper in op de verschillende types die JavaScript achter de schermen gebruikt bij het afhandelen van je code, en hoe je ermee kunt werken.