PHP PSR-2 coding style specification

Code style specification

This specification is the inheritance and extension of the [PSR-1][] basic code specification.

This specification hopes to reduce the inconvenience caused by different coding styles when browsing the code of different authors by formulating a series of rules for standardizing PHP code.

When multiple programmers collaborate in multiple projects, a common coding specification is needed.
The style specification in this article is derived from the common characteristics of the coding styles of multiple different projects.
Therefore, the value of this specification lies in We all follow this coding style, not in itself.

Keywords "must" ("MUST"), "must not/must not" ("MUST NOT"), "need" ("REQUIRED"),
"will" ("SHALL"), "won't" ("SHALL NOT"), "should" ("SHOULD"), "should not" ("SHOULD NOT"),
"recommended" ("RECOMMENDED"), "can" ("MAY") and "optional" ("OPTIONAL") is described in detail in [RFC 2119][].

Overview

---

Code must follow the coding conventions in [PSR-1][].

Codemustuse 4 spaces instead of the tab key for indentation.

The number of characters per line should be softly kept within 80. Theoretically must not exceed 120, but must not have a hard limit.

After each namespace declaration and use declaration block, must insert a blank line.

The opening curly brace ({) of a class must be written on its own line after the function declaration, and the closing curly brace (}) must also be written on its own line after the function body. The opening curly brace ({) of a method must be written on its own line after the function declaration, and the closing curly brace (}) must also be written on its own line after the function body.

Class properties and methods must add access modifiers (private, protected and public), abstract and final must be declared before the access modifier, while static

must

be declared after the access modifier. There must be a space after the keyword of the control structure, but there must not be when calling a method or function.

The opening curly brace ({)

of the control structure must be written on the same line as the declaration, while the closing curly brace (}) must be written on its own line after the body.

There must be no

spaces after the opening left bracket and before the closing right bracket of the control structure. 1.1. Example The following example program simply demonstrates most of the above specifications:

namespace VendorPackage;

use FooInterface;

use BarClass as Bar;

 if ($a === $b) {
 bar();
 } elseif ($a > $b) {
 $foo-> ;bar($arg1);
 } else {
 BazClass::bar($arg2, $arg3);
 }
 }

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


Copy code


General rules

2.1 Basic Coding Guidelines
Code  must  comply with all specifications in [PSR-1][]. 
2.2 Documentation
All PHP files  must  use Unix LF (linefeed) as the line terminator. 
All PHP files  must  end with a blank line. 
Pure PHP code filesmustomit the final ?> closing tag. 
2.3. OK
The length of the line  must not  have a hard limit. 
The soft length constraintmustbe limited to 120 characters. If it exceeds this length, the editor with code specification checkmustissue a warning, but must notissue an error prompt. 
Each line  should not  be more than 80 characters, and lines  larger than 80 characters should  be folded into multiple lines. 
There must not be  any extra spaces after the non-blank line. 
Blank lines  can  make it easier to read code and help to chunk the code. 
Each line  must not  contain more than one statement. 
2.4. Indentation
Codemustuse 4 spaces for indentation, must notuse the tab key. 
Note: The advantage of using spaces instead of tab keys for indentation is that avoids confusion when comparing code differences, patching, re-reading code, and comments. Also, use spaces for indentation to make alignment easier. 
2.5. Keywords and True/False/Null
PHP all [keywords][]mustall lowercase. 
The constants true, false and null also must be all lowercase. 
namespace and use declaration

A blank line must be inserted after the namespace declaration. 
All uses must be declared after namespace. 
Each use statement must have only one use keyword. 
There must be a blank line after the use statement block is declared. 
For example: 
namespace VendorPackage;

use FooClass;
use BarClass as Bar;
use OtherVendorOtherPackageBazClass;

// ... additional PHP code ...
Classes, properties and methods

The "class" here refers to all classes, interfaces and traits reusable code blocks. 
4.1. Extension and inheritance
The keywords extends and implementsmust be written on the same line as the class name. 
The opening brace  of a class must  occupy its own line, and the closing brace  must  occupy its own line after the class body. ? & Lt;? Phpnamespace VendorPackage;  // constants, Properties, Methods
}


Copy code


implements’ inheritance list can also
 be split into multiple lines. In this case, each inherited interface name
must be separated into separate lines, including the first one.
$foo->bar($arg1);

OK

Split into multiple lines. At this time, each parameter including the first parameter must be in a separate line.

 $longerArgument,
 $muchLongerArgument
);


Copy code

Control structure

The basic specifications of the control structure are as follows:

---

There must be

a space after the control structure keyword.

There must be no space after the left bracket (.

There must be no space before the right bracket ).

There must be

a space between the right bracket ) and the opening curly bracket { .

The main body of the structure must

be indented once. The closing curly brace }

must be placed on a separate line after the body of the structure.

The body of each structure must

be enclosed in pairs of curly braces,

This makes the structure more structured and reduces the possibility of errors when adding new lines. 5.1. if , elseif and else The standard if structure is as shown in the following code. Pay attention to the position of brackets, spaces, and curly braces.

Note that else and elseif are both on the same line as the previous closing curly brace.

if ($expr1) {
// if body

} elseif ($expr2) {

}


Copy The code



 should

must be indented relative to the switch, while the break statement and other statements within the case must be indented relative to the case.

If there is a non-empty case through statement, there must be a comment like // no break in the body.

switch ($expr) { case 0:
echo 'First case, with a break';

break;

 case 2:
 case 3:
 case 4:
 echo 'Third case, return instead of break';
 return;
 default:
 echo 'Default case';
 break;
}


Copy Code

5.3. while and do while

A standardized while statement should look like the following, pay attention to the position of brackets, spaces, and curly braces. while ($expr) {
 // structure body
}The standard do while statement is as follows. Likewise, pay attention to the brackets, spaces and flowers. The position of the brackets. do {
 // structure body;
} while ($expr);5.4. for

The standard for statement is as follows, pay attention to the position of brackets, spaces and curly braces. for ($i = 0; $i < 10; $i++) {
 // for body
}5.5. foreach

The standard foreach statement is as follows, pay attention to the position of brackets, spaces and curly braces. foreach ($iterable as $key => $value) {
 // foreach body
}Copy code5.6. try, catch

The standard try catch statement is as follows, pay attention to the position of brackets, spaces and curly braces. 
try {
 // try body
} catch (FirstExceptionType $e) {
 // catch body
} catch (OtherExceptionType $e) {
 // catch body
}Closure

When a closure is declared, there must be a space after the keyword function and before and after the keyword use. 
The opening brace  must  be written on the same line as the declaration, and the closing brace  must  follow the line immediately following the end of the body. 
There must be no spaces after the left bracket and before the right bracket in the parameter list and variable list. 
In the parameter and variable lists,  must not  have spaces before the comma, and  must  have spaces after the comma. 
Parameters with default values ​​ in the closure must  be placed at the end of the list. 
The standard closure declaration statement is as follows, pay attention to the position of parentheses, commas, spaces and curly braces. };

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


Copy codeParameter lists and variable lists  can function ($arg2) use ($var1) {
 // body
 },
 $arg3
);


Copy Code