42 Regeln / Tipps zur Performanceoptimierung in PHP

Dieses Thema im Forum "Webentwicklung" wurde erstellt von Smokers, 12. November 2007 .

  1. Diese Seite verwendet Cookies. Wenn du dich weiterhin auf dieser Seite aufhältst, akzeptierst du unseren Einsatz von Cookies. Weitere Informationen
  1. #1 12. November 2007
    Ich habe mal ein wenig im Internet zu Performanceoptimierung in PHP gestöbert un hab einen Intteressanten Artikel gefunden.
    Dieser enthielt 42 wertvolle Regeln, der optimierten Programmierung in PHP.

    Jedoch waren diese in Englisch, und somit nicht für alle hier verständlich.
    Also hatte ich sie mir kopiert und während meiner Bahnfahrt mal so wie ich konnte übersetzt.

    Nun möchte ich euch das Ergebnis natürlich nicht vorenthalten =)
    ( Ich hoffe die gabs nirgendwo schon in Deutsch ^^° )

    Das Original ist ohne Markierungen oder Formatierung.

    1. If a method can be static, declare it static. Speed improvement is by a factor of 4.
    2. echo is faster than print.
    3. Use echo's multiple parameters instead of string concatenation.
    4. Set the maxvalue for your for-loops before and not in the loop.
    5. Unset your variables to free memory, especially large arrays.
    6. Avoid magic like __get, __set, __autoload
    7. require_once() is expensive
    8. Use full paths in includes and requires, less time spent on resolving the OS paths.
    9. If you need to find out the time when the script started executing, $_SERVER[’REQUEST_TIME’] is preferred to time().
    10. See if you can use strncasecmp, strpbrk and stripos instead of regex
    11. str_replace is faster than preg_replace, but strtr is faster than str_replace by a factor of 4
    12. If the function, such as string replacement function, accepts both arrays and single characters as arguments, and if your argument list is not too long, consider writing a few redundant replacement statements, passing one character at a time, instead of one line of code that accepts arrays as search and replace arguments.
    13. It's better to use select statements than multi if, else if, statements.
    14. Error suppression with @ is very slow.
    15. turn on apache's mod_deflate
    16. Close your database connections when you're done with them
    17. $row[’id’] is 7 times faster than $row[id].
    18. Error messages are expensive
    19. Do not use functions inside of for loop, such as for ($x=0; $x < count($array); $x) The count() function gets called each time.
    20. Incrementing a local variable in a method is the fastest. Nearly the same as calling a local variable in a function.
    21. Incrementing a global variable is 2 times slow than a local var.
    22. Incrementing an object property (eg. $this->prop++) is 3 times slower than a local variable.
    23. Incrementing an undefined local variable is 9-10 times slower than a pre-initialized one.
    24. Just declaring a global variable without using it in a function also slows things down (by about the same amount as incrementing a local var). PHP probably does a check to see if the global exists.
    25. Method invocation appears to be independent of the number of methods defined in the class because I added 10 more methods to the test class (before and after the test method) with no change in performance.
    26. Methods in derived classes run faster than ones defined in the base class.
    27. A function call with one parameter and an empty function body takes about the same time as doing 7-8 $localvar++ operations. A similar method call is of course about 15 $localvar++ operations.
    28. Surrounding your string by ' instead of " will make things interpret a little faster since php looks for variables inside "..." but not inside '...'. Of course you can only do this when you don't need to have variables in the string.
    29. When echoing strings it's faster to separate them by comma instead of dot. Note: This only works with echo, which is a function that can take several strings as arguments.
    30. A PHP script will be served at least 2-10 times slower than a static HTML page by Apache. Try to use more static HTML pages and fewer scripts.
    31. Your PHP scripts are recompiled every time unless the scripts are cached. Install a PHP caching product to typically increase performance by 25-100% by removing compile times.
    32. Cache as much as possible. Use memcached - memcached is a high-performance memory object caching system intended to speed up dynamic web applications by alleviating database load. OP code caches are useful so that your script does not have to be compiled on every request
    33. When working with strings and you need to check that the string is either of a certain length you'd understandably would want to use the strlen() function. This function is pretty quick since it's operation does not perform any calculation but merely return the already known length of a string available in the zval structure (internal C struct used to store variables in PHP). However because strlen() is a function it is still somewhat slow because the function call requires several operations such as lowercase & hashtable lookup followed by the execution of said function. In some instance you can improve the speed of your code by using an isset() trick.

      if (strlen($foo) < 5) { echo "Foo is too short"; }
      if (!isset($foo{5})) { echo "Foo is too short"; }
       [/INDENT]Calling isset() happens to be faster then strlen() because unlike strlen(), isset() is a language construct and not a function meaning that it's execution does not require function lookups and lowercase. This means you have virtually no overhead on top of the actual code that determines the string's length.
      [*]When incrementing or decrementing the value of the variable $i++ happens to be a tad slower then ++$i. This is something PHP specific and does not apply to other languages, so don't go modifying your C or Java code thinking it'll suddenly become faster, it won't. ++$i happens to be faster in PHP because instead of 4 opcodes used for $i++ you only need 3. Post incrementation actually causes in the creation of a temporary var that is then incremented. While pre-incrementation increases the original value directly. This is one of the optimization that opcode optimized like Zend's PHP optimizer. It is a still a good idea to keep in mind since not all opcode optimizers perform this optimization and there are plenty of ISPs and servers running without an opcode optimizer.
      [*]Not everything has to be OOP, often it is too much overhead, each method and object call consumes a lot of memory.
      [*]Do not implement every data structure as a class, arrays are useful, too
      [*]Don't split methods too much, think, which code you will really re-use
      [*]You can always split the code of a method later, when needed
      [*]Make use of the countless predefined functions
      [*]If you have very time consuming functions in your code, consider writing them as C extensions
      [*]Profile your code. A profiler shows you, which parts of your code consumes how many time. The Xdebug debugger already contains a profiler. Profiling shows you the bottlenecks in overview
      [*]mod_gzip which is available as an Apache module compresses your data on the fly and can reduce the data to transfer up to 80%[/LIST][B]© Reinhold Weber[/B]
      [*]Wenn eine Methode statisch sein kann, deklariert sie auch statisch.
      (ca. 4-fache Zeitersparnis)
      [*]"echo" ist schneller als "print".
      [*]Benutzt "echo"'s verschiedene Parameter, als Ersatz zur String-Erweiterung.(Punkt-Operator)
      [*]Setzt die maximale Anzahl an Schleifendurchläufen (bei For-Schleifen) [B]vor[/B] der eigentlichen Schleife,nicht [B]in[/B] der Schleife.
      [*]Zestört eure Variablen wenn sie nichtmehr genutzt werden um Speicher freizuräumen, besonders große Arrays.
      [*]Vermeidet Magic-Methoden wie __get, __set und __autoload.
      [*]"require_once()" verbraucht viele Ressourcen.
      [*]Benutzt volle Pfadangaben in include und require Funktionen, dies spart die Zeit die gebraucht wird um von PHP den Pfad ermitteln zu lassen.
      [*]Wenn ihr herausfinden müsst wann das Script gestartet wurde wird "$_SERVER['REQUEST_TIME']" der Funktion "time()" vorgezogen.
      [*]Versucht Funktionen wie "strncasecmp()", "strpbrk()" und "stripos()" zu nutzen anstatt Funktionen die sich auf reguläre Ausdrücke beziehen.
      [*]"str_replace()" ist schneller als "preg_replace()", aber "strtr()" ist 4 mal schneller als "str_replace()".
      [*]!Wenn eine Funktion, z.B. String-Ersetzungsfuntionen, beides, Reihen und einzelnen Buchstaben, als Argumente verarbeitet und wenn die Argumentliste nicht zu lang ist, sollten sie lieber einige Ersetzungsunctionen redundant schreiben und einen Buchstaben, anstelle von mehreren Zeilen ersetzen, anstatt diese Funktion dafür Arrays als Such- und Ersetzungsargumente unterstützt.
      [*]Ein "select"-Ausdruck ist besser als mehrere "if()" und "else if()" -Ausdrücke.
      [*]Fehlerunterdrückung mittels "@"-Operator ist langsam.
      [*]Aktiviert das Apache-Modul :"mod_deflate".
      [*]Schließt eine Datenbankverbindung wenn sie nichtmehr aktiv genutzt wird.
      [*]"$row['id']" ist bis zu 7 mal schneller als "$row[id]". (Hochkommata)
      [*]Fehlermeldungen verbrauchen viele Ressourcen.
      [*]Nutz Funktionen nicht innerhalb eines "For-Schleifen-Kopfes" wie hier:"for ($x=0; $x < count($array); $x)". Die "count()"-Funktion wird in jedem Durchlauf aufgerufen.
      [*]Inkrementierung einer lokalen Variable ist die schnellste Methode. Nahezu genauso wie das aufrufen einer lokalen Variable in einer Funktion.
      [*]Inkrementierung einer globalen Variable ist 2 mal langsamer als bei einer lokalen Variable.
      [*]Inkrementierung einer Objekteigenschaft (z.B. $this->property++) ist 3 mal langsamer als Inkrementierung einer lokalen Variable.
      [*]Inrementierung einer undefinierten lokalen Variable ist bis zu 10 mal langsamer als bei einer zuvor initialisierten.
      [*]Das bloße Deklarieren einer globalen Variable ohne jene in einer Funktion o.Ä. zu nutzen, verlangsamt das Script ähnlich stark wie das inkrementieren einer lokalen Variable ( ca. 2fach ). PHP überprüft trotzdessen ob die Variable existiert.
      [*]Methodenaufrufe scheinen unabhängig von der Anzahl der Methoden die definiert sind zu sein, denn ich habe 10 Methoden zu meiner Testklasse hinzugefügt ( vor und nach der Testmethode ) ohne Performance einbußen verzeichnen zu können.
      [*]Methoden in abgeleiteten Klassen laufen schneller als jene in den Basis-Klassen.
      [*]Ein Funktionsaufruf mit einem Parameter und einem leeren Functionskörpers braucht genauso lang wie 7 - 8 Inkrementierungen einer lokalen Variable ( $localvar++ ). Ein ähnlicher Methodenaufruf ungefähr wie 15 Inkrementierungen .
      [*]Schließt eure Strings mit " ' " ein anstatt mit ' " '. Dies verschnellert euer Script ein wenig da PHP in einfachen Hochkommata nicht nach Variablen sucht im Gegensatz zu doppelten Hochkommata. Natürlich geht das nur solange ihr keine Variablen ausgeben wollt.
      [*]Beim Ausgeben von Strings ist es schneller sie per Komma zu übergeben als mit dem Punkt-Operator. (Dies funktioniert nur mit "echo()", da "echo()" mehrere Strings und Variablen als Argumente aufnehmen kann.
      [*]Ein PHP Script wird zwischen 2 und 10 mal langsamer durch Apache vorbereitet als ein statischer HTML-Text. Versucht mehr statische HTML-Seiten zu nutzen und ein paar mehr einzelne Scripte.
      [*]Eure PHP Scripte werden jedes Mal rekompiliert, egal ob das Script gecached ist oder nicht. Installiert ein "PHP-Cache-Produkt" um die Performance von 25% bis zu 100% zu erhöhen.( Kompilierzeit wird gespart)
      [*]Cached so viel es nur möglich ist. Nutzt "memcache" - "memcache" ist ein High-Performance Speichercache System welches beabsichtigt dynamische Web-Applicationen zu verschnellern, indem es der Datenbank Last abnimmt. "OpCode- Cache" Programme halten die geschriebenen Scripte im Cache, damit sie nicht bei jedem Aufruf erneut compiliert werden müssen.
      [*]Beim Arbeiten mit Strings ist es oft nötig ( verständlicher Weise) die Länge zu prüfen. Normalerweise würde man die Funktion "strlen()" nutzen um dieses zu testen. Diese Funktion ist auch sehr schnell geworden seitdem bei deren Aufruf keine Berechnungen durchführt und lediglich die bekannte Stringlänge zurückgibt.Wie auch immer ist "strlen()" jedoch eine Funktion und demnach auch "langsam" weil diese Funktion beim Aufruf viele "requiere" 's auslöst und mehrere Operationen lädt wie Z.B. Kleinbuchstaben und Hash Suchläufe. Durch einen kleinen Trick mittels der Funktion "isset()" kann man jene Geschwindigkeitseinbußen verringern.
      if (strlen($foo) < 5) { echo "Foo ist zu kurz"; }
      if (!isset($foo{5})) { echo "Foo ist zu kurz"; }
      !Der Aufruf von "isset()" geschieht schneller als bei "strlen()" weil im Gegensatz zu "strlen()" ist "isset()" ein Sprachkonstrukt und keine Funktion. Demnach brauch jene auch keine Funktions und Kleinbuchstaben Suchläufe. Das heißt wiederum das du keinen virtuellen Kopfbereich am Anfang des Dokumentes des aktuelen Codes das die Länge bestimmt.
    34. Beim In- oder Dekrementieren des Wertes einer Variable ist es der Fall das das vorangegangene in- oder dekrementieren ("++$i") schneller als das nachgestellte ("$i++") ist. Das ist allerdings ein PHP internes Problem somit nicht gültig für andere Programmiersprachen. Also ändert bitte nicht panisch euren C oder Java Quellcode in der Hoffnung das dieser schneller wird. "++$i" ist in PHP schneller, weil anstatt 4 Operationscodes, wie bei "$i++", nur 3 verwendet werden.Ursachen dafür liegen darin das bei der nachgestellten Inkrementation eine temporäre Variable erstellt wird,Welche den erhöhten Wert enthält.Während vorrangestellte Inkrementatin den Originalwert direkt erhöht.Dies ist auch eine der Optimierungen des Scripts die "Zend's PHP-Optimizer" nutzt.Trotzdessen sollte man diese Variante im Hinterkopf behalten, da nicht alle Optimizer diesen Schritt durchführen, und nicht auf allen Servern ein PHP Optimierer läuft.
    35. Nicht alles muss Objektorientiert programmiert sein, sehr oft ist es so das dadurch zuviel "Overhead" produziert wird, denn jeder Methoden- und Objektaufruf verbraucht unmengen an Speicher.
    36. Implemeniert nicht jede Datenstruktur ( jeden Datensatz ) als Klasse, Arrays sind dabei auch sehr nützlich.
    37. Teilt eure Methoden nicht zusehr auf. Überlegt euch vorher welchen Teil ihr genau erneut nutzen wollt.
    38. Du kannst jene Methoden auch noch später , wenn der Bedarf da ist , teilen.
    39. Nutz um himmelswillen die unendliche Anzahl an vordefinierten Funktionen.
    40. Wenn ihr sehr Zeitintensive Funktionen in eurem Code habt, überlegt euch sie nicht als C- Erweiterung zu schreiben.
    41. Pofiliert euren Code. Ein Profilier-Tool zeigt euch, welche Stellen in eurem Script am meisten Zeit beanspruchen. Der Xdebug -Debugger enthält sogar schon einen Profilierer. Profilierer zeigen euch Engpässe im Überblick.
    42. Das Apache-Modul "mod_gzip" komprimiert euren Code in Echtzeit und verringert den Datentransfer um bis zu 80%.
    © Reinhold Weber
    Übersetzung by Smokers

    Für Verbesserungsvorschläge oder Änderungen im Inhaltlichen bin ich gern offen.
    Beachtet das es eine Übersetzung ohne Hilfsmittel war ;P ich habs nur in der Bahn aufm PDA geschrieben und dann kopiert und gepostet ( Bin auf Arbeit ).

    Wem es gefallen hat und die Arbeit zu schätzen weis kann es ja bewerten =)

    So far


    Bei " ! " vor den Sätzen hats bei der Übersetzung wissentlich gehapert.


    Auf ausdrücklichen Wunsch hab ich nochmal eine ordentliche PDF Liste daraus gemacht.

    LINK: Download offline!/
    PW : " smokers@rr "
    Viel Spaß =)

  2. Anzeige
    Dealz: stark reduzierte Angebote finden.
  3. #2 12. November 2007
    AW: 42 Regeln / Tipps zur Performanceoptimierung in PHP

    Hey, äußerst interessant was du da gefunden hast.

    Sollte man als php Programmierer aufjedenfall mal gelesen haben.
    Cool thx :)

  4. #3 12. November 2007
    AW: 42 Regeln / Tipps zur Performanceoptimierung in PHP

    Danke fürs Übersetzen!

    Da ist echt vieles bei was ich noch nicht gewusst hab, z.b.:

    19. Nutz Funktionen nicht innerhalb eines "For-Schleifen-Kopfes" wie hier:"for ($x=0; $x < count($array); $x)". Die "count()"-Funktion wird in jedem Durchlauf aufgerufen.

    Greez 6000Loader
  5. #4 12. November 2007
    AW: 42 Regeln / Tipps zur Performanceoptimierung in PHP

    ...vielen dank, sind ein paar dinge dabei die ich noch ned kannte...bw is raus;)!
  6. #5 13. November 2007
    AW: 42 Regeln / Tipps zur Performanceoptimierung in PHP

    Klar, PHP muss jeden Schleifendurchlauf den Kopf erneut verarbeiteb (anders als CGI);)
    Darum ist PHP in solchen Angelegenheiten auch langsamer als Perl
  7. #6 13. November 2007
    AW: 42 Regeln / Tipps zur Performanceoptimierung in PHP

    Ich fand den strlen() Trick sehr geil... ^^

    Ich weis zwar nicht genau wieviel Ersparnis es bingt, aber ich schreibs jetzt immer so =)
  8. #7 13. November 2007
    AW: 42 Regeln / Tipps zur Performanceoptimierung in PHP

    ich möchte mich auch für deine mühe bedanke.
    deine übersetzung wir kopiert und in meine php faq intergiret.
    veröffentlich wird das jedoch nicht, ist nur eine eigene faq liste.

    besten dank
  9. #8 13. November 2007
    AW: 42 Regeln / Tipps zur Performanceoptimierung in PHP

    Kein Problem,
    gern geschehen..... .
    Kann kopiert und eingefügt werden wie ihr lustig seit. ^^

    Aber ihr solltet vllt das original (c) vom Herrn Weber drinne lassen.
    Ich denke mal das ausarbeiten / das wissen sich anzueignen
    war weitaus zeitintensiver als das Übersetzen.

    Und wer dann noch lustig ist lässt meinen Namen drunter....
    aber ehrlich gesgat is mir das egal xD

    Übersetzen kann ja heutzutage jede Maschiene =)

  10. #9 13. November 2007
    AW: 42 Regeln / Tipps zur Performanceoptimierung in PHP

    Ich habe stark den Eindruck dass dieser junge Mann nicht wirklich viel von OOP hält (durch unterschiedlichste Aussagen), er der Zeit hinterhängt und nicht alles Gold ist was glänzt. Zum Einen kenne ich eine Liste die sich genauso als Faktum verkauft und Wiedersprüche nennt, zum Zweiten bringt der junge Mann Wiederholungen, zum Dritten werden hier Dinge die sich logsisch erschließen lassen oder eigentlich zu Basics gehören ('einfache Strings', Funktionen in Schleifenköpfen etc.) genannt und Zum Letzten sollten Konstrukte wie z.b. isset({}) als kritisch betrachtet werden, denn es können z.B. Fälle auftreten wo man mit isset({}) "undeklarierte" Werte abfragt ....

    Als Anfänger von PHP5 eine schöne Liste, als fortgeschrittener Entwickler eher langweilig ....
  11. #10 13. November 2007
    AW: 42 Regeln / Tipps zur Performanceoptimierung in PHP

    Mhh naja dich als höheren programmierer lässt das vllt kalt. aber ich muss herlich sagen das ich viele Dinge davon nicht wusste, aber ja, ich gehöre ja zu diesen Anfängern^^

    Und ja.... die redundanz ist auch mir aufgefallen , aber es waren ursprünglich noch mehr Listenpunkte, ein paar hab ich gekürzt ^^
  12. #11 13. November 2007
    AW: 42 Regeln / Tipps zur Performanceoptimierung in PHP

    Im übrigen sind die Geschwindigen, von denen da geredet wird, in einem ziemlich kleinem Bereich.
    Wirst sowieso keinen Performance-Unterschied bemerken. Auf die Nanosekunde kann ich auf gut Deutsch gesagt :poop:n^^

    Solangs sauber und einigermaßen mit logischen und durchdachten Ansätzen programmiert ist, mach ich mir keine Sorgen.
  13. #12 13. November 2007
    AW: 42 Regeln / Tipps zur Performanceoptimierung in PHP

    echo ist schneller als print? so ein schmarn

    früher war print schneller als echo, mittlerweile sind die beiden sogut wie gleichschnell.

    Ausgabefunktionen &ndash; echo vs print vs printf &raquo; Beitrag &raquo; PHP Performance

    ich werd mir wegen 0,014ms ned das echo angewöhnen ;)

    require/include_once ist sinnvoller für sachen die man wirklich nur einmal im script braucht (zb klassen) außerdem vermeidet man fehlermeldungen damit wenn man zb die selbe klasse zweimal includieren will.

    zu 16. was beim shutdown von allein passiert.
  14. #13 14. November 2007
    AW: 42 Regeln / Tipps zur Performanceoptimierung in PHP

    Wenn man aber nur am Anfang die MySQL Connection braucht, und ein grösseres Script hat (iwas uploaden, ich denke an php cli) dann kann es schon n bisschen RAM sparen, aber wie du schon erwähnt hast lohnen sich die meisten Sachen nicht besonders.
    BTW benutze ich immer print, da echo in gewissen Sprachen (z.b. Python) gar nicht als Befehl existiert.

    So long wirednaTure
    Btw gewöhnt euch im allgemeinen die ' an, da es einfach zu einem sauberen Script gehört, dass man Variablen nicht in die Strings einbetten (finde ich zumindest :p -> Übersichtlichkeit wird erhöht)
  15. #14 14. November 2007
    AW: 42 Regeln / Tipps zur Performanceoptimierung in PHP

    Sehe ich ähnlich, wobei ich dieses allg. "Verbieten" von Variablen-"Einbettung" nicht teile ... dort wo nichts interpretiert wird, werden einfache Anführungszeichen genutzt und wo Variablen interpretiert werden, werden doppelte Zeichen und "Stringgrenzzeichen" ordentlich genutzt. Und wenn sich jeder ENDLICH an diese, doch recht offiziell gewollte Syntax (siehe z.B. PEAR - Standards) halten würde, hätten wir auch wieder ein Kindergartenthema bei PHP weniger.

    Genauso wie die offiziellen Meinungen zu require_once etc. pp ... auch mit Gründe wieso ich die Liste für "halbgar" halten ....
  16. #15 15. November 2007
    AW: 42 Regeln / Tipps zur Performanceoptimierung in PHP

    Die Schreibweise bleibt im großen und ganzen immernoch dem Anwender selber überlassen.
    Und um nochmal auf die Deklaration der Sichtbarkeit einer Methode zurückzukommen: Wenn eine Methode sowieso public ist, muss ich das nicht noch zusätzlich deklarieren - da spar ich mir Schreibarbeit.
  17. #16 15. November 2007
    AW: 42 Regeln / Tipps zur Performanceoptimierung in PHP

    Der "Anwender" hat sich wie in anderen Sprachen an eine Syntax zu halten, zumal du auf einen Post antwortest, der sich auf einen Post bezog, der wiederum auf die Übersichtlichkeit einging wenn man sich auf ein Stringbegrenzungszeichen einigt. Ich nahm darin Stellung, dass sich die Übersichtlichkeit deutlich erhöhen würde, wenn man sich endlich an Standards halten würde ... und dazu gehört, "Strings ohne Interpretion" in einfache Anführungszeichen und "Strings mit Interprationen" in doppelte Anführungszeichen. Nicht umsonst steht sowas in der Dokumentation o.Ä. (Und muss z.B. in solch einer Liste, der du offensichtlich zugestimmt hast, Erwähnung finden) ... Verhält sich wie bei HTML, wären die HTML - Schreibenden früher auf den Trichter der Semantik gekommen, sähe die HTML - Welt schon längst anders aus!

    "Wieso muss ich public hinschreiben wenn ich auch var benutzen kann?" Wieso muss ich <?php print hinschreiben, wenn ich auch <?= benutzen kann?" Mann mann mann ...

    Entweder ich schreibe ordentlich und weiß dass es auch in Zukunft läuft (da die Sichtbarkeiten in nahezu jeder Programmiersprache zu finden ist, wird sich das definitiv nicht ändern) oder schreibe halbgar und hoffe, dass PHP auch in Zukunft mir die Kompatibilitäten der Vergangenheit gewährt.
    Wenn du der Meinung bist, ich schreibe kein public weil PHP die Methoden ohne public als solche ansieht dann tue es, ich mach es nicht aus den oben genannten Gründen, um meinen Mitarbeitern höhere Übersichtlichkeit zu gewähren etc pp.

  18. Videos zum Thema
Die Seite wird geladen...
Similar Threads - Regeln Tipps zur
  1. Antworten:
  2. Antworten:
  3. Regeln zu Kleinanzeigen

    raid-rush , 20. Februar 2014 , im Forum: Kleinanzeigen
  4. Antworten:
  5. Antworten:
  • Annonce

  • Annonce