Master PHP Naming Conventions to Boost Code Readability and Maintainability

In PHP development, good naming conventions are the foundation of code readability, maintainability, and team collaboration. A chaotic naming style quickly makes code hard to understand, while a unified set of rules keeps it clear like prose.

1. General Basic Principles

Before diving into specific rules, understand two universal principles:

Clear intent: the name should explicitly indicate its purpose. Example: $d and $daysSinceCreation, the latter is self‑explanatory.

Consistency: use the same naming style throughout the project or team. If you choose camelCase, apply it everywhere.

2. Variable and Function Naming

Variables and functions are the most common elements; they should follow snake_case or camelCase.

Recommended style: snake_case, the most popular in the PHP community (e.g., Laravel, Symfony). Words are separated by underscores.

// Variables
$user_name = 'John Doe';
$is_logged_in = true;
$total_item_count = 42;

// Function
function get_user_profile($user_id) {
    // ...
}

function calculate_total_price($items) {
    // ...
}

// Class method
class UserController {
    public function update_profile() {
        // ...
    }
}

Optional style: camelCase, acceptable if your team historically uses it. Variable and function names start with a lowercase letter, subsequent words capitalized.

// Variables
$userName = 'John Doe';
$isLoggedIn = true;

// Function
function getUserProfile($userId) {
    // ...
}

Practical Tips

For boolean variables, use prefixes like is_, has_, can_ (e.g., $is_valid, $has_permission).

Function names should start with a verb describing the action, such as create_order() or validate_email().

3. Class and Interface Naming

Classes, interfaces, traits, and enums should use PascalCase. This rule is widely accepted in the PHP community.

Rule: capitalize the first letter of each word, no underscores.

// Class
class UserProfile {
    // ...
}

class DatabaseConnection {
    // ...
}

// Interface
interface LoggerInterface {
    // ...
}

// Trait
trait LoggableTrait {
    // ...
}

// Enum (PHP 8.1+)
enum OrderStatus {
    case PENDING;
    case PAID;
    case SHIPPED;
}

Note: PSR‑1 recommends adding an Interface suffix to interfaces (e.g., LoggerInterface) and a Trait suffix to traits (e.g., LoggableTrait) to improve clarity.

4. Constant Naming

Constants, both class and global, should use uppercase snake_case.

// Global constants
define('APP_VERSION', '1.0.0');
define('MAX_LOGIN_ATTEMPTS', 5);

// Class constant
class MathUtility {
    public const PI = 3.14159;
    public const DEFAULT_PAGINATION_LIMIT = 25;
}

5. Naming to Avoid

Single‑letter variables, except for short loop counters like $i or $j, should be avoided.

Useless type prefixes such as $strName or $arrItems; the name should describe “what it is”, not “what type it is”.

Mixing pinyin and English; stick to a single language, preferably accurate English words.

6. Follow Industry Standards: PSR

The PHP Framework Interop Group (PHP‑FIG) defines a series of coding standards called PSR. Following PSR keeps your code consistent with major frameworks and the community.

PSR‑1: Basic coding standard – requires class names to use PascalCase, class constants to use uppercase snake_case, and method names to use camelCase.

PSR‑12: Extended coding style guide – builds on PSR‑1 and PSR‑2, detailing formatting for files, namespaces, classes, methods, control structures, etc.

Conclusion

A solid naming convention is a hallmark of professional PHP developers. Remember these key points to instantly improve code quality:

Variables/functions: prefer snake_case ( $user_name, get_user_data).

Classes/interfaces: must use PascalCase ( UserController, LoggerInterface).

Constants: must use uppercase snake_case ( MAX_SIZE, STATUS_ACTIVE).

Core principle: aim for clear intent, maintain team consistency, and follow PSR standards whenever possible.