In jedem etwas komplexeren Script kommen if-Abfragen vor, oftmals auch mit mehreren Bedingungen verknüpft, und zwar mit AND oder OR, bzw. deren Equivalent && oder ||. Aber sind diese wirklich komplett gleich? Macht es auch von der Geschwindigkeit keinen Unterschied? Ich habe es unter die Lupe genommen.Weil es bei meinem letzten Beitrag soviel Kritik gab, weil ich zu wenig Angaben zu dem Test gemacht habe, mach ich diese jetzt direkt am Anfang, damit ich es nicht wieder vergesse *g*

Jede Abfrage wird 10.000 mal ausgeführt. Bei einer erfolgreichen Bedingung wird in der Abfrage nichts ausgeführt.

Die Codes:

if($var == 'a' AND $var2 == 'b'){
}
 
if($var == 'a' && $var2 == 'b'){
}
 
if($var == 'a' OR $var2 == 'b'){
}
 
if($var == 'a' || $var2 == 'b'){
}

Die Ergebnisse:

Benchmark AND/&&

Benchmark OR/||

Wie man also sieht, sind && und || schneller als AND und OR, aber auch nur minimal.

Ich persönlich werde weiterhin AND und OR benutzen, weil ich es einfacher zu schreiben finde

Um eine Variable in einen Integer zu verwandeln gibt es in PHP 2 Möglichkeiten.

$foo = (int)$foo;

$foo = intval($foo);

Also einmal das Typecasting, und einmal die Funktion.

Doch welche davon ist schneller? Ich habe es unter die Lupe genommen, mit jeweils 10.000 Durchläufen.

Benchmark (int)$foo oder intval($foo)

Wie man also sieht, ist der Unterschied minimal, und eigentlich kaum zu beachten. Ich werde deswegen auch weiterhin (int) verwenden, da ich es einfach gewohnt bin, eben schnell (int) zu tippen *g*

Wie angekündigt, gibt es von mir nun den Benchmark zu den verschiedenen Methoden der Passwortgenerierung.

Die 4. Methode könnte man, wie gesagt, noch so erweitern, dass es auch für Passwörter mit mehr als 40 Zeichen länge funktioniert. Dies hab ich einmal gemacht, und dies hier ist der Code:

1
2
3
4
5
6
7
8
9

function generatePW($length){
 $times = ceil($length/40);
 $password = '';
 for($i=0;$i<$times;$i++){
 	$password .= substr(sha1(time()*uniqid(mt_rand())), 0, $length);
 	$length -= 40;
 }
 return $password;
}

Ich hab das ganze auch noch mit in den Benchmark einbezogen. Es handelt sich dabei um Methode 5.

Ich möchte diesmal nicht lange um den heißen Brei reden, und stelle euch einfach die Ergebnisse, nach 10.000 Generierungen mit einer Länge von 8 Zeichen vor.

Benchmark Passwortgenerierung

Das Ergebnis hat mich nicht sonderlich verwundert. Das Methode 3 schneller ist als 4, kann man sich sicherlich denken, da die 4. Methode einfach nur erweitert ist. Mich hat es nur etwas verwundert, dass Methode 2 schneller ist als Methode 5. Deswegen sollte jeder, der wirklich Zufallscodes/Passwörter mit mehr als 40 Zeichen länge braucht, auf Funktion 2 zurückgreifen. Alle anderen sollten Funktion 4 verwenden, da dort die besten Zufallswerte herauskommen, und das auch noch in einer akzeptablen Zeit. Einziger Nachteil ist halt, dass man nicht problemlos weitere Zeichen hinzufügen kann.

Schreibt man ein Loginsystem, bei dem die Passwörter verschlüsselt gespeichert werden, ist es unmöglich ein vergessenes Passwort dem User zurückzuschicken. Also muss ein neues generiert werden. Dafür gibt es viele Möglichkeiten, und ich werde hier mal ein paar Auflisten, und bald einen Benchmark für diese Methoden nachliefern.

Mir sind spontan 2 Möglichkeiten eingefallen, die ich beide noch einmal in einer etwas anderen Ausführung aufgeschrieben habe, bzw. eine davon noch etwas präziser gestaltet habe, weil diese zu vorhersehbar ist.
Permalink zu diesem Thema

MuellerLukas hat mich auf die Idee für diesen Benchmark gebraucht, Danke nochmal

Oftmals liest man in Foren von Kommentaren, wo gesagt wird, dass das verwenden des Kommas schneller ist, wenn es darum geht 2 Strings zu verketten, und der User Punkte genutzt hat, also so:

echo $var1.$var2;

Die Variante mit Komma müsste also wie folgt sein:

echo $var1,$var2;

Ist die Variante mit Komma denn jetzt wirklich schneller? Oder doch die Punkte? Genau das werde ich jetzt testen.

Ich selber verwende Punkte, weil ich es dann einheitlich habe, und nicht an manchen Stellen Kommas, und dann bei Funktionen Punkte.

Permalink zu diesem Thema

Fehlermeldungen sollte ein Besucher nicht unbedingt sehen, doch manche wollen die Ausgabe nicht komplett abstellen. Man programmiert dann zwar entsprechend, so dass keine Fehlermeldungen ausgegeben werden, aber manchmal gibt es dann doch Situationen, wo Fehler auftreten können, z.B. wenn eine MySQL Verbindung fehlschlägt, weil die Daten falsch sind. In so einem Fall sollte man die Fehler unterdrücken, und dafür gibt es mehrere Möglichkeiten:
Permalink zu diesem Thema

Heute gibt es mal wieder einen Beitrag zur Optimierung von PHP Anwendungen von mir. Und zwar geht es darum, welche Schleife man am besten nutzt, wenn man eine bestimmte Anzahl an Durchläufen haben möchte. In meinem Fall soll nun von 1 bis 10.000 gezählt und diese Zahl ausgegeben werden.

Dafür gibt es 3 Möglichkeiten:

1. die for-Schleife:

   1 2 3

   for($i=1;$i<=100000;$i++){ echo $i; }

2. die while-Schleife:

   1 2 3 4 5

   $i = 1; while($i<=100000){ echo $i; $i++; }

3. die do-while Schleife:

   1 2 3 4 5

   $i = 0; do{ $i++; echo $i; } while($i<=100000);

Permalink zu diesem Thema

Vor einiger Zeit habe ich erklärt, wie man Hexadezimalzahlen in Dezimale, und umgekehrt, umwandelt. Heute erkläre ich das ganze für das Dualsystem, auch bekannt als Binärsystem. In diesem System gibt es nur 2 Ziffern, und zwar die 1 und die 0.

Beispiele:

1961 ≙ 11110101001
9138 ≙ 10001110110010

Umrechnung Dezimal => Dual

1961

1961/2    = 980    Rest: 1
980/2     = 490    Rest: 0
490/2     = 245    Rest: 0
245/2     = 122    Rest: 1
122/2     = 61     Rest: 0
61/2      = 30     Rest: 1
30/2      = 15     Rest: 0
15/2      = 7      Rest: 1
7/2       = 3      Rest: 1
3/2       = 1      Rest: 1
1/2       = 0      Rest: 1

= 11110101001

9138

9138/2    = 4569   Rest: 0
4569/2    = 2284   Rest: 1
2284/2    = 1142   Rest: 0
1142/2    = 571    Rest: 0
571/2     = 285    Rest: 1
285/2     = 142    Rest: 1
142/2     = 71     Rest: 0
71/2      = 35     Rest: 1
35/2      = 17     Rest: 1
17/2      = 8      Rest: 1
8/2       = 4      Rest: 0
4/2       = 2      Rest: 0
2/2       = 1      Rest: 0
1/2       = 0      Rest: 1

=> 10001110110010

Das Ergebnis der Rechnung liest man anhand des Restes von unten nach oben.

Berechnen tut man den dualen Wert also in dem man die erste Zahl durch 2 teilt, dann das Ergebnis davon (abgerundet) wieder, und das nächste Ergebnis usw. bis das Ergebnis 0 ist. Der Rest (also 1 oder 0) ist dann immer die verwendete Ziffer im Dualsystem.

Umrechnung Dual => Dezimal

10001110110010

  1*2^13 + 0*2^12 + 0*2^11 + 0*2^10 + 1*2^9 + 1*2^8 + 1*2^7 + 0*2^6 + 1*2^5 + 1*2^4 + 0*2^3 + 0*2^2 + 1*2^1 + 0*2^0
= 1*2^13              +               1*2^9 + 1*2^8 + 1*2^7      +    1*2^5 + 1*2^4          +        1*2^1
=  8192               +                512  +  256  +  128       +     32   +  16            +          2
= 9138

Die andere Zahl werde ich jetzt nicht noch umrechnen, da es doch eine verdammte Rechnerei ist *g*

Um eine duale Zahl zurück ins Dezimale zu rechnen, muss man die einzelnen Ziffern mit 2^(Position der Ziffer) multiplizieren und dann alle Produkte addieren. Die Position der Ziffer wird von hinten an gezählt, und beginnt bei 0.

Erst gestern hatte ich das Problem, dass eine Klammlose Slotseite von einem Besucher (eines anderen Landes) innerhalb von einer Sekunde 15 (!!!) mal geladen wurden. Also wirklich neu geladen, ich kann die Logs wohl analysieren Es waren nicht die Requests an andere Dateien auf dem Server.

Da der Seitenbetreiber keine IPs speichert, bzw. der Programmierer des Projektes dafür keine Funktion programmiert hat (wäre ich doch mal der Programmierer geworden, aber hatte leider zu wenig Zeit *gg*), konnte man den User nicht einfach anhand der IP suchen und sperren. Also musste ich diese IP direkt für den Zugriff auf den Server sperren (bin der Serveradmin). Und da es in letzter Zeit kaum Eintrag zu dem eigentlichen Thema meines Blogs gab, werde ich mit diesem Post mal wieder etwas in die “richtige” Richtung bloggen.

Permalink zu diesem Thema

Möchte man eine Zahl mit einer Potenz von 2 (2ⁿ) multiplizieren, oder dividieren, besteht die Möglichkeit einen Bitshift anzuwenden. Diese Möglichkeit ist performanter als z.B. eine normale Division durch die Zahl. Hier ein einfaches Beispiel des Links-Shifts (<<), welcher der Multiplikation entspricht.
Permalink zu diesem Thema