Begrip van Gegevenstypen in JavaScript

Inleiding

Gegevenstypen worden gebruikt om één specifiek type gegevens te classificeren in programmeertalen. Bijvoorbeeld, een getal en een reeks karakters zijn verschillende typen gegevens die anders zullen worden behandeld door JavaScript.

Dit is belangrijk omdat het specifieke gegevenstype dat je gebruikt zal bepalen welke waarden je eraan kunt toewijzen en wat je ermee kunt doen. Met andere woorden, om bewerkingen uit te kunnen voeren met variabelen in JavaScript, is het belangrijk om het gegevenstype van een variabele te begrijpen.

In deze tutorial zullen we bespreken hoe gegevenstypen werken in JavaScript, evenals de belangrijke gegevenstypen die inherent zijn aan de taal. Dit is geen uitputtend onderzoek naar gegevenstypen, maar het zal je helpen vertrouwd te raken met de opties die beschikbaar zijn in JavaScript.

Dynamische Typering

JavaScript heeft dynamische gegevenstypen, wat betekent dat typecontrole wordt uitgevoerd tijdens runtime in plaats van tijdens de compilatie. De gegevenstypen van Python zijn ook dynamisch getypeerd.

Met dynamisch getypeerde talen kan een variabele met dezelfde naam worden gebruikt om verschillende gegevenstypen vast te houden.

Bijvoorbeeld, de variabele t, gedefinieerd als een variabele door het let trefwoord (let erop dat let een gegeven variabele beperkt in scope), kan worden toegewezen om verschillende gegevenstypen vast te houden, of kan worden geïnitialiseerd maar ongedefinieerd worden gelaten:

let t = 16;			// t is een nummer
let t = "Teresa";	// t is een string
let t = true;		// t is een Booleaan
let t;				// t is ongedefinieerd

Elk van de bovenstaande variabelen t kan worden ingesteld op elk gegevenstype dat beschikbaar is in JavaScript; ze hoeven niet expliciet te worden verklaard met een gegevenstype voordat ze worden gebruikt.

Nummers

JavaScript heeft slechts één nummertype, er is geen aparte aanduiding voor gehele getallen en floating-point getallen. Hierdoor kunnen getallen in JavaScript worden geschreven met of zonder decimalen:

let num1 = 93;
let num2 = 93.00;

In beide gevallen hierboven is het gegevenstype een nummer en is het hetzelfde ongeacht of het nummer decimalen heeft of niet.

Wetenschappelijke exponentiële notatie kan worden gebruikt in JavaScript om zeer grote of zeer kleine getallen te verkorten, zoals in de volgende voorbeelden:

let num3 = 987e8;		// 98700000000
let num4 = 987e-8;		// 0.00000987

Getallen in JavaScript worden als nauwkeurig beschouwd tot 15 cijfers. Dat betekent dat getallen worden afgerond nadat het 16e cijfer is bereikt:

let num5 = 999999999999999;		// blijft als 999999999999999
let num6 = 9999999999999999;	// afgerond naar 10000000000000000

Naast het voorstellen van getallen heeft het JavaScript-getaltype ook drie symbolische waarden beschikbaar:

• Infinity — een numerieke waarde die een positief getal voorstelt dat oneindig nadert
• -Infinity — een numerieke waarde die een negatief getal voorstelt dat oneindig nadert
• NaN — een numerieke waarde die een niet-nummer voorstelt, wat staat voor niet een getal

Infinity of -Infinity wordt geretourneerd als je een getal berekent buiten het grootst mogelijke getal in JavaScript. Deze waarden zullen ook voorkomen voor ongedefinieerde waarden, zoals bij delen door nul:

let num7 = 5 / 0;	// zal Infinity retourneren
let num8 = -5 / 0;	// zal -Infinity retourneren

In technische termen wordt Infinity weergegeven wanneer een getal het getal 1.797693134862315E+308 overschrijdt, wat het bovengrens vertegenwoordigt in JavaScript.

Vergelijkbaar zal -Infinity worden weergegeven wanneer een getal de ondergrens van -1.797693134862316E+308 overschrijdt.

Het getal Infinity kan ook worden gebruikt in lussen:

while (num9 != Infinity) { 
	// Code hier zal worden uitgevoerd tot num9 = Oneindigheid
}

Voor getallen die geen wettige getallen zijn, wordt NaN weergegeven. Als u probeert een wiskundige bewerking uit te voeren op een getal en een niet-numerieke waarde, wordt NaN geretourneerd. Dit is het geval in het volgende voorbeeld:

let x = 20 / "Shark";	// x zal NaN zijn

Omdat het getal 20 niet kan worden gedeeld door de string "Haai" omdat het niet kan worden geëvalueerd als een getal, is de geretourneerde waarde voor de variabele x NaN.

Als echter een string kan worden geëvalueerd als een numerieke waarde, kan de wiskundige expressie worden uitgevoerd in JavaScript:

let y = 20 / "5";	// y zal 4 zijn

In het bovenstaande voorbeeld, omdat de string "5" kan worden geëvalueerd als een numerieke waarde in JavaScript, wordt deze als zodanig behandeld en zal werken met de wiskundige operator voor deling, /.

Wanneer de waarde NaN aan een variabele wordt toegewezen die wordt gebruikt in een bewerking, zal dit resulteren in de waarde NaN, zelfs wanneer het andere operand een wettig getal is:

let a = NaN;
let b = 37;
let c = a + b; 	// c zal NaN zijn

Er is slechts één getalgegevenstype in JavaScript. Bij het werken met getallen zal elk getal dat u invoert worden geïnterpreteerd als het gegevenstype voor getallen; u hoeft niet aan te geven wat voor soort gegevenstype u invoert omdat JavaScript dynamisch getypeerd is.

Teksten

A string is a sequence of one or more characters (letters, numbers, symbols). Strings are useful in that they represent textual data.

In JavaScript bestaan teksten binnen enkele aanhalingstekens ' of dubbele aanhalingstekens ", dus om een tekst te maken, omsluit je een reeks tekens tussen aanhalingstekens:

let singleQuotes = 'This is a string in single quotes.';

let doubleQuotes = "This is a string in double quotes.";

Je kunt ervoor kiezen om enkele of dubbele aanhalingstekens te gebruiken, maar wat je ook beslist, je moet consistent blijven binnen een programma.

Het programma “Hallo, wereld!” demonstreert hoe een tekst kan worden gebruikt in computerprogrammering, aangezien de tekens die de zin Hallo, wereld! vormen in de alert() hieronder een tekst zijn.

<!DOCTYPE HTML>
<html>
<head>
<script>
function helloFunction() {
    alert("Hello, World!");
}
</script>
</head>
<body>
<p><button onclick="helloFunction()">Click me</button></p>
</body>
</html>

Wanneer we de code uitvoeren en op de knop Klik op mij klikken, ontvangen we een pop-up met de volgende uitvoer:

Output
Hello, World!

Net zoals bij andere gegevenstypen kunnen we teksten opslaan in variabelen:

let hw = "Hello, World!";

En de tekst weergeven in de alert() door de variabele aan te roepen:

...
<script>
let hw = "Hello, World!";
function helloFunction() {
    alert(hw);
}
</script>
...

Output
Hello, World!

Er zijn veel bewerkingen die we kunnen uitvoeren op teksten binnen onze programma’s om ze te manipuleren om de resultaten te bereiken die we zoeken. Teksten zijn belangrijk om informatie aan de gebruiker door te geven, en voor de gebruiker om informatie terug te communiceren naar het programma.

Booleans

Het Boolean-gegevenstype kan een van twee waarden hebben, ofwel waar of onwaar. Booleans worden gebruikt om de waarheidswaarden weer te geven die geassocieerd zijn met de logische tak van de wiskunde, die algoritmes informeert in de informatica.

Veel bewerkingen in de wiskunde geven ons antwoorden die worden geëvalueerd als waar of onwaar:

• groter dan
  • 500 > 100 waar
  • 1 > 5 onwaar
• kleiner dan
  • 200 < 400 waar
  • 4 < 2 onwaar
• gelijk
  • 5 = 5 waar
  • 500 = 400 onwaar

Net als bij andere gegevenstypen kunnen we een Booleaanse waarde opslaan in een variabele:

let myBool = 5 > 8;	// onwaar

Omdat 5 niet groter is dan 8, heeft de variabele myBool de waarde onwaar.

Naarmate je meer programma’s schrijft in JavaScript, zul je meer vertrouwd raken met hoe Booleans werken en hoe verschillende functies en bewerkingen die evalueren als waar of onwaar de loop van het programma kunnen veranderen.

Arrays

Een array kan meerdere waarden bevatten binnen één variabele. Dit betekent dat je een lijst van waarden kunt bevatten binnen een array en er doorheen kunt itereren.

Elk item of waarde die zich in een array bevindt, wordt een element genoemd. Je kunt verwijzen naar de elementen van een array door een indexnummer te gebruiken.

Net zoals strings worden gedefinieerd als karakters tussen aanhalingstekens, worden arrays gedefinieerd door waarden tussen vierkante haken [ ].

Een array van strings ziet er bijvoorbeeld zo uit:

let fish = ["shark", "cuttlefish", "clownfish", "eel"];

Als we de variabele fish noemen, krijgen we de volgende uitvoer:

["shark", "cuttlefish", "clownfish", "eel"]

Arrays zijn een zeer flexibel gegevenstype omdat ze mutabel zijn, wat betekent dat elementwaarden kunnen worden toegevoegd, verwijderd en gewijzigd.

Objects

Het JavaScript object gegevenstype kan veel waarden bevatten als naam:waarde paren. Deze paren bieden een nuttige manier om gegevens op te slaan en te benaderen. De object letterlijke syntaxis bestaat uit naam:waarde paren gescheiden door dubbele punten met aan weerszijden accolades { }.

Normaal gesproken gebruikt om gegevens vast te houden die gerelateerd zijn, zoals de informatie die is opgenomen in een ID, ziet een JavaScript object letterlijk er als volgt uit, met spaties tussen de eigenschappen:

let sammy = {firstName:"Sammy", lastName:"Shark", color:"blue", location:"ocean"};

Alternatief, en vooral voor object literals met een groot aantal naam:waarde-paren, kunnen we dit gegevenstype op meerdere regels schrijven, met een spatie na elke dubbele punt:

let sammy = {
    firstName: "Sammy",
    lastName: "Shark",
    color: "blue",
    location: "Ocean"
};

Het objectvariabele sammy in elk van de bovenstaande voorbeelden heeft 4 eigenschappen: voornaam, achternaam, kleur en locatie. Deze worden elk door dubbele punten gescheiden waarden doorgegeven.

Werken met meerdere gegevenstypen

Hoewel elk programma dat je maakt meerdere gegevenstypen zal bevatten, is het belangrijk om in gedachten te houden dat je over het algemeen bewerkingen binnen hetzelfde gegevenstype zult uitvoeren. Dat wil zeggen, je zult wiskundige bewerkingen uitvoeren op getallen, of strings splitsen.

Wanneer je een operator gebruikt die over gegevenstypen heen werkt, zoals de + operator die getallen kan optellen of strings kan concatenaten, kun je onverwachte resultaten behalen.

Bijvoorbeeld, wanneer je de + operator gebruikt met getallen en strings samen, zullen de getallen worden behandeld als een string (dus ze zullen worden geconcateneerd), maar de volgorde van de gegevenstypen zal de concatenatie beïnvloeden.

Dus, als je een variabele maakt die de volgende concatenatie uitvoert, zal JavaScript elk element hieronder interpreteren als een string:

let o = "Ocean" + 5 + 3;

Als je de variabele o aanroept, krijg je de volgende waarde terug:

Output
Ocean53

Echter, als je begint met nummers, zullen de twee nummers worden opgeteld voordat ze worden geïnterpreteerd als een tekenreeks wanneer het programma de runtime bereikt "Ocean" , dus de geretourneerde waarde zal de som zijn van de twee nummers geconcateneerd met de tekenreeks:

let p = 5 + 3 + "Ocean";

Output
8Ocean

Vanwege deze onverwachte resultaten zul je waarschijnlijk bewerkingen en methoden uitvoeren binnen één gegevenstype in plaats van eroverheen. JavaScript geeft echter geen fouten terug bij het mixen van gegevenstypen, zoals sommige andere programmeertalen doen.

Conclusie

Op dit punt zou je een beter begrip moeten hebben van enkele van de belangrijkste gegevenstypen die beschikbaar zijn om te gebruiken in JavaScript.

Elk van deze gegevenstypen zal belangrijk worden naarmate je programmeerprojecten ontwikkelt in de JavaScript-taal.