# Operatoren

U kan de belangrijkste operatoren onderverdelen in vier groepen, namelijk rekenkundige, vergelijkende, logische en string operatoren.

## Rekenkundige operatoren

```javascript
*       // vermenigvuldiging
/       // deling
%       // modulo of rest van een deling   (13%5 = 3)
+       // optelling
-       // aftrekking
++      // increment   (a++ is identiek aan a = a +1 en aan a += 1)
--      // decrement   (a-- is identiek aan a = a -1 en aan a -= 1)
```

```javascript
getal1   = 17
getal2   = 3
string3  = "17"
string4  = "3"

getal1 + getal2 = 20
getal1 - getal2 = 14
getal1 * getal2 = 51
getal1 / getal2 = 5.666666666666667
getal1 % getal2 = 2

getal2 * string3     = 51        // getal * string = getal!!!
getal2 + string3     = "317"     // getal + string = string!!!
string3 + string4    = "173"     // string + string = string!!!
getal1 / 0           = Infinity

++getal2 = 4   // pre-increment: eerst + één, dan tonen
getal2++ = 4   // post-increment: eerst tonen, dan + één
getal2   = 5   // vorige increment nu pas zichtbaar
--getal2 = 4   // pre-decrement: eerst - één, dan tonen
getal2-- = 4   // post-decrement: eerst tonen, dan - één
getal2   = 3   // vorige decrement nu pas zichtbaar
```

## Vergelijkende operatoren

```javascript
==      // gelijk aan  (5 == "5" is True)
===     // gelijk aan en van hetzelfde datatype (5 === "5" is False)
<       // kleiner dan 
>       // groter dan  
<=      // kleiner of gelijk aan   
>=      // groter of gelijk aan    
!=      // niet gelijk aan 
!==     // niet gelijk aan en niet van hetzelfde datatype
```

Het resultaat van een vergelijkende bewerking geeft altijd een booleaanse waarde `true` (waar) of `false` (onwaar).

```javascript
getal1   = 17
getal2   = 3
string3  = "17"
string4  = "3"

(getal1 == getal2)   = false
!(getal1 == getal2)  = true
(getal1 < getal2)    = false
(getal1 > getal2)    = true
(getal1 <= getal2)   = false
(getal1 >= getal2)   = true
(getal1 != getal2)   = true

(getal1 == string3)  = true      // gelijk aan
(getal1 === string3) = false     // gelijk aan EN van hetzelfde datatype
(string3 < string4)  = true      // string '17' < string '3' !!!
(parseInt(string3) < parseInt(string4)) = false   // getal 17 > gatal 3
```

Let vooral op de drie laatste voorbeelden. De vergelijkingen `<`, `<=`, `>` en `>=` op twee strings geeft niet altijd het verwachte resultaat. Zo is string `'17'` kleiner dan string `'3'`!\
De vergelijking start bij het eerste karakter van elke string en, inderdaad, `'1'` is kleiner dan `'3'`.

Indien we later gegevens uit een formulier opvragen, krijgen we steeds een string terug, ook al vullen we een getal in. Indien we hierop één van bovenstaande vergelijkingen uitvoeren, moeten we de string eerst omzetten naar een getal, en dan pas de vergelijking uitvoeren. Een string converteren naar een getal kan met de JavaScriptmethode `parseInt()` voor het omzetten naar een geheel getal of met `parseFloat()` voor het omzetten naar een gebroken getal.

```javascript
parseInt('3')               // = 3
parseInt('54.74')           // = 54
parseInt('14a7')            // = 14
parseInt('de78')            // = NAN (Not A Number)

parseFloat('3')             // = 3
parseFloat('54.74')         // = 54.74
parseFloat(' 30 40 50 ')    // = 30
```

## Logische operatoren

```javascript
!       // ontkenning
&&      // en-functie
||      // of-functie
```

Het resultaat van een logische bewerking geeft eveneens een booleaanse waarde `true` (waar) of `false` (onwaar).

De en-functie is waar indien alle operatoren binnen de functie waar zijn. De of-functie is waar indien minstens één operand binnen de functie waar is.\
De ontkenning is waar indien de operand onwaar is.

```javascript
getal1 = 17
getal2 = 3

(getal1 == getal2)               = false
!(getal1 == getal2)              = true
(getal1 == 17 && getal2 < 2)     = false
(getal1 == 17 || getal2 < 2)     = true
```

Logische en vergelijkende operatoren worden hoofdzakelijk gebruikt binnen voorwaardelijke of conditionele instructies en lussen.

## String operatoren

```javascript
+       // samenvoegen van twee strings
+=      // voegt het rechtse argument aan het linkse toe.
        // (string1 += string2 is identiek aan string1 = string1 + string2)
```

```javascript
string1 = "dag"
string2 = "Jan"

string1 + string2        = "dagJan"
string1 + " " + string2  = "dag Jan"
string1 += string2       = "dagJan"   // string1 = string1 + string2
string1                  = "dagJan"
```
