O que são PSR Standards e por que importam
PSR (PHP Standards Recommendations) são diretrizes de codificação criadas pelo PHP-FIG (Framework Interop Group) para padronizar como escreveremos código PHP. Pense nelas como as "regras de trânsito" da comunidade PHP: sem elas, cada desenvolvedor dirigiria do jeito que quisesse, causando caos. Com elas, qualquer pessoa que abra seu código consegue ler e entender rapidamente. As PSRs que trabalharemos — PSR-1, PSR-2, PSR-4 e PSR-12 — cobrem desde convenções básicas de nomenclatura até autoloading automático de classes.
Por anos trabalhei em projetos onde cada time seguia seus próprios padrões. O resultado? Código inconsistente, dificuldade de manutenção e onboarding lento de novos desenvolvedores. Quando adotamos PSRs, a produtividade aumentou significativamente. Você verá por quê.
PSR-1 e PSR-2: Fundações Sólidas
PSR-1: Basic Coding Standard
PSR-1 define as convenções básicas inegociáveis. Aqui estão os pontos-chave: arquivos PHP devem usar apenas a tag <?php (nunca a abreviada <?), deve-se usar UTF-8 sem BOM, e nomes de classes devem estar em PascalCase enquanto métodos em camelCase.
<?php
namespace App\User;
class UserRepository
{
private $database;
public function __construct($database)
{
$this->database = $database;
}
public function getUserById($id)
{
return $this->database->query('SELECT * FROM users WHERE id = ?', [$id]);
}
public function createNewUser($email, $password)
{
// implementação
}
}
Repare: UserRepository em PascalCase, métodos como getUserById() em camelCase, namespace declarado no topo, tag <?php correta. Simples? Sim, mas crucial.
PSR-2: Coding Style Guide
PSR-2 é mais rigorosa. Especifica indentação de 4 espaços (não tabs), abertura de chaves na mesma linha, limitação de linhas (80 caracteres é recomendado), e regras precisas para estruturas de controle.
<?php
namespace App\User;
class UserService
{
private $repository;
public function __construct(UserRepository $repository)
{
$this->repository = $repository;
}
public function registerUser($email, $password)
{
if (empty($email) || empty($password)) {
throw new InvalidArgumentException('Email e senha são obrigatórios');
}
if ($this->userExists($email)) {
throw new RuntimeException('Usuário já cadastrado');
}
return $this->repository->createNewUser($email, $password);
}
private function userExists($email)
{
return $this->repository->findByEmail($email) !== null;
}
}
Repare a indentação consistente de 4 espaços, a abertura de chave na mesma linha do if, e espaçamento ao redor de operadores. Na prática, use ferramentas como PHP-CS-Fixer ou PHPCS para automatizar isso — ninguém digita manualmente.
PSR-4: Autoloading de Classes
Como Funciona PSR-4
PSR-4 define como carregar classes automaticamente baseado em namespaces. Não é necessário mais fazer require ou include para cada arquivo. Você define um mapeamento entre namespace e diretório, e o autoloader cuida do resto. A regra é simples: um arquivo, uma classe; a estrutura de diretórios reflete os namespaces.
// composer.json
{
"autoload": {
"psr-4": {
"App\\": "src/",
"Tests\\": "tests/"
}
}
}
// src/User/UserRepository.php
<?php
namespace App\User;
class UserRepository
{
// implementação
}
// index.php - uso automático
<?php
require 'vendor/autoload.php';
$repository = new \App\User\UserRepository();
No seu composer.json, você mapeia App\\ para o diretório src/. Quando o código chama new \App\User\UserRepository(), o autoloader procura em src/User/UserRepository.php. Nenhum require necessário. Isso é ouro puro em projetos grandes.
PSR-12: Modern PHP Coding Style
A Evolução Necessária
PSR-12 substitui PSR-2 com regras modernizadas para PHP 7+. Mantém o essencial, mas adiciona clareza para sintaxes mais recentes como tipos de retorno, tipos de propriedades e tipos de argumento.
<?php
namespace App\Order;
use App\User\User;
use Doctrine\ORM\EntityRepository;
class OrderService
{
private EntityRepository $repository;
public function __construct(EntityRepository $repository)
{
$this->repository = $repository;
}
public function processOrder(User $user, array $items): Order
{
if (empty($items)) {
throw new InvalidArgumentException('Pedido sem itens');
}
$order = new Order(
user: $user,
items: $items,
createdAt: new DateTime()
);
return $this->repository->save($order);
}
public function getOrderStatus(int $orderId): ?string
{
$order = $this->repository->find($orderId);
return $order?->getStatus();
}
}
Veja: tipagem forte (User, array, Order), propriedade tipada (EntityRepository $repository), named arguments (user:, items:), nullsafe operator ($order?->). PSR-12 abrange tudo isso com elegância e clareza.
Namespaces e Use Statements
PSR-12 também padroniza imports. Ordene alfabeticamente dentro de cada grupo: classes, depois interfaces, depois traits. Uma linha em branco separa cada grupo.
<?php
namespace App\Order;
use App\Notification\EmailService;
use App\Notification\SlackService;
use App\Repository\OrderRepository;
use DateTime;
use Throwable;
Organizado e legível. Ferramentas como PHP-CS-Fixer fazem isso automaticamente.
Conclusão
Três aprendizados principais: Primeiro, PSR-1 e PSR-2 são o alicerce — nomenclatura consistente e formatação padrão economizam horas de debug. Segundo, PSR-4 com Composer elimina gerenciamento manual de includes, deixando você focar na lógica. Terceiro, PSR-12 moderniza seu código para PHP 7+, aproveitando tipagem e sintaxe contemporânea. Juntas, essas padrões transformam código caótico em código profissional, legível e mantível por qualquer desenvolvedor.