Os PSRs (PHP Standard Recommendations) são um conjunto de recomendações técnicas que descrevem como diferentes aspectos do PHP devem ser implementados e organizados. Eles são criados pelo PHP-FIG (PHP Framework Interop Group), um grupo de desenvolvedores de frameworks PHP, bibliotecas e aplicativos que trabalham juntos para definir esses padrões. As recomendações incluem, por exemplo, como nomear classes, interfaces e métodos, como lidar com a injeção de dependência e como escrever código de autoloading.
Ao seguir as recomendações PSR, os desenvolvedores podem garantir que seu código seja fácil de entender e manter, e que possa ser reutilizado em diferentes projetos sem precisar de grandes adaptações. Além disso, aderir aos PSRs também ajuda a promover a interoperabilidade entre diferentes bibliotecas e frameworks PHP.
Aqui estão todas as PSRs existentes, com explicações e exemplos:
PSR-0: Autoloading Standard
Esta PSR define o padrão de como os namespaces e classes do PHP devem ser estruturados em um projeto para garantir um carregamento automático correto. Por exemplo:
<?php
namespace Foo\Bar;
class MyClass {}
PSR-1: Basic Coding Standard
Esta PSR define normas básicas para a codificação em PHP, como usar camelCase para nomes de variáveis e funções e evitar linhas de código com mais de 120 caracteres. Por exemplo:
<?php
class FooBar
{
public function helloWorld()
{
return 'Hello World';
}
}PSR-2: Coding Style Guide
Esta PSR define as regras de estilo que um desenvolvedor deve seguir ao escrever código PHP. Inclui diretrizes sobre como formatar o código, indentação, e comentários. Por exemplo:
<?php
namespace Foo\Bar;
class MyClass
{
public function myMethod()
{
if ($someCondition) {
// do something
} else {
// do something else
}
}
}PSR-3: Logger Interface
Esta PSR define uma interface de registro de eventos, que permite aos desenvolvedores escreverem mensagens de registro em um formato padronizado. Por exemplo:
<?php
use Psr\Log\LoggerInterface;
class MyClass
{
protected $logger;
public function __construct(LoggerInterface $logger)
{
$this->logger = $logger;
}
public function doSomething()
{
$this->logger->info('Doing something');
}
}PSR-4: Autoloader
Esta PSR estabelece um padrão para a organização dos arquivos do projeto PHP. Define como a estrutura do diretório de arquivos deve ser organizada para garantir uma fácil localização de classes e outras partes do código. Por exemplo:
<php
// PSR-4 autoloader
spl_autoload_register(function ($class) {
// namespace prefix
$prefix = 'Foo\\Bar\\';
// base directory for the namespace prefix
$baseDir = __DIR__ . '/src/';
// does the class use the namespace prefix?
$len = strlen($prefix);
if (strncmp($prefix, $class, $len) !== 0) {
// no, move to the next registered autoloader
return;
}
// get the relative class name
$relativeClass = substr($class, $len);
// replace the namespace prefix with the base directory, replace namespace separators with directory separators in the relative class name, append with .php
$file = $baseDir . str_replace('\\', '/', $relativeClass) . '.php';
// if the file exists, require it
if (file_exists($file)) {
require $file;
}
});PSR-5: PHPDoc Standard
Essa PSR define um conjunto de regras para a documentação de código PHP usando PHPDoc.
<php
/**
* Classe que representa um usuário do sistema.
*
* @package MyApp
*/
class User
{
/**
* ID do usuário.
*
* @var int
*/
private $id;
/**
* Nome do usuário.
*
* @var string
*/
private $name;
/**
* Construtor da classe.
*
* @param int $id ID do usuário.
* @param string $name Nome do usuário.
*/
public function __construct(int $id, string $name)
{
$this->id = $id;
$this->name = $name;
}
/**
* Retorna o ID do usuário.
*
* @return int ID do usuário.
*/
public function getId(): int
{
return $this->id;
}
/**
* Retorna o nome do usuário.
*
* @return string Nome do usuário.
*/
public function getName(): string
{
return $this->name;
}
}PSR-6: Caching Interface
Esta PSR define uma interface comum para implementações de cache em PHP. Fornece uma maneira padronizada de armazenar dados em cache para que possam ser recuperados rapidamente no futuro. Por exemplo:
<?php
use Psr\Cache\CacheItemPoolInterface;
class MyClass
{
protected $cache;
public function __construct(CacheItemPoolInterface $cache)
{
$this->cache = $cache;
}
public function doSomething()
{
$cacheItem = $this->cache->getItem('myCacheKey');
if (!$cacheItem->isHit()) {
// data not in cache, fetch it from the database and store it in cache
$data = $this->fetchDataFromDatabase();
$cacheItem->set($data);
$this->cache->save($cacheItem);
}
// use the data from cache
$data = $cacheItem->get();
// ...
}
}PSR-7: HTTP Message Interface
Esta PSR define uma interface comum para trabalhar com mensagens HTTP, como solicitações e respostas HTTP. Fornece uma maneira padronizada de lidar com as informações do cabeçalho e do corpo das mensagens. Por exemplo:
<?php
use Psr\Http\Message\ServerRequestInterface;
use Psr\Http\Message\ResponseInterface;
class MyController
{
public function handleRequest(ServerRequestInterface $request): ResponseInterface
{
$name = $request->getQueryParams()['name'] ?? 'World';
$response = new Response();
$response->getBody()->write(sprintf('Hello, %s!', $name));
return $response;
}
}PSR-11: Container Interface
Esta PSR define uma interface comum para contêineres de injeção de dependência em PHP. Fornece uma maneira padronizada de gerenciar e recuperar objetos em um aplicativo. Por exemplo:
<?php
use Psr\Container\ContainerInterface;
class MyClass
{
protected $container;
public function __construct(ContainerInterface $container)
{
$this->container = $container;
}
public function doSomething()
{
$logger = $this->container->get('logger');
$logger->info('Doing something');
// ...
}
}PSR-13: Hypermedia Links
Esta PSR define uma maneira padronizada de lidar com links em documentos de hipermídia, como o HTML. Fornece uma maneira de definir links e recursos relacionados de maneira consistente e padronizada. Por exemplo:
<?php
use Psr\Link\LinkInterface;
class MyController
{
public function handleRequest(): Response
{
$link = new Link('http://example.com', 'self');
$response = new Response();
$response = $response->withAddedHeader('Link', (string) $link);
return $response;
}
}PSR-14: Event Dispatcher
A PSR-14 é uma especificação do PHP-FIG (PHP Framework Interop Group) que define um padrão para a implementação de um sistema de eventos no PHP. O objetivo da PSR-14 é permitir que as aplicações possam ser construídas com uma arquitetura mais modular e escalável, com componentes que possam se comunicar entre si através de eventos.
Em resumo, a PSR-14 define uma interface para a criação e disparo de eventos, bem como para o registro de ouvintes (listeners) que serão notificados quando esses eventos ocorrerem.
Um exemplo de uso da PSR-14 seria em um sistema de e-commerce, onde uma classe de pagamento poderia disparar um evento “pagamento_realizado” quando uma transação for concluída com sucesso. Outras classes, como a de envio de e-mails e a de atualização de estoque, poderiam se registrar como ouvintes desse evento para realizar suas ações correspondentes.
A implementação da PSR-14 pode variar de acordo com o framework ou biblioteca utilizada, mas a especificação em si fornece um conjunto mínimo de requisitos que devem ser atendidos para que a interoperabilidade seja garantida entre diferentes componentes que implementam essa PSR.
E as outras PSRs?
As PSRs 8, 9, 10 e 12 ainda não existem oficialmente. Esses números foram reservados pelo PHP-FIG (PHP Framework Interop Group) para futuras propostas de especificações.
É importante notar que a aderência a esses padrões pode melhorar significativamente a qualidade do código PHP e torná-lo mais fácil de manter e escalar.