Vreemde programma constructie zonder return

Volgens mij staat hier effectief gewoon

if(empty($this->validation_data)) $this->_reset_data_array($_POST);

Het tweede deel van de && wordt nl. alleen uitgevoerd als de 1e true geeft.

Geen idee waarom dit zo "cryptisch" is gedaan. Misschien schrijft de coding standard accolades voor en had het dan

if(empty($this->validation_data))
{
  $this->_reset_data_array($_POST);
}

moeten worden - en had de auteur geen zin in die 3 extra regels?

Waarschijnlijk wordt hier gebruik (misbruik?) gemaakt van lazy evaluation.

Stel dat je het predikaat (het Boolse statement) A && B hebt. Het resultaat van A && B is alleen true als beide delen, zowel A alsook B, true zijn. Bij lazy evaluation wordt in beginsel enkel het eerste deel geïnspecteerd. Immers, als A ongelijk is aan true (oftewel false), dan kan A && B nooit true opleveren en je hoeft dan dus B ook niet te inspecteren (of uit te voeren).

PHP valideert op deze manier Boolse statements. Het bovenstaande is equivalent aan:

<?php
if (empty($this->validation_data)) {
    $this->_reset_data_array($_POST);
}
?>

In dit geval is het waarschijnlijk "gewoon" een verkorte schrijfwijze van het bovenstaande, maar je hebt interessantere toepassingen van lazy evaluation als de operaties mogelijk "duur" zijn. Je zou dan zoiets kunnen doen:

<goedkope operatie> && <dure operatie>

De <dure operatie> (CPU, geheugen) wordt dan niet uitgevoerd als <goedkope operatie> false teruggeeft.

Maar voor hetzelfde geld gebruik je dus een if-statement. Indien dan mogelijk is. De &&-constructie zou je bijvoorbeeld kunnen gebruiken in query-optimalisatie door de goedkope condities vooraan te zetten in je WHERE-statement.

Op eenzelfde wijze werkt lazy evaluation voor ||. Indien in A || B het eerste deel (A) true is, dan maakt het niet uit wat voor waarde B heeft, het resultaat is dan toch true, dus ook dan wordt B niet geïnspecteerd (noch uitgevoerd).

Beste Rob, Thomas, bedankt voor jullie leerrijke reactie! Had ik nog nooit van gehoord...

Voorbeeldje:

<?php
// https://www.phphulp.nl/php/forum/topic/vreemde-programma-constructie-zonder-return/103138

function executeA($in) {
    if ($in) {
        echo 'A';
    } else {
        echo 'not A';
    }
    return $in;
}

function executeB($in) {
    if ($in) {
        echo 'B';
    } else {
        echo 'not B';
    }
    return $in;
}

$a = true;
$b = true;

executeA($a) && executeB($b); // levert AB
echo '<br>';
executeA($a) || executeB($b); // levert A - vanwege lazy evaluation, executeB() wordt niet uitgevoerd
echo '<br>';
$a = false;
executeA($a) && executeB($b); // levert not A - vanwege lazy evaluation, executeB() wordt niet uitgevoerd
echo '<br>';
executeA($a) || executeB($b); // levert not AB
?>

Alles goed en wel maar dat soort grappen maken je code niet bepaald leesbaarder.

Zo kom je soms ook van die rare if statements tegen:

<?php
$a = '';

if(!empty($a) === true) {
echo 'not empty';
} else {
echo 'empty';
}
?>
Terwijl dit hetzelfde doet
<?php
if(empty($a)) {
echo 'empty';
} else {
echo 'not empty';
}
?>
Soms zit een programmeur ook even zonder koffie ;-)

Frank Nietbelangrijk op 18/10/2019 17:15:41

Zo kom je soms ook van die rare if statements tegen:

<?php
$a = '';

if(!empty($a) === true) {
echo 'not empty';
} else {
echo 'empty';
}
?>

Sja, maar dat soort fratsen kun je zelf makkelijk voorkomen door je te bedienen van simpele programmeerprincipes, zoals jij ook doet:
- het is vaak niet nodig om expliciet te vergelijken met Boolse waarde (=== true, === false)
- als je de conditieblokken kunt inverteren zodat je een negatie (!) kunt vermijden dan zou je dat moeten doen

Wat dat betreft is de "A && B" constructie nog redelijk clean, maar je moet wel weten wat voor implicaties dit heeft icm lazy evaluation.

Precies Thomas. Soms komt het else gedeelte wat later en dan moet je het gewoon omdraaien.

Over die boolse waarden daar heeft ook iedere programmeur blijkbaar zijn eigen voorkeur in. Voor mij zou <?php if(empty($a) ?> ook prima zijn. Wat wel een klein voordeel heeft is de true of false links in de conditie te plaatsen. Je krijgt dan een parse error als je per ongeluk een = (assignment) in plaats van een == of === gebruikt.
<?php
if(true = $banaan) { // PARSE ERROR
?>

Mja maar het grappige van die ezelsbrug is weer dat, op het moment dat dat voor jou een tweede natuur is, je dat ook niet meer fout doet. Dus dan heb je in principe die Yoda-statements ook niet meer (expliciet) nodig.

Wat mij betreft hebben functies/constructs die (vaak door naamgeving) al min of meer impliceren dat ze een Boolse waarde retourneren niet nog een expliciete vergelijking met een Boolean nodig, tenzij je maar één case hebt (en geen else-deel) die interessant is.

En in dat opzicht is het misschien ook weer beter om een expliciete vergelijking te doen met false in plaats van een negatie (!) ofzo. Een uitroepteken zie je snel(ler) over het hoofd.

Of wanneer return-values ten onrechte tot de verkeerde Boolse waarde kunnen evalueren (omdat PHP het niet zo nauw met types neemt) als dat niet de bedoeling is.

Er zijn altijd uitzonderingen op regels :).