Differences between PHP PSR-12 and PSR-2

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

2.5 Keywords and types

Short form of type keywords MUST be used i.e. bool instead of boolean, int instead of integer etc.

3. Declare Statements, Namespace, and Import Statements

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
        // ... additional PHP code ...
    ?>
</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
}

4. Classes, Properties, and Methods

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();

4.1. Extends and Implements

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.

4.2 Using traits

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

4.3 Properties and Constants

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.

4.4 Methods and Functions

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.

4.5 Method and Function Arguments

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)
{
    // processing
}

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)
{
    // processing
}

4.7 Method and Function Calls

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

5. Control Structures

The body MUST be on the next line after the opening brace

5.1 if, elseif, else

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
) {
    // if body
} elseif (
    $expr3
    && $expr4
) {
    // elseif body
}

5.2 switch, case

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
) {
    // structure body
}

5.3 while, do while

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
) {
    // structure body
}

<?php

do {
    // structure body;
} while (
    $expr1
    && $expr2
);

5.4 for

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++
) {
    // for body
}

5.6 try, catch, finally

It is now specified how finally must be used:

<?php

try {
    // try body
} catch (FirstThrowableType $e) {
    // catch body
} catch (OtherThrowableType | AnotherThrowableType $e) {
    // catch body
} finally {
    // finally body
}

6. Operators

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.

6.1. Unary operators

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;

6.2. Binary operators

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

6.3. Ternary operators

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

7. Closures

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 {
    // body
};

8. Anonymous Classes

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

// Brace on the same line
$instance = new class extends \Foo implements \HandleableInterface {
    // Class content
};

// Brace on the next line
$instance = new class extends \Foo implements
    \ArrayAccess,
    \Countable,
    \Serializable
{
    // Class content
};

Orlando's Blog

Orlando's Blog

Differences between PHP PSR-12 and PSR-2

PSR-12 additionally takes the following constructs into account, compared to PSR-2:

What’s changed in PSR-12 in comparison to PSR-2

2.5 Keywords and types

3. Declare Statements, Namespace, and Import Statements

4. Classes, Properties, and Methods

4.1. Extends and Implements

4.2 Using traits

4.3 Properties and Constants

4.4 Methods and Functions

4.5 Method and Function Arguments

4.7 Method and Function Calls

5. Control Structures

5.1 if, elseif, else

5.2 switch, case

5.3 while, do while

5.4 for

5.6 try, catch, finally

6. Operators

6.1. Unary operators

6.2. Binary operators

6.3. Ternary operators

7. Closures

8. Anonymous Classes