php-coding-standards
Invoke BEFORE writing PHP code. Provides coding standards and naming conventions.
When & Why to Use This Skill
This Claude skill serves as a comprehensive PHP development authority, enforcing the Nette Coding Standard and PSR-12 conventions. It ensures high-quality, maintainable code by providing strict guidelines on type safety, naming conventions, and formatting—such as mandatory strict types, tab indentation, and specific architectural patterns—to streamline the development workflow and reduce technical debt.
Use Cases
- Standardizing PHP Codebases: Ensuring all team members follow uniform naming conventions and formatting rules (like tab indentation and method spacing) for better collaboration.
- Enforcing Type Safety: Automatically applying 'declare(strict_types=1)' and ensuring all properties, parameters, and return values are properly typed to prevent runtime errors.
- Modernizing Legacy Code: Refactoring older PHP scripts to use modern syntax, such as named arguments, arrow functions, and concise null-coalescing expressions.
- Automated Style Compliance: Providing a pre-coding checklist that aligns with Nette and PSR-12 standards, including specific rules for interface naming and global function imports.
| name | php-coding-standards |
|---|---|
| description | Invoke BEFORE writing PHP code. Provides coding standards and naming conventions. |
PHP Coding Standards
Using nette/coding-standard
Install globally using the /install-nette-cs command.
After installation, PHP files are automatically checked when edited. Do not run ecs manually.
General Rules
- Every PHP file must include
declare(strict_types=1) - Use two empty lines between methods for better readability
- Document shut-up operator use:
@mkdir($dir); // @ - directory may already exist - Document weak comparison operators:
// == accept null - Multiple exceptions can be written in a single
exceptions.phpfile - Interface methods don't need visibility as they're always public
- All properties, return values, and parameters must have types
- Final constants don't need types as they're self-evident
- Use single quotes for strings unless containing apostrophes
- Write all code, comments, variables etc. in English only! (even if you communicate with me in chat in Czech)
Naming Conventions
- Avoid abbreviations unless full name is too long
- Use UPPERCASE for two-letter abbreviations, PascalCase/camelCase for longer ones
- Use nouns or noun phrases for class names
- Class names should include both specificity and generality (e.g.,
ArrayIterator) - Use PascalCaps for class constants and enums
- Never use prefixes/suffixes like
Abstract,Interface, orIfor interfaces/abstract classes - PascalCase for classes, camelCase for methods/properties
Formatting
- Use TABS for indentation (Everywhere! V PHP, JS, HTML, CSS/SCSS, NEON, ...)
- Prefer to use single quotes (except for HTML)
- PHP follows Nette Coding Standard (based on PSR-12) with these modifications:
- No space before parentheses in arrow functions:
fn($a) => $b - No blank lines required between different
useimport types - Return type and opening brace on separate lines:
- No space before parentheses in arrow functions:
public function example(
string $param,
array $options,
):
// method body
}
Global Functions and Constants
- Write global functions/constants without leading backslash:
count($arr)not\count($arr) - For compiler-optimizable functions, add
use functionat the file beginning:use Nette; use function count, is_array, is_scalar, sprintf; - Occasionally import constants that may help the compiler:
use const PHP_OS_FAMILY;
Other rules
- Use try/catch for external operations
- Prefer modern PHP syntax and concise expressions
- Example: Use
if (is_array($response['data'] ?? null))instead ofif (isset($response['data']) && is_array($response['data']))
- Example: Use
- Uses DOM API with HTML5 parser Lexbor
- Use named arguments for boolean parameters whose meaning isn't obvious from context (e.g.,
is_a($obj, $class, allow_string: true)), but not when the method name makes it clear (e.g.,setReadonly(true)) - Place interface/base class outside the namespace containing its implementations (e.g.,
Foo\Networknext toFoo\Networks\*, not inside it)