Operatoren in programmeren

Operatoren zijn symbolen die een bepaalde bewerking uitvoeren op waarden of variabelen. Het begrijpen van operatoren is essentieel om logica in code correct uit te drukken.

Toekenningsoperatoren

Een variabele kan een waarde krijgen door gebruik te maken van de toekenningsoperator =.

Voorbeeld: toekennen van een nieuwe waarde

let x = 5;
x = 10;   // x krijgt nu een nieuwe waarde

Samengestelde vormen zoals += of -= combineren een berekening met een toekenning.

Voorbeeld: samengestelde toekenning (+=, -=)

let x = 5;
x += 2;   // hetzelfde als: x = x + 2
x -= 3;   // hetzelfde als: x = x - 3

Rekenkundige operatoren

Deze worden gebruikt om wiskundige berekeningen te maken.

• + optellen
• - aftrekken
• * vermenigvuldigen
• / delen
• % modulo (restwaarde van een deling)

Voorbeeld: rekenkundige operatoren in actie

let a = 10;
let b = 3;

let som = a + b;     // 13
let verschil = a - b; // 7
let product = a * b; // 30
let quotient = a / b; // 3.333...
let rest = a % b;    // 1

Vergelijkingsoperatoren

Vergelijkingen geven altijd een boolean terug: true of false.

• == gelijk aan
• != ongelijk aan
• > groter dan
• < kleiner dan
• >= groter of gelijk aan
• <= kleiner of gelijk aan

Voorbeeld: vergelijkingsoperatoren gebruiken

let score = 8;
let voldoende = score >= 6;  // true
let onvoldoende = score < 6; // false

Strikte gelijkheid

Naast == en != bestaan er ook === en !==. Deze controleren niet alleen de waarde, maar ook het type.

Voorbeeld: verschil tussen == en ===

let x = 5;
let y = "5";

x == y;   // true
x === y;  // false, omdat het type verschilt

Logische operatoren

Met logische operatoren combineer je voorwaarden.

• && (en)
• || (of)
• ! (niet)

Voorbeeld: logische operatoren in een conditie

let leeftijd = 20;
let ticket = true;

if (leeftijd > 18 && ticket) {
    // toegang toegestaan
}

Operator precedence (volgorde van evaluatie)

Net als in de wiskunde heeft de volgorde van operatoren invloed op de uitkomst.

Voorbeeld: operatorprecedence (volgorde van evaluatie)

let resultaat = 2 + 3 * 4;  // 14, want * gaat vóór +
let correct = (2 + 3) * 4;  // 20

Self-assignment en increment

Vaak wil je een variabele met 1 ophogen. Dit kan op verschillende manieren, die hetzelfde resultaat geven.

Voorbeeld: verschillende manieren om te incrementeren

let x = 0;

x = x + 1;
x += 1;
x++;

Ternary operator

Een compacte vorm van een if-else.

Voorbeeld: ternary operator voor korte if-else

let score = 7;
let resultaat = (score >= 6) ? "voldoende" : "onvoldoende";

---

Hier is een uitbreiding van het document met een apart gedeelte over veelgemaakte beginnersfouten. Ik heb het in dezelfde stijl geschreven, met korte voorbeelden en uitleg.

---

Veelgemaakte beginnersfouten

Verwarring tussen = en ==

Een veel voorkomende fout is het gebruik van = (toekenning) in plaats van == (vergelijking).

Fout voorbeeld: toekennen in plaats van vergelijken

let score = 8;

if (score = 6) {   // fout: dit wijzigt de variabele!
    // deze code wordt altijd uitgevoerd
}

Correct voorbeeld: juiste vergelijking gebruiken

let score = 8;

if (score == 6) {  // correct: dit vergelijkt de waarde
    // wordt alleen uitgevoerd als score gelijk is aan 6
}

---

Vergelijking zonder strikte gelijkheid

Bij gebruik van == kan typeconversie onverwachte resultaten geven.

Fout voorbeeld: losse gelijkheid veroorzaakt typecoercion

let x = "5";
if (x == 5) {   // true, maar niet altijd gewenst
    // kan verwarrend zijn
}

Correct voorbeeld: strikte gelijkheid gebruiken

let x = "5";
if (x === 5) {  // false, duidelijk verschil in type
    // beter voorspelbaar gedrag
}

---

Modulo verkeerd begrijpen

Beginners denken soms dat % een percentage berekent. In werkelijkheid geeft het de rest van een deling.

Fout voorbeeld: modulo is geen percentage

let deel = 10 % 50;  // verwacht: 20% van 50, krijgt: 10

Correct voorbeeld: modulo geeft restwaarde

let rest = 10 % 3;   // 1, want 10 = 3 * 3 + 1

---

Misbruik van increment

Beginners gebruiken vaak lange vormen terwijl een kortere versie bestaat.

Onhandig voorbeeld: lange increment

let i = 0;
i = i + 1;

Handiger voorbeeld: korte increment

let i = 0;
i++;

---

Verkeerd gebruik van logische operatoren

Soms wordt || (of) gebruikt waar && (en) nodig is, of andersom.

Fout voorbeeld: verkeerde logische operator

let leeftijd = 20;
let heeftTicket = false;

if (leeftijd > 18 || heeftTicket) {
    // geeft toegang, ook al heeft de persoon geen ticket
}

Correct voorbeeld: juiste logische operator

let leeftijd = 20;
let heeftTicket = false;

if (leeftijd > 18 && heeftTicket) {
    // geeft alleen toegang als beide voorwaarden waar zijn
}

---

Operator precedence vergeten

Beginners denken vaak dat operatoren altijd van links naar rechts worden uitgevoerd.

Fout voorbeeld: precedence verkeerd ingeschat

let resultaat = 2 + 3 * 4; // verwacht: (2 + 3) * 4 = 20

Correct voorbeeld: juiste precedence toegepast

let resultaat = 2 + 3 * 4; // is 14, want * gaat vóór +

---

Begrippenlijst

• Operator – symbool dat een bewerking uitvoert
• Toekenningsoperator – =, +=, -= enz.
• Rekenkundige operator – +, -, *, /, %
• Vergelijkingsoperator – ==, !=, >, <, >=, <=
• Strikte gelijkheid – ===, !==
• Logische operator – &&, ||, !
• Boolean – waarde die true of false kan zijn
• Operator precedence – volgorde waarin operatoren worden toegepast
• Increment – variabele ophogen met 1 (++)
• Ternary operator – compacte schrijfwijze van if-else

---