PHPCS: WordPress

Generic.Classes.DuplicateClassName | [ref]

Class and Interface names should be unique in a project. They should never be duplicated.

class Foo
{
}

class Foo
{
}

class Foo
{
}

Generic.Classes.OpeningBraceSameLine | [ref]

The opening brace of a class must be on the same line after the definition and must be the last thing on that line.

class Foo {
}

class Foo
{
}

class Foo {
}

class Foo { // Start of class.
}

Generic.CodeAnalysis.AssignmentInCondition | [ref]

Variable assignments should not be made within conditions.

if ($test === 'abc') {
    // Code.
}

if ($test = 'abc') {
    // Code.
}

Generic.CodeAnalysis.EmptyPHPStatement | [ref]

Empty PHP tags are not allowed.

<?php echo 'Hello World'; ?>
<?= 'Hello World'; ?>

<?php ; ?>
<?=  ?>

function_call();
if (true) {
    echo 'Hello World';
}

function_call();;;
if (true) {
    echo 'Hello World';
};

Generic.CodeAnalysis.EmptyStatement | [ref]

Control Structures must have at least one statement inside of the body.

if ($test) {
    $var = 1;
}

if ($test) {
    // do nothing
}

Generic.CodeAnalysis.ForLoopShouldBeWhileLoop | [ref]

For loops that have only a second expression (the condition) should be converted to while loops.

for ($i = 0; $i < 10; $i++) {
    echo "{$i}\n";
}

for (;$test;) {
    $test = doSomething();
}

Generic.CodeAnalysis.ForLoopWithTestFunctionCall | [ref]

For loops should not call functions inside the test for the loop when they can be computed beforehand.

$end = count($foo);
for ($i = 0; $i < $end; $i++) {
    echo $foo[$i]."\n";
}

for ($i = 0; $i < count($foo); $i++) {
    echo $foo[$i]."\n";
}

Generic.CodeAnalysis.JumbledIncrementer | [ref]

Incrementers in nested loops should use different variable names.

for ($i = 0; $i < 10; $i++) {
    for ($j = 0; $j < 10; $j++) {
    }
}

for ($i = 0; $i < 10; $i++) {
    for ($j = 0; $j < 10; $i++) {
    }
}

Generic.CodeAnalysis.RequireExplicitBooleanOperatorPrecedence | [ref]

Forbids mixing different binary boolean operators (&&, ||, and, or, xor) within a single expression without making precedence clear using parentheses.

$one = false;
$two = false;
$three = true;

$result = ($one && $two) || $three;
$result2 = $one && ($two || $three);
$result3 = ($one && !$two) xor $three;
$result4 = $one && (!$two xor $three);

if (
    ($result && !$result3)
    || (!$result && $result3)
) {}

$one = false;
$two = false;
$three = true;

$result = $one && $two || $three;

$result3 = $one && !$two xor $three;


if (
    $result && !$result3
    || !$result && $result3
) {}

Generic.CodeAnalysis.UnconditionalIfStatement | [ref]

If statements that are always evaluated should not be used.

if ($test) {
    $var = 1;
}

if (true) {
    $var = 1;
}

if ($test) {
    $var = 1;
}

if (false) {
    $var = 1;
}

Generic.CodeAnalysis.UnnecessaryFinalModifier | [ref]

Methods should not be declared final inside of classes that are declared final.

final class Foo
{
    public function bar()
    {
    }
}

final class Foo
{
    public final function bar()
    {
    }
}

Generic.CodeAnalysis.UnusedFunctionParameter | [ref]

All parameters in a functions signature should be used within the function.

function addThree($a, $b, $c)
{
    return $a + $b + $c;
}

function addThree($a, $b, $c)
{
    return $a + $b;
}

Generic.CodeAnalysis.UselessOverridingMethod | [ref]

Methods should not be defined that only call the parent method.

final class Foo
{
    public function bar()
    {
        parent::bar();
        $this->doSomethingElse();
    }
}

final class Foo
{
    public function bar()
    {
        parent::bar();
    }
}

Generic.Commenting.DocComment | [ref]

Generic.ControlStructures.InlineControlStructure | [ref]

Control Structures should use braces.

if ($test) {
    $var = 1;
}

if ($test)
    $var = 1;

Generic.Files.ByteOrderMark | [ref]

Byte Order Marks that may corrupt your application should not be used. These include 0xefbbbf (UTF-8), 0xfeff (UTF-16 BE) and 0xfffe (UTF-16 LE).

Generic.Files.LineEndings | [ref]

Unix-style line endings are preferred ("\n" instead of "\r\n").

Generic.Files.OneObjectStructurePerFile | [ref]

There should only be one class or interface or trait defined in a file.

<?php
trait Foo
{
}

<?php
trait Foo
{
}

class Bar
{
}

Generic.Formatting.DisallowMultipleStatements | [ref]

Multiple statements are not allowed on a single line.

$foo = 1;
$bar = 2;

$foo = 1; $bar = 2;

Generic.Formatting.MultipleStatementAlignment | [ref]

There should be one space on either side of an equals sign used to assign a value to a variable. In the case of a block of related assignments, more space may be inserted to promote readability.

$shortVar        = (1 + 2);
$veryLongVarName = 'string';
$var             = foo($bar, $baz);

$shortVar = (1 + 2);
$veryLongVarName = 'string';
$var = foo($bar, $baz);

$shortVar       += 1;
$veryLongVarName = 1;

$shortVar        += 1;
$veryLongVarName  = 1;

$shortVar         = 1;
$veryLongVarName -= 1;

$shortVar        = 1;
$veryLongVarName -= 1;

Generic.Formatting.SpaceAfterCast | [ref]

Exactly one space is allowed after a cast.

$foo = (string) 1;

$foo = (string)1;

Generic.Functions.CallTimePassByReference | [ref]

Call-time pass-by-reference is not allowed. It should be declared in the function definition.

function foo(&$bar)
{
    $bar++;
}

$baz = 1;
foo($baz);

function foo($bar)
{
    $bar++;
}

$baz = 1;
foo(&$baz);

Generic.Functions.FunctionCallArgumentSpacing | [ref]

Function arguments should have one space after a comma, and single spaces surrounding the equals sign for default values.

function foo($bar, $baz)
{
}

function foo($bar,$baz)
{
}

function foo($bar, $baz = true)
{
}

function foo($bar, $baz=true)
{
}

Generic.Functions.OpeningFunctionBraceKernighanRitchie | [ref]

Function declarations follow the "Kernighan/Ritchie style". The function brace is on the same line as the function declaration. One space is required between the closing parenthesis and the brace.

function fooFunction($arg1, $arg2 = '') {
    ...
}

function fooFunction($arg1, $arg2 = '')
{
    ...
}

Generic.NamingConventions.UpperCaseConstantName | [ref]

Constants should always be all-uppercase, with underscores to separate words.

define('FOO_CONSTANT', 'foo');

class FooClass
{
    const FOO_CONSTANT = 'foo';
}

define('Foo_Constant', 'foo');

class FooClass
{
    const foo_constant = 'foo';
}

Generic.PHP.BacktickOperator | [ref]

Disallow the use of the backtick operator for execution of shell commands.

Generic.PHP.DeprecatedFunctions | [ref]

Deprecated functions should not be used.

$foo = explode('a', $bar);

$foo = split('a', $bar);

Generic.PHP.DisallowAlternativePHPTags | [ref]

Always use <?php ?> to delimit PHP code, do not use the ASP <% %> style tags nor the <script language="php"></script> tags. This is the most portable way to include PHP code on differing operating systems and setups.

Generic.PHP.DisallowShortOpenTag | [ref]

Always use <?php ?> to delimit PHP code, not the <? ?> shorthand. This is the most portable way to include PHP code on differing operating systems and setups.

Generic.PHP.DiscourageGoto | [ref]

Discourage the use of the PHP goto language construct.

Generic.PHP.ForbiddenFunctions | [ref]

The forbidden functions sizeof() and delete() should not be used.

$foo = count($bar);

$foo = sizeof($bar);

Generic.PHP.LowerCaseConstant | [ref]

The true, false and null constants must always be lowercase.

if ($var === false || $var === null) {
    $var = true;
}

if ($var === FALSE || $var === NULL) {
    $var = TRUE;
}

Generic.PHP.LowerCaseKeyword | [ref]

All PHP keywords should be lowercase.

$foo = array();

$foo = Array();

Generic.PHP.LowerCaseType | [ref]

All PHP types used for parameter type and return type declarations should be lowercase.

function myFunction(int $foo) : string {
}

function myFunction(Int $foo) : STRING {
}

$foo = (bool) $isValid;

$foo = (BOOL) $isValid;

Generic.PHP.Syntax | [ref]

The code should use valid PHP syntax.

echo "Hello!";
$array = [1, 2, 3];

echo "Hello!" // Missing semicolon.
$array = [1, 2, 3; // Missing closing bracket.

Generic.Strings.UnnecessaryStringConcat | [ref]

Strings should not be concatenated together.

echo '5 + 2 = ' . (5 + 2);

echo 'Hello' . ' ' . 'World';

Generic.VersionControl.GitMergeConflict | [ref]

Generic.WhiteSpace.ArbitraryParenthesesSpacing | [ref]

Arbitrary sets of parentheses should have no spaces inside.

$a = (null !== $extra);

$a = ( null !== $extra );

$a = (
    null !== $extra
);

Generic.WhiteSpace.DisallowSpaceIndent | [ref]

Tabs should be used for indentation instead of spaces.

Generic.WhiteSpace.IncrementDecrementSpacing | [ref]

There should be no whitespace between variables and increment/decrement operators.

++$i;
--$i['key']['id'];
ClassName::$prop++;
$obj->prop--;

++ $i;
--   $i['key']['id'];
ClassName::$prop    ++;
$obj->prop
--;

Generic.WhiteSpace.LanguageConstructSpacing | [ref]

Language constructs that can be used without parentheses, must have a single space between the language construct keyword and its content.

echo 'Hello, World!';
throw new Exception();
return $newLine;

echo'Hello, World!';
throw   new   Exception();
return
$newLine;

yield from [1, 2, 3];

yieldfrom [1, 2, 3];
yield  from [1, 2, 3];
yield
from [1, 2, 3];

Generic.WhiteSpace.ScopeIndent | [ref]

Indentation for control structures, classes, and functions should be 4 spaces per level.

if ($test) {
    $var = 1;
}

if ($test) {
        $var = 1;
}

Generic.WhiteSpace.SpreadOperatorSpacingAfter | [ref]

There should be no space between the spread operator and the variable/function call it applies to.

function foo(&...$spread) {
    bar(...$spread);

    bar(
        [...$foo],
        ...array_values($keyedArray)
    );
}

function bar(... $spread) {
    bar(...
        $spread
    );

    bar(
        [...  $foo ],.../*comment*/array_values($keyedArray)
    );
}

Modernize.FunctionCalls.Dirname | [ref]

PHP >= 5.3: Usage of dirname(FILE) can be replaced with DIR.

$path = __DIR__;

$path = dirname(__FILE__);

$path = dirname($file, 3);

$path = dirname(dirname(dirname($file)));

NormalizedArrays.Arrays.ArrayBraceSpacing | [ref]

There should be no space between the "array" keyword and the array open brace.

$args = array(1, 2);

$args = array  (1, 2);

$args = array();

$args = [];

$args = array( );

$args = [  ];

$args = array(1, 2);

$args = [1, 2];

$args = array( 1, 2 );

$args = [  1, 2  ];

$args = array(
    1,
    2
);

$args = [
    1,
    2
];

$args = array(1,
    2);

$args = [1,
    2];

NormalizedArrays.Arrays.CommaAfterLast | [ref]

For single-line arrays, there should be no comma after the last array item.

  However, for multi-line arrays, there *should* be a comma after the last array item.

$args = array(1, 2, 3);

$args = array(1, 2, 3, );

$args = [
    1 => 'foo',
    2 => 'bar',
];

$args = [
    1 => 'foo',
    2 => 'bar'
];

PEAR.Files.IncludingFile | [ref]

Anywhere you are unconditionally including a class file, use require_once. Anywhere you are conditionally including a class file (for example, factory methods), use include_once. Either of these will ensure that class files are included only once. They share the same file list, so you don't need to worry about mixing them - a file included with require_once will not be included again by include_once. Note that include_once and require_once are statements, not functions. Parentheses should not surround the subject filename.

require_once 'PHP/CodeSniffer.php';

require_once('PHP/CodeSniffer.php');

PEAR.Functions.FunctionCallSignature | [ref]

Functions should be called with no spaces between the function name, the opening parenthesis, and the first parameter; and no space between the last parameter, the closing parenthesis, and the semicolon.

$var = foo($bar, $baz, $quux);

$var = foo ( $bar, $baz, $quux ) ;

PEAR.NamingConventions.ValidClassName | [ref]

Classes should be given descriptive names. Avoid using abbreviations where possible. Class names should always begin with an uppercase letter. The PEAR class hierarchy is also reflected in the class name, each level of the hierarchy separated with a single underscore.

Log
Net_Finger
HTML_Upload_Error

log
NetFinger
HTML-Upload-Error

PSR2.Classes.ClassDeclaration | [ref]

There should be exactly 1 space between the abstract or final keyword and the class keyword and between the class keyword and the class name. The extends and implements keywords, if present, must be on the same line as the class name. When interfaces implemented are spread over multiple lines, there should be exactly 1 interface mentioned per line indented by 1 level. The closing brace of the class must go on the first line after the body of the class and must be on a line by itself.

abstract class Foo
{
}

abstract  class  Foo
{
}

PSR2.Classes.PropertyDeclaration | [ref]

Property names should not be prefixed with an underscore to indicate visibility. Visibility should be used to declare properties rather than the var keyword. Only one property should be declared within a statement. The static declaration must come after the visibility declaration.

class Foo
{
    private $bar;
}

class Foo
{
    private $_bar;
}

class Foo
{
    private $bar;
}

class Foo
{
    var $bar;
}

class Foo
{
    private $bar;
    private $baz;
}

class Foo
{
    private $bar, $baz;
}

class Foo
{
    public static $bar;
    private $baz;
}

class Foo
{
    static protected $bar;
}

PSR2.ControlStructures.ElseIfDeclaration | [ref]

PHP's elseif keyword should be used instead of else if.

if ($foo) {
    $var = 1;
} elseif ($bar) {
    $var = 2;
}

if ($foo) {
    $var = 1;
} else if ($bar) {
    $var = 2;
}

PSR2.ControlStructures.SwitchDeclaration | [ref]

Case statements should be indented 4 spaces from the switch keyword. It should also be followed by a space. Colons in switch declarations should not be preceded by whitespace. Break statements should be indented 4 more spaces from the case statement. There must be a comment when falling through from one case into the next.

switch ($foo) {
    case 'bar':
        break;
}

switch ($foo) {
case 'bar':
    break;
}

switch ($foo) {
    case 'bar':
        break;
}

switch ($foo) {
    case'bar':
        break;
}

switch ($foo) {
    case 'bar':
        break;
    default:
        break;
}

switch ($foo) {
    case 'bar' :
        break;
    default :
        break;
}

switch ($foo) {
    case 'bar':
        break;
}

switch ($foo) {
    case 'bar':
    break;
}

switch ($foo) {
    case 'bar':
    // no break
    default:
        break;
}

switch ($foo) {
    case 'bar':
    default:
        break;
}

PSR2.Files.ClosingTag | [ref]

Checks that the file does not end with a closing tag.

<?php
echo 'Foo';

<?php
echo 'Foo';
?>

PSR2.Files.EndFileNewline | [ref]

PHP Files should end with exactly one newline.

PSR2.Methods.FunctionClosingBrace | [ref]

Checks that the closing brace of a function goes directly after the body.

function foo()
{
    echo 'foo';
}

function foo()
{
    echo 'foo';

}

PSR2.Methods.MethodDeclaration | [ref]

Method names should not be prefixed with an underscore to indicate visibility. The static keyword, when present, should come after the visibility declaration, and the final and abstract keywords should come before.

class Foo
{
    private function bar()
    {
    }
}

class Foo
{
    private function _bar()
    {
    }
}

class Foo
{
    final public static function bar()
    {
    }
}

class Foo
{
    static public final function bar()
    {
    }
}

PSR2.Namespaces.NamespaceDeclaration | [ref]

There must be one blank line after the namespace declaration.

namespace \Foo\Bar;

use \Baz;

namespace \Foo\Bar;
use \Baz;

PSR12.Classes.ClassInstantiation | [ref]

When instantiating a new class, parenthesis MUST always be present even when there are no arguments passed to the constructor.

new Foo();

new Foo;

PSR12.Files.FileHeader | [ref]

PSR12.Functions.NullableTypeDeclaration | [ref]

In nullable type declarations there MUST NOT be a space between the question mark and the type.

public function functionName(
    ?string $arg1,
    ?int $arg2
): ?string {
}

public function functionName(
    ? string $arg1,
    ? int $arg2
): ? string {
}

public function foo(?int $arg): ?string
{
}

public function bar(? /* comment */ int $arg): ?
    // nullable for a reason
    string
{
}

PSR12.Functions.ReturnTypeDeclaration | [ref]

For function and closure return type declarations, there must be one space after the colon followed by the type declaration, and no space before the colon.

The colon and the return type declaration have to be on the same line as the argument list closing parenthesis.

$closure = function ( $arg ): string {
   // Closure body.
};

$closure = function ( $arg ):string {
   // Closure body.
};

function someFunction( $arg ): string {
   // Function body.
};

function someFunction( $arg )   : string {
   // Function body.
};

PSR12.Keywords.ShortFormTypeKeywords | [ref]

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

$foo = (bool) $isValid;

$foo = (boolean) $isValid;

PSR12.Traits.UseDeclaration | [ref]

Squiz.Classes.SelfMemberReference | [ref]

The self keyword should be used instead of the current class name, should be lowercase, and should not have spaces before or after it.

self::foo();

SELF::foo();

self::foo();

self :: foo();

class Foo
{
    public static function bar()
    {
    }

    public static function baz()
    {
        self::bar();
    }
}

class Foo
{
    public static function bar()
    {
    }

    public static function baz()
    {
        Foo::bar();
    }
}

Squiz.Commenting.BlockComment | [ref]

Squiz.Commenting.ClassComment | [ref]

Squiz.Commenting.ClosingDeclarationComment | [ref]

Squiz.Commenting.DocCommentAlignment | [ref]

The asterisks in a doc comment should align, and there should be one space between the asterisk and tags.

/**
 * @see foo()
 */

/**
  * @see foo()
*/

/**
 * @see foo()
 */

/**
 *  @see foo()
 */

Squiz.Commenting.EmptyCatchComment | [ref]

Squiz.Commenting.FileComment | [ref]

Squiz.Commenting.FunctionComment | [ref]

Squiz.Commenting.FunctionCommentThrowTag | [ref]

If a function throws any exceptions, they should be documented in a @throws tag.

/**
 * @throws Exception all the time
 * @return void
 */
function foo()
{
    throw new Exception('Danger!');
}

/**
 * @return void
 */
function foo()
{
    throw new Exception('Danger!');
}

Squiz.Commenting.InlineComment | [ref]

Squiz.Commenting.VariableComment | [ref]

Squiz.ControlStructures.ControlSignature | [ref]

Squiz.Functions.FunctionDeclarationArgumentSpacing | [ref]

Squiz.Functions.FunctionDuplicateArgument | [ref]

All PHP built-in functions should be lowercased when called.

if (isset($foo)) {
    echo $foo;
}

if (isSet($foo)) {
    echo $foo;
}

Squiz.Functions.MultiLineFunctionDeclaration | [ref]

Squiz.Operators.IncrementDecrementUsage | [ref]

Squiz.Operators.ValidLogicalOperators | [ref]

Squiz.PHP.CommentedOutCode | [ref]

Squiz.PHP.DisallowMultipleAssignments | [ref]

Squiz.PHP.DisallowSizeFunctionsInLoops | [ref]

Squiz.PHP.EmbeddedPhp | [ref]

Squiz.PHP.Eval | [ref]

Squiz.PHP.NonExecutableCode | [ref]

Squiz.Scope.MethodScope | [ref]

Squiz.Strings.ConcatenationSpacing | [ref]

Squiz.Strings.DoubleQuoteUsage | [ref]

Squiz.WhiteSpace.CastSpacing | [ref]

Casts should not have whitespace inside the parentheses.

$foo = (int)'42';

$foo = ( int )'42';

Squiz.WhiteSpace.ScopeKeywordSpacing | [ref]

The php keywords static, public, private, and protected should have one space after them.

public static function foo()
{
}

public  static  function foo()
{
}

Squiz.WhiteSpace.SemicolonSpacing | [ref]

Semicolons should not have spaces before them.

echo "hi";

echo "hi" ;

Squiz.WhiteSpace.SuperfluousWhitespace | [ref]

Universal.Arrays.DisallowShortArraySyntax | [ref]

The array keyword must be used to define arrays.

$arr = array(
    'foo' => 'bar',
);

$arr = [
    'foo' => 'bar',
];

Universal.Arrays.DuplicateArrayKey | [ref]

When a second array item with the same key is declared, it will overwrite the first. This sniff detects when this is happening in array declarations.

$args = array(
    'foo' => 22,
    'bar' => 25,
    'baz' => 28,
);

$args = array(
    22,
    25,
    2 => 28,
);

$args = array(
    'foo' => 22,
    'bar' => 25,
    'bar' => 28,
);

$args = array(
    22,
    25,
    1 => 28,
);

Universal.Classes.ModifierKeywordOrder | [ref]

Requires that class modifier keywords consistently use the same keyword order.

By default the expected order is "abstract/final readonly", but this can be changed via the sniff configuration.

final readonly class Foo {}
abstract readonly class Bar {}

readonly final class Foo {}
readonly abstract class Bar {}

Universal.Classes.RequireAnonClassParentheses | [ref]

Require the use of parentheses when declaring an anonymous class.

$anon = new class() {};

$anon = new class {};

Universal.CodeAnalysis.ConstructorDestructorReturn | [ref]

A class constructor/destructor can not have a return type declarations. This would result in a fatal error.

class Foo {
    public function __construct() {}
}

class Foo {
    public function __construct(): int {}
}

class Foo {
    public function __construct() {
        // Do something.
    }

    public function __destruct() {
        // Do something.
        return;
    }
}

class Foo {
    public function __construct() {
        // Do something.
        return $this;
    }

    public function __destruct() {
        // Do something.
        return false;
    }
}

Universal.CodeAnalysis.ForeachUniqueAssignment | [ref]

When a foreach control structure uses the same variable for both the $key as well as the $value assignment, the key will be disregarded and be inaccessible and the variable will contain the value. Mix in reference assignments and the behaviour becomes even more unpredictable.

This is a coding error. Either use unique variables for the key and the value or don't assign the key.

foreach ($array as $k => $v ) {}

foreach ($array as $k => $k ) {}

Universal.CodeAnalysis.NoDoubleNegative | [ref]

Detects double negation in code, which is effectively the same as a boolean cast, but with a much higher cognitive load.

$var = $a && ! $b;

if((bool) callMe($a)) {}

$var = $a && ! ! $b;

if(! ! ! callMe($a)) {}

Universal.CodeAnalysis.NoEchoSprintf | [ref]

Detects use of echo [v]sprintf(...);. Use [v]printf() instead.

printf('text %s text', $var);
echo callMe('text %s text', $var);

echo sprintf('text %s text', $var);
echo vsprintf('text %s text', [$var]);

Universal.CodeAnalysis.StaticInFinalClass | [ref]

When a class is declared as final, using the static keyword for late static binding is unnecessary and redundant. This rule also covers using static in a comparison with instanceof, using static for class instantiations or as a return type.

`self` should be used instead.

This applies to final classes, anonymous classes (final by nature) and enums (final by design).

final class Foo
{
    public function myMethod($param) : self
    {
        $var = self::functionCall();
        $var = $obj instanceof self;
        $var = new self;
    }
}

$anon = new class {
    public function myMethod(
    ): int|static|false {
        $var = static::$prop;
        $var = $obj instanceof static;
        $var = new static();
    }
};

Universal.Constants.LowercaseClassResolutionKeyword | [ref]

The "class" keyword when used for class name resolution, i.e. ::class, must be in lowercase.

echo MyClass::class;

echo MyClass::CLASS;

Universal.Constants.ModifierKeywordOrder | [ref]

Requires that constant modifier keywords consistently use the same keyword order.

By default the expected order is "final visibility", but this can be changed via the sniff configuration.

class CorrectOrder {
    final public const FOO = 'foo';
}

class IncorrectOrder {
    #[SomeAttribute]
    protected final const BAR = 'foo';
}

Universal.Constants.UppercaseMagicConstants | [ref]

The PHP native __...__ magic constant should be in uppercase.

echo __LINE__;
include __DIR__ . '/file.php';

echo __NameSpace__;
include dirname(__file__) . '/file.php';

Universal.ControlStructures.DisallowLonelyIf | [ref]

Disallows if statements as the only statement in an else block.

If an `if` statement is the only statement in the `else` block, use `elseif` instead.

if ($foo) {
    // ...
} elseif ($bar) {
    // ...
}

if ($foo) {
    // ...
} else {
    if ($bar) {
        // ...
    }

    doSomethingElse();

}

if ($foo) {
    // ...
} else {
    if ($bar) {
        // ...
    } else {
        // ...
    }
}

Universal.Files.SeparateFunctionsFromOO | [ref]

A file should either declare (global/namespaced) functions or declare OO structures, but not both.

Nested function declarations, i.e. functions declared within a function/method will be disregarded for the purposes of this sniff.
The same goes for anonymous classes, closures and arrow functions.

// Valid1.php
<?php
class Bar {
    public function foo() {}
}

// Valid2.php
<?php
function foo() {}
function bar() {}
function baz() {}

// Invalid.php
<?php
function foo() {}

class Bar {
    public function foo() {}
}

function bar() {}
function baz() {}

Universal.Namespaces.DisallowCurlyBraceSyntax | [ref]

Namespace declarations using the curly brace syntax are not allowed.

namespace Vendor\Project\Sub;

// Code

namespace Vendor\Project\Scoped {
    // Code.
}

Universal.Namespaces.DisallowDeclarationWithoutName | [ref]

Namespace declarations without a namespace name are not allowed.

namespace Vendor\Name {
}

namespace {
}

Universal.Namespaces.OneDeclarationPerFile | [ref]

There should be only one namespace declaration per file.

namespace Vendor\Project\Sub;

namespace Vendor\Project\Sub\A {
}

namespace Vendor\Project\Sub\B {
}

Universal.NamingConventions.NoReservedKeywordParameterNames | [ref]

It is recommended not to use reserved keywords as parameter names as this can become confusing when people use them in function calls using named parameters.

function foo( $input, $description ) {}

function foo( $string, $echo = true ) {}

Universal.Operators.DisallowShortTernary | [ref]

Using short ternaries is not allowed.

While short ternaries are useful when used correctly, the principle of them is often misunderstood and they are more often than not used incorrectly, leading to hard to debug issues and/or PHP warnings/notices.

echo !empty($a) ? $a : 'default';

echo !empty($a) ?: 'default';
echo $a ? : 'default';

Universal.Operators.DisallowStandalonePostIncrementDecrement | [ref]

In a stand-alone in/decrement statement, pre-in/decrement should always be favoured over post-in/decrement.

This reduces the chance of bugs when code gets moved around.

++$i;
--$j;

$i++;
$j--;

++$i;

--$i++++;

Universal.Operators.StrictComparisons | [ref]

Using loose comparisons is not allowed.

Loose comparisons will type juggle the values being compared, which often results in bugs.

if ($var === 'text') {}

if ($var !== true) {}

if ($var == 'text') {}

if ($var != true) {}

Universal.Operators.TypeSeparatorSpacing | [ref]

There should be no spacing around the union type separator or the intersection type separator.

This applies to all locations where type declarations can be used, i.e. property types, parameter types and return types.

function foo(
    int|string $paramA,
    TypeA&TypeB $paramB
): int|false {}

function foo(
    int | string $paramA,
    TypeA & TypeB $paramB
): int
   |
   false {}

Universal.PHP.LowercasePHPTag | [ref]

Enforces that the PHP open tag is lowercase.

<?php
echo 'hello!';

<?PHP
echo 'hello!';

Universal.UseStatements.DisallowMixedGroupUse | [ref]

Disallow group use statements which combine imports for namespace/OO, functions and/or constants in one statement.

use Some\NS\ {
    ClassName,
    AnotherClass,
};
use function Some\NS\ {
    SubLevel\functionName,
    SubLevel\AnotherFunction,
};
use const Some\NS\ {
    Constants\MY_CONSTANT as SOME_CONSTANT,
};

use Some\NS\ {
    ClassName,
    function SubLevel\functionName,
    const MY_CONSTANT as SOME_CONSTANT,
    function SubLevel\AnotherName,
    AnotherLevel,
};

Universal.UseStatements.KeywordSpacing | [ref]

Enforce a single space after the use, function, const keywords and both before and after the as keyword in import use statements.

use function strpos;
use const PHP_EOL as MY_EOL;

use    function   strpos;
use
  const
  PHP_EOL
  as
  MY_EOL;

Universal.UseStatements.LowercaseFunctionConst | [ref]

function and const keywords in import use statements should be in lowercase.

use function strpos;
use const PHP_EOL;

use Function strpos;
use CONST PHP_EOL;

Universal.UseStatements.NoLeadingBackslash | [ref]

Import use statements must never begin with a leading backslash as they should always be fully qualified.

use Package\ClassName;

use \Package\ClassName;

Universal.UseStatements.NoUselessAliases | [ref]

Detects useless aliases for import use statements.

Aliasing something to the same name as the original construct is considered useless.
Note: as OO and function names in PHP are case-insensitive, aliasing to the same name, using a different case is also considered useless.

use Vendor\Package\ClassName as AnotherName;
use function functionName as my_function;
use const SOME_CONSTANT as MY_CONSTANT;

use Vendor\Package\ClassName as ClassName;
use function functionName as FunctionName;
use const SOME_CONSTANT as SOME_CONSTANT;

Universal.WhiteSpace.AnonClassKeywordSpacing | [ref]

Checks the spacing between the "class" keyword and the open parenthesis for anonymous classes with parentheses.

The desired amount of spacing is configurable and defaults to no space.

$foo = new class($param)
{
    public function __construct($p) {}
};

$foo = new class ($param)
{
    public function __construct($p) {}
};

Universal.WhiteSpace.CommaSpacing | [ref]

There should be no space before a comma and exactly one space, or a new line, after a comma.

The sniff makes the following exceptions to this rule:
1. A comma preceded or followed by a parenthesis, curly or square bracket.
   These will not be flagged to prevent conflicts with sniffs handling spacing around braces.
2. A comma preceded or followed by another comma, like for skipping items in a list assignment.
   These will not be flagged.
3. A comma preceded by a non-indented heredoc/nowdoc closer.
   In that case, unless the `php_version` config directive is set to a version higher than PHP 7.3.0,
   a new line before will be enforced to prevent parse errors on PHP < 7.3.

isset($param1, $param2, $param3);

function_call(
    $param1,
    $param2,
    $param3
);

$array = array($item1, $item2, $item3);
$array = [
    $item1,
    $item2,
];

list(, $a, $b,,) = $array;
list(
    ,
    $a,
    $b,
) = $array;

unset($param1  ,   $param2,$param3);

function_call(
    $a
    ,$b
    ,$c
);

$array = array($item1,$item2  ,  $item3);
$array = [
    $item1,
    $item2  ,
];

list( ,$a, $b  ,,) = $array;
list(
    ,
    $a,
    $b  ,
) = $array;

function_call(
    $param1, // Comment.
    $param2, /* Comment. */
);

function_call(
    $param1 // Comment.
    ,
    $param2 /* Comment. */,
);

Universal.WhiteSpace.DisallowInlineTabs | [ref]

Spaces must be used for mid-line alignment.

$title[space]= 'text';
$text[space][space]= 'more text';

$title[tab]= 'text';
$text[tab]= 'more text';

Universal.WhiteSpace.PrecisionAlignment | [ref]

Detects when the indentation is not a multiple of a tab-width, i.e. when precision alignment is used.

// Code samples presume tab width = 4.
[space][space][space][space]$foo = 'bar';

[tab]$foo = 'bar';

// Code samples presume tab width = 4.
[space][space]$foo = 'bar';

[tab][space]$foo = 'bar';

WordPress.Arrays.ArrayDeclarationSpacing | [ref]

WordPress.Arrays.ArrayIndentation | [ref]

The array closing bracket indentation should line up with the start of the content on the line containing the array opener.

$args = array(
    'post_id' => 22,
);

$args = array(
    'post_id' => 22,
        );

$args = array(
    'post_id'       => 22,
    'comment_count' => array(
        'value'   => 25,
        'compare' => '>=',
    ),
    'post_type' => array(
        'post',
        'page',
    ),
);

$args = array(
    'post_id'       => 22,
    'comment_count' => array(
    'value'   => 25,
    'compare' => '>=',
    ),
    'post_type' => array(
    'post',
    'page',
    ),
);

$args = array(
    'phrase' => 'start of phrase'
        . 'concatented additional phrase'
        . 'more text',
);

$args = array(
    'phrase' => 'start of phrase'
. 'concatented additional phrase'
. 'more text',
);

$text = array(
    <<<EOD
    start of phrase
    concatented additional phrase
    more text
EOD
    ,
);

$text = array(
<<<EOD
    start of phrase
    concatented additional phrase
    more text
EOD
,
);

WordPress.Arrays.ArrayKeySpacingRestrictions | [ref]

When referring to array items, only include a space around the index if it is a variable or the key is concatenated.

$post       = $posts[ $post_id ];
$post_title = $post[ 'concatenated' . $title ];
$post       = $posts[ HOME_PAGE ];
$post       = $posts[123];
$post_title = $post['post_title'];

$post       = $posts[$post_id];
$post_title = $post['concatenated' . $title ];
$post       = $posts[HOME_PAGE];
$post       = $posts[ 123 ];
$post_title = $post[ 'post_title' ];

WordPress.Arrays.MultipleStatementAlignment | [ref]

When declaring arrays, there should be one space on either side of a double arrow operator used to assign a value to a key.

$foo = array( 'cat' => 22 );
$bar = array( 'year' => $current_year );

$foo = array( 'cat'=>22 );
$bar = array( 'year'=>   $current_year );

$args = array(
    'cat'      => 22,
    'year'     => $current_year,
    'monthnum' => $current_month,
);

$args = array(
    'cat' => 22,
    'year' => $current_year,
    'monthnum' => $current_month,
);

WordPress.CodeAnalysis.AssignmentInTernaryCondition | [ref]

WordPress.CodeAnalysis.EscapedNotTranslated | [ref]

Text intended for translation needs to be wrapped in a localization function call. This sniff will help you find instances where text is escaped for output, but no localization function is called, even though an (unexpected) text domain argument is passed to the escape function.

echo esc_html__( 'text', 'domain' );

echo esc_html( 'text', 'domain' );

WordPress.DateTime.CurrentTimeTimestamp | [ref]

Don't use current_time() to get a timestamp as it doesn't produce a Unix (UTC) timestamp, but a "WordPress timestamp", i.e. a Unix timestamp with current timezone offset.

$timestamp = time();

$timestamp = current_time( 'timestamp', true );

$timestamp = current_time( 'Y-m-d' );

$timestamp = current_time( 'U', false );

WordPress.DateTime.RestrictedFunctions | [ref]

The restricted functions date_default_timezone_set() and date() should not be used. Using the PHP native date_default_timezone_set() function isn't allowed, because WordPress Core needs the default time zone to be set to UTC for timezone calculations using the WP Core API to work correctly.

$date = new DateTime();
$date->setTimezone(
    new DateTimeZone( 'Europe/Amsterdam' )
);

date_default_timezone_set( 'Europe/Amsterdam' );

$last_updated = gmdate(
    'Y-m-d\TH:i:s',
    strtotime( $plugin['last_updated'] )
);

$last_updated = date(
    'Y-m-d\TH:i:s',
    strtotime( $plugin['last_updated'] )
);

WordPress.DB.DirectDatabaseQuery | [ref]

WordPress.DB.PreparedSQL | [ref]

WordPress.DB.PreparedSQLPlaceholders | [ref]

WordPress.DB.RestrictedClasses | [ref]

WordPress.DB.RestrictedFunctions | [ref]

WordPress.DB.SlowDBQuery | [ref]

WordPress.Files.FileName | [ref]

WordPress.NamingConventions.PrefixAllGlobals | [ref]

All globals terms must be prefixed with a theme/plugin specific term. Global terms include Namespace names, Class/Interface/Trait/Enum names (when not namespaced), Functions (when not namespaced or in an OO structure), Constants/Variable names declared in the global namespace, and Hook names.

A prefix must be distinct and unique to the plugin/theme, in order to prevent potential conflicts with other plugins/themes and with WordPress itself.

The prefix used for a plugin/theme may be chosen by the developers and should be defined in a custom PHPCS ruleset to allow for this sniff to verify that the prefix is consistently used.
Prefixes will be treated in a case-insensitive manner.
https://github.com/WordPress/WordPress-Coding-Standards/wiki/Customizable-sniff-properties#naming-conventions-prefix-everything-in-the-global-namespace

define( 'ECPT_VERSION', '1.0' );

$ecpt_admin = new ECPT_Admin_Page();

class ECPT_Admin_Page {}

apply_filter(
    'ecpt_modify_content',
    $ecpt_content
);

define( 'PLUGIN_VERSION', '1.0' );

$admin = new Admin_Page();

class Admin_Page {}

apply_filter(
    'modify_content',
    $content
);

namespace ECPT_Plugin\Admin;

// Constants declared using `const` will
// be namespaced and therefore prefixed.
const VERSION = 1.0;

// A class declared in a (prefixed) namespace
// is automatically prefixed.
class Admin_Page {}

// Variables in a namespaced file are not
// namespaced, so still need prefixing.
$ecpt_admin = new Admin_Page();

// Hook names are not subject to namespacing.
apply_filter(
    'ecpt_modify_content',
    $ecpt_content
);

namespace Admin;

// As the namespace is not prefixed, this
// is still bad.
const VERSION = 1.0;

// As the namespace is not prefixed, this
// is still bad.
class Admin_Page {}

function mycoolplugin_save_post() {}

function wp_save_post() {}

interface MyPluginIsCool {}

interface My {}

WordPress.NamingConventions.ValidFunctionName | [ref]

WordPress.NamingConventions.ValidHookName | [ref]

Use lowercase letters in action and filter names. Separate words using underscores.

do_action( 'prefix_hook_name', $var );

do_action( 'Prefix_Hook_NAME', $var );

apply_filters( 'prefix_hook_name', $var );

apply_filters( 'prefix\hook-name', $var );

WordPress.NamingConventions.ValidPostTypeSlug | [ref]

The post type slug used in register_post_type() must be between 1 and 20 characters.

register_post_type(
    'my_short_slug',
    array()
);

register_post_type(
    'my_own_post_type_too_long',
    array()
);

register_post_type(
    'my_post_type_slug',
    array()
);

register_post_type(
    'my/post/type/slug',
    array()
);

register_post_type(
    'my_post_active',
    array()
);

register_post_type(
    "my_post_{$status}",
    array()
);

register_post_type(
    'prefixed_author',
    array()
);

register_post_type(
    'author',
    array()
);

register_post_type(
    'prefixed_author',
    array()
);

register_post_type(
    'wp_author',
    array()
);

WordPress.NamingConventions.ValidVariableName | [ref]

WordPress.PHP.DevelopmentFunctions | [ref]

WordPress.PHP.DiscouragedPHPFunctions | [ref]

WordPress.PHP.DontExtract | [ref]

WordPress.PHP.IniSet | [ref]

Using ini_set() and similar functions for altering PHP settings at runtime is discouraged. Changing runtime configuration might break other plugins and themes, and even WordPress itself.

// ini_set() should not be used.

ini_set( 'short_open_tag', 'off' );

wp_raise_memory_limit();

ini_set( 'memory_limit', '256M' );

WordPress.PHP.NoSilencedErrors | [ref]

WordPress.PHP.POSIXFunctions | [ref]

WordPress.PHP.PregQuoteDelimiter | [ref]

WordPress.PHP.RestrictedPHPFunctions | [ref]

WordPress.PHP.StrictInArray | [ref]

When using functions which compare a value to a range of values in an array, make sure a strict comparison is executed.

Typically, this rule verifies function calls to the PHP native `in_array()`, `array_search()` and `array_keys()` functions pass the `$strict` parameter.

$array = array( '1', 1, true );
if ( in_array( $value, $array, true ) ) {}

$array = array( '1', 1, true );
if ( in_array( $value, $array ) ) {}

$key = array_search( 1, $array, true );

$key = array_search( 1, $array );

$keys = array_keys( $array, $key, true );

$keys = array_keys( $array, $key );

WordPress.PHP.TypeCasts | [ref]

WordPress.PHP.YodaConditions | [ref]

When doing logical comparisons involving variables, the variable must be placed on the right side. All constants, literals, and function calls must be placed on the left side. If neither side is a variable, the order is unimportant.

if ( true === $the_force ) {
    $victorious = you_will( $be );
}

if ( $the_force === false ) {
    $victorious = you_will_not( $be );
}

WordPress.Security.EscapeOutput | [ref]

WordPress.Security.NonceVerification | [ref]

WordPress.Security.PluginMenuSlug | [ref]

WordPress.Security.SafeRedirect | [ref]

wp_safe_redirect() should be used whenever possible to prevent open redirect vulnerabilities. One of the main uses of an open redirect vulnerability is to make phishing attacks more credible. In this case the user sees your (trusted) domain and might get redirected to an attacker controlled website aimed at stealing private information.

wp_safe_redirect( $location );

wp_redirect( $location );

WordPress.Security.ValidatedSanitizedInput | [ref]

WordPress.Utils.I18nTextDomainFixer | [ref]

WordPress.WhiteSpace.CastStructureSpacing | [ref]

A type cast should be preceded by whitespace. There is only one exception to this rule: when the cast is preceded by the spread operator there should be no space between the spread operator and the cast.

$a = (int) '420';

// No space between spread operator and cast.
$a = function_call( ...(array) $mixed );

$a =(int) '420';

WordPress.WhiteSpace.ControlStructureSpacing | [ref]

Put one space on both sides of the opening and closing parentheses of control structures.

while ( have_posts() ) {}

// For multi-line conditions,
// a new line is also accepted.
if ( true === $condition
    && $count > 10
) {}

// No spaces.
while(have_posts()){}

// Too much space.
while   (   have_posts()   )   {}

try {
    // Do something.
} catch (
    ExceptionA | ExceptionB $e
) {
}

try
{
    // Do something.
} catch ( Exception $e )
(
}

if ( $condition ) {
    // Do something.
}

if ( $condition )     {
    // Do something.
}

foreach ( $types as $type ) :
    // Do something.
endforeach;

foreach ( $types as $type ):
    // Do something.
endforeach;

if ( $a === $b ) {
    if ( $something ) {
        // Do something.
    }
}

if ( $a === $b ) {
    if ( $something ) {
        // Do something.
    }


}

if ( $a === $b ) {
    echo $a;
}

if ( $a === $b ) {


    echo $a;


}

WordPress.WhiteSpace.ObjectOperatorSpacing | [ref]

The object operators (->, ?->, ::) should not have any spaces around them, though new lines are allowed except for use with the ::class constant.

$foo->bar();

$foo  ?->  bar();

WordPress.WhiteSpace.OperatorSpacing | [ref]

Always put one space on both sides of logical, comparison and concatenation operators. Always put one space after an assignment operator.

if ( $a === $b && $b === $c ) {}
if ( ! $var ) {}

// Too much space.
if ( $a === $b   &&   $b ===      $c ) {}
if (  ! $var ) {}

// Too little space.
if ( $a===$b &&$b ===$c ) {}
if ( !$var ) {}

if ( $a === $b
    && $b === $c
) {}

if ( $a === $b
    &&     $b === $c
) {}

$a   = 'foo';
$all = 'foobar';

$a   =     'foo';
$all ='foobar';

WordPress.WP.AlternativeFunctions | [ref]

WordPress.WP.Capabilities | [ref]

Capabilities passed should be valid capabilities (custom capabilities can be added in the ruleset).

if ( author_can( $post, 'manage_sites' ) ) { }

map_meta_cap( 'manage_site', $user->ID );

add_options_page(
    esc_html__( 'Options', 'textdomain' ),
    esc_html__( 'Options', 'textdomain' ),
    'manage_options',
    'options_page_slug',
    'project_options_page_cb'
);

add_options_page(
    esc_html__( 'Options', 'textdomain' ),
    esc_html__( 'Options', 'textdomain' ),
    'author',
    'options_page_slug',
    'project_options_page_cb'
);

if ( author_can( $post, 'read' ) ) { }

if ( author_can( $post, 'level_6' ) ) { }

WordPress.WP.CapitalPDangit | [ref]

The correct spelling of "WordPress" should be used in text strings, comments and object names.

In select cases, when part of an identifier or a URL, WordPress does not have to be capitalized.

class WordPress_Example {

    /**
     * This function is about WordPress.
     */
    public function explain() {
        echo 'This is an explanation
            about WordPress.';
    }
}

class Wordpress_Example {

    /**
     * This function is about Wordpress.
     */
    public function explain() {
        echo 'This is an explanation
            about wordpress.';
    }
}

WordPress.WP.ClassNameCase | [ref]

It is strongly recommended to refer to WP native classes by their properly cased name.

$obj = new WP_Query;

$obj = new wp_query;

WordPress.WP.CronInterval | [ref]

Cron schedules running more often than once every 15 minutes are discouraged. Crons running that frequently can negatively impact the performance of a site.

function adjust_schedules( $schedules ) {
    $schedules['every_hour'] = array(
        'interval' => HOUR_IN_SECONDS,
        'display'  => __( 'Every hour' )
    );
    return $schedules;
}

add_filter(
    'cron_schedules',
    'adjust_schedules'
);

function adjust_schedules( $schedules ) {
    $schedules['every_9_mins'] = array(
        'interval' => 9 * 60,
        'display'  => __( 'Every 9 minutes' )
    );
    return $schedules;
}

add_filter(
    'cron_schedules',
    'adjust_schedules'
);

WordPress.WP.DeprecatedClasses | [ref]

Please refrain from using deprecated WordPress classes.

$a = new WP_User_Query();

$a = new WP_User_Search(); // Deprecated WP 3.1.

WordPress.WP.DeprecatedFunctions | [ref]

Please refrain from using deprecated WordPress functions.

$sites = get_sites();

$sites = wp_get_sites(); // Deprecated WP 4.6.

WordPress.WP.DeprecatedParameters | [ref]

Please refrain from passing deprecated WordPress function parameters. In case, you need to pass an optional parameter positioned after the deprecated parameter, only ever pass the default value.

// First - and only - parameter deprecated.
get_the_author();

// First - and only - parameter deprecated.
get_the_author( $string );

// Third parameter deprecated in WP 2.3.0.
add_option( 'option_name', 123, '', 'yes' );

// Third parameter deprecated in WP 2.3.0.
add_option( 'my_name', 123, 'oops', 'yes' );

WordPress.WP.DeprecatedParameterValues | [ref]

Please refrain from using deprecated WordPress function parameter values.

bloginfo( 'url' );

bloginfo ( 'home' ); // Deprecated WP 2.2.0.

WordPress.WP.DiscouragedConstants | [ref]

WordPress.WP.DiscouragedFunctions | [ref]

WordPress.WP.EnqueuedResourceParameters | [ref]

The resource version must be set, to prevent the browser from using an outdated, cached version after the resource has been updated.

wp_register_style(
    'someStyle-css',
    $path_to_local_file,
    array(),
    '1.0.0'
);

wp_register_style(
    'someStyle-css',
    $path_to_local_file,
    array()
);

wp_enqueue_script(
    'someScript-js',
    $path_to_local_file,
    array( 'jquery' ),
    '1.0.0',
    true
);

wp_enqueue_script(
    'someScript-js',
    $path_to_local_file,
    array( 'jquery' ),
    false,
    true
);

Loading scripts in the header blocks parsing of the page and has a negative impact on load times. However, loading in the footer may break compatibility when other scripts rely on the resource to be available at any time.
In that case, you can pass `false` to make it explicit that the script should be loaded in the header of the page.

wp_register_script(
    'someScript-js',
    $path_to_local_file,
    array( 'jquery' ),
    '1.0.0',
    true
);

wp_register_script(
    'someScript-js',
    $path_to_local_file,
    array( 'jquery' ),
    '1.0.0'
);

WordPress.WP.EnqueuedResources | [ref]

Scripts must be registered/enqueued via wp_enqueue_script().

wp_enqueue_script(
    'someScript-js',
    $path_to_file,
    array( 'jquery' ),
    '1.0.0',
    true
);

printf(
    '<script src="%s"></script>',
    esc_url( $path_to_file )
);

wp_enqueue_style(
    'style-name',
    $path_to_file,
    array(),
    '1.0.0'
);

printf(
    '<link rel="stylesheet" href="%s" />',
    esc_url( $path_to_file )
);

WordPress.WP.GlobalVariablesOverride | [ref]

WordPress.WP.I18n | [ref]

WordPress.WP.PostsPerPage | [ref]

Using "posts_per_page" or "numberposts" with the value set to an high number opens up the potential for making requests slow if the query ends up querying thousands of posts.

You should always fetch the lowest number possible that still gives you the number of results you find acceptable.

$args = array(
    'posts_per_page' => -1,
);
$args = array(
    'posts_per_page' => 100,
);
$args = array(
    'posts_per_page' => '10',
);

$query_args['posts_per_page'] = 100;

_query_posts( 'nopaging=1&posts_per_page=50' );

$args = array(
    'posts_per_page' => 101,
);

$query_args['posts_per_page'] = 200;

_query_posts( 'nopaging=1&posts_per_page=999' );

$args = array(
    'numberposts' => -1,
);
$args = array(
    'numberposts' => 100,
);
$args = array(
    'numberposts' => '10',
);

$query_args['numberposts'] = '-1';

_query_posts( 'numberposts=50' );

$args = array(
    'numberposts' => 101,
);

$query_args['numberposts'] = '200';

_query_posts( 'numberposts=999' );