Für die nächste Version ist wieder einiges in Planung. So stehen zB folgende Dinge auf der Roadmap

• Inhalte (neue Tutorials)
• Lokalisierung (deutsch/englisch)
• Anbindung von Youtube Videos
• Anbindung von externen Tutorials
• Favoriten Box
• Dashboard für eingeloggte User

und vieles vieles mehr.

Wer übrigens mit an dem Projekt arbeiten möchte ist herzlichst eingeladen. Einfach bei mir melden.
Ebenfalls suchen wir noch nach Sponsoren, hier gibt es mehrere Möglichkeiten, auch hier einfach bei mir melden wenn Interesse besteht

Tutorial Wünsche können hier aufgegeben werden ;-)

Euer Julian (kj187)

Da es nach knapp 4 Jahren Stillstand Zeit wurde eine neue technische Basis zu schaffen, wurde Mitte 2009 damit begonnen über einen Relaunch nachzudenken. Statt wieder auf das Content Management System TYPO3 selbst zu setzen, hat sich Julian Kleinhans aus persönlicher Interesse, schon recht früh für das neue PHP Application Framework FLOW3 entschieden. Kurz vor dem ersten Beta Release von FLOW3, ist nun die erste Version des neuen Internetauftritts online.

Das schlichte Design wirkt nun mehr aufgeräumt, ein Slider auf der Startseite zeigt immer die letzten zehn Tutorials aus allen Kategorien an. Autoren haben die Möglichkeit durch Angabe Ihrer Paypal Adresse spenden für Ihre geschriebenen Tutorials zu empfangen. Andere Dienste wie Flattr sind in Planung. Erstes Ziel ist es reichlich Feedback, Kritik und Verbesserungsvorschläge zu sammeln. Für die nächsten Versionen stehen dann schon einige weitere Features an. Beispielsweise ein Dashboard für eingeloggte Benutzer mit einer Übersicht über die eigenen Tutorials, eine Favoriten Box in der man seine persönlichen Favoriten pflegen kann, ein vernünftiges Bewertungssystem und und und.

Bei Fragen, Kritik, Lob oder Verbesserungsvorschlägen wenden Sie sich an: info -at- typo3-tutorials -dot- org

[1] http://flow3.org
[2] http://www.typo3-tutorials.org

Die Bergisch Media GmbH ist seit 2005 Online-Marketing-Spezialist für die technische Konzeption und Realisierung professioneller Internet-Anwendungen für mittelständische Unternehmen und bietet ganzheitliche Lösungen in den Bereichen E-Commerce, Content-Management-Systeme, Konzeption und Design.

Wir expandieren weiter und suchen zum nächstmöglichen Zeitpunkt eine/n engagierte/n

TYPO3 Entwickler (m/w)

Deine Aufgaben

• Technische Konzeption von kleinen bis großen TYPO3 Projekten
• Entwicklung komplexer, individueller TYPO3 Projekte
• Programmierung kundenspezifischer TYPO3 Extensions
• Objektorientierte Programmierung (OOP) in PHP5 unter Verwendung von Design Patterns und Unit Tests

Dein Profil

• 2-3 Jahre Berufserfahrung in der Softwareentwicklung mit Internettechnologien
• Außerordentlich hohe Internetaffinität
• Umfangreiche TYPO3 Kenntnisse aus Entwicklersicht
• Fundierte Kenntnisse in MySQL, HTML, CSS, PHP & JavaScript
• Sehr gute Kenntnisse in TypoScript
• Sehr gute Kenntnisse in objektorientierter PHP Programmierung
• Zuverlässigkeit
• Pflichtbewusstsein

Von Vorteil

• Erfahrung mit Extbase und Fluid
• Erfahrung mit FLOW3
• TYPO3 certified integrator

Wir bieten dir

• Ein professionelles und modernes Arbeitsumfeld
• Eine offene Unternehmenskultur mit flachen Hierarchien und schnellen Entscheidungswegen
• Eine schnelle Verantwortungsübernahme und motiviertes Arbeiten in einem jungen, dynamischen Team

Einsatzort: Heiligenhaus

Das brauchen wir von dir:
Um einen ersten Eindruck von dir zu gewinnen, schicke uns bitte:

• Referenzen/Beispiele bereits durchgeführter TYPO3-Projekte
• Aussagen über deine PHP-Kenntnisse (OO, PHP5 etc.)
• Informationen zu deiner Person und deinem Werdegang (Lebenslauf)
• Gehaltsvorstellungen
• Informationen zum frühestmöglichen Eintrittstermins

Ansprechpartner: Dennis van Almsick
E-Mail: vanalmsick – at – bergisch-media – . – de
URL: http://www.bergisch-media.de

Impressionen – Verschaffe dir einen Überblick über unsere neuen Räumlichkeiten

Der Autor, Nikko Bautista schreibt dabei was genau Test Driven Development ist, wie es arbeitet, warum man es einsetzen sollte und wie man es am sinnvollsten nutzt. Eine Super Einführung für Neulinge! Ein Blick lohnt sich aufjedenfall.

In den 2 Monaten habe ich mich relativ schnell eingelebt und fühle mich hier rundum pudelwohl! Nicht nur die Kollegen sind der hammer, auch die Projekte die mir anvertraut wurden sind äußerst interessant und bieten jede menge Herausforderungen. Auf Qualität wird hier umheimlich geachtet was die starke Kundenzufriedenheit denke ich auch ausmacht. Ich selbst bin ja seit knapp einem halben Jahr auf einem Qualitätstrip, daher ist mir dieser Aspekt hier ziemlich schnell und positiv aufgefallen.

Als TYPO3 Association Silver Member ist die Bergisch Media dieses Jahr mit 3 Mitarbeitern auf den TYPO3 Developer Days vertreten. Ich freue mich dann dort das erste mal für Bergisch Media unterwegs zu sein!

1. Platz
Aktuelle Ausgabe des Magazins „Zukunft – leckere Webtrends“ + ein Open-Source T-Shirt

2 + 3 Platz
Aktuelle Ausgabe des Magazins „Zukunft – leckere Webtrends“

Einen Einblick in die aktuelle Ausgabe gibt es hier!

Ok, wie könnt Ihr teilnehmen ? Das ist relativ einfach, hinerlasst hier einen Kommentar oder ein Track-/Pingback auf dieses Seite. Ich werde dann nach dem Zufallsprinzip die jeweiligen Gewinner bestimmen.
Die Gewinne werden dann direkt von t3n versendet. Damit ich Kontakt zu den Gewinnern aufnehmen kann ist es wichtig das Ihr eine gültige E-Mail Adresse hinterlasst!

Den Gewinner des Platz 1. wird am 11.06 bestimmt und kontaktiert.
Die Gewinner von Platz 2 und 3 werden am 18.06 bestimmt und kontaktiert.

Viel spass und glück :-)

PS: Wenn Ihr das Magazin dann habt, schenkt den Seiten 122/123 besonders Aufmerksamkeit… der Artikel ist von mir :-) “TYPO3 und AJAX”

EDIT: Alle Gewinner wurden informiert! Damit ist das Gewinnspiel offiziell vorbei :-) Aber schon bald wird es ein neues geben!

In diesem Jahr läuft alles unter dem Motto “Getting things done” was bedeuten wird, das es keine gewohnten Vorträge mehr gibt, sondern  eher Workshops. Jeder Workshop soll dabei auf maximal 20 Teilnehmer begrenzt werden und knapp 4 Stunden gehen. Es soll jeweils 3 verschiedene Worksphops parallel ablaufen.

Ich werde da sein und bestimmt den ein und anderen Blog Eintrag live aus Elmshorn posten!

Wollen wir auch sofort zum Thema kommen! Um es in einem Satz zu sagen: Exceptions sind Ausnahmezustände die eine Möglichkeit bieten auf verschiedene kritische Bedingungen bzw. Fehler während des Programmablaufs zu reagieren. BAM!

Geschnallt ? :-) Wenn nicht, nicht schlimm! Der Artikel fängt ja jetzt erst richtig an!

Um bei meiner lieblings Sprache zu bleiben, das Exception Handling gibt es in PHP erst seit der Version 5. Dort ist Sie standardmäßig dabei! Es muss also nix installiert, konfiguriert oder aktiviert werden! Wenn Ihr also noch mit PHP 4 arbeitet, leuteee, geht mit der Zeit :-)

Ok, das Exception Handling bietet uns also eine Möglichkeit! Wie sieht diese Möglichkeit aus? In PHP und auch in andere Sprachen gibt es das try und catch Konstrukt. Mit throw werfen wir einen Fehler und mit catch fangen wir diesen Fehler und können entsprechend auf diesen reagieren! Um das Fangen von Exceptions zu ermöglichen, muss der jeweilige Code in dem wir einen Fehler vermuten würden in einem try Block umschlossen werden. Dabei muss jeder try Block mindestens einen catch Block besitzen! Mehrere catch Blöcke sind dabei natürlich zu genaueren Filterung von Fehlern möglich.

Damit wir uns das ein bischen besser vorstellen können gibts dazu auch direkt ein Beispiel

class TestClass {
    public function sayHello($name) {
        if (!$name) {
            throw new Exception('Der Name fehlt!');
        } else {
            echo 'Hello ' . $name;
        }
    }
}

$object = new TestClass;

try {
    $object->sayHello('Julian');
    $object->sayHello('');
    $object->sayHello('David');
} catch (Exception $error) {
    echo 'Exception abgefangen: ' . $error->getMessage();
}

echo 'Schönen Tag wünsche ich!';

Wir haben also eine Klasse TestClass. Diese besitzt eine Methode sayHello die uns freundlicherweise begrüßt wenn wir Ihr als Parameter einen Namen mit übergeben. Nette Methode oder ? Doch wenn wir Ihr unseren Namen nicht veraten ist das recht unfreundlich, daher wird Sie uns auch nicht Hallo sagen sondern wird mit einem Fehler schmeißen und uns darauf aufmerksam machen wollen!

Wir instanzieren also ein Objekt der Klasse TestClass. Dann kommt der try Block in dem wir unseren Code schreiben in dem wir evtl einen Fehler vermuten würden. Wir rufen die Methode sayHello auf und übergeben Ihr einen Namen “Julian”. “Julian”, in dem Fall ich, wird begrüßt! Dann rufen wir die Methode auf vergessen Ihr aber unseren Namen zu sagen! Oh Oh… Was macht die Methode, Sie wirft per throw eine Exception! Unser try catch Block bekommt davon sofort Wind und fängt diesen Fehler per catch ab!

Wie sieht unsere Ausgabe eigentlich aus ?

Hello Julian
Exception abgefangen: Der Name fehlt!
Schönen Tag wünsche ich!

Aber hey, ich habe nachdem ich bemerkt habe das ich meinen Namen vergessen hab doch direkt einen weiteren Aufruf hingeknallt! Warum wird David also nicht begrüßt ? Das ist ganz einfach! Nachdem in einem try Block eine Exception geworfen wurde wird innerherhalb des try Blocks nichts mehr ausgeführt! Der try Block wird also sofort verlassen und der rest des Scripts wird ausgeführt, daher wird uns also noch ein schöner Tag gewünscht!

Gut das Beispiel ist etwas blöd um den Sinn hinter dem Exception Handling zu demonstieren weil in diesem Beispiel hätten wir ja auch alles einfach über eine if else Bedingung steuern können. Exception Handling ist eigentlich auch nichts anderes wenn man es man grob betrachtet. Aber es bringt doch etliche Vorteile mit! Man braucht sich nicht mehr um Rückgabewerte kümmern, man schmeisst per throw einfach den Fehler! In etwas komplexeren Szenen kommt dort der Sinn und Zweck schon deutlich zum Vorschein! Würdet Ihr mit dem if Konstrukt arbeiten würdet Ihr sehr schnell in einem tiefen verschachtelten Dschungel landen :-)

Wollt Ihr verschiedene Arten von Fehlern behandeln, empfiehlt es sich, mit unterschiedlichen Fehlerklassen zu arbeiten. Höö?
Ja Ihr werdet staunen, aber wir können sehr einfach eigene Exception Klassen erstellen. Beispiel:

class unfreundlicherUser extends Exception {
    public function __construct($message) {
        parent::__construct($message);
    }
}

Wichtig dabei ist das a) unsere Klasse von der Basisklasse Exception erbt und b) das wir einen Konstruktor definieren damit die Fehlermeldung aufgenommen werden kann!
Unseren obigen Code könnten wir also wie folgt ändern, Ausgangsbasis ist, das uns der User verarschen will und einfach ein “x” eingibt weil er weiss das er was übergeben muss! Aber unser Programm soll auf eine Eingabe von einem “x” mit einem Fehler um sich schmeißen :-)

class TestClass {

    public function sayHello($name) {
        if (!$name) {
            throw new Exception('Der Name fehlt!');
        } elseif ('x' === $name) {
            throw new unfreundlicherUser('Ah Mr. X will uns seinen Namen nicht veraten!');
        } else {
            echo 'Hello ' . $name;
        }
    }

}

$object = new TestClass;

try {
    $object->sayHello('Julian');
    $object->sayHello('x');
} catch (Exception $error) {
    echo 'Exception abgefangen: ' . $error->getMessage();
} catch (unfreundlicherUser $error) {
    echo 'Exception abgefangen: ' . $error->getMessage();
}

$object->sayHello('David');

Wie wir sehen hat sich der Code erweitert. In der Methode sayHello wurde die Abfrage eingebaut wo der Name mit dem “x” verglichen wird. Hat der User also nur ein “x” eingegeben wird eine Exception vom Typ unfreundlichenUser geschmissen die wir vorher selbst definiert haben. An unseren ersten catch Block haben wir einen weiteren gehangen in dem die Fehler vom Typ unfreundlichenUser gefangen werden.

Ist doch super! Wir können also auf alle verschiedenen Fehler verschiedenen reagieren!

In unserem catch Block haben wir nebem getMessage noch mehrere Methoden die uns zur Verfügung stehen.
Darunter zählen

- getCode() zur Ausgabe eines Fehlercodes
- getFile() zur Ausgabe des Dateinamens in dem der Fehler geschmissen wurde
- getLine() die Zeile in dem der Fehler geschmissen wurde
- getTrace() liefert ein Array mit dem Stacktrace
- getTraceAsString() liefert den Stacktrace nicht als Array sondern als String

Wir sehen, es stehen uns reichlich Mittel zur Verfügung um auf jeden Fehler zu reagieren!

Ich hoffe mein Kollege David konnte sich mit dem Thema Exceptions jetzt ein wenig anfreunden und wird es in Zukunft in allen Projekten einsetzen :-)
Ich bin gespannt hehe… und euch hat es hoffentlich auch gefallen! Ein Kommentar und eine Bewertung hier unten würde mich wie immer freuen!

1) Vermeide SELECT * (sternchen)

Über SELECT * werden ALLE Spalten einer Tabelle eingelesen! Aber nicht immer benötigt man wirklich alle Spalten aus einer Tabelle! Meißt benötigt man nur 2-3 Spalten wie den “title” oder die “id” und trotzem ist man zu faul die Spaltennamen auszuschreiben. Also knallen wir einfach mal das * (sternchen) hin, ist ja einfacher nicht wahr?! Jaha… nur bei einem * (sternchen) werden wie gesagt ALLE Spalten einer Tabelle eingelesen und das kostet Performance.

Benötigen wir also zum Beispiel aus einer Tabelle nur die Spalte “id” und “title” sollten wir unbedingt darauf achten auch nur diese beiden Spalten einzulesen:

// Nicht empfehlenswert
$result = mysql_query('SELECT * FROM tabelle WHERE id = 1');

// Empfehlenswert
$result = mysql_query('SELECT id, title FROM tabelle WHERE id = 1');

2) Vermeide ORDER BY RAND()

Ein sehr beliebtes Feature! Sie möchten auf Ihrer Webseite per Zufall “einen” Artikel aus Ihrer Tabelle darstellen!
Was schreiben wir also, ganz easy:

$result = mysql_query('SELECT title FROM tabelle ORDER BY RAND() LIMIT 1');

Sehr cool! Wir bekommen also per Zufall immer nur einen Artikel (eine Row), ganz wie wir es uns vorgestellt haben!
Jedoch muss ich euch sagen, ORDER BY RANDOM() ernährt sich unheimlich gerne von unserer köstlichen und wertvollen Zutat namens Performance. Wie also können wir unsere Abfrage so optimieren dass wir das gleiche Ergebnis bekommen ?

Ganz einfach, wir besorgen uns erstmal die Anzahl aller verfügbaren Zeilen, generieren uns dann eine Zufallszahl zwischen 0 und der Gesamtanzahl und nutzen LIMIT :-)

Moment, *taschenrechner.. klick klick*… hum, das sind ja jetzt mehr Zeilen als mein schöner Einzeiler da! Ja richtig, aber er frist garantiert nicht so viel Performance! Also, hier der Code:

$result = mysql_query('SELECT COUNT(*) FROM tabelle);
$row = mysql_fetch_row($result);
$randomizeNumber = mt_rand(0, $row[0]-1);
$result = mysql_query('SELECT title FROM tabelle LIMIT ' . $randomizeNumber . ', 1');

Diese 4 Zeilen führen zum gleichen Ergebnis und sind nicht so Performancelastig.
Hier wird gezielt per LIMIT nur eine Row gelesen. Bei ORDER BY RAND() werden erst ALLE Rows gelesen und dann erst per LIMIT begrenzt.

3) Benutze LIMIT 1 bei eindeutigen Abfragen

Es kommt sehr oft vor das wir genau wissen welche Zeile wir brauchen. Also schreibt man folgende Query

$result = mysql_query('SELECT title FROM tabelle WHERE title = "Hello World"');

1 row in set (0.36 sec)

Wir wissen also daß wir nur eine Zeile zurückbekommen!
Auch hier können wir ein minimale Performacesteigerung erzwingen, und wie ? Naja, wir wissen das es nur eine Zeile gibt, lasst uns also ein LIMIT 1 dran hängen:

$result = mysql_query('SELECT id, title, crdate FROM tabelle WHERE title = "Hello World" LIMIT 1');

1 row in set (0.17 sec)

Auch wenn nicht wirklich spürbar, aber der Query ist schneller!
Wenn wir nach einer Spalte suchen die einen Index hat, wie zB die Spalte id, diese ist ja unique, macht es keinen Sinn da über den Index das Ergebnis schon rasend schnell geliefert wird.

4) Query Cache nutzen

Seit MySQL Version 4 steht uns der MySQL Query Cache zur Verfügung der in den meisten Fällen unsere Abfragen beschleunigt. Vorausgesetzt ist natürlich das dieser aktiviert und konfiguriert ist! Die Betonung im ersten Satz liegt übrigens auf “in den meisten Fällen” ;-)

Was macht dieser Query Cache genau ?
Hier werden Querys und deren Ergebnismengen abgespeichert. Wenn die gleiche Abfrage mehrmals benutzt wird und sich die betroffenen Datensätze nicht geändert haben, wird das Ergebnis aus diesem Cache geliefert anstatt eine neue Abfrage zu generieren.

Jetzt ist es so das wir als Programmierer eigentlich nichts spezielles beachten müssen. Unsere Querys landen eigentlich automatisch im Cache. Stop! Nicht immer! Nutzen wir in unserer Abfrage eine nichtdeterministische Funktion wird der Cache nicht benutzt!

Ok, halten wir mal kurz an! Ihr fragt euch jetzt bestimmt: “Was für eine Funktion ? nichtdeterwas ?” :-) hehe! Hier ein kleines Zitat aus der MySQL Doku:

Eine Prozedur oder Funktion gilt als “deterministisch”, wenn sie für gleiche Eingabeparameter immer gleiche Resultate erzeugt; ansonsten ist sie “nichtdeterministisch”. Wenn in der Definition der Routine weder DETERMINISTIC noch NOT DETERMINISTIC steht, ist die Voreinstellung NOT DETERMINISTIC.

Soweit klar ? Super… dann können wir ja weiter machen.
Also, sobald wir eine solche Funktion in unserer Abfrage nutzen wird nicht mehr mit dem Cache gearbeitet! Soweit klar, hier ein Beispiel:

$result = mysql_query('SELECT title FROM tabelle WHERE myDate <= CURDATE()');

Mit diesem Query holen wir uns alle Zeilen wo die Spalte “myDate” kleiner gleich dem aktuellen Datum ist! CURDATE ist in diesem Fall eine nichtdeterministische Funktion! NOW() oder RAND() wären andere Beispiele!

Diesen Query können wir natürlich optimieren. Und zwar so das auch der Cache benutzt wird. Wir verzichten einfach auf diese komische nichtdeterministische Funktion und nutzen ein wenig PHP

$curdate = date('Y-m-d');
$result = mysql_query('SELECT title FROM tabelle WHERE date <= ' . $curdate);

5) Nutze das Werkzeug EXPLAIN

Wenn man einer SELECT Anweisung das Schlüsselwort EXPLAIN voranstellt, zeigt MySQL Informationen des Optimierers zum Ausführungsplan der Abfrage an. MySQL erläutert also, wie es die SELECT-Anweisung verarbeiten würde, und gibt zudem an, wie und in welcher Reihenfolge Tabellen miteinander verknüpft werden.

Zitat aus der MySQL Doku : http://dev.mysql.com/doc/refman/5.1/de/explain.html

Super, bedeutet wir haben ein Werkzeug mit dessen Hilfe wir Step by Step einen SELECT Query optimieren können!

Wir können jetzt also beim entwickeln unserer Applikation jedes mal wenn wir einen SELECT bauen direkt schauen ob dieser performant ist! Da wir die Applikation ja gerade erst bauen, die Datenbank nur ein paar Testeinträge besitzt, geht alles in allem recht flot und wir stempeln unseren Query als Performant ab!

1 Jahr später, die Applikation ist gut besucht, die Datenbank ist fett mit wunderbaren Informationen gefüllt, fragen wir uns, warum ist meine Webseite so langsam. Als ich die gebaut hab war doch alles so schnell. Mit der Zeit hat sich viel verändert, als wir beim entwickeln getestet haben hatten wir auch noch keinen Bezug auf die Realität, keine volle Datenbank, keine X-hundert Hits am Tag!

Wir wollen also versuchen unsere Webseite im MySQL Bereich zu optimieren. Um jetzt nicht jede einzelne Query wieder zu suchen und von Hand zu testen nutzen wir ein wunderbares Feature! Wir können MySQL sagen ab welcher Ausführungszeit eine Abfrage als “zu langsam” gilt. Und diese lassen wir dann mitloggen! Extrem cool nicht war.. wir haben also jetzt eine Möglichkeit Querys ausfindig zu machen die langsam sind. Diese nehmen wir uns jetzt genauer unter die Lupe und zwar mit unserem Werkzeug EXPLAIN!

EXPLAIN analysiert unsere Abfrage und stellt dar was die Datenbank mit der Abfrage genau macht.
Beispiel:

$result = mysql_query('EXPLAIN SELECT title FROM tabelle');

Was uns das Ergebnis genau sagt können wir auf der MySQL Seite nachlesen: http://dev.mysql.com/doc/refman/5.1/de/explain.html eine ausführliche Antwort um dieses zu verstehen würde sonst diesen Beitrag sprengen :-)

6) Suchfelder indizieren

Oft müssen wir per MySQL nach irgendwelchen Sachen suchen. Nehmen wir an, wir haben einen selbstprogrammierten Blog. Der User möchte nach einem Artikel suchen wo er sich nur schwach an den Titel erinnern kann. Irgendwas mit “Hello” war das….

Statisch umgesetzt könnte das so aussehen:

$result = mysql_query('SELECT COUNT(*) FROM tabelle WHERE title LIKE "Hello%"');

Wenn wir uns die Zeit dazu mal anschauen sehen wir das das schon ziemlich lange dauert: 1 row in set (0.31 sec)

Also, legen wir einen INDEX auf die Spalte “title” in der gesucht werden soll:

[mysql]ALTER TABLE tabelle ADD INDEX (“title”);[/mysql]

Führen wir unseren Query erneut aus:

$result = mysql_query('SELECT COUNT(*) FROM tabelle WHERE title LIKE "Hello%"');

sieht unser Ergebnis schon ganz anders aus: 1 row in set (0.07 sec)

Mit einem INDEX kann man also extreme Performancesteigerungen erreichen!

Kleiner Tip: Wo welcher Index verwendet wird können wir ganz einfach mit der Abfrage

SHOW INDEX FROM tabelle;

rausbekommen!

Es gibt bestimmt noch dutzende weitere Möglichkeiten seine Scripte zu optimieren! Ich möchte hier aber erst mal einen Cut machen. Wenn Ihr noch gute Optimierungsmöglichkeiten kennt die ich hier mit aufnehmen sollte, benutzt bitte die Kommentarfunktion!

Jedenfalls hoffe ich das euch der Artikel gefallen und vor allem geholfen hat! Ihr könnt diesen Artikel auch unten Bewerten oder per Twitter ein wenig pushen :-)

Lieben Gruß
Julian

Verständlich oder ? Etwa nicht ? Keine Angst ich werde gleich ein Beispiel zeigen in dem das ganze dann deutlich wird!

Die Polymorphie gibt es in PHP nicht wirklich, warum? Weil PHP eine dynamisch getypte Programmiersprache ist, viele sagen eine typenlose Programmiersprache. Was so viel bedeutet wie, wir müssen den Variablen nicht fest vorgeben was in Ihnen gespeichert wird, ob ein String, ein Integer oder Double oder oder oder. Wir können jederzeit von einem Typ zum anderen wechseln.

In anderen Programmiersprachen wie Java zum Beispiel muss man jeder Variable sagen welcher Typ in Ihr gespeichert wird und diesen kann man dann nicht mal eben ändern bzw man kann keinen String in einer als Integer definierten Variable speichern. Das nennt man dann eine statisch getypte Programmiersprache.

Daher gibt es in PHP keine direkte Polymorphie. Um das ganze jetzt etwas deutlicher zu machen möchte ich euch ein Beispiel aus der Java Welt zeigen.

class MyClassName {

 public void methodName (int variableName) {
 // Es wurde ein Integer übergeben
 }

 public void methodName (String variableName) {
 // Es wurde ein String übergeben
 }

}

Würden wir die Methode “methodName” jetzt aufrufen und Ihr als Parameter einen Integer mit übergeben, würde die erste Methode auufgerufen werden. Rufen wir die gleiche Methode auf aber übergeben Ihr einen String als Parameter, wird die zweite Methode aufgerufen. Es wird also überprüft welcher Typ übergeben wurde und entsprechend mit den Typen der Methodensignatur verglichen.

Das gleiche können wir aber auch mit der Anzahl der Parameter machen

class MyClassName {

 public void methodName (int variableName, String variableName) {
 // Es wurde ein Integer und ein String übergeben
 }

 public void methodName (int variableName) {
 // Es wurde ein Integer übergeben
 }

}

Rufen wir die Methode “methodName” mit nur einem Parameter, einen Integer Parameter auf, wird die zweite Methode aufgerufen. Rufen wir aber die Methode mit einem Integer UND einem String Parameter auf, ja richtig, dann wird die zweite Methode aufgerufen.

Das bedeutet Vielgestaltigkeit!

Soviel dazu, jetzt habe ich aber gesagt das PHP eine typenlose Sprache ist. Daher dann die Deklaration von mehreren Methoden des gleichen Namens nicht verwendet werden. Wie klappt das dann in PHP ?

Es bieten sich folgende Möglichkeiten an:
Eine Methode kann einen Parameter akzeptieren der unterschiedliche Typen enthält. Über eine if Bedingungen überprüfen wir den Typen und agieren entsprechend

class MyClassName {

 public function methodName ($variableName) {
 if (is_string($variableName)) {
 // Die Variable ist ein String
 } elseif (is_integer($variableName)) {
 // Die Variable ist ein Integer
 } elseif (is_array($variableName)) {
 // Die Variable ist ein Array
 }
 // usw.
 }

}

Wenn noch fragen offen sind könnt Ihr gerne die Kommentarfunktion benutzen!