• Code MUST follow a “coding style guide” PSR [PSR-1].

• Code MUST use 4 spaces for indenting, not tabs.

• There MUST NOT be a hard limit on line length; the soft limit MUST be 120 characters; lines SHOULD be 80 characters or less.

• There MUST be one blank line after the namespace declaration, and there MUST be one blank line after the block of use declarations.

• Opening braces for classes MUST go on the next line, and closing braces MUST go on the next line after the body.

• Opening braces for methods MUST go on the next line, and closing braces MUST go on the next line after the body.

• Visibility MUST be declared on all properties and methods; abstract and final MUST be declared before the visibility; static MUST be declared after the visibility.

• Control structure keywords MUST have one space after them; method and function calls MUST NOT.

• Opening braces for control structures MUST go on the same line, and closing braces MUST go on the next line after the body.

• Opening parentheses for control structures MUST NOT have a space after them, and closing parentheses for control structures MUST NOT have a space before.

• Code MUST follow all rules outlined in PSR-1.

• All PHP files MUST use the Unix LF (linefeed) line ending.

• All PHP files MUST end with a single blank line.

• The closing ?> tag MUST be omitted from files containing only PHP.

• There MUST NOT be a hard limit on line length.

• The soft limit on line length MUST be 120 characters; automated style checkers MUST warn but MUST NOT error at the soft limit.

• Lines SHOULD NOT be longer than 80 characters; lines longer than that SHOULD be split into multiple subsequent lines of no more than 80 characters each.

• There MUST NOT be trailing whitespace at the end of non-blank lines.

• Blank lines MAY be added to improve readability and to indicate related blocks of code.

• There MUST NOT be more than one statement per line.

• Code MUST use an indent of 4 spaces, and MUST NOT use tabs for indenting.

N.b.: 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.

• PHP keywords MUST be in lower case.

• The PHP constants true, false, and null MUST be in lower case.

Strings

• 6.1 Use single quotes '' for strings. eslint: quotes jscs: validateQuoteMarks

  // bad
  const name = "Capt. Janeway";
  
  // bad - template literals should contain interpolation or newlines
  const name = `Capt. Janeway`;
  
  // good
  const name = 'Capt. Janeway';

• 6.3 When programmatically building up strings, use template strings instead of concatenation. eslint: prefer-template template-curly-spacing jscs: requireTemplateStrings

  Why? Template strings give you a readable, concise syntax with proper newlines and string interpolation features.

  // bad
  function sayHi(name) {
    return 'How are you, ' + name + '?';
  }
  
  // bad
  function sayHi(name) {
    return ['How are you, ', name, '?'].join();
  }
  
  // bad
  function sayHi(name) {
    return `How are you, ${ name }?`;
  }
  
  // good
  function sayHi(name) {
    return `How are you, ${name}?`;
  }

Functions

• 7.3 Never declare a function in a non-function block (if, while, etc). Assign the function to a variable instead. Browsers will allow you to do it, but they all interpret it differently, which is bad news bears. eslint: no-loop-func

• 7.4 Note: ECMA-262 defines a block as a list of statements. A function declaration is not a statement.

  // bad
  if (currentUser) {
    function test() {
      console.log('Nope.');
    }
  }
  
  // good
  let test;
  if (currentUser) {
    test = () => {
      console.log('Yup.');
    };
  }

• 7.10 Never use the Function constructor to create a new function. eslint: no-new-func

  Why? Creating a function in this way evaluates a string similarly to eval(), which opens vulnerabilities.

  // bad
  var add = new Function('a', 'b', 'return a + b');
  
  // still bad
  var subtract = Function('a', 'b', 'return a - b');

• 7.11 Spacing in a function signature. eslint: space-before-function-paren space-before-blocks

  Why? Consistency is good, and you shouldn’t have to add or remove a space when adding or removing a name.

  // bad
  const f = function(){};
  const g = function (){};
  const h = function() {};
  
  // good
  const x = function () {};
  const y = function a() {};

• 7.13 Never reassign parameters. eslint: no-param-reassign

  Why? Reassigning parameters can lead to unexpected behavior, especially when accessing the arguments object. It can also cause optimization issues, especially in V8.

  // bad
  function f1(a) {
    a = 1;
    // ...
  }
  
  function f2(a) {
    if (!a) { a = 1; }
    // ...
  }
  
  // good
  function f3(a) {
    const b = a || 1;
    // ...
  }
  
  function f4(a = 1) {
    // ...
  }

Arrow Functions

• 8.5 Avoid confusing arrow function syntax (=>) with comparison operators (<=, >=). eslint: no-confusing-arrow

  // bad
  const itemHeight = item => item.height > 256 ? item.largeSize : item.smallSize;
  
  // bad
  const itemHeight = (item) => item.height > 256 ? item.largeSize : item.smallSize;
  
  // good
  const itemHeight = item => (item.height > 256 ? item.largeSize : item.smallSize);
  
  // good
  const itemHeight = (item) => {
    const { height, largeSize, smallSize } = item;
    return height > 256 ? largeSize : smallSize;
  };

Classes & Constructors

• 9.1 Always use class. Avoid manipulating prototype directly.

  Why? class syntax is more concise and easier to reason about.

  // bad
  function Queue(contents = []) {
    this.queue = [...contents];
  }
  Queue.prototype.pop = function () {
    const value = this.queue[0];
    this.queue.splice(0, 1);
    return value;
  };
  
  // good
  class Queue {
    constructor(contents = []) {
      this.queue = [...contents];
    }
    pop() {
      const value = this.queue[0];
      this.queue.splice(0, 1);
      return value;
    }
  }

• 9.2 Use extends for inheritance.

  Why? It is a built-in way to inherit prototype functionality without breaking instanceof.

  // bad
  const inherits = require('inherits');
  function PeekableQueue(contents) {
    Queue.apply(this, contents);
  }
  inherits(PeekableQueue, Queue);
  PeekableQueue.prototype.peek = function () {
    return this.queue[0];
  };
  
  // good
  class PeekableQueue extends Queue {
    peek() {
      return this.queue[0];
    }
  }

Variables

• 13.4 Assign variables where you need them, but place them in a reasonable place.

  Why? let and const are block scoped and not function scoped.

  // bad - unnecessary function call
  function checkName(hasName) {
    const name = getName();
  
    if (hasName === 'test') {
      return false;
    }
  
    if (name === 'test') {
      this.setName('');
      return false;
    }
  
    return name;
  }
  
  // good
  function checkName(hasName) {
    if (hasName === 'test') {
      return false;
    }
  
    const name = getName();
  
    if (name === 'test') {
      this.setName('');
      return false;
    }
  
    return name;
  }

Blocks

• 16.1 Use braces with all multi-line blocks. eslint: nonblock-statement-body-position

  // bad
  if (test)
    return false;
  
  // good
  if (test) return false;
  
  // good
  if (test) {
    return false;
  }
  
  // bad
  function foo() { return false; }
  
  // good
  function bar() {
    return false;
  }