Wer sich schon immer gefragt hat, was in PHP 5.3 schneller funktioniert, ein null Vergleich (null === $a) oder das is_null, kann das recht schnell mit einem kleinen Testskript auf der Console überprüfen.
Bei mir kam folgendes heraus:
Start... null === $sut: 38.199098110199 Sekunden
Start... is_null($sut): 143.10559892654 Sekunden
Falls ihr euch schon mit dem Cycle Helper von Zend beschäftigt habt, werdet ihr irgendwann an den Punkt kommen, wo ihr mehrere “cycles” in einer Ausgabeseite verwenden möchtet. Dazu sieht der Helper vor, dass man Namen für jeden Cycle vergibt. Wählt man diese nicht, wird der default Name verwendet. Dies kann wiederum zu nervigen Seiteneffekten führen. Hierzu ein kleines Beispiel:
Sieht auf den ersten Blick nicht unbedingt falsch aus. An dieser Stelle sollte man jedoch wissen, dass der zweite next() Aufruf problematisch ist. Um das Problem zu lösen verwendet man Namen für jeden Cycle, in etwa so:
Was mir neulich auch noch passiert ist, ist eine falsche Ausgabe des Ergebnisses. Bei einem echo auf den cycle()->next() Aufruf wird automatisch die toString() Methode des Helpers aufgerufen. Möchte man nun mit Variablen arbeiten, wird es auch hier leicht verwirrend, wenn man dies nicht im Hinterkopf behält. Dazu auch ein kleines Beispiel:
// Hiermit erhalten wir lediglich das helper Objekt
$output = $this->Cycle(array('blue', 'red'))->next();
// Eigentlich möchten wir aber dies hier
$output = $this->Cycle(array('blue', 'red'))->next()->toString();
// Ausgabe im Verbund funktioniert beim ersten Beispiel nicht...
echo 'Text' . $output;
// Bei einem direkten echo alledings schon
echo $output;
Ich wünsche viel Spaß beim Ausprobieren und viel Erfolg bei der Entwicklung neuer SuperApplikationen 
Eclipse bietet (auch für PHP) eine sehr gute Möglichkeit sich ein wenig Arbeit beim Tippen zu ersparen. Um z.B. Ausdrücke, die man oft verwendet, nicht ständig selbst tippen muss, kann man sich diese mit Hilfe von Templates auf ein bestimmtes Pattern legen.
Wenn ich nun z.B. folgendes abkürzen möchte…
Zend_Debug::dump();
..lege ich ein neues Template in Eclipse mit dem Kürzel “debug” an. In etwa so:
Der Vorteil ist, dass ich beim Tippen des Wortes “debug” einen Vorschlag für Zend_Debug::dump() erhalte und somit nicht alles selbst tippen muss.
Ich wünsche viel Spaß beim Ausprobieren und Abkürzen
Da ich nun auch mit Module rumgespielt habe, ist mir ein recht seltsames Verhalten aufgefallen. Man definiert ein Hauptmodul, was man als default oder core bezeichnen kann. Zudem kann man auch ein Modulverzeichnis angeben und sogar die Ordnernamen für darunter liegende Controller definieren. Soweit so gut, hört sich doch nicht schlecht an.
Die oben genannten Schritte erledigt man z.B. so:
$frontController = Zend_Controller_Front::getInstance();
$frontController->setDefaultModule('core');
$frontController->setModuleControllerDirectoryName('controllers');
$frontController->addModuleDirectory(APPLICATION_PATH . '/modules');
Interessanterweise ist es nun so, dass man irgendwann, wenn man einen Controller außerhalb des core-Moduls (in dem obigen Beispiel) aufruft, erhalt man eine Meldung, die dann z.B. sowas hier enthält:
Message: Invalid controller class (“Mymodule_IndexController”)
Bei Zend ist es ein wenig tricky. Man muss bei zusätzlichen Modulen den Modulnamen vor den Controller-Namen schreiben. Der Dateiname des Controllers bleibt davon allerdings verschont. Klingt irgendwie seltsam, ist aber so.
In der Praxis sieht das nun so aus, in der Datei IndexController.php schreiben wir einfach:
class Mymodule_IndexController extends Zend_Controller_Action
{
}
Schon funktioniert alles wie man es haben möchte. Ich wünsche viel Spaß und Erfolg
In diesem Beitrag möchte ich euch die Syntax von PHP näher bringen. Die Syntax leitet sich geschichtlich von der Programmiersprache C ab. Allerdings finden sich auch Einflüsse der Programmiersprache Perl in PHP wieder. Seit PHP 5 und dem Einfluss von Java hat auch eine gewisse Java-Syntax in PHP Einzug gehalten. Dies mag aufgrund der vielen unterschiedlichen Einflüsse im ersten Moment etwas verwirrend sein, so ist die Syntax von PHP doch recht einfach und simpel. Starten wir zunächst mit PHP-Dateien.
PHP-Dateien und PHP-Tags
Um PHP-Dateien zu verstehen, schauen wir uns dazu einfach die ausformulierte Version der Abkürzung PHP an:Hypertext Preprocessor. Wie man sieht, handelt es sich scheinbar um eine Art Text, der verarbeitet werden kann. Das bedeutet im Umkehrschluss, dass wir PHP-Code auch in einer simplen Text-Datei unterbringen dürfen. Obligatorisch werden diese Dateien mit der Endung .php abgespeichert.
Als Kennzeichnung für PHP-Code dienen sogenannte PHP-Tags. Diese Tags bestimmen also wann Code beginnt und wann dieser endet. In PHP hat man vier verschiedene Möglichkeiten Tags auszuschreiben.
Die Standard-Tags () sind der einfachste und beste Weg. Zum einen sind sie sowohl zukunftssicher als auch abwärtskompatibel. Ein weiterer Vorteil besteht darin, dass diese Notation nicht durch eine Änderung der PHP-Konfiguration abgestellt werden kann.
Die Kurztags () galten lange Zeit als Standard, sind jedoch mittlerweile in den aktuellen PHP-Versionen als deprecated gekennzeichnet. Diese Kennzeichnung bedeutet in der Software-Entwicklung, dass eine Klasse, Methode oder Notation veraltet ist und (aus gründen der Zukunftssicherheit der eigenen Anwendung) nicht mehr angewendet werden soll. Daneben kollidiert diese Notation oft mit der XML-Syntax.
Script-Tags wurden als Analogie zu Java-Script-Tags eingeführt. Somit konnten HTML-Programmierer leichter PHP-Code und HTML auseinander halten. Heutzutage spielt diese Notation fast keine Rolle mehr. Ebenso die ASP-Tags, die streng betrachtet noch nie eine gewisse Daseinsberechtigung genossen.
Ihr könnt selbstverständlich alle Tag-Notationen verwenden. Ich empfehle euch jedoch, sich an die impliziten Standards zu halten, damit ihre Web-Anwendung auch in Zukunft funktionsfähig bleibt.
Das Singleton-Pattern ist eines der einfachsten Pattern und lässt sich auch in PHP implementieren. Es sorgt dafür, dass von einer Singleton-Klasse jeweils nur eine Instanz erzeugt werden kann. Somit ist das Objekt zentral zugänglich, was allerdings auch als großer Nachteil ausgelegt werden kann.
Eine Beispielimplementierung kann z.B. wie folgt aussehen:
/**
* Implementierung des Singleton Pattern
*
* Der Konstruktor und das Klonen sind private Methoden, können
* somit nicht von außen aufgerufen werden.
*/
class Singleton
{
/*
* @var Singleton
*/
static private $_instance = null;
/**
* Konstruktor
*/
private function __constructor() {}
private function __clone() {}
/**
* Liefert die einzelne Instanz
*/
static public function getInstance()
{
if (is_null(self::$_instance)) {
self::$_instance = new self;
}
return self::$_instance;
}
}
Instanziierung im Programmcode
// Objekt instanziieren $singleton = Singleton::getInstance();
In meinem ersten Tutorial zu PHP (Basics zu PHP – First Steps Tutorial) habe ich bereits einige kleine Beispiele geschildert. In diesem Beitrag soll sich nun alles um Variablen in PHP drehen. Das Tutorial richtet sich in erster Linie an PHP-Einsteiger, enthält aber auch interessante Tipps für erfahrene Entwickler.
Um PHP-Variablen beschreiben zu können, möchte ich zunächst die Frage klären, was Variablen eigentlich sind. Rein technisch müsste man nun kurz und knapp zusammenfassen: Eine Variable ist eine veränderliche Größe im Programm. Ein etwas anschaulicheres Bild – welches ich häufig verwende, um Laien Variablen zu erklären – könnte z.B. so aussehen: Man stelle sich ein Programm als einen großen Schrank mit vielen Schubladen vor. Die Schubladen sind beschriftet, man kann sie aufschieben/zuschieben, etwas hineinlegen und natürlich Dinge aus Schubladen entnehmen. Die Beschriftung der Schubladen sind sogenannte Variablennamen. Das Beschriften selbst, genauer gesagt die Aktion, nennt man Variablendefinition. Der Inhalt einer Schublade ist der Wert einer Variable, welcher natürlich auch leer sein kann. Ich kann nun eine Schublade öffnen, meine Schuhe hineinlegen und die Schublade zuschieben. In der Entwicklung spricht man hier von der Wertzuweisung. Der Zugriff auf eine Variable ist im weitesten Sinne das einfache Hineinschauen in eine Schublade (z.B. um zu prüfen, ob sie evtl. leer ist).
Im PHP-Code werden Variablen mit einem einfachen Dollarzeichen markiert, in etwa so:
$meineErsteVariable = 'Hallo Welt';
In der Zeile habe ich bereits mehrere Dinge erledigt. Ich habe eine Schublade beschriftet (mit dem Namen “meineErsteVariable”) und bereits den Text “Hallo Welt” hineingelegt. Ihr seht also, dass eine Wertzuweisung durch ein einfaches Gleichheitszeichen erfolgt. Was auch zu erkennen ist, dass Variablennamen aus einem zusammenhängenden Text bestehen müssen. In der Entwicklung verwendet man oft die CamelCase-Schreibweise (eine Schreibweise von zusammengesetzten Worten bei der die einzelnen Worte ohne Zwischenraum aber jeweils mit einem Großbuchstaben am Anfang geschrieben werden), um die Lesbarkeit zu erhöhen.
Datentypen
Mit diesem Verständnis könnt ihr nun mit den Variablen arbeiten. Der Wert einer Variable kann beliebig sein, PHP nimmt es hier ein wenig lockerer als andere Programmiersprachen, wie z.B. Java. Das bedeutet, dass ich in einer Variable einen “Text-Wert” (String) oder auch einen “Zahlen-Wert” (Integer) zuweisen kann, ohne dies vorher explizit festgelegt zu haben. String und Integer sind Datentypen und nur ein kleiner Auszug der insgesamt möglichen Datentypen in PHP.
Mit Variablen arbeiten
Eine Interessante Verwendung der Variablen findet sich beim Berechnen von Werten. Nachfolgend einige (kommentierte) Beispiele:
Beispiel Addition:
// Definition und Zuweisung der Variable $anzahlRoterBälle, Wert 4 $anzahlRoterBaelle = 4; // Definition und Zuweisung der Variable $anzahlBlauerBälle, Wert 3 $anzahlBlauerBaelle = 3; // Addition, die Gesamtanzahl aller Bälle, Wert 7 $gesamtAnzahl = $anzahlRoterBaelle + $anzahlBlauerBaelle;
Beispiel Subtraktion:
// Kontostand vorher, Wert 1500 $kontostand = 1500; // Kosten für einen neuen PC, Wert 600 $kostenComputer = 600; // Subtraktion, neuer Kontostand, Wert 900 (1500 - 600) $kontostand = $kontostand - $kostenComputer;
An beiden Beispielen kann man bereits viele wichtige Aspekte beim Umgang mit Variablen erkennen. In Beispiel 1 habe ich eine Addition mit Hilfe des Plus-Operators durchgeführt. Des Weiteren sieht man, dass in Variablennamen keine Sonderzeichen vorkommen dürfen (am Anfang eine recht häufige Fehlerquelle). In Beispiel 2 (Subtraktion) ist das Besondere, dass wir in Zeile 8 einer Variable aus Zeile 2 einen neuen Wert zuweisen. D.h. bis zur Änderung hat die Variable $kontostand den Wert 1500 und danach 900. Natürlich gibt es auch verschiedene weitere Operatoren, die man zum Arbeiten mit Variablen verwenden kann. Die häufigsten notiere ich nachfolgend:
// Variable a $a = 1; //Variable b $b = 2; // Addition, (1 + 2 = 3) $ergebnis = $a + $b; // Subtraktion (2 - 1 = 1) $ergebnis = $b - $a; // Division (1/2 = 0.5) $ergebnis = $a / $b; // Multiplikation (1 x 2 = 2) $ergebnis = $a * $b;
Aus aktuellem Anlass – einer Neuinstallation meines Systems – möchte ich euch die Schritte erklären, die zu einer lokalen LAMP (Linux Apache MySQL und PHP) Entwicklungsumgebung für Zend-Framework Projekte unter Ubuntu 9.10 Karmic Koala führen.
Ein fertiges Linux-System solltet ihr mit Ubuntu ja bereits besitzen. D.h. den nächsten Schritt, den man gehen muss, ist den Apache-Server zu installieren. Unter Ubuntu bewerkstelligt man dies in der Console mit dem einfachen Aufruf
sudo apt-get install apache2
Eine Internetverbindung vorausgesetzt, solltet ihr nun die Download-, Installations- und Konfigurationsroutine sehen. Um zu überprüfen, ob der Apache nach der Installation läuft, öffnet einen Browser eurer Wahl und versucht die Adresse http://127.0.1.1 aus. Ihr solltet etwas in der Art “It Works” zu lesen erhalten.
Das Zend-Framework basiert ja bekanntlich auf PHP und so benötigen wie jetzt entsprechend PHP. Um PHP5 zu installieren, bemüht man widerum die Console und holt die aktuelle Version aus den Quellen:
sudo apt-get install php5
Nach erfolgreicher Installation sollte der Apache neu starten und wir können überprüfen, ob die Installation korrekt ausgeführt wurde. Dazu wechselt man in das Web-Verzeichnis des Servers:
cd /var/www
Hier sollte bereits eine index.html existieren, die wir schon im Web-Browser bewundern durften. Mit dem Aufruf…
sudo gedit phpinfo.php
… erstellt man die Datei phpinfo.php und öffnet diese gleichzeitig mit dem (in Ubuntu mitgelieferten) Editor, welcher übrigens um einges mächtiger ist, als z.B. Notepad unter Windows, da er für sehr viele Dateitypen Syntax-Highlighting unterstützt. In diese Datei fügt ihr nun folgende Zeile ein und speichert die Datei ab:
<?php phpinfo(); ?>
Damit haben wir eine Test-PHP-Datei erstellt, welche die Methode phpinfo aufruft und uns somit ausführliche Informationen über die installierte PHP-Version liefert. Diese Datei könnt ihr über den Web-Browser unter http://127.0.1.1/phpinfo.php aufrufen. Bei erfolgreicher PHP-Installation solltet ihr nun PHP-Informationen (z.B. die Version) sehen.
Einen großen Teil habt ihr damit schon geschafft und könntet schon fast mit einem Zend-Projekt anfangen. Was noch fehlt ist die Datenbank und das Apache ModRewrite Modul. Wofür die Datenbank (MySQL) gebraucht wird, sollte klar sein. Das Modul benötigen wir, um euer Projekt zu “privatisieren”. Das bedeutet, dass wir – gemäß ZF-Vorgabe – einzig und allein einen öffentlichen Zugriff auf die index.php anbieten.
Starten wir doch mit dem Einfacheren, dem Modul. Dieses ist nämlich schon installiert und muss nur noch aktiviert werden. Dazu wieder die Konsole:
sudo a2enmod rewrite
Kurze Erklärung dazu: a2 (Apache2, unser Server) en (enable, aktivieren) mod (Modul) rewrite. Eventuell – falls nicht automatisch durchgeführt – müsst ihr den Apache neu starten.
Nun möchten wir uns noch um die letzte Komponente, einen MySQL-Server kümmern. Dazu bemühen wir wieder die geliebte Konsole und holen uns den mysql-server mit Hilfe von apt:
sudo apt-get install mysql-server
Bei der Installation solltet ihr die entsprechenden Zugriffspasswörter wählen, der Rest passiert automatisch. Für diejenigen, die phpMyAdmin kennen und nutzen möchten, bietet sich an das Paket phpmyadmin zu installieren, welches dann unter http://127.0.1.1/phpmyadmin zu finden ist.
sudo apt-get install phpmyadmin
Mit dieser Konfiguration könnt ihr euch nun in aller Ruhe in ein neues Zend-Projekt stürzen. Falls ihr möchtet, könnt ihr auch entsprechende Tipps und Tutorials dazu in meinem kleinen ScienceBlog zur Hilfe nehmen.
In meinem ersten Tutorial werde ich versuchen euch die (absoluten) Grundlagen von PHP zu vermitteln. Ich hoffe, dass ich nicht zu sehr technisch abschweife, falls doch, weist mich gerne mit Hilfe der Kommentare darauf hin.
Nun also zu den ersten Schritten bei PHP. Ich gehe einfach mal davon aus, dass ihr es schon hinbekommen habt PHP lauffähig zu bekommen, d.h. ihr seid in der Lage PHP Code auf einem Server (z.B. Apache) ausführen zu lassen. Um dies zu überprüfen, versucht doch bitte eine Datei zu erstellen (bei Windows z.B: mit dem Editor/Notepad und bei Ubuntu-Linux mit dem gedit) und diesen Inhalt abzuspeichern:
<?php phpinfo(); ?>
Speichert diese Datei unter dem Namen phpinfo.php ab und ruft es über den Browser eurer Wahl auf. Ihr sollte nun eine Ausgabe sehen, welche euch über die auf dem Server installierte PHP-Version Auskunft gibt und viele weitere Informationen bereit stellt. Die Ausgabe können wir später noch verwenden, zunächst reicht es aber als Nachweiss, dass PHP erfolgreich installiert ist.
PHP-Code schreiben
In einer PHP-Datei, d.h. mit der Endung .php kann man sowohl PHP-Code als auch reines HTML unterbringen. Mir als Entwickler sträuben sich leider des Öfteren die Haare, wenn beides in einer Datei passiert, aber ganz unvermeidbar ist es nicht. Gehen wir doch Schritt für Schritt vor. Um PHP-Code in der Datei zu markieren, verwendet man sogenannte öffnende und schließende PHP-Tags, in etwa so:
<?php // Hier würde nun PHP Code stehen ?>
HTML-Elemente darf man ‘einfach-so’ hinschreiben. Ein kleiner Mix aus PHP- und HTML-Code könnte z.B. so aussehen:
<?php // Hier würde nun PHP Code stehen ?>Hello PHP-World<?php // Hier würde nun weiterer PHP Code stehen ?>
Damit sind auch schon die ersten Beispiele für PHP fertig. Ihr könnt diese gerne speichern und auf eurem Entwicklungsrechner ausprobieren. Viele passieren wird dabei nicht, da wir ja eigentlich auch noch nichts programmiert haben.
Kommentieren lernen
Ganz wichtig sind sogenannte Kommentare. Kommentare dienen dazu den Code zu erklären. D.h. man macht sich direkt im Code Notizen. Diese Notizen werden bei der Ausführung des PHP-Codes einfach ignoriert. Das bedeutet, dass man hier Freitext verwenden darf. In PHP kann man diese entweder mit einem “//” (Doppelslash) oder “/* */” markieren. Allgemein gilt in der Entwicklung: Einzeilige Kommentare mit einem Doppelslash und mehrzeilige Kommentare mit der anderen Variante verwenden.
// Einzeiliger Kommentar
/** * Mehrzeiliger Kommentar * Hier darf man ruhig etwas mehr schreiben */
Wozu brauche ich Kommentare? Nun, das wird man spätestens dann merken, wenn man ein etwas größeres Projekt vor sich hat und der PHP-Code nicht mehr so übersichtlich und einfach zu lesen ist, wie in den ersten Beispielen. Kommentare können z.B. dabei helfen komplizierte Methoden zu erklären. Ich rate jedem an sich das Kommentieren so schnell wie möglich anzueignen. Es ist kein Muss, hilft aber unheimlich weiter.
Das Hello World Beispiel
Als Nächstes möchten wir einen Text ausgeben. Per HTML könnt ihr das bestimmt schon. Es gibt verschiedene Möglichkeiten Text direkt in PHP auszugeben. Ich verwende ganz gerne das echo. Da es in PHP ein sogenanntes “reserviertes” Wort ist, sollte euer Editor – sofern er dies Unterstützt – auch entsprechend highlighten, in etwa so:
echo 'Hello PHP-World';
Diese Zeile würde und nun den “Hello PHP-World” in die Browser-Ausgabe zaubern. Einige Dinge möchte ich zu dem Echo noch erklären, es gibt nämlich auch die folgende Variante, von der ich aber abrate:
echo "Hello PHP-World";
An dieser Stelle sind die einfachen Anführungszeichen den doppelten gewichen. Der Nachteil ist, dass man nun im Text keine doppelten Anführungszeichen verwenden kann, ohne sie zu “Escapen”. Dazu wieder ein kleines Beispiel:
echo 'Hello "PHP-World" in einem Satz'; echo "Hello \"PHP-World\" in einem Satz";
Den Unterschied kann man recht schnell sehen. Was nun noch dazu kommen würde, wären die Variablen, die in den beiden Varianten unterschiedlich behandelt werden. Ich lasse es allerdings an dieser Stelle weg, da die Variablen erst in dem nächsten Tutorial erklärt werden. Für eine kleine PHP-Einführung soll es das zunächst gewesen sein. Falls es euch gefallen hat, könnt ihr euch natürlich direkt auf das nächste Tutorial stürzen.
Im Rahmen meiner Recherche möchte ich hier einige Tipps zur Migration von PHP 5.2.x auf 5.3.x liefern. Das Besondere bei dieser Migration ist die Tatsache, dass PHP 5.3.x nicht abwärtskopatibel mit 5.2.x ist. In einer gewissen Hinsicht erscheint dies auch logisch, da die neue PHP Version bei Abwärtskompatibilität eher einer weitere 5.2.x, als eine 5.3.x Version wäre.
Woaruaf sollte man nun also achten? Dieser Frage möchte ich mich in diesem Beitrag widmen. Eine etwas positive Nachricht zuerst: Falls man bisher schon bei der Programmierung auf Aktualität geachtet hat, wird man bei der Migration recht wenig zu tun haben. Andersherum sieht man sich ums größeren Problemen gegenüber je mehr man sich den älteren 5.2 Versionen gewidmet hat.
Deprecated
Fangen wird doch mit etwas recht einfachem an. PHP bitet seit 5.3 die Möglichkeit auch E_DEPRECATED Warnings auszugeben. In vielen Fällen ist das sehr nützlich. So haben auch die Entwickler der 5.3 Version einige PHP-Methoden als deprecated markiert. D.h. diese Methoden soll man in Zukunft nicht mehr verwenden. In den meisten Fällen wird jeweils auf den passenden Ersatz hingewiesen. Man kann an dieser Stelle recht einfach migrieren indem man den eigenen Code nach diesen Methoden durchsucht:
Reservierte Keywords
Das nächste Problem sollte in den meisten Fällen auch ohne große Anstrengung zu bewältigen sein. Seit 5.3 gibt es nämlich zwei weitere reservierte Keywords:
Durchsucht man also den eigenen Code nach diesen Keywords, dürfte man recht schnell feststellen, ob dieser Migrationsschritt erfolgreich durchgeführt werden kann.
Methoden mit Array-Parameter
Einige Methoden, die vor 5.3 noch Objekte und Arrays gleicherweise als Parameter akzeptiert haben erwarten nun einzig und allein Arrays als Parameter. Das bedeutet, dass man zunächst prüfen sollte, ob eine der Methoden im eigenen Code verwendet wird und falls dem so ist überprüfen muss, ob der übergebene Parameter ein Objekt ist. Dieses Objekt muss in dem Fall zunächst zu einem Array umgewandelt werden. Es handelt sich dabei um folgende Methoden: