Operatoren in JavaScript

In dit artikel leggen we operatoren in JavaScript uit.

YouTube Video

Operatoren in JavaScript

Operatoren in JavaScript zijn symbolen of trefwoorden die worden gebruikt om berekeningen of vergelijkingen uit te voeren op nummers en variabelen. Er zijn verschillende soorten operatoren, die elk verschillende bewerkingen uitvoeren. Hier zijn enkele van de belangrijkste operatoren samengevat:.

Rekenkundige operatoren

De rekenkundige operatoren van JavaScript omvatten het volgende:.

 1let a = 10; // Initialize variable 'a' with the value 10
 2let b = 3;  // Initialize variable 'b' with the value 3
 3
 4// Perform and display arithmetic operations between 'a' and 'b'
 5console.log("Addition (a + b):      ", a + b); // 13
 6console.log("Subtraction (a - b):   ", a - b); // 7
 7console.log("Multiplication (a * b):", a * b); // 30
 8console.log("Division (a / b):      ", a / b); // 3.333...
 9console.log("Modulus (a % b):       ", a % b); // 1
10
11// Demonstrate post-increment operation on 'a'
12// Output the current value of 'a' (10), then increment
13console.log("Post-increment (a++):  ", a++);
14// Display the incremented value of 'a' (11)
15console.log("Value of 'a' after increment:", a);
16
17// Demonstrate pre-increment operation on 'a'
18// Increment 'a' first (12) then output
19console.log("Pre-increment (++a):   ", ++a);
20
21// Demonstrate post-decrement operation on 'a'
22// Output the current value of 'a' (12), then decrement
23console.log("Post-decrement (a--):  ", a--);
24// Display the decremented value of 'a' (11)
25console.log("Value of 'a' after decrement:", a);
26
27// Demonstrate pre-decrement operation on 'a'
28// Decrement 'a' first (10) then output
29console.log("Pre-decrement (--a):   ", --a);

Rekenkundige operatoren voeren basis-wiskundige berekeningen uit op nummers. Naast optelling en aftrekking kun je bewerkingen uitvoeren zoals modulus, increment en decrement. Merk op dat de waarde die wordt geretourneerd door incrementele of decrementele bewerking verschilt afhankelijk van of de operator voor of na de operand wordt geplaatst.

Toewijzingsoperatoren

De toewijzingsoperatoren van JavaScript omvatten het volgende:.

 1let x = 10;
 2
 3x += 5;  // x = x + 5, so x becomes 15
 4console.log('After x += 5 : ', x);  // 15
 5
 6x -= 10;
 7console.log('After x -= 10 : ', x);  // 5
 8
 9x *= 3;
10console.log('After x *= 3 : ', x);  // 15
11
12x /= 3;
13console.log('After x /= 3 : ', x);  // 5
14
15x %= 2;
16console.log('After x %= 2 : ', x);  // 1

Toewijzingsoperatoren worden gebruikt om waarden aan variabelen toe te wijzen of om de waarden van variabelen bij te werken. Naast reguliere toewijzing zijn er toewijzingsoperatoren voor rekenkundige operaties zoals optelling en modulo.

Vergelijkingsoperatoren

De vergelijkingsoperatoren van JavaScript omvatten het volgende:.

 1console.log("5 == '5' evaluates to:", 5 == "5");   // true (because the values are equal)
 2console.log("5 === '5' evaluates to:", 5 === "5"); // false (because the types are different)
 3console.log("5 != '5' evaluates to:", 5 != "5");   // false
 4console.log("5 !== '5' evaluates to:", 5 !== "5"); // true
 5console.log("5 > 2 evaluates to:", 5 > 2);         // true
 6console.log("5 < 2 evaluates to:", 5 < 2);         // false
 7console.log("5 >= 5 evaluates to:", 5 >= 5);       // true
 8console.log("5 <= 4 evaluates to:", 5 <= 4);       // false
 9console.log("5 >= '5' evaluates to:", 5 >= "5");   // true
10console.log("5 <= '5' evaluates to:", 5 <= "5");   // true

• Vergelijkingsoperatoren vergelijken waarden en retourneren óf waar óf onwaar.
• De gelijkheidsoperator (==) converteert automatisch verschillende typen indien nodig voordat de vergelijking wordt uitgevoerd. De strikte gelijkheidsoperator (===) voert geen typeconversies uit tijdens de vergelijking en retourneert alleen true als beide waarden hetzelfde type en dezelfde waarde hebben. Het gebruik van de strikte gelijkheidsoperator (===) helpt bugs te voorkomen die worden veroorzaakt door onbedoelde typeconversie, daarom wordt aanbevolen deze bij voorkeur te gebruiken.

Logische operatoren

De logische operatoren van JavaScript omvatten het volgende:.

1let a = true;
2let b = false;
3
4console.log("a && b evaluates to:", a && b);  // false
5console.log("a || b evaluates to:", a || b);  // true
6console.log("!a evaluates to:", !a);          // false

Logische operatoren worden gebruikt bij meerdere voorwaarden om combinaties van voorwaarden te evalueren.

Prioriteit van logische operatoren

In JavaScript worden logische operatoren over het algemeen geëvalueerd in de volgorde van eerst NOT, gevolgd door AND en ten slotte OR.

NOT heeft de hoogste prioriteit

NOT is een een-operand-operator en wordt geëvalueerd met de hoogste prioriteit.

1console.log(!true || false);  // false

AND heeft voorrang op OR

AND heeft een hogere prioriteit dan OR, dus het AND-gedeelte wordt als eerste geëvalueerd.

1console.log(true || false && false);  // true

Op deze manier wordt het AND-gedeelte (&&) eerst geëvalueerd, en het resultaat wordt doorgegeven aan OR (||).

AND en OR voeren een short-circuit evaluatie uit

De AND en OR van JavaScript voeren een short-circuit evaluatie uit. Als het resultaat bepaald kan worden door de waarde aan de linkerkant, wordt de expressie aan de rechterkant niet geëvalueerd.

1let a = false && console.log("This will not be printed");
2console.log(a);  // false
3
4let b = true || console.log("This will not be printed");
5console.log(b);  // true

In beide gevallen zal console.log() niet worden uitgevoerd.

Stel expliciete prioriteit vast

Door expressies expliciet te groeperen met haakjes, kun je misverstanden over prioriteit voorkomen.

1console.log(true || (false && false));  // true

Verschillen tussen natuurlijke taal en programmainterpretatie

Bij het gebruik van logische operatoren is het belangrijk om je bewust te zijn van de dubbelzinnigheden in natuurlijke taal. Bijvoorbeeld, als je zegt 'witte hond of kat,' kan het betekenen 'een witte hond of een kat van willekeurige kleur' of 'een witte hond of een witte kat.'. In code zou het er als volgt uitzien:.

1if (isWhite && isDog || isCat) {
2    console.log(' "A white dog" or "a cat of any color" ');
3}
4
5if (isWhite && (isDog || isCat)) {
6    console.log(' "A white dog" or "a white cat" ');
7}
8
9console.log(true || (false && false));  // true

Omdat natuurlijke taal dergelijke dubbelzinnigheden bevat, is voorzichtigheid geboden bij het coderen of ontwerpen.

Ternaire operator (Voorwaardelijke operator)

JavaScript bevat een ternaire operator (voorwaardelijke operator).

1let age = 20;
2let message = age >= 18 ? "Adult" : "Minor";
3console.log(message);  // "Adult"

Het wordt geschreven in de vorm voorwaarde ? waarde indien waar : waarde indien onwaar.

Bitwise operatoren

JavaScript bitwise-operatoren omvatten het volgende.

 1let x = 0x0F & 0x0C;
 2console.log("0x0F & 0x0C evaluates to:", x, "(0x0C, 12)");  // 0x0C (12)
 3
 4x = 0x04 | 0x02;
 5console.log("0x04 | 0x02 evaluates to:", x, "(0x06, 6)");  // 0x06 (6)
 6
 7x = 0x0F ^ 0x0C;
 8console.log("0x0F ^ 0x0C evaluates to:", x, "(0x03, 3)");  // 0x03 (3)
 9
10// The inverted number is represented as a negative value
11// because JavaScript numbers are stored as signed 32-bit integers.
12x = ~0x0C;
13console.log("~0x0C evaluates to:", x, "(-13, 0xF3)");  // 0xF3 (-13)
14
15x = 0x04 << 1;
16console.log("0x04 << 1 evaluates to:", x, "(0x08, 8)");    // 0x08 (8)
17x = 0x04 >> 1;
18console.log("0x04 >> 1 evaluates to:", x, "(0x02, 2)");    // 0x02 (2)

Bit operators voeren berekeningen uit op nummers op bit-niveau. Ze worden meestal gebruikt voor verwerking op laag niveau.

Type operators

JavaScript type-operatoren omvatten het volgende.

1console.log(typeof "Hello");  // "string"
2console.log(typeof 42);       // "number"
3
4let arr = [1, 2, 3];
5console.log("arr instanceof Array : ", arr instanceof Array); // true

Type operators worden gebruikt om het type van een waarde te controleren of om het naar een specifiek type te converteren.

De operator typeof geeft het type van een variabele terug.

De operator instanceof controleert of een object tot een specifieke klasse behoort.

Samenvatting

• Rekenkundige operators voeren basisberekeningen uit.
• Toewijzingsoperators wijzen waarden toe aan of werken waarden bij in variabelen.
• Vergelijkingsoperators vergelijken twee waarden en geven waar of onwaar terug.
• Logische operators evalueren combinaties van voorwaarden.
• Ternaire operators stellen u in staat om voorwaardelijke uitspraken in een kortere vorm dan if te schrijven.
• Bitwise operators voeren berekeningen uit op bit-niveau.
• Type operators stellen u in staat het type van een waarde te controleren.

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

YouTube Video