Overview
The PSR-12 coding standard replaces the previous PSR-2 standard. It takes new PHP features into account.
PSR-12 additionally takes the following constructs into account, compared to PSR-2:
Traits
Types (for class properties and method parameters)
Constants
Return types
Variadic three dot operator (['foo', ...$barArray, 'baz'])
Definitions for multi-line expressions/conditions
finally
Operators (===, ++, ...)
Anonymous classes
Changes:
- Underscores to indicate visibility are now forbidden.
What’s changed in PSR-12 in comparison to PSR-2
Short form of type keywords MUST be used i.e. bool instead of boolean, int instead of integer etc.
In PSR-2 the ordering of statements was not set.
The order is now strictly defined:
Opening <?php tag.
File-level docblock.
One or more declare statements.
The namespace declaration of the file.
One or more class-based use import statements.
One or more function-based use import statements.
One or more constant-based use import statements.
The remainder of the code in the file.
Differentiation between class-, function- and constant-based use imports.
When a file contains a mix of HTML and PHP, any of the above sections may still be used. If so, they MUST be present at the top of the file, even if the remainder of the code consists of a closing PHP tag and then a mixture of HTML and PHP.
When the opening <?php tag is on the first line of the file, it MUST be on its own line with no other statements unless it is a file containing markup outside of PHP opening and closing tags.
Import statements MUST never begin with a leading backslash as they must always be fully qualified.
Compound namespaces with a depth of more than two MUST NOT be used. Therefore the following is the maximum compounding depth allowed:
<?php
use Vendor\Package\SomeNamespace\{
SubnamespaceOne\ClassA,
SubnamespaceOne\ClassB,
SubnamespaceTwo\ClassY,
ClassZ,
};
And the following would not be allowed:
<?php
use Vendor\Package\SomeNamespace\{
SubnamespaceOne\ClassA,
SubnamespaceOne\ClassB,
SubnamespaceTwo\ClassY,
ClassZ,
};
When wishing to declare strict types in files containing markup outside PHP opening and closing tags, the declaration MUST be on the first line of the file and include an opening PHP tag, the strict types declaration and closing tag.
For example:
<?php declare(strict_types=1) ?>
<html>
<body>
<?php
?>
</body>
</html>
Declare statements MUST contain no spaces and MUST be exactly declare(strict_types=1) (with an optional semi-colon terminator).
Block declare statements are allowed and MUST be formatted as below. Note position of braces and spacing:
declare(ticks=1) {
// some code
}
Any closing brace MUST NOT be followed by any comment or statement on the same line.
When instantiating a new class, parentheses MUST always be present even when there are no arguments passed to the constructor.
new Foo();
Opening braces MUST be on their own line and MUST NOT be preceded or followed by a blank line.
Closing braces MUST be on their own line and MUST NOT be preceded by a blank line.
The use keyword used inside the classes to implement traits MUST be declared on the next line after the opening brace.
<?php
namespace Vendor\Package;
use Vendor\Package\FirstTrait;
class ClassName
{
use FirstTrait;
}
Each individual trait that is imported into a class MUST be included one-per-line and each inclusion MUST have its own use import statement.
<?php
namespace Vendor\Package;
use Vendor\Package\FirstTrait;
use Vendor\Package\SecondTrait;
use Vendor\Package\ThirdTrait;
class ClassName
{
use FirstTrait;
use SecondTrait;
use ThirdTrait;
}
When the class has nothing after the use import statement, the class closing brace MUST be on the next line after the use import statement.
<?php
namespace Vendor\Package;
use Vendor\Package\FirstTrait;
class ClassName
{
use FirstTrait;
}
Otherwise, it MUST have a blank line after the use import statement.
<?php
namespace Vendor\Package;
use Vendor\Package\FirstTrait;
class ClassName
{
use FirstTrait;
private $property;
}
When using the insteadof and as operators they must be used as follows taking note of indentation, spacing, and new lines.
<?php
class Talker
{
use A;
use B {
A::smallTalk insteadof B;
}
use C {
B::bigTalk insteadof C;
C::mediumTalk as FooBar;
}
}
Visibility MUST be declared on all constants if your project PHP minimum version supports constant visibilities (PHP 7.1 or later).
What was previously SHOULD NOT in PSR-2:
Property names MUST NOT be prefixed with a single underscore to indicate protected or private visibility. That is, an underscore prefix explicitly has no meaning.
There MUST be a space between type declaration and property name.
Visibility MUST be declared on all methods.
Method names MUST NOT be prefixed with a single underscore to indicate protected or private visibility. That is, an underscore prefix explicitly has no meaning.
When you have a return type declaration present, there MUST be one space after the colon followed by the type declaration. The colon and declaration MUST be on the same line as the argument list closing parenthesis with no spaces between the two characters.
<?php
declare(strict_types=1);
namespace Vendor\Package;
class ReturnTypeVariations
{
public function functionName(int $arg1, $arg2): string
{
return 'foo';
}
public function anotherFunction(
string $foo,
string $bar,
int $baz
): string {
return 'foo';
}
}
In nullable type declarations, there MUST NOT be a space between the question mark and the type.
<?php
declare(strict_types=1);
namespace Vendor\Package;
class ReturnTypeVariations
{
public function functionName(?string $arg1, ?int &$arg2): ?string
{
return 'foo';
}
}
When using the reference operator & before an argument, there MUST NOT be a space after it, like in the previous example.
There MUST NOT be a space between the variadic three dot operator and the argument name:
public function process(string $algorithm, ...$parts)
{
}
When combining both the reference operator and the variadic three dot operator, there MUST NOT be any space between the two of them:
public function process(string $algorithm, &...$parts)
{
}
A single argument being split across multiple lines (as might be the case with an anonymous function or array) does not constitute splitting the argument list itself.
<?php
somefunction($foo, $bar, [
], $baz);
$app->get('/hello/{name}', function ($name) use ($app) {
return 'Hello ' . $app->escape($name);
});
The body MUST be on the next line after the opening brace
Expressions in parentheses MAY be split across multiple lines, where each subsequent line is indented at least once. When doing so, the first condition MUST be on the next line. The closing parenthesis and opening brace MUST be placed together on their own line with one space between them. Boolean operators between conditions MUST always be at the beginning or at the end of the line, not a mix of both.
<?php
if (
$expr1
&& $expr2
) {
} elseif (
$expr3
&& $expr4
) {
}
Expressions in parentheses MAY be split across multiple lines, where each subsequent line is indented at least once. When doing so, the first condition MUST be on the next line. The closing parenthesis and opening brace MUST be placed together on their own line with one space between them. Boolean operators between conditions MUST always be at the beginning or at the end of the line, not a mix of both.
<?php
switch (
$expr1
&& $expr2
) {
}
For both while and do while:
Expressions in parentheses MAY be split across multiple lines, where each subsequent line is indented at least once. When doing so, the first condition MUST be on the next line. The closing parenthesis and opening brace MUST be placed together on their own line with one space between them. Boolean operators between conditions MUST always be at the beginning or at the end of the line, not a mix of both.
<?php
while (
$expr1
&& $expr2
) {
}
<?php
do {
} while (
$expr1
&& $expr2
);
Expressions in parentheses MAY be split across multiple lines, where each subsequent line is indented at least once. When doing so, the first expression MUST be on the next line. The closing parenthesis and opening brace MUST be placed together on their own line with one space between them.
<?php
for (
$i = 0;
$i < 10;
$i++
) {
}
It is now specified how finally must be used:
<?php
try {
} catch (FirstThrowableType $e) {
} catch (OtherThrowableType | AnotherThrowableType $e) {
} finally {
}
Style rules for operators are grouped by arity (the number of operands they take).
When space is permitted around an operator, multiple spaces MAY be used for readability purposes.
All operators not described here are left undefined.
The increment/decrement operators MUST NOT have any space between the operator and operand.
$i++;
++$j;
Type casting operators MUST NOT have any space within the parentheses:
$intValue = (int) $input;
All binary arithmetic, comparison, assignment, bitwise, logical, string, and type operators MUST be preceded and followed by at least one space:
if ($a === $b) {
$foo = $bar ?? $a ?? $b;
} elseif ($a > $b) {
$foo = $a + $b * $c;
}
The conditional operator, also known simply as the ternary operator, MUST be preceded and followed by at least one space around both the ? and : characters:
$variable = $foo ? 'foo' : 'bar';
When the middle operand of the conditional operator is omitted, the operator MUST follow the same style rules as other binary comparison operators:
$variable = $foo ?: 'bar';
If a return type is present, it MUST follow the same rules as with normal functions and methods; if the use keyword is present, the colon MUST follow the use list closing parentheses with no spaces between the two characters.
$closureWithArgsVarsAndReturn = function ($arg1, $arg2) use ($var1, $var2): bool {
};
Anonymous Classes MUST follow the same guidelines and principles as closures in the above section.
<?php
$instance = new class {};
The opening brace MAY be on the same line as the class keyword so long as the list of implements interfaces does not wrap. If the list of interfaces wraps, the brace MUST be placed on the line immediately following the last interface.
<?php
$instance = new class extends \Foo implements \HandleableInterface {
};
$instance = new class extends \Foo implements
\ArrayAccess,
\Countable,
\Serializable
{
};
