eval()

Introdução à Função eval()

A função eval() avalia uma string como código PHP e a executa em tempo de execução — no momento em que o script chega à chamada eval(). Em vez de escrever código que o parser PHP compila antecipadamente, você passa para eval() uma string que é compilada e executada dinamicamente.

Isso torna eval() um dos constructs mais poderosos — e mais perigosos — da linguagem. Esta página aborda sua sintaxe, o que ela retorna, os raros casos em que é genuinamente útil, os riscos de segurança que a tornam um último recurso e as alternativas mais seguras que você deve preferir.

eval() é um construct de linguagem, não uma função comum. Você não pode chamá-la indiretamente por meio do nome de uma função em variável ou passá-la para funções de callback.

Sintaxe

eval(string $code): mixed

O único argumento é uma string de código PHP. Algumas regras importantes:

• Não inclua a tag de abertura <?php. A string já é tratada como fonte PHP, então adicionar <?php te faria retornar ao "modo HTML".
• O código deve ser sintaticamente válido e terminado. Um ponto e vírgula ausente ou chave sem fechamento gera um erro de análise. A partir do PHP 7, um erro de análise dentro de eval() lança uma exceção ParseError que pode ser capturada — versões anteriores retornavam false.

Valor de Retorno

Como eval() retorna um valor depende do que o código avaliado faz:

• Se o código executa uma instrução return, eval() retorna esse valor.
• Caso contrário, retorna null.

<?php

$result = eval('return 2 + 3;');
echo $result; // 5

É por isso que um return dentro de eval() termina a string avaliada, não o script inteiro — o controle retorna para a linha após eval(). Veja a instrução return para entender como return se comporta em funções comuns.

Exemplo Básico

Aqui está o uso mais simples possível — construir uma string de código e executá-la:

A variável $code contém PHP válido que imprime Hello, world!. eval() compila e executa essa string em tempo de execução, então a mensagem é exibida. Observe que não há tag <?php dentro da string.

Capturando Erros com Segurança

Como código inválido lança um ParseError, envolva código não confiável ou gerado em um bloco try/catch para que uma string inválida não quebre toda a requisição:

<?php

try {
    eval('echo "missing semicolon"'); // no terminating ;
} catch (ParseError $e) {
    echo "Could not evaluate: " . $e->getMessage();
}

Isso imprime uma mensagem "Could not evaluate" em vez de um erro fatal, permitindo que o script continue.

Quando Usar eval()?

No PHP moderno, quase nunca — e essa é a resposta honesta. Casos de uso legítimos e limitados incluem:

• Motores de template/expressão que compilam uma mini-linguagem personalizada em PHP (Twig e Blade fazem algo conceitualmente semelhante, mas com sandboxing robusto).
• Armazenamento em cache de configurações compiladas como PHP que é posteriormente avaliado com eval, embora escrever um arquivo .php real e usar include seja mais rápido e seguro.
• Ferramentas educacionais ou de depuração, como REPLs, onde a entrada é totalmente confiável.

Se o valor que você precisa calcular é um dado (números, JSON, uma lista de opções), quase certamente você não precisa de eval().

Riscos de Segurança

eval() executa tudo o que recebe. Se qualquer parte da string puder ser influenciada por entrada do usuário, um atacante pode executar código arbitrário — ler arquivos, excluir dados ou comprometer o servidor. Isso é uma vulnerabilidade clássica de execução remota de código (RCE).

<?php

// NEVER do this:
$expr = $_GET['expr'];          // attacker-controlled
eval("\$answer = $expr;");      // attacker can inject any PHP

Uma requisição como ?expr=1; system('rm -rf /') executaria o comando injetado. Trate qualquer eval() com entrada do usuário como uma exploração garantida.

Alternativas Mais Seguras

Antes de recorrer a eval(), verifique se uma dessas opções cobre sua necessidade:

Conclusão

eval() avalia uma string como código PHP em tempo de execução, retornando o resultado de uma instrução return contida nela ou null caso contrário. É genuinamente poderosa, mas também é uma das principais fontes de falhas de segurança — qualquer entrada controlada pelo usuário passada a ela representa uma vulnerabilidade de execução remota de código. Use-a somente quando a entrada for totalmente confiável e nenhum construct nativo se adequar, envolva-a em um try/catch para ParseError e prefira as alternativas mais seguras acima sempre que possível.

Prática