Inhaltsverzeichnis

im englischen Original von PHP-FIG PSR-2

Coding Style Guide

Diese Anleitung verlängert und erweitert den Basis-Standard 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

Beispiel

Für einen schnelleren Überblick umfasst dieses Beispiel einige der obigen Regeln. 

<?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
    }
}

Allgemein

Basic Coding Standard

Der Code MUSS allen in PSR-1 aufgezeigten Regeln folgen.

Dateien

Zeilen

Einzüge, Einrückungen

Code MUSS eine Einzugsweite von 4 Leerzeichen und DARF NICHT Tabulatoren für Einzüge nutzen.

:!: 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.

Schlüsselwörter und True/False/Null

Namensräume und USE-Deklarationen

Beispiel 

<?php
namespace Vendor\Package;
 
use FooClass;
use BarClass as Bar;
use OtherVendor\OtherPackage\BazClass;
 
// ... additional PHP 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. 

<?php
namespace Vendor\Package;
 
use FooClass;
use BarClass as Bar;
use OtherVendor\OtherPackage\BazClass;
 
class ClassName extends ParentClass implements \ArrayAccess, \Countable
{
    // constants, properties, methods
}

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. 

<?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
}

Eigenschaften

Beispiel einer Eigenschaftendeklaration: 

<?php
namespace Vendor\Package;
 
class ClassName
{
    public $foo = null;
}

Methoden

Beispiel einer Methodendeklaration. Beachten Sie die Anordnung von Klammern, Leerstellen, Kommata etc. 

<?php
namespace Vendor\Package;
 
class ClassName
{
    public function fooBarBaz($arg1, &$arg2, $arg3 = [])
    {
        // method body
    }
}

Methoden Argumente

<?php
namespace Vendor\Package;
 
class ClassName
{
    public function foo($arg1, &$arg2, $arg3 = [])
    {
        // method body
    }
}
<?php
namespace Vendor\Package;
 
class ClassName
{
    public function aVeryLongMethodName(
        ClassTypeHint $arg1,
        &$arg2,
        array $arg3 = []
    ) {
        // method body
    }
}

abstract, final und static

<?php
namespace Vendor\Package;
 
abstract class ClassName
{
    protected static $foo;
 
    abstract protected function zim();
 
    final public static function bar()
    {
        // method body
    }
}

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. 

bar();
$foo->bar($arg1);
Foo::bar($arg2, $arg3);
$foo->bar(
    $longArgument,
    $longerArgument,
    $muchLongerArgument
);

Kontrollstrukturen

Für alle Kontrollstrukturen gelten erst einmal folgende, allgemeine Regeln:

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. 

if ($expr1) {
    // if body
} elseif ($expr2) {
    // elseif body
} else {
    // else body;
}

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. 

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;
}

while, do while

Ein while-Statement sieht wie nachfolgend aus. Beachten Sie die Plazierung von Klammern, Leerstellen und geschweiften Klammern. 

while ($expr) {
    // structure body
}

ebenso sieht ein do while-Statement wie nachfolgend aus. Beachten Sie die Plazierung von Klammern, Leerstellen und geschweiften Klammern. 

do {
    // structure body;
} while ($expr);

for

Ein for-Statement sieht wie nachfolgend aus. Beachten Sie die Plazierung von Klammern, Leerstellen und geschweiften Klammern. 

for ($i = 0; $i < 10; $i++) {
    // for body
}

foreach

Ein foreach-Statement sieht wie nachfolgend aus. Beachten Sie die Plazierung von Klammern, Leerstellen und geschweiften Klammern. 

foreach ($iterable as $key => $value) {
    // foreach body
}

try, catch

Ein try catch-Statement sieht wie nachfolgend aus. Beachten Sie die Plazierung von Klammern, Leerstellen und geschweiften Klammern. 

try {
    // try body
} catch (FirstExceptionType $e) {
    // catch body
} catch (OtherExceptionType $e) {
    // catch body
}

Closures

Eine Closure Deklaration sieht wie nachfolgend aus. Beachten Sie die Plazierung von Klammern, Leerstellen und geschweiften Klammern. 

$closureWithArgs = function ($arg1, $arg2) {
    // body
};
 
$closureWithArgsAndVars = function ($arg1, $arg2) use ($var1, $var2) {
    // body
};

Beispiele von Closures mit und ohne Argumentenliste und Variableliste die über mehrere Zeilen gesplittet sind. 

$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
};

Beachten Sie, dass die Formatierungsregeln auch greifen, wenn ein Closure direkt in einem Funktions- oder Methodenaufruf als Argument eingesetzt ist. 

$foo->bar(
    $arg1,
    function ($arg2) use ($var1) {
        // body
    },
    $arg3
);