Ein Interessanter Artikel zum Thema wie man schnellen Code schreibt. Sehr zu empfehlen: How to write fast code

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!

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