<?xml version="1.0" encoding="iso-8859-1"?>
<!-- up-to-date against phpdoc/en/language/experssions.xml:1.1.1.1 -->
 <chapter id="language.expressions">
   <title>Expressies</title>

   <simpara>
    Expressies zijn de belangrijkste bouwstenen van PHP. In PHP is bijna
    alles wat je schrijft een expressie. De eenvoudigste en meest
    accurate manier om een expressie te defineren is &quot;alles dat een
    waarde heeft&quot;.</simpara>

   <simpara>
    De basis vorm van expressies zijn constanten en variabelen. Als je
    typt "$a = 5", dan geef je $a de waarde '5'. '5', heeft als waarde
    (natuulijk) 5, of met andere woorden '5' is een expressie met de
    waarde 5 (in dit voorbeeld, '5' is een integer constante).</simpara>

   <simpara>
    Na deze toekenning verwacht je dat de waarde van $a ook 5 zal zijn,
    en als je nu zou schrijven $b = $a, dan verwacht je dat dit precies
    hetzelfde zal doen als $b = 5. Met andere woorden, $a is ook een
    expressie met de waarde 5. Als alles werkt zoals het hoort, zal
    $b dus ook de waarde 5 krijgen.</simpara>

   <para>
    Wat complexere voorbeelden van expressies zijn functies. Kijk
    bijvoorbeeld naar de volgende functie:

    <informalexample>
     <programlisting>
function foo () {
    return 5;
}
     </programlisting>
    </informalexample></para>

   <simpara>
    Aangenomen dat je bekend met met het concept 'functiens' (als je
    dit niet bent kijk dan in het hoofdstukk over functies), verwacht je
    dat het typen van <literal>$c = foo()</literal> in essentie precies
    hetzelfde is als het typen van <literal>$c = 5</literal>, en dit is ook
    waar. Functies zijn expressies met de waarde die gelijk is aan de return
    waarde van de functie. Omdat foo() 5 teruggeeft, is de waarde van de
    expressie 'foo()' 5. Normaal gesproken retourneren functies geen
    statische waarden natuurlijk, maar berekenen ze iets.</simpara>

   <simpara>
    Natuurlijk kunnen waarden in PHP ook iets anders zijn dan integers.
    PHP ondersteund drie scalaire types: integers, floating points en
    strings. (Scalaire types hebben waardes die je niet in kleinere stukken
    kunt breken, dit in tegenstelling tot bijvoorbeeld array's).
    PHP ondersteund ook twee niet scalaire types: array's en objecten
    Al deze types kunnen worden toegekend aan variabelen of worden 
    teruggegeven uit functies.</simpara>

   <simpara>
    Tot zover zullen de gebruikers van PHP/FI 2 geen verschil merken,
    maar PHP gaat veel verder met expressies, op dezelfde manier als
    veel andere talen doen. PHP is een expressie-geori&euml;nteerde
    taal waarbij bijna alles een expressie is. Neem bijvoorbeeld het
    voorbeeld dat je eerder hebt gezien: '$a = 5'. Het is eenvoudig
    te zien dat het hier om twee waardes gaat, de waarde van de
    integer constante '5' en de waarde van $a waaraan 5 wordt
    toegekend. Maar in werkelijkheid is er nog een waarde, en deze
    waarde is de waarde van de toekenning zelf. De toekenning zelf
    evalueert tot de toegekende waarde, in dit geval 5. Dit betekend
    dat '$a = 5', terzijde gelegd wat het doet, een expressies is met
    de waarde 5. Dus als je zou schrijven: '$b = ($a = 5)' gebeurd er
    precies als je zou schrijven: '$a = 5; $b = 5;' (een puntkomma
    markeerd het einde van een statement). Omdat toekenningen worden
    geparsed van rechts naar links, zou je ook kunnen schrijven
    '$b = $a = 5'.</simpara>

   <simpara>
    Een ander goed voorbeeld van expressie ori&euml;ntatie zijn
    pre- en  post-increment en decrement. Gebruikers van PHP/FI 2
    en vele andere talen zullen wellicht de notatie variabele++
    en variable-- kunnen. Dit zijn de increment en decrement
    operaties. In PHP/FI 2, heeft het statement '$a++' geen waarde
    (het is geen expressie), en daarom kun je het niet toewijzen
    of gebruiken op een andere manier. PHP voegt increment/decrement
    toe aan de expressies, net zoals dit in C is. In PHP zijn er 
    twee types of increment, pre-increment en post-increment.
    Zowel pre-increment en post-increment verhogen de variabele, en
    het effect op de variabele is identiek. Het verschil ligt hem
    aan de waarde van de totale increment expressie. Pre-increment,
    dat wordt geschreven als '++$variable', evaluaeerd tot de 
    opgehoogde waarde (PHP increments de variabele voordat de waarde
    wordt gelezen, vandaar de naam 'pre-increment'). Post-increment,
    dat wordt geschreven als '$variable++' evalueert tot de
    oorspronkelijke waarde van $variable, voordat deze is 
    opgehoogd (PHP increments de variable nadat deze is uitgelezen,
    vandaar de naam 'post-increment').</simpara>

   <simpara>
    Andere normale expressies zijn vergelijkings expressies. Deze
    expressies evalueren tot 0 of 1 (dit betekent respectievelijk
    &false; en &true;). PHP ondersteund &gt; (groter dan), &gt;= (groter dan
    of gelijk aan), == (gelijk), != (niet gelijk), &lt; (kleiner dan)
    en &lt;= (kleinder dan of gelijk aan). Deze expressies worden meestal
    gebruikt binnen conditionele statements, zoals <literal>if</literal>
    statements.</simpara>

   <simpara>
    Het laatste type expressies waar we het over zullen hebben zijn
    gecombineerde operatie-toewijzings expressies. Je weet al dat
    als je $a wilt verminderen met 1, je '$a++' of '++$a' kunt
    schrijven. Maar wat als je er meer wailt afhalen, bijvoorbeeld 3?
    Je zou natuurlijk vaker '$a++' kunnen scjrijven, maar dit is
    natuurlijk niet effici&euml; of handig. Veel vaker wordt er
    geschreven '$a = $a + 3'. '$a + 3' evaluaeerd tot de waarde van $a
    plus 3, en wordt dan weer teruggewezen aan $a, dit resulteert in
    een nieuwe waarde van $a die 3 onder d ehuidige waarde ligt.
    In PHP, en in vele andere talen waaronder C, kun je dit korter
    schrijven, zodat het makkelijker leest en sneller te begrijpen is.
    Het ophogen van de huidige waarde van $a met 3 kan worden geschreven
    als '$a += 3'. Dit betekend "neem de waarde van $a, tel er 3 bij
    op, en ken het weer toe aan $a". Als derde voordeel (naast korter
    en makkelijker te lezen, zal het statement ook sneller worden
    uitgevoerd. De waarde van '$a += 3', is net zoals de waarde van
    een normale toekenning, de toegekende waarde. Begrijp goed dat dit
    NIET 3 is, maar de gecombineerde waarde van $a plus 3 (dit is
    namelijk de waarde die wordt toegekend aan $a). Elke binairy
    operator kan worden gebruikt voor deze operatie-toekennings mode,
    bijvoorbeeld '$a -= 5' (verminder de waarde van $a met 5), 
    '$b *= 7' (vermenigvuldig de waarde van $b met 7), enz.</simpara>

   <para>
    Er is nog een expressie die vreemd zal lijken als je het nog niet
    hebt gezien in andere talen, namelijk ternaire conditionele
    operator:

    <informalexample><programlisting>
$eerste ? $tweede : $derde
</programlisting></informalexample>

    Als de waarde van de eerste sub-expressie waar is (niet-nul), dan
    worde de tweede sub-expressie geevalueerd, en dit resultaat zijn
    van de conditionele expressie. Anders worde de derde sub-expressie
    geevalueerd, en wordt dit de waarde van de operatie.</para>

   <para>
    Het volgende voorbeeld helpt je met het beter begrijpen van pre- en
    post-increment en expressies in het algemeen:

    <informalexample>
     <programlisting>
function dubbel($i) {
    return $i*2;
}
$b = $a = 5;        /* ken de waarde 5 toe aan de variabelen $a en $b */
$c = $a++;          /* post-increment, ken de originele waarde van $a 
                       (5) toe aan $c */
$e = $d = ++$b;     /* pre-increment, ken de opgehoogde waarde van 
                       $b (6) toe aan $d en $e */

/* op dit punt zijn $d en $e beide gelijk aan 6 */

$f = double($d++);  /* ken twee keer de waarde van $d <emphasis>voor</emphasis> 
                       de ophoging, 2*6 = 12 toe aan $f */
$g = double(++$e);  /* ken twee keer de waarde van $e <emphasis>na</emphasis>
                       de ophoging, 2*7 = 14 toe aan $g */
$h = $g += 10;      /* als eerste wordt $g opgehoogd met 10 en eindigt met de 
                       waarde 24. De waarde van de toekenning (24) wordt dan
                       toegekend aan $h, zodat ook $h uiteindelijk de waarde
                       24 krijgt. */
</programlisting></informalexample></para>

   <simpara>
    Aan het begin van dit hoofdstuk vertelden we dat we verschillende
    statement types zouden beschrijven, en zoals is gebleken kunnen
    expressies statements zijn. Maar niet iederen expressie is een statement.
    Een statement heeft de vorm 'expressie' ';' dat is een expressie
    gevolgt door een punt-komma. In '$b=$a=5;' is $a=5 een geldige
    expressie, maar niet een statement. '$b=$a=5;' is wel een geldig
    statement in dit voorbeeld.</simpara>

   <simpara>
    Er is nog een laatste ding waar we het over willende hebben, en
    dat is de waarheids-waarde van expressies. In veel gevallen,
    vaak in loops en andere conditionele dingen, ben je niet
    ge&iuml;nteresseerd in een specifieke waarde, maar alleen of deze
    waarde &true; of &false; betekent. (PHP heeft geen appart boolean
    type). De waarheidswaarde van expressies in PHP is hetzelfde als
    dat in Perl. Allen numerieke niet-nul waarden zijn &true;, 0 is
    &false;. Let erop negatieve waardes ook niet-nul zijn en daarom
    de waarheids-waarde &true; is!. De lege string en de string "0"
    zijn ook &false;; alle andere strings zijn &true;. In het geval van
    niet scalaire waarden (array's en objecten) is de waardheids-
    waarde &false; als deze geen elementen bevat, anders evalueren ze
    tot &true;.</simpara>

   <simpara>
    PHP heeft een volledige en krachtige implementatie van expressie,
    en om dit te documenteren gaat geheel buiten de scope van deze
    handleiding. De bovenstaande voorbeelden zouden je een goed idee
    moeten geen over wat expressies zijn en hoe je ze goed kan
    construeren. In de rest van deze handleiding zullen we
    <replaceable>expr</replaceable> schrijven om een geldige PHP
    expressie aan te geven.</simpara>

  </chapter>
 
 <!-- Keep this comment at the end of the file
 Local variables:
 mode: sgml
 sgml-omittag:t
 sgml-shorttag:t
 sgml-minimize-attributes:nil
 sgml-always-quote-attributes:t
 sgml-indent-step:1
 sgml-indent-data:t
indent-tabs-mode:nil
 sgml-parent-document:nil
 sgml-default-dtd-file:"../manual.ced"
 sgml-exposed-tags:nil
 sgml-local-catalogs:nil
 sgml-local-ecat-files:nil
 End:
 -->