O que é PHP moderno e como ele evoluiu

1. A origem e o contexto do PHP

1.1. Do PHP/FI ao PHP 4: primeiros passos e a popularização como linguagem procedural

O PHP surgiu em 1994, criado por Rasmus Lerdorf como um conjunto de scripts Perl para monitorar seu currículo online. O que começou como "Personal Home Page Tools" evoluiu para PHP/FI (Forms Interpreter) e, em 1997, ganhou o motor Zend Engine 1 com o PHP 3. O PHP 4, lançado em 2000, consolidou a linguagem como uma ferramenta procedural robusta para desenvolvimento web, mas ainda carecia de recursos modernos de orientação a objetos.

<?php
// PHP 4 - estilo procedural puro
function saudacao($nome) {
    return "Olá, " . $nome . "!";
}
echo saudacao("Mundo");
?>

1.2. PHP 5: a revolução da orientação a objetos e o Zend Engine 2

O PHP 5 (2004) foi um divisor de águas. Com o Zend Engine 2, a linguagem ganhou um modelo de objetos completo: visibilidade (public, protected, private), interfaces, classes abstratas, exceções e o padrão de design __autoload. A PDO (PHP Data Objects) unificou o acesso a bancos de dados.

<?php
// PHP 5 - orientação a objetos madura
interface SaudacaoInterface {
    public function dizerOla(): string;
}

class Saudacao implements SaudacaoInterface {
    private string $nome;

    public function __construct(string $nome) {
        $this->nome = $nome;
    }

    public function dizerOla(): string {
        return "Olá, {$this->nome}!";
    }
}

$saudacao = new Saudacao("Mundo");
echo $saudacao->dizerOla();
?>

1.3. PHP 6 (cancelado) e a transição para o PHP 7: o marco da performance

O PHP 6 tentou implementar suporte nativo a Unicode, mas o projeto foi abandonado por complexidade técnica. Essa experiência levou a uma reestruturação completa que resultou no PHP 7 (2015), com o Zend Engine 3 e ganhos de performance de até 2x em relação ao PHP 5.6.

2. PHP 7: a virada de chave para o moderno

2.1. Motor Zend Engine 3 e ganhos massivos de desempenho

O PHP 7 reescreveu o core da linguagem, reduzindo o consumo de memória e acelerando a execução. Aplicações como WordPress e Magento viram melhorias dramáticas sem alteração de código.

2.2. Tipos escalares declarados e funções de retorno tipado

Pela primeira vez, o PHP permitiu declarar tipos para parâmetros e retornos de funções, tanto para tipos escalares (int, float, string, bool) quanto para tipos compostos.

<?php
declare(strict_types=1);

function calcularArea(float $raio): float {
    return pi() * $raio ** 2;
}

echo calcularArea(5.0); // 78.539816339745
?>

2.3. Operador de coalescência nula (??) e operador spaceship (<=>)

Dois operadores que simplificaram padrões comuns: ?? para valores padrão e <=> para comparação de três vias.

<?php
$nome = $_GET['nome'] ?? 'Visitante';
echo $nome;

$resultado = 5 <=> 3; // 1 (maior)
$resultado = 3 <=> 5; // -1 (menor)
$resultado = 5 <=> 5; // 0 (igual)
?>

3. PHP 8: maturidade e novas fronteiras

3.1. JIT (Just-In-Time Compilation): como funciona e impacto real

O PHP 8 (2020) introduziu um compilador JIT que traduz bytecode para código de máquina em tempo de execução. O impacto é mais perceptível em cargas de trabalho computacionais intensivas (processamento de imagens, cálculos matemáticos) do que em aplicações web típicas, onde o ganho é marginal (cerca de 5-10%).

3.2. Atributos (Annotations nativas) e construtores com promoção de propriedades

Os atributos substituem as annotations PHPDoc com uma sintaxe nativa, enquanto a promoção de propriedades no construtor elimina boilerplate.

<?php
#[Attribute]
class Rota {
    public function __construct(public string $caminho) {}
}

class Controlador {
    public function __construct(
        private string $nome,
        private int $idade
    ) {}

    #[Rota('/usuario')]
    public function exibir(): string {
        return "Usuário: {$this->nome}, {$this->idade} anos";
    }
}
?>

3.3. Tipos union, match expression e named arguments

<?php
function processar(int|string $valor): string {
    return match (true) {
        is_int($valor) => "Número: $valor",
        is_string($valor) => "Texto: $valor",
        default => "Desconhecido"
    };
}

// Named arguments
function criarUsuario(string $nome, string $email, bool $admin = false): array {
    return compact('nome', 'email', 'admin');
}

$usuario = criarUsuario(
    admin: true,
    nome: 'João',
    email: 'joao@exemplo.com'
);
?>

4. PHP 8.1 a 8.3: refinamento e suporte ao desenvolvedor

4.1. Enums verdadeiros e Fibers para concorrência

As enums do PHP 8.1 são objetos completos com métodos e valores, enquanto as Fibers permitem concorrência cooperativa.

<?php
enum StatusPedido: string {
    case Pendente = 'pendente';
    case Pago = 'pago';
    case Enviado = 'enviado';
    case Entregue = 'entregue';

    public function label(): string {
        return match($this) {
            self::Pendente => 'Aguardando pagamento',
            self::Pago => 'Pagamento confirmado',
            self::Enviado => 'Pedido enviado',
            self::Entregue => 'Pedido entregue',
        };
    }
}

$status = StatusPedido::Pago;
echo $status->label(); // Pagamento confirmado
?>

4.2. Readonly properties, intersection types e readonly classes

<?php
readonly class Configuracao {
    public function __construct(
        public string $host,
        public int $porta = 3306
    ) {}
}

// Intersection types
function logar(Logger&Logavel $objeto): void {
    $objeto->log('Mensagem');
}
?>

4.3. Melhorias incrementais: typed constants, json_validate e override attribute

<?php
class Constantes {
    final public const string NOME_APP = 'MeuApp';
}

var_dump(json_validate('{"nome": "João"}')); // bool(true)

class Base {
    public function metodo(): void {}
}

class Filho extends Base {
    #[\Override]
    public function metodo(): void {
        parent::metodo();
    }
}
?>

5. Ecossistema de ferramentas modernas

5.1. Composer: gerenciamento de dependências e autoloading PSR-4

O Composer revolucionou o PHP ao padronizar o gerenciamento de bibliotecas e o autoloading. Um composer.json bem configurado garante que todas as dependências sejam carregadas automaticamente.

{
    "require": {
        "php": ">=8.2",
        "guzzlehttp/guzzle": "^7.0"
    },
    "autoload": {
        "psr-4": {
            "App\\": "src/"
        }
    }
}

5.2. PHPStan e Psalm: análise estática de tipos para código seguro

Ferramentas como PHPStan (nível máximo 9) e Psalm detectam erros de tipo sem executar o código, prevenindo bugs em produção.

# Exemplo de análise com PHPStan
vendor/bin/phpstan analyse src/ --level=max

5.3. PHPUnit moderno, Rector e ferramentas de qualidade de código

O PHPUnit 11+ suporta atributos modernos, enquanto o Rector automatiza a migração entre versões do PHP.

<?php
use PHPUnit\Framework\Attributes\Test;
use PHPUnit\Framework\TestCase;

class CalculadoraTest extends TestCase {
    #[Test]
    public function soma_deve_retornar_correto(): void {
        $this->assertEquals(4, 2 + 2);
    }
}
?>

6. Padrões e boas práticas do PHP moderno

6.1. PSRs essenciais (PSR-1, PSR-4, PSR-7, PSR-12) e código interoperável

As PHP Standard Recommendations (PSRs) garantem que código de diferentes bibliotecas funcione junto. PSR-12 define o estilo de codificação moderno.

<?php
declare(strict_types=1);

namespace App\Service;

use Psr\Http\Message\ResponseInterface;
use Psr\Http\Message\ServerRequestInterface;

class Middleware {
    public function __invoke(
        ServerRequestInterface $request,
        ResponseInterface $response
    ): ResponseInterface {
        // Código PSR-7 compatível
        return $response;
    }
}
?>

6.2. Strict typing e tipagem forte como padrão recomendado

Usar declare(strict_types=1) no topo de cada arquivo evita coerções implícitas de tipo, prevenindo bugs sutis.

6.3. Separação de responsabilidades com frameworks (Laravel, Symfony) e princípios SOLID

Frameworks modernos aplicam SOLID naturalmente. Laravel usa Service Container e injeção de dependência; Symfony promove componentes desacoplados.

7. O futuro do PHP

7.1. PHP 8.4 e além: o que esperar das próximas versões

A RFC para property hooks (similar a getters/setters automáticos) e melhorias no JIT estão em discussão. A linguagem caminha para mais segurança de tipo sem perder a flexibilidade.

7.2. PHP assíncrono e concorrência real (Fibers, Revolt, AMPHP)

Com Fibers nativas e bibliotecas como Revolt e AMPHP, o PHP pode processar múltiplas requisições simultâneas sem bloqueio de I/O.

<?php
use Revolt\EventLoop;

$fiber = new Fiber(function (): void {
    $resultado = Fiber::suspend('processando...');
    echo "Resultado: $resultado\n";
});

$valor = $fiber->start();
echo "Valor do fiber: $valor\n";
$fiber->resume('finalizado');
?>

7.3. O lugar do PHP frente a outras linguagens: nicho web, performance e simplicidade

O PHP moderno compete diretamente com Node.js, Python e Go no nicho web, oferecendo a melhor relação custo-benefício para desenvolvimento web tradicional, com performance comparável e ecossistema maduro.

Referências