<?php
App::import('model','Bar');

class Foo extends AppModel {
  public $Bar;
        
  public function __construct($id = false, $table = null, $ds = null) {
    parent::__construct($id, $table, $ds);
    $this->Bar = new Bar();
  }      
}

Danach wie gewohnt aufrufen.

<?php
$this->Bar->find();

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.

• Onlinetool zum (Neu-)Formatieren von JavaScript-Code
  http://jsbeautifier.org/
• PHP Benchmark gibt einen Überblick über die Performance vergleichbarer Operationen
  http://www.phpbench.com/
• Responsive Design/Layout-Tester (siehe auch meinen Neujahrsartikel )
  http://mattkersley.com/responsive/

Das Prinzip ist einfach: in der (abstrakten) Basisklasse wird eine leere Methode definiert, die durch eine konkrete Klasse überschrieben werden kann.

Der Vorteil ist recht offensichtlich. Die Methode kann ohne vorherige Prüfung verwendet werden und das spart an vielen Stellen unnötigen Code. Aus meinem ästhetischem Empfinden der richtige Weg.

Aber auch den anderen Weg habe ich auch schon desöfteren gesehen und mein Bauchgefühl hat ja auch nicht immer recht. Vielleicht ist der schöne Weg ja auch der langsamere?

Gefühl ist gut, Zahlen sind besser! Also habe ich schnell drei Testklassen geschrieben und probiere die verschiedenen Möglichkeiten durch.

Variante 1: Wir verlassen uns darauf, dass die Methode aufgerufen werden kann.

<?php
class Test1 {
    public function machWas() {
        $this->machWasAnderes();
    }

    public function machWasAnderes() {
    }
}

Variante 2: Wir prüfen, ob die Methode existiert und finden nichts.

<?php
class Test2 {
    public function machWas() {
        if (method_exists($this, 'machWasAnderes')) {
            $this->machWasAnderes();
        }
    }
}

Variante 3: Wir prüfen, ob die Methode existiert und rufen sie auf.

<?php
class Test3 {
    public function machWas() {
        if (method_exists($this, 'machWasAnderes')) {
            $this->machWasAnderes();
        }
    }

    public function machWasAnderes() {
    }
}

Zum Vergleich habe ich das folgende Script verwendet.

<?php
foreach (array('Test1', 'Test2', 'Test3') as $class) {
    $object = new $class();
    $start = microtime(true);

    for($i=0; $i<100000; $i++) {
        $object->machWas();
    }
    echo $class . ' = ' . round(microtime(true) - $start, 5) . '<br/>';
}

Ausgabe:

Test1 = 0.44767
Test2 = 0.48588
Test3 = 0.70881

In mehreren Durchläufen waren “Test1″ und “Test2″ immer fast gleich auf, nur “Test3″ brauchte etwas länger, weil in der Klasse die Prüfung und die Ausführung der Methode stattfindet.

Fazit: Der Einsatz von Schablonenmethoden lohnt sich doppelt, da der Code übersichtlich bleibt und auch die Geschwindigkeit etwas besser ist.

Wer also mal clientseitig mit der Datenbank sprechen will oder muss, dem bietet die Referenz einen einfachen Einstieg.

Beide Seiten, also sowohl der Sender als auch der Empfänger, kennen diese Zeichenkette und erzeugen auf die selbe Art die Prüfsumme.

Durch die Prüfsumme soll verhindert werden, dass die Daten bei der Übertragung durch Fremde manipuliert werden können. In dem Fall würde der Hashwert nicht mehr stimmen.

Eine sehr einfache Funktion normalisiert das Array durch Sortierung und bildet dann daraus den Hashwert mit einer Rückruffunktion (callback).

<?php
/**
 * Calculate hashvalue for params
 *
 * @param    array $params
 * @param    string $salt
 * @param    string $callback OPTIONAL (default='sha1')
 * @return   string
 */
function getParamsHash(array $params, $salt, $callback = 'sha1') {
    $params['__SALT__'] = $salt;
    ksort($params);
    return call_user_func($callback, implode(',', $params));
}

$params1 = array(
    'key1' => 'value1',
    'key2' => 'value2'
);

$params2 = array(
    'key2' => 'value2',
    'key1' => 'value1'
);

$salt = 'blablubb';

echo 'p1-hash: ' . getParamsHash($params1, $salt, 'md5') . '<br/>';
echo 'p2-hash: ' . getParamsHash($params2, $salt, 'md5') . '<br/>';

Die Ausgabe ist unabhängig von der Reihenfolge der Werte im Array identisch.

p1-hash: 3e71eda7b8539791ea2fd8f159b5e57b
p2-hash: 3e71eda7b8539791ea2fd8f159b5e57b

Natürlich kann die Funktion auch auf andere Art den Wert berechnen, nun muss das dann wieder auf beiden Seiten gleich sein.

Wie zu jedem Jahreswechsel und/oder Geburtstag wird oft das vergangene Jahr resümiert und man macht Pläne für das Nächste. Ohne mich groß in langweiligen Statistiken zu verlieren kann man sagen, dass es hier im Blog recht ruhig war und ich im Vergleich zum Vorjahr wesentlich weniger Artikel verfasst habe.

Der Grund dafür war ein recht turbulentes Jahr und leider zu wenig Zeit zum Schreiben. Dafür bekam das Blog sehr viel Aufmerksamkeit durch diverse Spambots und teilweise mehre Tausend Spamkommentare pro Monat.

Wie ihr sehen könnt, gibt es ein neues Design und ich hoffe es gefällt euch. Als Basis habe ich das freie Theme Yoko von Elmastudio verwendet. Es bietet unter Anderem responsive layout, d.h. das Layout der Seite passt sich dem Format des jeweiligen Anzeigegerätes an und ist dadurch sowohl auf einem großen Monitor, wie auch auf einem Handy gut zu lesen.

Wer es sich einfach mal im Vergleich ansehen will oder gerade an der eigenen Seite bastelt, dem empfehle ich das Responsive Design Testing Tool von Matt Kersley.

Technisch habe ich nur ein paar Kleinigkeiten verändert, so werden z.B. statische Inhalte nun “keksfrei” über eine andere Subdomain ausgeliefert. Dazu vielleicht bei Gelegenheit einen Artikel.

Im meinem letzten Artikel in 2010 habe ich ja schon darüber berichtet, dass ebene7 nun auch auf Twitter zu finden ist, ich bin gespannt, wie es angenommen wird und ob es sich lohnt. Ebenso gibt es eine ebene7-Seite bei Facebook, die aber noch nicht automatisch gefüttert wird. Das kommt mit einer der nächsten Verbesserungen mit.

Zu guter letzt habe ich eine neue Blogroll eingebaut, weil ich verschiedene Blogs gerne lese und die Links nicht irgendwo in der Sidebar untergehen sollten. Die Rocking Blogroll lässt sich recht leicht in das Blog integrieren und anpassen. Noch habe ich nicht alle Blogs in die Liste eingepflegt und auch die Bilder dazu fehlen noch.

Noch stehen ein paar Sachen auf meiner ToDo-Liste und es wird sich hier in Zukunft sicher noch mal eine Kleinigkeit verändern.

Ich hoffe die Änderungen gefallen euch und ihr lest und kommentiert auch im dritten Jahr wieder fleissig mit. Ich freue mich auf eure Kommentare, Lob, Kritik und was euch sonst so ein- oder auffällt.