This is an old revision of the document!
This page is not fully translated, yet. Please help completing the translation.
(remove this paragraph once the translation is finished)
originating from PHP-FIG PSR-2
This guide extends and expands the basic coding standard PSR-1.
The intent of this guide is to reduce cognitive friction when scanning code from different authors. It does so by enumerating a shared set of rules and expectations about how to format PHP code.
This example encompasses some of the rules below as a quick overview: <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 }
} </PHP>
The code MUST follow all rules outlined in PSR-1.
Code MUST use an indent of 4 spaces, and MUST NOT use tabs for indenting.
Using only spaces, and not mixing spaces with tabs, helps to avoid problems with diffs, patches, history, and annotations. The use of spaces also makes it easy to insert fine-grained sub-indentation for inter-line alignment.
For example: <PHP> <?php namespace Vendor\Package;
use FooClass; use BarClass as Bar; use OtherVendor\OtherPackage\BazClass;
… additional PHP code …
</PHP>
===== Classes, Properties, and Methods =====
The term 'class' refers to all classes, interfaces, and traits.
==== Extends and Implements ====
The extends and implements keywords MUST be declared on the same line as the class name.
The opening brace for the class MUST go on its own line; the closing brace for the class MUST go on the next line after the body.
<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
}
</PHP>
Lists of implements MAY be split across multiple lines, where each subsequent line is indented once.
When doing so, the first item in the list MUST be on the next line, and there MUST be only one interface per line.
<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
} </PHP>
A property declaration looks like the following. <PHP> <?php namespace Vendor\Package;
class ClassName {
public $foo = null;
} </PHP>
A method declaration looks like the following. Note the placement of parentheses, commas, spaces, and braces: <PHP> <?php namespace Vendor\Package;
class ClassName {
public function fooBarBaz($arg1, &$arg2, $arg3 = []) { // method body }
} </PHP>
<PHP> <?php namespace Vendor\Package;
class ClassName {
public function foo($arg1, &$arg2, $arg3 = []) { // method body }
} </PHP>
<PHP> <?php namespace Vendor\Package;
class ClassName {
public function aVeryLongMethodName( ClassTypeHint $arg1, &$arg2, array $arg3 = [] ) { // method body }
} </PHP>
<PHP> <?php namespace Vendor\Package;
abstract class ClassName {
protected static $foo;
abstract protected function zim();
final public static function bar() { // method body }
} </PHP>
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. <PHP> bar(); $foo→bar($arg1); Foo::bar($arg2, $arg3); </PHP>
<PHP> $foo→bar(
$longArgument, $longerArgument, $muchLongerArgument
); </PHP>
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.
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. <PHP> if ($expr1) {
// if body
} elseif ($expr2) {
// elseif body
} else {
// else body;
} </PHP> Das Schlüsselwort elseif SOLLTE anstelle von else if so dass alle Schlüsselworte wie einzelne Worte aussehen.
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. <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;
} </PHP>
Ein while-Statement sieht wie nachfolgend aus. Beachten Sie die Plazierung von Klammern, Leerstellen und geschweiften Klammern. <PHP> while ($expr) {
// structure body
} </PHP> ebenso sieht ein do while-Statement wie nachfolgend aus. Beachten Sie die Plazierung von Klammern, Leerstellen und geschweiften Klammern. <PHP> do {
// structure body;
} while ($expr); </PHP>
Ein for-Statement sieht wie nachfolgend aus. Beachten Sie die Plazierung von Klammern, Leerstellen und geschweiften Klammern. <PHP> for ($i = 0; $i < 10; $i++) {
// for body
} </PHP>
Ein foreach-Statement sieht wie nachfolgend aus. Beachten Sie die Plazierung von Klammern, Leerstellen und geschweiften Klammern. <PHP> foreach ($iterable as $key ⇒ $value) {
// foreach body
} </PHP>
Ein try catch-Statement sieht wie nachfolgend aus. Beachten Sie die Plazierung von Klammern, Leerstellen und geschweiften Klammern. <PHP> try {
// try body
} catch (FirstExceptionType $e) {
// catch body
} catch (OtherExceptionType $e) {
// catch body
} </PHP>
Eine Closure Deklaration sieht wie nachfolgend aus. Beachten Sie die Plazierung von Klammern, Leerstellen und geschweiften Klammern. <PHP> $closureWithArgs = function ($arg1, $arg2) {
// body
};
$closureWithArgsAndVars = function ($arg1, $arg2) use ($var1, $var2) {
// body
}; </PHP>
Beispiele von Closures mit und ohne Argumentenliste und Variableliste die über mehrere Zeilen gesplittet sind. <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
}; </PHP> Beachten Sie, dass die Formatierungsregeln auch greifen, wenn ein Closure direkt in einem Funktions- oder Methodenaufruf als Argument eingesetzt ist. <PHP> $foo→bar(
$arg1, function ($arg2) use ($var1) { // body }, $arg3
); </PHP>