Operatoren

DXL ondersteunt verschillende categorieën operatoren voor berekeningen, vergelijkingen en logica.

Rekenkundige operatoren

Operator	Naam	Voorbeeld	Resultaat
+	Optellen	3 + 4	7
-	Aftrekken	10 - 3	7
*	Vermenigvuldigen	4 * 5	20
/	Delen	15 / 3	5
%	Modulo (rest)	17 % 5	2
- (unair)	Negatie	-5	-5

Optellen (+)

Werkt met getallen en tekst:

// Getallen
3 + 4                         // 7
1.5 + 2.5                     // 4

// Tekst concatenatie
"hallo" + " " + "wereld"      // "hallo wereld"
"Score: " + 42                // "Score: 42"
"Status: " + true             // "Status: true"

Aftrekken (-)

Werkt met getallen en datums:

// Getallen
10 - 3                        // 7

// Datums (geeft verschil in dagen)
2024-06-20 - 2024-06-15       // 5

Delen (/)

Deling door nul

Deling door nul geeft een fout. Controleer altijd of de deler niet nul is:

if count > 0 then total / count else 0

Vergelijkingsoperatoren

Operator	Naam	Voorbeeld	Resultaat
==	Gelijk aan	1 == 1	true
!=	Niet gelijk aan	1 != 2	true
<	Kleiner dan	1 < 2	true
<=	Kleiner of gelijk	2 <= 2	true
>	Groter dan	3 > 2	true
>=	Groter of gelijk	2 >= 2	true

Gelijkheid (== en !=)

Vergelijkt waarden van hetzelfde type:

// Getallen
42 == 42                      // true
42 != 43                      // true

// Tekst
"hello" == "hello"            // true
"hello" == "HELLO"            // false (case-sensitive)

// Boolean
true == true                  // true
true == false                 // false

// Null
null == null                  // true
42 == null                    // false

// Datums
2024-06-15 == 2024-06-15      // true

Ordening (<, <=, >, >=)

Werkt met getallen, tekst en datums:

// Getallen
5 < 10                        // true
5 <= 5                        // true

// Tekst (alfabetisch)
"aap" < "beer"                // true
"Aap" < "aap"                 // true (hoofdletters eerst)

// Datums
2024-01-01 < 2024-12-31       // true

Type matching

Vergelijkingsoperatoren werken alleen tussen waarden van hetzelfde type. "5" < 10 geeft een fout.

Logische operatoren

Operator	Naam	Voorbeeld	Resultaat
&&	Logische AND	true && false	false
||	Logische OR	true || false	true
!	Logische NOT	!true	false

AND (&&)

Retourneert true alleen als beide kanten true zijn:

true && true                  // true
true && false                 // false
false && true                 // false
false && false                // false

OR (||)

Retourneert true als minstens één kant true is:

true || true                  // true
true || false                 // true
false || true                 // true
false || false                // false

NOT (!)

Keert de waarde om:

!true                         // false
!false                        // true
!(1 < 2)                      // false

Short-circuit evaluatie

Logische operatoren evalueren "short-circuit":

• &&: Als de linkerkant false is, wordt de rechterkant niet geëvalueerd
• ||: Als de linkerkant true is, wordt de rechterkant niet geëvalueerd

// Safe: er wordt niet gedeeld als count 0 is
count > 0 && (done / count > 0.5)

// Default waarde als linkerkant falsy is
value || "standaard"

Null coalesce operator (??)

Retourneert de linkerkant als die niet null is, anders de rechterkant:

null ?? 42                    // 42
10 ?? 42                      // 10
name ?? "Onbekend"            // name of "Onbekend" als name null is

Ketenen

Je kunt meerdere ?? aan elkaar ketenen:

first_choice ?? second_choice ?? default

Property access operatoren

Punt operator (.)

Benadert een property of roept een methode aan:

action.name                   // Property access
action.budget                 // Property access
"hello".upper()               // Methode aanroep

Safe navigation (?.)

Retourneert null als de linkerkant null is, in plaats van een fout:

action?.name                  // null als action null is
owner?.email                  // null als owner null is

Verschil met punt

// Met punt operator - fout als owner null is
owner.name

// Met safe navigation - retourneert null als owner null is
owner?.name

// Combineren met null coalesce
owner?.name ?? "Niet toegewezen"

Filter operator ([])

Filtert een array op een conditie:

@actions[status == "done"]                 // Acties met status "done"
@actions[budget > 1000]                    // Acties met budget > 1000
@actions[due_date < today]                 // Acties met verlopen deadline

De "it" variabele

Binnen een filter is it beschikbaar als verwijzing naar het huidige element:

@actions[it.budget > 1000]                 // Expliciet met it
@actions[budget > 1000]                    // Impliciet (velden zijn beschikbaar)

Filters combineren

// AND: beide condities moeten waar zijn
@actions[status == "done" && budget > 1000]

// OF: minstens één conditie moet waar zijn
@actions[status == "done" || status == "cancelled"]

// Geneste filters
@results[status != "done"].actions[budget > 1000]

Operator precedentie

Van hoog naar laag:

1. () - Groepering
2. ., ?., [] - Property access, safe nav, filter
3. !, - (unair) - NOT, negatie
4. *, /, % - Multiplicatief
5. +, - - Additief
6. <, <=, >, >= - Vergelijking
7. ==, != - Gelijkheid
8. && - Logische AND
9. || - Logische OR
10. ?? - Null coalesce

Voorbeelden

// Zonder haakjes
1 + 2 * 3                     // 7 (niet 9)
true || false && false        // true (not false)

// Met haakjes voor duidelijkheid
1 + (2 * 3)                   // 7
(true || false) && false      // false

Gebruik haakjes

Gebruik bij twijfel haakjes om de volgorde expliciet te maken. Dit maakt de expressie ook leesbaarder.