PHP: A Linguagem da Web Moderna

PHP continua sendo uma das linguagens mais utilizadas na web, alimentando cerca de 77% de todos os sites, incluindo WordPress, Facebook e Wikipedia. Com o PHP 8.x, a linguagem passou por uma transformação significativa, incorporando recursos modernos como tipagem forte, JIT compilation e atributos.

Mito desfeito: PHP moderno é completamente diferente do PHP legado. Com frameworks como Laravel e Symfony, PHP rivaliza com qualquer stack moderna em produtividade e elegância.

Recursos do PHP 8.x

1. JIT Compilation - Performance significativamente melhorada
2. Named Arguments - Argumentos nomeados para clareza
3. Attributes - Metadados nativos (como annotations)
4. Match Expression - Switch mais poderoso
5. Constructor Promotion - Classes mais concisas
6. Union Types - Múltiplos tipos permitidos
7. Nullsafe Operator - ?-> para encadeamento seguro

Fundamentos Modernos

Tipos e Variáveis

<?php

declare(strict_types=1);

// Tipos escalares
$nome = 'Maria';           // string
$idade = 25;               // int
$altura = 1.68;            // float
$ativo = true;             // bool

// Arrays
$frutas = ['maçã', 'banana', 'laranja'];
$usuario = [
    'nome' => 'Maria',
    'email' => '[email protected]',
    'idade' => 25
];

// Array destructuring
['nome' => $nome, 'email' => $email] = $usuario;

// Spread operator
$numeros = [1, 2, 3];
$maisNumeros = [...$numeros, 4, 5, 6];

// Null coalescing
$valor = $usuario['telefone'] ?? 'Não informado';

// Nullsafe operator (PHP 8.0+)
$cidade = $usuario?->endereco?->cidade;

Classes Modernas

<?php

declare(strict_types=1);

// Constructor promotion (PHP 8.0+)
class Usuario
{
    public function __construct(
        public readonly int $id,
        public string $nome,
        public string $email,
        public bool $ativo = true,
        public ?\DateTimeImmutable $criadoEm = null
    ) {
        $this->criadoEm ??= new \DateTimeImmutable();
    }
    
    public function saudar(): string
    {
        return "Olá, {$this->nome}!";
    }
    
    public function desativar(): void
    {
        $this->ativo = false;
    }
}

// Enums (PHP 8.1+)
enum Status: string
{
    case Pendente = 'pendente';
    case Aprovado = 'aprovado';
    case Rejeitado = 'rejeitado';
    
    public function label(): string
    {
        return match($this) {
            self::Pendente => 'Aguardando análise',
            self::Aprovado => 'Aprovado ✓',
            self::Rejeitado => 'Rejeitado ✗',
        };
    }
}

// Readonly classes (PHP 8.2+)
readonly class Produto
{
    public function __construct(
        public string $nome,
        public float $preco,
        public int $quantidade
    ) {}
    
    public function valorTotal(): float
    {
        return $this->preco * $this->quantidade;
    }
}

Interfaces e Traits

<?php

interface Repositorio
{
    public function buscarPorId(int $id): ?object;
    public function listarTodos(): array;
    public function salvar(object $entidade): object;
    public function deletar(int $id): void;
}

trait Timestamps
{
    public ?\DateTimeImmutable $criadoEm = null;
    public ?\DateTimeImmutable $atualizadoEm = null;
    
    public function atualizarTimestamp(): void
    {
        $this->atualizadoEm = new \DateTimeImmutable();
        $this->criadoEm ??= $this->atualizadoEm;
    }
}

class UsuarioRepositorio implements Repositorio
{
    use Timestamps;
    
    private array $usuarios = [];
    
    public function buscarPorId(int $id): ?Usuario
    {
        return $this->usuarios[$id] ?? null;
    }
    
    public function listarTodos(): array
    {
        return array_values($this->usuarios);
    }
    
    public function salvar(object $entidade): Usuario
    {
        $this->usuarios[$entidade->id] = $entidade;
        $this->atualizarTimestamp();
        return $entidade;
    }
    
    public function deletar(int $id): void
    {
        unset($this->usuarios[$id]);
    }
}

Match Expression e Attributes

<?php

// Match expression (PHP 8.0+)
function descrever(mixed $valor): string
{
    return match(true) {
        is_null($valor) => 'Nulo',
        is_string($valor) && $valor === '' => 'String vazia',
        is_string($valor) => "String: $valor",
        is_int($valor) && $valor > 0 => "Inteiro positivo: $valor",
        is_int($valor) => "Inteiro: $valor",
        is_array($valor) => 'Array com ' . count($valor) . ' itens',
        default => 'Tipo desconhecido',
    };
}

// Attributes (PHP 8.0+)
#[Attribute(Attribute::TARGET_PROPERTY)]
class Validar
{
    public function __construct(
        public string $regra,
        public string $mensagem = 'Campo inválido'
    ) {}
}

#[Attribute(Attribute::TARGET_CLASS)]
class Entidade
{
    public function __construct(
        public string $tabela
    ) {}
}

#[Entidade(tabela: 'usuarios')]
class Usuario
{
    #[Validar(regra: 'required', mensagem: 'Nome é obrigatório')]
    public string $nome;
    
    #[Validar(regra: 'email')]
    public string $email;
}

Fibers e Async (PHP 8.1+)

<?php

// Fiber básico
$fiber = new Fiber(function(): void {
    echo "Início do Fiber\n";
    $valor = Fiber::suspend('pausado');
    echo "Valor recebido: $valor\n";
});

$resultado = $fiber->start(); // 'pausado'
$fiber->resume('continuando');

// Exemplo prático com generadores
function processarEmLotes(array $items, int $tamanhoLote = 100): Generator
{
    foreach (array_chunk($items, $tamanhoLote) as $lote) {
        yield $lote;
    }
}

// Uso
$todosItens = range(1, 1000);
foreach (processarEmLotes($todosItens) as $lote) {
    // Processa cada lote de 100 itens
    processar($lote);
}

Laravel Moderno

<?php

// Controller com Route::resource
class ProdutoController extends Controller
{
    public function __construct(
        private ProdutoService $service
    ) {}
    
    public function index(): JsonResponse
    {
        return response()->json(
            $this->service->listar()
        );
    }
    
    public function store(ProdutoRequest $request): JsonResponse
    {
        $produto = $this->service->criar($request->validated());
        
        return response()->json($produto, 201);
    }
    
    public function show(Produto $produto): JsonResponse
    {
        return response()->json($produto->load('categoria'));
    }
}

// Eloquent Model
class Produto extends Model
{
    protected $fillable = ['nome', 'preco', 'categoria_id'];
    
    protected $casts = [
        'preco' => 'decimal:2',
        'ativo' => 'boolean',
    ];
    
    public function categoria(): BelongsTo
    {
        return $this->belongsTo(Categoria::class);
    }
    
    public function scopeAtivos(Builder $query): Builder
    {
        return $query->where('ativo', true);
    }
    
    public function scopeCaros(Builder $query, float $minimo = 1000): Builder
    {
        return $query->where('preco', '>=', $minimo);
    }
}

// Query Builder fluente
$produtos = Produto::query()
    ->ativos()
    ->caros(500)
    ->with('categoria')
    ->orderBy('preco', 'desc')
    ->paginate(20);

Ferramentas Essenciais

Ferramenta	Propósito
Composer	Gerenciador de dependências
Laravel	Framework full-stack
Symfony	Framework enterprise
PHPUnit	Testes unitários
PHPStan	Análise estática
Pest	Testes elegantes

Checklist de Aprendizado

• Dominar PHP 8.x features
• Entender Composer e autoloading
• Aprender Laravel ou Symfony
• Estudar padrões de design
• Praticar testes com PHPUnit/Pest
• Explorar APIs REST com Laravel
• Implementar autenticação e autorização

Recursos Essenciais

• PHP.net
• Laravel Docs
• PHP The Right Way
• Laracasts

Citação

“PHP moderno não tem nada a ver com o PHP que você pode ter ouvido falar. É uma linguagem madura, tipada e performática.” - Taylor Otwell

---

PHP continua evoluindo e se mantém como uma excelente escolha para desenvolvimento web!