Skip to content
ICT Fusion Knowledgebase

Operatoren

Operatoren zijn symbolen of sleutelwoorden die een bewerking uitvoeren op één of meer waarden. \ De meeste operatoren zijn identiek in beide talen; een paar kleine verschillen worden hieronder uitgelicht.

Toekenning

De toekenningsoperator (=) geeft een variabele een waarde. \ Samengestelde vormen combineren een berekening met een toekenning.

let x = 5;
x += 2;    // x = x + 2  →  7
x -= 1;    // x = x - 1  →  6
x *= 3;    // x = x * 3  →  18
x /= 2;    // x = x / 2  →  9
x++;       // x = x + 1  →  10

x = 5
x += 2    # x = x + 2  →  7
x -= 1    # x = x - 1  →  6
x *= 3    # x = x * 3  →  18
x /= 2    # x = x / 2  →  9.0
# Python heeft geen x++ operator

int x = 5;
x += 2;    // x = x + 2  -> 7
x -= 1;    // x = x - 1  -> 6
x *= 3;    // x = x * 3  -> 18
x /= 2;    // x = x / 2  -> 9
x++;       // x = x + 1  -> 10

Rekenkundige operatoren

+ optellen · - aftrekken · * vermenigvuldigen · / delen · % rest (modulo) · ** machtsverheffing

let a = 10, b = 3;
console.log(a + b);   // 13
console.log(a - b);   // 7
console.log(a * b);   // 30
console.log(a / b);   // 3.333...
console.log(a % b);   // 1
console.log(2 ** 3);  // 8

a, b = 10, 3
print(a + b)    # 13
print(a - b)    # 7
print(a * b)    # 30
print(a / b)    # 3.333...
print(a % b)    # 1
print(2 ** 3)   # 8
print(a // b)   # 3  ← Python heeft ook gehele deling

int a = 10, b = 3;
Serial.println(a + b);      // 13
Serial.println(a - b);      // 7
Serial.println(a * b);      // 30
Serial.println((float)a / b); // 3.333...
Serial.println(a % b);      // 1
Serial.println(pow(2, 3));  // 8

Vergelijkingsoperatoren

Vergelijkingen leveren altijd een booleaanse waarde op: true / True (waar) of false / False (niet waar).

In JavaScript is er een onderscheid tussen losse gelijkheid (==, converteert types) en strikte gelijkheid (===, vergelijkt ook type). \ In Python is er maar één gelijkheidsoperator (==) die altijd strikt vergelijkt.

let score = 8;
console.log(score >= 6);    // true
console.log(score < 5);     // false
console.log(score === 8);   // true  (strikt: waarde én type)
console.log("8" == 8);      // true  (losse gelijkheid: type wordt geconverteerd)
console.log("8" === 8);     // false (strikt: string ≠ number)

score = 8
print(score >= 6)    # True
print(score < 5)     # False
print(score == 8)    # True
print("8" == 8)      # False  (Python converteert types nooit automatisch)

int score = 8;
Serial.println(score >= 6);   // 1 (true)
Serial.println(score < 5);    // 0 (false)
Serial.println(score == 8);   // 1
Serial.println(score != 8);   // 0

Logische operatoren

Logische operatoren combineren meerdere voorwaarden. \ JavaScript gebruikt symbolen; Python gebruikt sleutelwoorden in gewoon Engels.

let leeftijd = 20;
let heeftTicket = true;

console.log(leeftijd > 18 && heeftTicket);  // true  (EN)
console.log(leeftijd < 18 || heeftTicket);  // true  (OF)
console.log(!heeftTicket);                  // false (NIET)

leeftijd = 20
heeft_ticket = True

print(leeftijd > 18 and heeft_ticket)  # True  (EN)
print(leeftijd < 18 or heeft_ticket)   # True  (OF)
print(not heeft_ticket)                # False (NIET)

int leeftijd = 20;
bool heeftTicket = true;

Serial.println(leeftijd > 18 && heeftTicket);  // 1 (EN)
Serial.println(leeftijd < 18 || heeftTicket);  // 1 (OF)
Serial.println(!heeftTicket);                  // 0 (NIET)

Inline keuze (ternary / conditionele expressie)

Een compacte manier om een waarde te kiezen op basis van een voorwaarde.

let score = 7;
let resultaat = (score >= 6) ? "voldoende" : "onvoldoende";
console.log(resultaat);  // voldoende

score = 7
resultaat = "voldoende" if score >= 6 else "onvoldoende"
print(resultaat)  # voldoende

int score = 7;
String resultaat = (score >= 6) ? "voldoende" : "onvoldoende";
Serial.println(resultaat);  // voldoende

Operator precedence (volgorde)

Net als in wiskunde worden operatoren in een vaste volgorde toegepast: ** > *, /, % > +, -. \ Gebruik haakjes om de volgorde te verduidelijken.

console.log(2 + 3 * 4);    // 14  (niet 20)
console.log((2 + 3) * 4);  // 20

print(2 + 3 * 4)    # 14  (niet 20)
print((2 + 3) * 4)  # 20

Serial.println(2 + 3 * 4);    // 14 (niet 20)
Serial.println((2 + 3) * 4);  // 20

Samenvatting begrippen

Begrip Betekenis
Operator Symbool dat een bewerking uitvoert
Toekenning = geeft een variabele een waarde
Modulo (%) Geeft de rest van een deling
Machtsverheffing (**) Getal tot de macht
Strikte gelijkheid Vergelijkt zowel waarde als type (JS: ===)
Logische operator Combineert voorwaarden: EN / OF / NIET
Operator precedence Volgorde waarin operatoren worden toegepast