[size=10]im englischen Original von [[http://www.php-fig.org/psr/psr-2/|PHP-FIG PSR-2]][/size]
====== Coding Style Guide ======
Diese Anleitung verlängert und erweitert den Basis-Standard [[dev:all:psr:psr-1|PSR-1]].

Das Ziel dieser Anleitung ist es, dafür zu sorgen dass Code unterschiedlicher Autoren ohne Probleme gelesen und verglichen werden kann. 
Erreicht wird dieses Ziel durch einen gemeinsamen Satz an Regeln und Erwartungen an das Format von PHP-Code.

===== Übersicht =====
  * Der Code MUSS [[dev:all:psr:psr-1|PSR-1]] folgen.
  * Der Code MUSS 4 Leerzeichen für Einzüge benutzen aber keine Tabulatoren.
  * Es DARF NICHT ein festes Limit für Zeilenlängen geben. Das Soft-Limit MUSS bei 120 Zeichen liegen und Zeilen SOLLTEN max 80 Zeichen oder weniger haben.
  * Es MUSS jeweils eine Leerzeile nach der Namespace Deklaration und nach dem Block der **use** Deklarationen eingefügt werden.
  * Bei Klassen MÜSSEN öffnende, geschweifte Klammern in der nächsten Zeile und die schließenden Klammern MÜSSEN in der nächsten Zeile nach dem Klassenkörper stehen.
  * Bei Methoden MÜSSEN öffnende, geschweifte Klammern in der nächsten Zeile und die schließenden Klammern MÜSSEN in der nächsten Zeile nach dem Methodenkörper stehen.
  * Die Sichtbarkeit MUSS für alle Eigenschaften und Methoden deklariert werden. **abstrakt** und **final** MUSS vor der Sichtbarkeit; **static** MUSS nach der Sichtbarkeit deklariert werden.
  * Schlüsselwörter von Kontrollstrukturen MÜSSEN von einem Leerzeichen gefolgt werden. Leerzeichen nach Methoden- oder Funktionsaufrufen DÜRFEN NICHT benutzt werden.
  * Bei Kontrollstrukturen MÜSSEN öffnende, geschweifte Klammern in der selben Zeile und die schließenden Klammern MÜSSEN in der nächsten Zeile nach dem Strukturkörper stehen.
  * Öffnende Klammern für Argumente von Kontrollstrukturen DÜRFEN NICHT von einem Leerzeichen gefolgt werden und vor der schließenden Klammer DARF NICHT ein Leerzeichen stehen.

==== Beispiel ====
Für einen schnelleren Überblick umfasst dieses Beispiel einige der obigen Regeln.
<code php>
<?php
namespace Vendor\Package;

use FooInterface;
use BarClass as Bar;
use OtherVendor\OtherPackage\BazClass;

class Foo extends Bar implements FooInterface
{
    public function sampleFunction($a, $b = null)
    {
        if ($a === $b) {
            bar();
        } elseif ($a > $b) {
            $foo->bar($arg1);
        } else {
            BazClass::bar($arg2, $arg3);
        }
    }

    final public static function bar()
    {
        // method body
    }
}
</code>

===== Allgemein =====
==== Basic Coding Standard ====
Der Code MUSS allen in [[dev:all:psr:psr-1|PSR-1]] aufgezeigten Regeln folgen.

==== Dateien ====
  * Alle PHP-Dateien MÜSSEN das Unix **LF** (linefeed) Zeichen für das Zeilenende benutzen.
  * Alle PHP-Dateien MÜSSEN mit einer einzelnen Leerzeile enden.
  * Das schließende **?>** PHP-Tag MUSS bei Datein die nur PHP-Code enthalten oder mit solchem enden weggelassen werden.

==== Zeilen ====
  * Es DARF NICHT ein hartes Limit für die Zeilenlänge gesetzt werden (Zeilenumbruch etc.)
  * Das Soft-Limit für die Zeilenlänge MUSS auf 120 Zeichen gesetzt werden. Automatische Style-Checker MÜSSEN eine Warnung ausgeben aber sie DÜRFEN NICHT bei erreichen des Limits einen Fehler auslösen.
  * Zeilen SOLLTEN NICHT länger als 80 Zeichen sein. Längere Zeilen SOLLTEN in mehrere untergeordnete Zeilen mit jeweils max. 80 Zeichen aufgesplittet werden.
  * An Ende der Zeilen DÜRFEN NICHT irgendwelche Whitespaces (Leerzeichen etc.) folgen.
  * Leerzeilen KÖNNEN eingefügt werden um die Lesbarkeit zu erhöhen und zusammenhängende Blöcke leichter zu identifizieren.
  * Eine Zeile DARF NICHT mehr als ein Statement enthalten.

==== Einzüge, Einrückungen ====
Code MUSS eine Einzugsweite von 4 Leerzeichen und DARF NICHT Tabulatoren für Einzüge nutzen.
<blockquote>:!: Die ausnahmslose Benutzung von Leerzeichen ohne Vermischung mit Tabulatoren, hilft Probleme mit diffs, patches, history und Anmerkungen zu vermeiden. Die Benutzung von Leerzeichen macht es ebenso einfacher, feiner abgestufte Einzüge für Untereinzüge einzusetzen.</blockquote>

==== Schlüsselwörter und True/False/Null ====
  * PHP [[http://php.net/manual/en/reserved.keywords.php|Schlüsselwörter]] MÜSSEN in Kleinbuchstaben sein.
  * Die PHP Konstanten **true**, **false** und **null** MÜSSEN in Kleinbuchstaben sein.

===== Namensräume und USE-Deklarationen =====
  * Wenn vorhanden, dann MUSS eine Leerzeile nach der Namespace Deklaration sein.
  * Wenn vorhanden, dann MÜSSEN alle **use** Deklarationen nach der Namespace Deklaration eingefügt werden.
  * Es DARF NICHT mehr als ein **use** Schlüsselwort pro Deklaration benutzt werden.
  * Es MUSS eine Leerzeile nach dem **use** Deklarationsblock eingefügt werden.
Beispiel
<code php>
<?php
namespace Vendor\Package;

use FooClass;
use BarClass as Bar;
use OtherVendor\OtherPackage\BazClass;

// ... additional PHP code ...
</code>

===== Klassen, Eigenschaften und Methoden =====
Das Term 'Klasse' betrifft alle Klassen, Interfaces und Traits

==== Extends und Implements ====
Die Schlüsselwörter **extends** und **implements** MÜSSEN in der selben Zeile stehen wie der Klassenname.

Die öffnende, geschweifte Klammer für die Klasse MUSS alleine in der nächsten freien Zeile stehen. Die zugehörende schließende Klammer exakt darunter in der ersten freien Zeile nach dem Klassenkörper.
<code php>
<?php
namespace Vendor\Package;

use FooClass;
use BarClass as Bar;
use OtherVendor\OtherPackage\BazClass;

class ClassName extends ParentClass implements \ArrayAccess, \Countable
{
    // constants, properties, methods
}
</code>
Eine Liste von **implements** KANN über mehrere Zeilen gesplittet werden, wobei jede Unterzeile jeweils einen Schritt eingerückt wird.\\
Wird das gemacht, dann MUSS der erste Eintrag in der nächsten Zeile sein und es DARF NICHT mehr als ein Interface pro Zeile angegeben werden.
<code php>
<?php
namespace Vendor\Package;

use FooClass;
use BarClass as Bar;
use OtherVendor\OtherPackage\BazClass;

class ClassName extends ParentClass implements
    \ArrayAccess,
    \Countable,
    \Serializable
{
    // constants, properties, methods
}
</code>

==== Eigenschaften ====
  * Die Sichtbarkeit MUSS für alle Eigenschaften angegeben werden.
  * Das Schlüsselwort **var** DARF NICHT zur Deklaration von Eigenschaften benutzt werden.
  * Es DARF NICHT mehr als eine Eigenschaft je Statement deklariert werden.
  * Eigenschaftennamen DÜRFEN NICHT zur Kennzeichnung von private oder protected einen _ als Vorzeichen erhalten.
Beispiel einer Eigenschaftendeklaration:
<code php>
<?php
namespace Vendor\Package;

class ClassName
{
    public $foo = null;
}
</code>




==== Methoden ====
  * Die Sichtbarkeit MUSS für alle Methoden angegeben werden.
  * Methodennamen DÜRFEN NICHT zur Kennzeichnung von private oder protected einen **_** als Vorzeichen erhalten.
  * Nach dem Methodennamen DÜRFEN NICHT Leerstellen eingefügt werden. Die öffnende, geschweifte Klammer MUSS alleine in einer eigenen Zeile stehen und die schließende Klammer MUSS in der nächsten Leeren Zeile nach dem Methodenkörper stehen. Nach der öffnenden und vor der schließenden Klammer der Argumentenliste DÜRFEN NICHT Leerstellen eingefügt werden.

Beispiel einer Methodendeklaration. Beachten Sie die Anordnung von Klammern, Leerstellen, Kommata etc.
<code php>
<?php
namespace Vendor\Package;

class ClassName
{
    public function fooBarBaz($arg1, &$arg2, $arg3 = [])
    {
        // method body
    }
}
</code>





==== Methoden Argumente ====
  * In der Argumentenliste DARF NICHT eine Leerstelle vor einem Komma sein, aber es MUSS eine Leerstelle nach jedem Komma folgen.
  * Methodenargumente mit Vorgabewerten(default) MÜSSEN an das Ende der Liste.
<code php>
<?php
namespace Vendor\Package;

class ClassName
{
    public function foo($arg1, &$arg2, $arg3 = [])
    {
        // method body
    }
}
</code>
  * Argumentenlisten KÖNNEN über mehrere Zeilen gesplittet werden, wenn jede Unterzeile um eine Stufe eingerückt wird. Wenn so verfahren wird, MUSS das erste Element in die nächste Zeile und es DARF NICHT mehr als ein Argument je Zeile angegeben werden.
  * Wenn eine Argumentenliste gesplittet wird, so MUSS die schließende Klammer und die öffnende geschweifte Klammer mit einer Leerstelle dazwischen in eine eigene Zeile.
<code php>
<?php
namespace Vendor\Package;

class ClassName
{
    public function aVeryLongMethodName(
        ClassTypeHint $arg1,
        &$arg2,
        array $arg3 = []
    ) {
        // method body
    }
}
</code>




==== abstract, final und static ====
  * Wenn vorhanden, MÜSSEN die Deklarationen für **abstract** und **final** vor der Sichtbarkeitsdeklaration eingefügt werden.
  * Wenn vorhanden, MUSS die Deklarationen für **static** nach der Sichtbarkeitsdeklaration eingefügt werden.
<code php>
<?php
namespace Vendor\Package;

abstract class ClassName
{
    protected static $foo;

    abstract protected function zim();

    final public static function bar()
    {
        // method body
    }
}
</code>





==== Methoden- und Funktionsaufrufe ====
Bei einem Methoden- oder Funktionsaufruf DARF NICHT zwischen dem Methoden- oder Funktionsnamen und der öffnenden Klammer eine Leerstelle sein; Es DARF NICHT eine Leerstelle __nach__ der öffnenden Klammer und es DARF NICHT eine Leerstelle __vor__ der schließenden Klammer eingefügt werden. In der Argumentenliste DARF NICHT eine Leerstelle __vor__ einem Komma stehen und es MUSS eine Leerstelle __nach__ jedem Komma eingefügt werden.
<code php>
bar();
$foo->bar($arg1);
Foo::bar($arg2, $arg3);
</code>

  * Argumentenlisten KÖNNEN über mehrere Zeilen gesplittet werden, wenn jede Unterzeile um eine Stufe eingerückt wird. Wenn so verfahren wird, MUSS das erste Element in die nächste Zeile und es DARF NICHT mehr als ein Argument je Zeile angegeben werden.
  * Wenn eine Argumentenliste gesplittet wird, so MUSS die schließende Klammer und das Semikolon ohne eine Leerstelle dazwischen in eine eigene Zeile.
<code php>
$foo->bar(
    $longArgument,
    $longerArgument,
    $muchLongerArgument
);
</code>

===== Kontrollstrukturen =====
Für alle Kontrollstrukturen gelten erst einmal folgende, allgemeine Regeln:
  * Es MUSS ein Leerzeichen hinter dem Schlüsselwort der Kontrollstruktur sein.
  * Es DARF NICHT ein Leerzeichen nach der öffnenden Klammer stehen.
  * Es DARF NICHT ein Leerzeichen vor der schließenden Klammer stehen.
  * Es MUSS ein Leerzeichen zwischen der schließenden Klammer und der öffnenden, geschweiften Klammer stehen.
  * Der Strukturkörper MUSS um eine Stufe eingerückt werden.
  * Die schließende, geschweifte Klammer MUSS in der Zeile nach dem Kontrollkörper stehen.
Der Körper einer Struktur MUSS in geschweifte Klammern eingeschlossen werden. Diese Standardisierung verhindert Fehler, falls zufällig Leerzeilen im Körper eingefügt werden.



==== if, elseif, else ====
Eine **if**-Struktur sieht wie nachfolgend aus. Beachten Sie die Plazierung von Klammern, Leerstellen und geschweiften Klammern. Die Schlüsselwörter **else** und **elseif** MÜSSEN sich mit einer Leerstelle Abstand auf der selben Zeile befinden, wie die schließende, geschweifte Klammer des vorhergehenden Strukturkörpers.
<code php>
if ($expr1) {
    // if body
} elseif ($expr2) {
    // elseif body
} else {
    // else body;
}
</code>
Das Schlüsselwort **elseif** SOLLTE anstelle von **else if** so dass alle Schlüsselworte wie einzelne Worte aussehen.


==== switch, case ====
Eine **switch**-Struktur sieht wie nachfolgend aus. Beachten Sie die Plazierung von Klammern, Leerstellen und geschweiften Klammern.
Das **case**-Statement MUSS eine Stufe ab **switch** eingerückt werden und das **break** Schlüsselwort (oder ein anderes, abschließendes Schlüsselwort) MUSS auf die selbe Ebene eingerückt werden, wie der **case**-Körper. Es MUSS ein Kommentar wie %%//%%// no break//  eingefügt werden, wenn ein 'durchfallen' zum nächsten **case** erwünscht ist.
<code php>
switch ($expr) {
    case 0:
        echo 'First case, with a break';
        break;
    case 1:
        echo 'Second case, which falls through';
        // no break
    case 2:
    case 3:
    case 4:
        echo 'Third case, return instead of break';
        return;
    default:
        echo 'Default case';
        break;
}
</code>



==== while, do while ====
Ein **while**-Statement sieht wie nachfolgend aus. Beachten Sie die Plazierung von Klammern, Leerstellen und geschweiften Klammern.
<code php>
while ($expr) {
    // structure body
}
</code>
ebenso sieht ein **do while**-Statement wie nachfolgend aus. Beachten Sie die Plazierung von Klammern, Leerstellen und geschweiften Klammern.
<code php>
do {
    // structure body;
} while ($expr);
</code>



==== for ====
Ein **for**-Statement sieht wie nachfolgend aus. Beachten Sie die Plazierung von Klammern, Leerstellen und geschweiften Klammern. 
<code php>
for ($i = 0; $i < 10; $i++) {
    // for body
}
</code>


==== foreach ====
Ein **foreach**-Statement sieht wie nachfolgend aus. Beachten Sie die Plazierung von Klammern, Leerstellen und geschweiften Klammern. 
<code php>
foreach ($iterable as $key => $value) {
    // foreach body
}
</code>


==== try, catch ====
Ein **try catch**-Statement sieht wie nachfolgend aus. Beachten Sie die Plazierung von Klammern, Leerstellen und geschweiften Klammern. 
<code php>
try {
    // try body
} catch (FirstExceptionType $e) {
    // catch body
} catch (OtherExceptionType $e) {
    // catch body
}
</code>


===== Closures =====
  * Closures MÜSSEN mit einem Leerzeichen nach denm Schlüsselwort **function** und je einem Leerzeichen vor und nach dem Schlüsselwort **use** deklariert werden.
  * Die öffnende, geschweifte Klammer MUSS in der selben Zeile wie das Schlüsselwort **function** sein und die schließende Klammer MUSS in der nächsten Zeile nach dem Funktionskörper sein.
  * Nach der öffnenden Klammer der Argumentenliste DARF NICHT ein Leerzeichen stehen und vor der schließenden Klammer DARF NICHT ein Leerzeichen sein.
  * In der Argumentenliste und der Variablenliste DARF NICHT ein Leerzeichen vor einem Komma stehen und nach einem Komma MUSS ein Leerzeichen sein.
  * Closure Argumente mit Vorgabewerten (default) MÜSSEN an das Ende der Argumentenliste.
Eine Closure Deklaration sieht wie nachfolgend aus. Beachten Sie die Plazierung von Klammern, Leerstellen und geschweiften Klammern. 
<code php>
$closureWithArgs = function ($arg1, $arg2) {
    // body
};

$closureWithArgsAndVars = function ($arg1, $arg2) use ($var1, $var2) {
    // body
};
</code>
  * Argumenten- und Variablenlisten KÖNNEN über mehrere Zeilen gesplittet werden, wenn jede Unterzeile um eine Stufe eingerückt wird. Wenn so verfahren wird, MUSS das erste Element in die nächste Zeile und es DARF NICHT mehr als ein Argument oder Variable je Zeile angegeben werden.
  * Wenn eine Argumenten- oder Variablenliste gesplittet wird, so MUSS die schließende Klammer und die öffnende geschweifte Klammer mit einer Leerstelle dazwischen in eine eigene Zeile.
Beispiele von Closures mit und ohne Argumentenliste und Variableliste die über mehrere Zeilen gesplittet sind.
<code php>
$longArgs_noVars = function (
    $longArgument,
    $longerArgument,
    $muchLongerArgument
) {
   // body
};

$noArgs_longVars = function () use (
    $longVar1,
    $longerVar2,
    $muchLongerVar3
) {
   // body
};

$longArgs_longVars = function (
    $longArgument,
    $longerArgument,
    $muchLongerArgument
) use (
    $longVar1,
    $longerVar2,
    $muchLongerVar3
) {
   // body
};

$longArgs_shortVars = function (
    $longArgument,
    $longerArgument,
    $muchLongerArgument
) use ($var1) {
   // body
};

$shortArgs_longVars = function ($arg) use (
    $longVar1,
    $longerVar2,
    $muchLongerVar3
) {
   // body
};
</code>
Beachten Sie, dass die Formatierungsregeln auch greifen, wenn ein  Closure direkt in einem Funktions- oder Methodenaufruf als Argument eingesetzt ist.
<code php>
$foo->bar(
    $arg1,
    function ($arg2) use ($var1) {
        // body
    },
    $arg3
);
</code>