Vor kurzem habe ich gezeigt wie man ein Interface erstellt und dieses Implementiert. Nun ist es durchaus von Interesse zu prüfen ob eine Klasse dieses Interface implementiert hat. Dies geht wie folgt:

$p=new klasseMitInterface($db);
if ($p instanceof Plugin2)
{
//Interface implementiert
}
else
{
//leider nein
}

Interfaces definieren eine Schnittstelle nach Außen. Durch Sie ist sichergestellt das bestimmte Funktionen vorhanden sind und exakt so aussehen wie sie definiert wurden.

In PHP wird ein Interface wie folgt definiert:

interface Plugin
{
public function __construct($db);
public function start();
}

Hier wird definiert das die Klasse welches das Interface implementiert einen Konstruktor haben muss der als Parameter eine Variable nimmt. Außerdem muss eine Methode vorhanden sein die start heißt und keine Parameter benötigt.

Implementiert wird das ganze wie folgt:

class Ueberweisung implements Plugin
{

function __construct($db)
{
//…
}
function start()
{
//…
}
}

Nur wenn alle Funktionen implemtiert wirden funktioniert dies. Ansonsten gibt der PHP Interpretor eine Error Meldung.

Es ist auch möglich das ein Interface von einem anderen erbt.

interface Plugin2 extends Plugin
{
public function machwas();
}

Eine Klasse die jetzt Plugin2 implementiert muss nun alle Methoden von Plugin und Plugin2 bereitstellen.

Relativ viel Performance kostet es, mehrere Javascript und/oder Stylesheet Dateien einzubinden. Zwar geht die Abarbeitung relativ fix dank keep-alive aber dennoch kostet es Zeit. Bestimmte Javascript Bibiotheken bestehen ja schonmal locker aus 10 Dateien.

Daher kann es sinnvoll sein, mehrere Dateien in einer Zusammenzufassen.

Weiterhin ist so die Möglichkeit gegeben, evtl noch etwas nachzubearbeiten um weitere Dateigröße einzusparen.

Besonders User mit langsammen Verbindungen würden dies dankbar annehmen.

Nehmen wir also an, wir nutzen folgende beiden Dateien:

<script src=”script/script1.js” type=”text/javascript”></script>
<script src=”script/script2.js” type=”text/javascript”></script>

dann ersetzen wir das durch:

<script src=”javascript.php” type=”text/javascript”></script>

Dieses müssen wir dann nur noch wie folgt anlegen:

<?php
header(‘Content-type: application/javascript’); //Typ setzen
//Dateien ausgeben
require_once(’script/script1.js’);
require_once(’script/script2.js’);
?>

Das wars auch schon. Nun werden beide Dateien in einer ausgegeben. Dabei muss lediglich drauf geachtet werden das alles mit einem Semikolon abgeschlossen wird (auch die letzte Zeile der einzelnen Dateien!)

Der obrige Code kann noch weiter optimiert werden. Zuerst einmal könnten wir dem Browser sagen, das er die Script Datei Cachen soll, so muss sie lediglich einmal übertragen werden:

header (“cache-control: must-revalidate; max-age: 2592000″);
header (“expires: ” . gmdate (“D, d M Y H:i:s”, time() + 2592000) . ” GMT”);

zweitens:
es könnten alle Zeilenumbrüche entfernt , kommentare gefiltert und doppelte Leerzeichen durch einzelne ersetzt werden. Bei Dateien mit mehreren (tausend) Zeilen lässt sich so nochmal (ordentlich) Platz gespart werden:

function verkleiner($data) {
// Kommentare entfernen
$data = preg_replace(‘!/\*[^*]*\*+([^/][^*]*\*+)*/!’, ”, $data);
// Zeilenumbruch und Tab entfernen
$data = str_replace(array(“\r\n”, “\r”, “\n”, “\t”), ”, $data);
//Doppelte Leerzeichen entfernen
$data = preg_replace(‘/\s\s+/’, ‘ ‘, $data);
return $data;
}

und drittens können wir zusätzlich noch evtl verfügbare Komprimierungstechniken benutzen:

header(‘Content-Length: ‘ . strlen($data));
if (stripos($_SERVER["HTTP_ACCEPT_ENCODING"],‘x-gzip’) !== false) {
header(“Content-encoding:x-gzip”);
$data = gzencode($data);
}
elseif (stripos($_SERVER["HTTP_ACCEPT_ENCODING"],‘gzip’) !== false) {
header(“Content-encoding:gzip”);
$data = gzencode($data);
}
elseif (stripos($_SERVER["HTTP_ACCEPT_ENCODING"],‘deflate’) !== false) {
header(“Content-encoding:deflate”);
$data = gzdeflate($data);
}

Somit sieht die verkleiner funktion insgesammt wie folgt aus:

function verkleiner($data) {
// Kommentare entfernen
$data = preg_replace(‘!/\*[^*]*\*+([^/][^*]*\*+)*/!’, ”, $data);
// Zeilenumbruch und Tab entfernen
$data = str_replace(array(“\r\n”, “\r”, “\n”, “\t”), ”, $data);
//Doppelte Leerzeichen entfernen
$data = preg_replace(‘/\s\s+/’, ‘ ‘, $data);
header(‘Content-Length: ‘ . strlen($data));
if (stripos($_SERVER["HTTP_ACCEPT_ENCODING"],‘x-gzip’) !== false) {
header(“Content-encoding:x-gzip”);
$data = gzencode($data);
}
elseif (stripos($_SERVER["HTTP_ACCEPT_ENCODING"],‘gzip’) !== false) {
header(“Content-encoding:gzip”);
$data = gzencode($data);
}
elseif (stripos($_SERVER["HTTP_ACCEPT_ENCODING"],‘deflate’) !== false) {
header(“Content-encoding:deflate”);
$data = gzdeflate($data);
}
return $data;
}

Jetzt müssen wir nur noch die Javascript Dateien anders einlesen so das wir sie bearbeiten können und das ganze sieht wie folgt aus:

<?php
function verkleiner($data) {
// Kommentare entfernen
$data = preg_replace(‘!/\*[^*]*\*+([^/][^*]*\*+)*/!’, ”, $data);
// Zeilenumbruch und Tab entfernen
$data = str_replace(array(“\r\n”, “\r”, “\n”, “\t”), ”, $data);
//Doppelte Leerzeichen entfernen
$data = preg_replace(‘/\s\s+/’, ‘ ‘, $data);
header(‘Content-Length: ‘ . strlen($data));
if (stripos($_SERVER["HTTP_ACCEPT_ENCODING"],‘x-gzip’) !== false) {
header(“Content-encoding:x-gzip”);
$data = gzencode($data);
}
elseif (stripos($_SERVER["HTTP_ACCEPT_ENCODING"],‘gzip’) !== false) {
header(“Content-encoding:gzip”);
$data = gzencode($data);
}
elseif (stripos($_SERVER["HTTP_ACCEPT_ENCODING"],‘deflate’) !== false) {
header(“Content-encoding:deflate”);
$data = gzdeflate($data);
}
return $data;
}
header(‘Content-type: application/javascript’); //Typ setzen
header (“cache-control: must-revalidate; max-age: 2592000″); //Caching
header (“expires: ” . gmdate (“D, d M Y H:i:s”, time() + 2592000) . ” GMT”);
$text=file_get_contents(’script/script1.js’);
$text.=file_get_contents(’script/script2.js’);
echo verkleiner($text);
?>

Dies funktioniert natürlich auch mit CSS Dateien. HTML Seiten sollte man so nicht ausliefern da die Formatierung für bestimmte Elemente (z.B. pre) zerstört werden würde.
Ich weise allerdings nochmal darauf hin, das die Javascript Dateien sauber geschrieben sein müssen und auch die letzte Klasse in einer Datei mit einem Semikolon beendet werden muss!

Hier eine praktische Generatorfunktion für Gutscheincodes, Passwörter etc.

function generator($laenge)
{
//Generator für Passwörter Gutscheine etc!
$wert=”";
$generator_zeichen=’abcdefghijklmnopqrstuvwxyz’;
$generator_zeichen.=’ABCDEFGHIJKLMNOPQRSTUVWXYZ’;
$generator_zeichen.=’0123456789′;

for($a=0; $a<=$laenge-1; $a++)
{
srand((double)microtime()*1000000);
$id = rand (0,sizeof($generator_zeichen)-1);
$wert=$wert.$generator_zeichen[$id];
}
return $wert;
}

Oft steht man vor dem Problem, E-Mail Adressen zu verifizieren.

Dazu kann man gut folgenden Code benutzen:

Es gibt in PHP ja mehrere Schleifen. For, While, DoWhile und Foreach. Doch welche von diesen ist eigentlich am Perfomantesten wenn es darum geht einfach nur X Schleifendurchläufe zu erzeugen?

Zuerst einmal muss erwähnt werden, das alle Schleifentypen natürlich ihre Berechtigung haben. Davon unabhängig prüfen wir einfach mal, welche am schnellsten X ( in unserem Fall 10.000.000) Durchläufe abgewickelt hat.

Mittelwerte aus 5 Messungen; * = Test nicht möglich da nicht genug Speicher für ein Array mit 10000000 Elementen vorhanden war.

Wie man erkennt, kann man keine klare Aussage treffen welche Schleife am besten geeignet ist. Wie schon im vorherigen Test vom Post und Preinkrement scheint dies vom Server an sich abhängig zu sein.

Folgendes Script wurde verwendet:

<?php
define(“ROUNDS”, 10000000);
$i=0;

$start1 = microtime(true);
for ($i=0; $i<ROUNDS; $i++);
$end1 = microtime(true);
$i=0;

$start2 = microtime(true);
while ($i<ROUNDS) $i++;
$end2 = microtime(true);
$i=0;

$start3 = microtime(true);
do {
$i++;
}while($i<ROUNDS);
$end3 = microtime(true);

echo “for: “.round($end1 – $start1, 3).” Sekunden\n”;
echo “while: “.round($end2 – $start2, 3).” Sekunden\n”;
echo “dowhile: “.round($end3 – $start3, 3).” Sekunden\n”;
?>

]]> http://iteamwork.de/schleifen-vergleich.html/feed 0 http://iteamwork.de/preinkrement_gegen_postinkrement.html http://iteamwork.de/preinkrement_gegen_postinkrement.html#comments Sat, 31 May 2008 12:45:53 +0000 H.Grafe http://iteamwork.de/?p=11

In diversen Blog’s ist zu lesen, das $i++ bedeutend schneller ist als ++$i. In genug anderen ist zu lesen dass es genau andersherum ist. Grund genug, dieses selbst einmal auszutesten.

Dazu wurde folgendes Skript benutzt:

$start1 = microtime(true);
while ($i++<$rounds);
$end1 = microtime(true);

$i=0;

$start2 = microtime(true);
while (++$i<$rounds);
$end2 = microtime(true);

Wobei die Anzahl der Erhöhungen sowohl mit 10.000.000 als auch mit 100.000.000 Durchläufen getestet wurde. Um ein vernünftiges Ergebnis zu erzielen haben wir den Test auch gleich auf drei Servern durchgeführt.

Und hier ist da Ergebnis:

	Server 1 10.000.000 Durchläufe	Server 1 100.000.000 Durchläufe	Server 2 10.000.000 Durchläufe	Server 3 10.000.000 Durchläufe	Server 3 100.000.000 Durchläufe
$i++	2,205 s	20,081 s	2,461 s	1,708 s	9,444 s
++$i	2,549 s	27,444 s	1,250 s	0,904 s	9,002 s

(Mittelwerte aus jeweils 3 Testläufen) Getestet wurde auf jedem Server mit der gleichen PHP Version.

Wie man erkennt, ist $i++ schneller. ++$i aber auch. Man kann also keine allgemeine Aussage darüber treffen, welches die schnellere Variante ist.

Dies könnte daran liegen, dass die Compiler den Source Code unterschiedlich optimieren.

In einigen anderen Blogs wird noch darauf hingewiesen das $i−− bzw −−$i schneller bearbeitet wird. Dies haben wir mit folgendem Script ebenfalls gleich getestet:

$i=$rounds;
$start3 = microtime(true);
while ($i−−>0);
$end3 = microtime(true);

$i=$rounds;

$start4 = microtime(true);
while (−−$i>0);
$end4 = microtime(true);

Ergebnis:

	Server 1 10.000.000 Durchläufe	Server 1 100.000.000 Durchläufe	Server 2 10.000.000 Durchläufe	Server 3 10.000.000 Durchläufe	Server 3 100.000.000 Durchläufe
$i−−	2,325 s	23,052 s	1,047 s	0,830 s	8,382 s
−−$i	2,159 s	24,776 s	1,179 s	0,900 s	8,987 s

(Mittelwerte aus jeweils 3 Testläufen) Getestet wurde auf jedem Server mit der gleichen PHP Version.

Tatsächlich ist die Dekrement Variante schneller als die Inkrement Variante.

Hier noch einmal das ganze Skript:

<?php
$rounds = 100000000;
$i=0;

$start1 = microtime(true);
while ($i++<$rounds);
$end1 = microtime(true);

$i=0;

$start2 = microtime(true);
while (++$i<$rounds);
$end2 = microtime(true);

$i=$rounds;

$start3 = microtime(true);
while ($i−−>0);
$end3 = microtime(true);

$i=$rounds;

$start4 = microtime(true);
while (−−$i>0);
$end4 = microtime(true);

echo “\$i++: “.round($end1 – $start1, 3).”Sekunden\n”;
echo “++\$i: “.round($end2 – $start2, 3).”Sekunden\n”;
echo “\$i−− : “.round($end3 – $start3, 3).”Sekunden\n”;
echo “−−\$i: “.round($end4 – $start4, 3).”Sekunden\n”;

?>

]]> http://iteamwork.de/preinkrement_gegen_postinkrement.html/feed 0 http://iteamwork.de/alternative-zu-mysql_querysql-or-diemysql_error.html http://iteamwork.de/alternative-zu-mysql_querysql-or-diemysql_error.html#comments Wed, 28 May 2008 00:33:42 +0000 O.Kriz http://iteamwork.de/?p=10

Wer kennt das nicht: Ein großes Projekt überall mit SQL-Anfragen gespickt.
Um Fehler abzufangen gehen viele so vor:

1. $sql = [SQL-STATEMENT];
2.  
3. mysql_query($sql) or die(mysql_error());

Nun bekommt man jedoch nur den SQL Error ausgegeben,
und kann sich auf eine lange Suche einstellen.

Nicht so bei verwenden der debug_backtrace() Funktion.

Hier ein praktisches Snippet, teils von php.net, teils von mir
So wird im Fehlerfall nicht nur der SQL-Error ausgegeben, sondern
auch jede Stelle, an der er in den Skripten auftritt.

1. function querysqlsimple($sql) // für simple kommandos wie update, insert…
2. {
3.     $result = mysql_query($sql) OR dieDebug(mysql_error());
4.     return mysql_affected_rows();
5. }
6.  
7. function querysql($sql) //für select anweisungen
8. {
9.     $result = mysql_query($sql) OR dieDebug(mysql_error());
10.     return $result;
11. }
12.  
13. function dieDebug($sError)
14. {
15.  
16.     echo "<hr /><div><b>".$sError."</b><hr /><br /><table border=’1′>";
17.     $sOut=""; $aCallstack=debug_backtrace();
18.  
19.     echo "<thead><tr><th>file</th><th>line</th><th>function</th>".
20.     "</tr></thead>";
21.  
22.     foreach($aCallstack as $aCall)
23.     {
24.  
25.     if (!isset($aCall[‘file’])) $aCall[‘file’] = ‘[PHP Kernel]‘;
26.     if (!isset($aCall[‘line’])) $aCall[‘line’] = "";
27.  
28.     echo "<tr><td>{$aCall["file"]}</td><td>{$aCall["line"]}</td>".
29.     "<td>{$aCall["function"]}</td></tr>";
30.  
31.     }
32.     echo "</table></div><hr /></p>";
33.     die();
34.  
35. }
36.  
37. querysqlsimple("UPDATE table SET value=…"); //beispiel für update
38. $result = querysql("SELECT * FROM table …"); //beispiel für select
39. $db = mysql_fetch_object($result);
40. …

Links:
debug_backtrace() Funktion Erklärung (php.net)
dieDebug() Snippet (php.net)

Hoffe es hilft euch

]]> http://iteamwork.de/alternative-zu-mysql_querysql-or-diemysql_error.html/feed 0