Data Types

Een datatype of gegevenstype is een specifieke soort van data, het datatype bepaalt welke waarde de variabele kan bevatten.

De datatypes kan je verdelen in enkelvoudige en samengestelde datatypes.

Ontdek het datatype met de typeof operator.

typeof "hello" // "string"
typeof 0 // "number"
typeof 1n // "bigint"
typeof true // "boolean"
typeof undefined // "undefined"
typeof Symbol("id") // "symbol"
typeof {} // "object"
typeof null // "object"

PS: null wordt door de typeof operator beschouwd als een object, dit is een bug dat men nooit zal fixen omdat dit bestaande code zou breken

• Primitieve datatypes (enkelvoudige)
• Niet-primitieve datatypes (samengestelde)
• Waarom is dit verschil belangrijk?

Primitieve datatypes (enkelvoudige)

Een primitief datatype is gedefinieerd door de programmeertaal zelf. Ze maken deel uit van de kern van een taal.

De primitieve datatypes in JavaScript zijn:

• Boolean
  • true of false
• String
  • Strings weergeven
• Number
  • Integers of Floating Points
• Null
  • Ontbreken van een waarde
• Undefined
  • Er is nog geen waarde toegewezen
• BigInt
  • Gehele getallen groter dan 2⁵³ -1

Primitieve datatypes zijn ‘immutable’, je zal de waarde niet kunnen muteren aanmaal deze is aangemaakt, je zal wel de volledige waarde kunnen vervangen of reassignen.

var string = 'This is a string.';
string[1] = 'H'
console.log(string) // 'This is a string.'

Bovendien zullen primitieve waarden vergeleken worden op basis van hun waarde. Variabelen zijn enkel volledig gelijk wanneer de waardes hetzelfde zijn.

var number1 = 5;
var number2 = 5;
number1 === number2; // true

var string1 = 'This is a string.';
var string2 = 'This is a string.';
string1 === string2; // true

Niet-primitieve datatypes (samengestelde)

De niet-primitieve datatypes in JavaScript zijn:

• Array
• Object
• Functions

Niet-primitieve datatypes zijn wel muteerbaar, je zal de waarden kunnen aanpassen nadat deze is aangemaakt.

var arr = [ 'one', 'two', 'three', 'four', 'five' ];
arr[1] = 'TWO';
console.log(arr) // [ 'one', 'TWO', 'three', 'four', 'five' ];

Bij niet-primitieve datatypes zal niet de waarde vergeleken worden maar eerder de instantie of referentie. Dus ook al hebben twee objecten dezelfde waarde, ze zullen toch niet gelijk zijn.

var obj1 = { 'cat': 'playful' };
var obj2 = { 'cat': 'playful' };
obj1 === obj2;  // false

var arr1 = [ 1, 2, 3, 4, 5 ];
var arr2 = [ 1, 2, 3, 4, 5 ];
arr1 === arr2;  // false

Omdat deze soort datatypes gekenmerkt worden door het referentie worden ze ook wel soms ‘Referentie datatypes’ genoemd.

Twee objecten zullen enkel gelijk zijn wanneer ze verwijzen naar dezelfde referentie.

var obj3 = { 'car' : 'purple' }
var obj4 = obj3;
obj3 === obj4;  // true

Waarom is dit verschil belangrijk?

Dit is een belangrijk concept om te begrijpen aangezien dit veel invloed kan hebben op je code. Natuurlijk is dit gewoon relevant als je twee waardes vergelijkt maar dit is een concept waarop memoisatie op is gebaseerd.

Memoisation is het cachen van bepaalde data tot er een dependency zal wijzigen. Als je een object of functie als dependency zal gebruiken zal de data nooit cachen aangezien de referentie steeds wijzigt.