Gegevenstypen in JavaScript

Dit artikel legt de gegevenstypen in JavaScript uit.

YouTube Video

Gegevenstypen in JavaScript

JavaScript heeft gegevenstypen om waarden te classificeren, die grofweg kunnen worden onderverdeeld in primitieve typen en objecttypen. Gegevenstypen bepalen welk soort gegevens in een variabele wordt opgeslagen en beïnvloeden hoe deze kunnen worden gemanipuleerd.

Primitieve typen

Primitieve typen zijn eenvoudige gegevenstypen die een enkele waarde vertegenwoordigen. JavaScript heeft de volgende 7 primitieve typen.

number

1let num = 42;
2let pi = 3.14;
3
4console.log("Value of num:", num);
5console.log("Value of pi:", pi);

• number is een type dat wordt gebruikt voor het verwerken van numerieke waarden, inclusief gehele getallen en drijvende komma's (decimalen). Het verwerken van waarden die bepaalde limieten overschrijden resulteert in Infinity of NaN (Not-a-Number).

1// Decimal calculations
2console.log(0.1 + 0.2 === 0.3); // false
3console.log(0.1 + 0.2); // 0.30000000000000004
4
5// Calculations with large numbers
6console.log(9007199254740991 + 1); // correct value
7console.log(9007199254740991 + 2); // incorrect value

• In JavaScript worden getallen weergegeven als zwevendekommagetallen. Als gevolg hiervan kunnen bepaalde decimalen (vooral die niet precies in binaire vorm kunnen worden weergegeven) mogelijk niet nauwkeurig worden uitgedrukt.
• Wanneer nauwkeurige berekeningen vereist zijn, zoals bij monetaire waarden, is het noodzakelijk om dergelijke afrondingsfouten te vermijden. U kunt bijvoorbeeld BigInt gebruiken of het aantal decimalen aanpassen met toFixed().

string

1let greeting = "Hello, world!";
2let char = 'A';
3const message = `"${greeting}" in JavaScript`;
4
5console.log("Value of greeting:", greeting);
6console.log("Value of char:", char);
7console.log("Value of message:", message);

• string is een gegevenstype dat wordt gebruikt voor het verwerken van tekst, dat een reeks tekens vertegenwoordigt. Het wordt weergegeven door tekst tussen enkele aanhalingstekens (') of dubbele aanhalingstekens (") te plaatsen. Vanaf ES6 maken template literals het eenvoudig om variabelen in te voegen met behulp van backticks (). Gebruik de ${}-syntaxis om een variabele in te voegen.

boolean

1let isAvailable = true;
2let hasError = false;
3
4console.log("Value of isAvailable:", isAvailable);
5console.log("Value of hasError:", hasError);

• boolean vertegenwoordigt een logische waarde en kan alleen de waarden true of false hebben. Het wordt gebruikt als het resultaat van conditionele expressies of als een vlag.

null

1let result = null;
2
3console.log("Value of result:", result);

• null is een gegevenstype dat expliciet aangeeft 'geen waarde' te hebben. null wordt door ontwikkelaars ingesteld om opzettelijke leegte aan te geven.

undefined

1let score;
2let subject = undefined;
3
4console.log("Value of score:", score);     // undefined
5console.log("Value of subject:", subject);

• undefined is een gegevenstype dat 'onbepaald' betekent. undefined wordt automatisch toegewezen wanneer een variabele is gedeclareerd maar geen waarde is toegewezen.

bigint

1let bigIntValue = 9007199254740991n;
2let anotherBigInt = 123456789012345678901234567890n;
3
4console.log("Value of bigIntValue:", bigIntValue);
5console.log("Value of anotherBigInt:", anotherBigInt);

• bigint is een gegevenstype voor het omgaan met grote gehele getallen. bigint maakt een nauwkeurige weergave mogelijk van grote gehele getallen die niet door het number-type kunnen worden weergegeven. bigint-literals worden weergegeven door een n aan het einde van een getal toe te voegen.
• bigint is een type voor het omgaan met gehele getallen van willekeurige grootte, zonder grenzen aan het bereik. Echter, bigint en number kunnen niet direct samen worden gebruikt, dus voorzichtigheid is vereist.

Symbol

1let sym1 = Symbol('id');
2let sym2 = Symbol('id');
3
4console.log("sym1 === sym2:", sym1 === sym2); // false

• Symbool is een gegevenstype dat wordt gebruikt om unieke identificatoren te maken. Het wordt gemaakt met Symbol() en kan als eigenschap van een object worden gebruikt. In tegenstelling tot andere primitieve typen heeft Symbool unieke waarden, dus zelfs met dezelfde inhoud wordt het als een ander Symbool beschouwd.

Objecttypen

Objecttypen zijn datastructuren die meerdere waarden kunnen opslaan. Een object is een verzameling sleutel-waardeparen en kan eigenschappen en methoden hebben.

Object

1let person = {
2    name: "John",
3    age: 30,
4    isEmployee: true
5};
6console.log(person.name); // John

• Object is een verzameling van eigenschappen (sleutel-waardeparen) die verschillende soorten gegevens kan opslaan. Objecten worden weergegeven door accolades {}, en elke eigenschap wordt verbonden door : tussen de sleutel en de waarde.

Array

1let numbers = [10, 20, 30];
2console.log(numbers[0]); // 10
3console.log(numbers[1]); // 20
4console.log(numbers[2]); // 30
5console.log(numbers[3]); // undefined

• Array is een lijst die meerdere waarden op een geordende manier bevat. Arrays worden weergegeven door vierkante haken [], en waarden worden gescheiden door komma's ,. Elk element wordt benaderd met behulp van een index die begint bij 0.

Function

1function greet(name) {
2    return "Hello, " + name;
3}
4console.log(greet("Alice")); // Hello, Alice

• Functies zijn een soort objecten en herbruikbare blokken code. Functies kunnen worden gedefinieerd met behulp van het trefwoord function.

Andere objecttypen

• JavaScript beschikt ook over ingebouwde objecttypen zoals Date, RegExp, Map en Set. Deze beheren gegevens volgens specifieke gebruiksscenario's.

Typeconversie

Impliciete en expliciete typeconversies worden vaak uitgevoerd in JavaScript.

Impliciete typeconversie

• JavaScript kan typen automatisch converteren wanneer bewerkingen tussen verschillende typen worden uitgevoerd.

1let result = 5 + "5"; // "55" (the number is converted to a string)
2
3console.log(result);

• In dit voorbeeld wordt het getal 5 impliciet geconverteerd naar een string, wat resulteert in de string "55".

Expliciete typeconversie

• Ontwikkelaars kunnen ook expliciet typeconversies uitvoeren.

1let num = "123";
2let convertedNum = Number(num); // Converts "123" to the number 123
3
4console.log(typeof num);
5console.log(typeof convertedNum);

• In dit voorbeeld wordt de Number()-functie gebruikt om de string "123" expliciet te converteren naar het getal 123.

Typecontrole

In JavaScript kun je de typeof-operator gebruiken om het gegevenstype van een variabele te controleren.

 1// Output: The type of 42 is: number
 2console.log('The type of 42             is:', typeof 42);
 3
 4// Output: The type of 42 is: bigint
 5console.log('The type of 42n            is:', typeof 42n);
 6
 7// Output: The type of "hello" is: string
 8console.log('The type of "hello"        is:', typeof "hello");
 9
10// Output: The type of true is: boolean
11console.log('The type of true           is:', typeof true);
12
13// Output: The type of undefined is: undefined
14console.log('The type of undefined      is:', typeof undefined);
15
16// Output: The type of null is: object
17console.log('The type of null           is:', typeof null);
18
19// Output: The type of Symbol() is: symbol
20console.log('The type of Symbol()       is:', typeof Symbol());
21
22// Output: The type of {} is: object
23console.log('The type of {}             is:', typeof {});
24
25// Output: The type of function () {} is: function
26console.log('The type of function () {} is:', typeof function () {});

Conclusie

• Primaire typen omvatten number, string, boolean, null, undefined en symbol.
• Objecttypen omvatten Object, Array, Function en anderen.
• Aangezien zowel automatische als expliciete typeconversies plaatsvinden, is het belangrijk om het juiste gebruik van gegevenstypen te begrijpen.

Je kunt het bovenstaande artikel volgen met Visual Studio Code op ons YouTube-kanaal. Bekijk ook het YouTube-kanaal.

YouTube Video