PSR Standards: Why Standards Matter in PHP

What is PSR?

PSR stands for PHP Standards Recommendations. They are specifications created by the PHP-FIG (Framework Interop Group) to standardize how PHP code is written.

Why Standards Matter

Without standards:          With standards:

Team A uses tabs            Everyone uses same style
Team B uses spaces          Code looks identical across
Team C uses camelCase        projects and teams
Team D uses snake_case       Libraries work together
Libraries can't integrate    Easy to switch projects
New developers struggle      Quick onboarding

Key PSR Standards

Benefits of PSR Standards

1. INTEROPERABILITY
   Libraries following PSR standards work together seamlessly
   A PSR-4 autoloader loads any PSR-4 compliant package

2. CONSISTENCY
   Code looks the same regardless of who wrote it
   Easier to read and maintain

3. REUSABILITY
   Code can be extracted into packages
   Packages can be shared via Composer

4. COLLABORATION
   Teams can work together without style debates
   Focus on logic, not formatting

5. TOOLING
   Static analyzers (PHPStan, Psalm) work better
   Code formatters (PHP-CS-Fixer) can auto-fix style

PSR Compliance in Magento

<?php
// Magento follows PSR-1: One class per file
// File: Product.php contains only Product class

class Product
{
    // Magento follows PSR-12: Proper formatting
    private string $name;      // Visibility declared
    private float $price;      // Type declared

    public function __construct(
        string $name,
        float $price
    ) {
        $this->name = $name;
        $this->price = $price;
    }

    // Magento follows PSR-4: Namespace matches directory
    // Vendor\Module\Model\Product -> Model/Product.php
}

Where to Learn More

Official PSR website: https://www.php-fig.org/psr/

PSR-1:   https://www.php-fig.org/psr/psr-1/
PSR-4:   https://www.php-fig.org/psr/psr-4/
PSR-12:  https://www.php-fig.org/psr/psr-12/
PSR-7:   https://www.php-fig.org/psr/psr-7/

Key Takeaway

PSR standards ensure PHP code is consistent, interoperable, and maintainable. Magento follows PSR-1, PSR-4, PSR-12, and other standards. Understanding these standards makes you a better PHP developer.

PSR-1: Basic Coding Standard

<?php
// PSR-1 Rules:

// 1. Files must use <?php or <?= tags
// 2. Files must use UTF-8 without BOM
// 3. Files should either declare symbols or have side effects
//    (not both)

// 4. Class names MUST be declared in StudlyCaps
nclass ProductRepository {}  // Correct
nclass productRepository {}  // Wrong

// 5. Class constants MUST be declared in upper case
nclass Status
{
    const ACTIVE = 1;    // Correct
    const active = 1;    // Wrong
}

// 6. Method names MUST be declared in camelCase
nclass Product
{
    public function getPrice() {}   // Correct
    public function get_price() {}  // Wrong
}

PSR-4: Autoloading

<?php
// PSR-4 Rules:

// 1. Namespace prefix maps to base directory
// 2. Subdirectories follow namespace segments
// 3. Class name matches filename (case-sensitive)
// 4. One class per file

// composer.json:
// "autoload": {
//     "psr-4": {
//         "Vendor\\Module\\": "src/"
//     }
// }

// Vendor\Module\Product
// -> src/Product.php

// Vendor\Module\Helper\Data
// -> src/Helper/Data.php

// Vendor\Module\Model\ResourceModel\Product\Collection
// -> src/Model/ResourceModel/Product/Collection.php

PSR-12: Extended Coding Style

<?php
// PSR-12 Rules:

// 1. Code MUST use 4 spaces for indenting
// 2. There MUST NOT be a hard limit on line length
// 3. There MUST be one blank line after namespace declaration
// 4. There MUST be one use keyword per declaration
// 5. There MUST be one blank line after the use block

namespace Vendor\Module\Model;

use Magento\Framework\Model\AbstractModel;       // One per line
use Magento\Catalog\Api\ProductRepositoryInterface;
use Psr\Log\LoggerInterface;

class Product extends AbstractModel
{
    // 6. Visibility MUST be declared on all properties and methods
    private string $name;
    private float $price;

    // 7. Method and function arguments with default values MUST go at end
    public function __construct(
        string $name,
        float $price,
        string $sku = ''     // Default at end
    ) {
        $this->name = $name;
        $this->price = $price;
    }

    // 8. Method braces MUST go on the next line
    // 9. Method body MUST be on the next line after opening brace
    public function getFormattedPrice(): string
    {
        return '\$' . number_format($this->price, 2);
    }

    // 10. Control structure keywords MUST have one space after
    if ($this->price > 0) {
        return true;
    }

    // 11. Opening braces for control structures go on same line
    // 12. Opening braces for classes and methods go on next line
}

PSR-7: HTTP Messages

<?php
// PSR-7 defines interfaces for HTTP requests and responses
// Used by Magento for API and middleware

use Psr\Http\Message\RequestInterface;
use Psr\Http\Message\ResponseInterface;
use Psr\Http\Message\UriInterface;

// Request interface
$request->getMethod();       // GET, POST, etc.
$request->getUri();          // URI object
$request->getHeaders();     // Array of headers
$request->getBody();        // Stream body

// Response interface
$response->getStatusCode();  // 200, 404, etc.
$response->getHeaders();    // Array of headers
$response->getBody();       // Stream body

// URI interface
$uri->getScheme();   // https
$uri->getHost();     // magento-store.com
$uri->getPath();     // /catalog/product
$uri->getQuery();    // id=123

Key Takeaway

PSR-1: Basic naming conventions. PSR-4: Namespace-to-directory mapping. PSR-12: Detailed formatting rules. PSR-7: HTTP message interfaces. Magento follows all of these.