Nun habe ich in der Vergangenheit ja schon das eine oder andere über Closures in PHP und Java Comparatoren für PHP geschrieben und wollte das nun mal zusammenbringen.

Einige PHP-Sortierfunktionen erlauben Callbacks, um die Reihenfolge zu bestimmen. Da ich das Ganze aber gerne in gut testbaren OOP-Einheiten hätte, müssen wir einen kleinen Umweg gehen.

Zunächst das obligatorische Interface.

namespace E7;

interface Comparator {
  public function compare($a, $b);
}

Diese Schnittstelle implementieren wir mit einer abstrakten Klasse.

namespace E7;

class BaseComparator implements Comparator {
  public function compare($a, $b) {
    if ($a == $b) { return 0; }
    return $a < $b ? -1 : 1;
  }

  public function __invoke() {
    return call_user_func_array(array($this, 'compare'), func_get_args());
  }
}

Und schon haben wir einen einfachen, und zugegebenermaßen nicht typsicheren, Comparator.

Durch die magische Methode __invoke() kann ein Objekt nun wie eine Callbackfunktion verwendet werden.

Für die Sortierung von Objekten kann das dann einfach erweitert werden.

class PersonComparator extends BaseComparator {
  public function compare($a, $b) {
    // hier Prüfung auf Typ etc.
    return parent::compare($a->getId(), $b->getId());
  }    
}

Um die Sortierreihenfolge negieren zu können, können wir einen einfachen Wrapper nutzen.

class ReverseOrder implements Comparator {
  private $_comparator;

  public function __construct(Comparator $comparator) {
    $this->_comparator = $comparator;
  }

  public function compare($a, $b) {
    return $this->_comparator->compare($a, $b) * -1;
  }
}

Beispiel…

//--
$people = array();
for ($i = 0; $i < 10; $i ++) {
  $people[] = new Person();
}

echo 'BEFORE<br/>';
foreach($people as $person) {
  echo "$person<br/>";
}

$comparator = new ReverseOrder( new PersonComparator() );

uasort($people, function($a, $b) use ($comparator) {
    return $comparator->compare($a, $b);
});

// oder

uasort($people, $comparator);

echo 'AFTER<br/>';
foreach($people as $person) {
  echo "$person<br/>";
}

Bislang musste man Callback-Funktionen gewöhnlich definieren, bevor man sie verwenden konnte.

<?php
function myCallback($output) {
  return '##' . $output . '##';
}

echo call_user_func('myCallback', 'Hallo Welt');

// Ausgabe:
##Hallo Welt##

Als Closure geschrieben sähe das dann so aus:

<?php
echo call_user_func(
  function($output) { return '##' . $output . '##'; },
  'Hallo Welt');

// Ausgabe:
##Hallo Welt##

Zugegeben, dieses Beispiel hätte man durch einfache Stringverkettung wesentlich einfacher schreiben können und eigentlich war das mit create_function() auch schon unter PHP4 möglich.

Wir können die Funktion natürlich wie früher auch schon in einer Variablen speichern und dann weiter verwenden.

<?php
$myFunction = function($output) {
  return '##' . $output . '##';
};

echo call_user_func($myFunction, 'Hallo Welt') . '<br/>';
echo $myFunction('Hallo Welt') . '<br/>';

//Ausgabe:
##Hallo Welt##
##Hallo Welt##

Und auch das ist ja noch nichts Neues. Mit Closures haben wir nun aber auch die Möglichkeit, teile unserer “Umgebung” zum Zeitpunkt der Funktionsdefinition zu konservieren.

Dazu müssen wir nur die Definition etwas erweitern.

<?php
$before = '>';
$after = '<';

$myFunction = function($output) use ($before, $after) {
    return $before . $output . $after;
};

echo $myFunction('Hallo Welt') . '<br/>';

//Ausgabe:
>Hallo Welt<

An dieser Stelle frieren wir mit “use” sozusagen die Werte für $before und $after innerhalb unserer Funktion ein. Spätere Änderungen der beiden Variablen haben keine Auswirkungen auf die Funktion.

$before = 'foo';
$after = 'bar';
echo $myFunction('Hallo Welt') . '<br/>';

//Ausgabe:
>Hallo Welt<

In PHP wir mittlerweile sehr viel mit Standardinterfaces und -klassen (SPL) abgedeckt und so ist es auch in diesem Fall. In der Variablen $myFunction ist ein Objekt vom Typ “Closure” gespeichert.

<?php
echo '<pre>' . print_r($myFunction, true) . '</pre>';

//Ausgabe:
Closure Object
(
  [static] => Array
    (
      [before] => >
      [after] => <
    )
  [parameter] => Array
    (
      [$output] =>
    )
)

Will man eigene Objekte wie Funktionen aufrufen, dann geht das mit der magischen Methode __invoke(), die auch hier verwendet wird.

Anfangs erwähnte ich, dass Closure-Callbacks zur Filterung, aber auch zur Manipulation von Array verwendet werden können.

Wenn nur der Inhalt interessant ist, dann kommen wir mit array_map() und einem Parameter aus.

<?php
$values = array(
  array(
    'a' => array(
      'b' => 'foo'
    )
  ),
  array(
    'a' => array(
      'b' => 'bar'
    )
  ),
);

$filtered = array_map(
  function ($item) { return $item['a']['b']; },
  $values
);
echo '<pre>' . print_r($filtered, true) . '</pre>';

// Ausgabe:
Array
(
  [0] => foo
  [1] => bar
)

Wollen wir aber Werte im Array in Abhängigkeit zum Key/Index verändern, dann geht das mit array_walk und einem zweiten Parameter im Callback. Bei beiden kann natürlich auch “use” verwendet werden. Der Parameter $value wird dabei als Referenz übernommen.

$values = array(
  'a' => 100,
  'b' => 200,
  'c' => 300,
);

array_walk(
  $values,
  function (&$value, $key) {
    if ('b' == $key) {
      $value = 42;
    }
  }
);

echo '<pre>' . print_r($values, true) . '</pre>';

// Ausgabe:
Array
(
  [a] => 100
  [b] => 42
  [c] => 300
)

Ich hoffe, dass ich ein wenig Licht ins Dunkel bringen konnte und “Closure” nun kein geheimnisvolles Zauberwort mehr ist.

Wenn ihr noch gute Ergänzungen oder Anwendungbeispiele habt, dann immer her damit und bitte fleissig kommentieren.

Der eine oder andere kennt die Funktion vielleicht schon, aber für mich ist sie neu. Daher habe ich damit einfach mal etwas rumprobiert und einen kleinen Codeschipsel dazu gebastelt. Die Apache-Logs können für vielfältige Auswertungen verwendet werden.

Zum Beispiel welche Seiten besucht oder nicht gefunden werden können, zum Tracken von Werbemitteln oder in dem Fall auch zum Protokollieren weiterer PHP-Werte.

In einem früheren Projekt haben wir mal die Zeit und den Speicherverbrauch gemessen die ein PHP-Script braucht, um die Seite auszuliefern. Dazu hatten wir eine einfache Klasse, ähnlich der folgenden (im dem Beispiel wird nur die Zeit gemessen):

class PageBenchmark
{
  private $_startTime;
  private static $_instance;

  protected function __construct()
  {
    register_shutdown_function(array(self::$_instance, 'stop'));
    $this->start();
  }

  protected function __clone() {}

  public function getInstance()
  {
    if (null === self::$_instance) {
      self::$_instance = new self();
    }
    return self::$_instance;
  }

  public function start()
  {
    $this->_startTime = microtime(true);
  }

  public function stop()
  {
    $time = microtime() - $this->_startTime;
    apache_note('worktime', $time);
  }
}

PageBenchmark::getInstance();

Die Klasse ist bewusst einfach gehalten und sollte möglichst ohne weitere Abhängigkeiten funktionieren. Die Verwendung ist dabei recht einfach. Das Script an einer zentralen Stelle möglichst früh einbinden. Durch den Aufruf von getInstance() wird ein Objekt instanziiert und die Methode stop() als Callback registriert.

Wird das Script nun abgearbeitet, wird diese Methode zum Ende aufgerufen und die verbrauchte Zeit wird errechnet und an Apache übergeben.

Damit das ganze dann einen Sinn bekommt, muss die Konfiguration des Webservers noch etwas angepasst werden. Für unser Beispiel schreiben wir die Zeit an das Ende jeder Zeile.

LogFormat "%h %l %u %t \"%r\" %>s %b \"%{Referer}i\" [%{worktime}n]" mylogformat
CustomLog /var/www/sandkasten/logs/access.log mylogformat

Danach natürlich den Webserver neu starten, bzw. ein Reload machen. Ab jetzt sollte zu jedem Logeintrag die verbrauchte Zeit mitgeschrieben werden. Die verwendeten Kürzel werden in der Doku zu mod_log_config erklärt.

Viel Spaß beim Probieren!

Die Funktionen call_user_func() oder call_user_func_array() fallen leider aus, da wir noch kein Callback-Objekt haben. Es gibt aber einen sehr einfachen Weg mit Reflections.

Zuerst ein paar einfache Klassen zum Testen. Von der Klasse Foo soll ein Objekt erstellt werden und diese erwartet je ein Objekt vom Typ Bar und Baz als Parameter im Konstruktor.

<?php
class Bar {}
class Baz {}

class Foo
{
  public function __construct(Bar $bar, Baz $baz)
  {
    echo '<pre>' . print_r(func_get_args(), true) . '</pre>';
  }
}

Nun wird das Objekt über eine sehr einfache Factory-Methode erzeugt und dabei wird die Parameterliste von create() an den Konstruktor weitergegeben.

<?php
class Factory
{
  public static function create($type)
  {
    $args = func_get_args();
    array_shift($args);
    $class = new ReflectionClass($type);
    return $class->newInstanceArgs($args);
  }
}

$foo = Factory::create('Foo', new Bar(), new Baz());

So einfach ist es. Über die Reflection-Klasse wird ein neues Objekt erzeugt.