Technieken, tricks en tips

<?php

$input = new Input(); 
// we zouden de waarden ook hier kunnen meegeven 

// maar dat gaan we niet doen, anders valt het hele idee weg

$input->setType('text');

$input->setName('voornaam');
$input->setValue('Koen');
// setten

echo $input->get();

// weergeven

?>

<?php

$input = new Input();

echo $input->setType('text')->setName('voornaam')->setValue('Koen')->get();


?>

<?php

class Input {

  var $type;
  var $name;
  var $value;

  function Input() {} /* kan nog iets komen */


  function setType($type) {
    $this->type = $type;
    return $this;
  }

  function setName($name) {

    $this->name = $name;
    return $this;
  }
  
  function setValue($value) {

    $this->value = $value;
    return $this;
  }

  function get() {
    return '<input type="' . $this->type . '" name="' . $this->name . '" value="' . $this->value . '" />';

  }

}

?>

<?php
$dal->select('naam_kolom, adres_kolom')->from('naw')->where('leeftijd=15');

// source: http://www.scriptorama.nl/algemeen/fluent-interfaces
?>

<?php

class Test {

   public function __construct($var, $foo, $bar) {


      list($this->tvar, $this->foo, $this->bar) = array($var, $foo, $bar);


   }

   function __sleep() {

     // deze vars zullen mee geserializeerd worden

     return array('tvar', 'foo');


   }

   function __wakeup() {

     $this->bar = "blaat";

   }

   public function run() {


     echo $this->tvar . $this->foo . $this->bar;

   }

   private $tvar;

   private $foo;
   private $bar;

}

$test = new Test('blaat', 'blaat2', 'blaat3');

$test = serialize($test); // __sleep wordt aangeroepen
$test = unserialize($test); // __wakeup wordt aangeroepen

$test->run(); // 'blaatblaat2blaat'
?>

<?php

class Singleton {

  private function __construct() {}
  private function Singleton() {}
  

  // zowel php5 als php4 constructor blokkeren
  
}

?>

<?php

$eenObject = new Singleton();

?>

<?php


class Singleton {

  static private $instance = NULL;

  // we zouden hier een teller kunnen bijhouden met het aantal instanties zodat we het kunnen verhogen tot 2 of 3


  private function __construct() {}
  private function Singleton() {}
  // zowel php5 als php4 constructor blokkeren

  
  static public function createInstance() {
  
    if(self::$instance == NULL) {
      self::$instance = new self;

    }
    
    return self::$instance;
    
  }
  
  public function aFunction() {
  
    echo "Ik wordt aangeroepen";

    
  }
  
}

?>

<?php

$eenObject = Singleton::createInstance();
$eenObject->aFunction();

?>

Recursie is een interessante techniek met vele voordelen, Fenrir heeft ze ooit eens besproken maar dat artikel is verdwenen. Daarom probeer ik het opnieuw te documenteren zodat mensen dit kunnen ontdekken en gebruiken.

Recursie komt niet alleen voor bij programmeertalen maar ook bij taal en wiskunde. Recursie betekend 'zelf-verwijzing'. PHP is een recursief acroniem: een afkorting die naar zichzelf verwijst. PHP staat voor: 'PHP Hypertext Preprocessor', het woord PHP komt voor in de afkorting ervan. Een ander voorbeeld is GNU: 'GNU's Not Unix'.

Een ander voorbeeld is bijvoorbeeld wanneer je met een webcamera een filmpje maakt en dit rechtstreeks afspeelt op de computer. Als je dan met de camera naar het computerscherm kijkt dan blijft het beeld zich oneindig diep herhalen. Een voordeel van recursie bij programmeertalen is dat we het kunnen beïnvloeden en dus op tijd laten stoppen.

Een alternatief voor recursie is iteratie, denk maar aan de 'for'- en 'while'-loop. Toch kan je met recursie net iets meer, je kan veel dieper verwijzen.

Er zijn twee vormen van recursieve functies binnen PHP:
- Gewone recursieve functies
- Wederkerig recursieve functies

We beginnen met de gewone te bespreken, of in ieder geval: het maken ervan.

Om te beginnen ga ik eerst een klein voorbeeldje van iteratie geven. We gaan een tellertje maken dat van 5 naar 0 telt.

Bovenstaand voorbeeld is een basisvoorbeeld van herhaling, om hetzelfde resultaat te bekomen met recursie moet je een functie maken die zichzelf aanroept. In de functie moet een voorwaardelijke constructie (if) zitten zodat je geen oneindige loop krijgt.

We zullen dit stukje code stap voor stap analyseren. We maken een functie aan genaamd 'countDown' en geven deze een standaardargument mee namelijk '$teller'. Als deze niet is 'geset' heeft deze de waarde 5, anders de gesette waarde. Vervolgens gaan we kijken of teller groter of gelijk is aan 0, zoja dan gaan we verder, zo nee: dan stopt het programma. We gaan nu het getal op het scherm weergeven en als laatste roept de functie zichzelf aan met de de waarde van $teller min 1.

Wat gebeurt er nu?
Eerst wordt de functie 'recursief_1' aangeroepen met het argument 10. Dit wordt weergegeven en de functie 'recursief_2' wordt aangeroepen met de waarde van $arg (10) min 2. De functie 'recursief_2' ontvangt dan het argument 2. Om het als een stappenplan op te schrijven:

Wat is nu het nut van recursieve functies denk je nu misschien. Ten eerste: je kan oneindig diep gaan zoeken in een array, natuurlijk is daarvoor de functie 'array_map()' die een functie kan uitvoeren op een gehele array. Je kan bijvoorbeeld ook een gehele directory uitlezen, je kan stoppen wanneer je wil, je kan een bestand unzippen en ga maar door. Je zou bijvoorbeeld een array tot drie lagen diep kunnen doorzoeken en dan stoppen.

Waar het ook voor gebruikt wordt is 'brute force'. Je kan alle mogelijke combinaties kunnen afgaan en blijven afgaan tot je het hebt. Met recursie heb kan je met variabele lengtes werken.

Een voorbeeldje van hoe je een array kan uitlezen met recursie (zonder gebruik van 'array_map') vind je hieronder.

Hopelijk zal recursie voortaan het scripten voor jou versnellen, ik vind het in ieder geval een van de handigste dingen technieken het programmeren. Je kan er zoveel mee zonder veel te moeten doen.

<?php

abstract class Mens {

  abstract function slapen();
  abstract function opstaan();

  abstract function eten();
  abstract function bezigheid();
  
  final function dagVerloop() {
    $this->slapen();

    $this->opstaan();
    $this->eten();
    $this->bezigheid();
    $this->eten();
    $this->slapen();

  }
  
}

?>

<?php

abstract class Mens {

  abstract function slapen();
  abstract function opstaan();

  abstract function eten();
  abstract function bezigheid();
  
  final function dagVerloop() {
    $this->slapen();

    $this->opstaan();
    $this->eten();
    $this->bezigheid();
    $this->eten();
    $this->slapen();

  }
  
}

class Westers extends Mens {

  function slapen() {
  
    echo "Ik lig in een bed<br />";

    
  }
  
  function opstaan() {
  
    echo "Ik sta op en kleed mij aan<br />";

    
  }
  
  function eten() {
  
    echo "Ik doe de koelkast open en pak eten<br />";

    
  }
  
  function bezigheid() {
  
    echo "Ik stap in de auto. Ik rijd naar het werk. Ik doe mijn werk. Ik ga middageten. ...<br />";

    
  }
  
}

class Indiaan extends Mens {

  function slapen() {
  
    echo "Ik lig onder een matje in mijn WigWam<br />";

    
  }
  
  function opstaan() {
  
    echo "Ik sta op<br />";
    

  }
  
  function eten() {
  
    echo "Gelukkig ben ik gisteren gaan jagen, nu kan ik eten<br />";

    
  }
  
  function bezigheid() {
  
    echo "Ik pak mijn pijl en boog en ga jagen<br />";

    
  }
  
}

$jan = new Westers;
$jan->dagVerloop();

echo "<hr />";


$rodeBeer = new Indiaan;
$rodeBeer->dagVerloop();

?>

<?php

class Core {

  private function __construct() {}
  private function Core() {}

  
}

?>

<?php

$myInput = Core::loadModule("Core_Form_Input");

// dit zou dan synoniem moeten zijn voor $myForm = new Core_Form_Input;

?>

<?php

class Core {

  private function __construct() {}
  private function Core() {}
  // Singleton
  

  static public function loadModule($theClass) {
  
    $the_file = str_replace("_", "/", $theClass) . ".php"; // nu krijgen we Core/Form/Input.php

    
    if(self::isReadable($the_file)) {
      //bestaat deze file wel
      
      require_once $the_file; // we hoeven hem maar 1maal in te laden, 

// zo kan de klasse meerdere keren worden aangeroepen 

// maar moet het maar 1maal worden ingeladen

      return new $theClass;
      
    } else {
    
      return false;
      
    }
  
  }
  

  
  /** 
  * functie gekopieerd van ZEND FRAMEWORK
  * Map: /
  * File: Zend.php
  * Class: Zend

  * Original author: Zend
  **/
    static public function isReadable($filename)
    {
        $f = @fopen($filename, 'r', true);

        $readable = is_resource($f);
        if ($readable) {
            fclose($f);
        }
        return $readable;

    }
  
}

$input = Core::loadModule("Core_Form_Input");

?>