Seu primeiro script PHP e como o interpretador funciona

1. O ciclo de vida de um script PHP

1.1. Fases de execução: parsing, compilação (opcache) e interpretação

Quando você executa um script PHP, o interpretador passa por três fases principais:

  1. Parsing (Análise Sintática): O PHP lê o código-fonte e verifica se a sintaxe está correta. Se houver algum erro de sintaxe, um "parse error" é gerado e a execução é interrompida antes mesmo de começar.

  2. Compilação (Opcache): O código é compilado para uma representação intermediária chamada opcodes (códigos de operação). Com o OPcache habilitado (padrão no PHP 8), essas opcodes são armazenadas em cache na memória, evitando recompilações desnecessárias em requisições subsequentes.

  3. Interpretação (Zend Engine): O Zend Engine executa as opcodes linha a linha, gerando a saída final (HTML, JSON, texto, etc.).

1.2. O papel do interpretador PHP (Zend Engine) e SAPI (CLI vs. Web)

O Zend Engine é o coração do PHP — ele interpreta e executa o código compilado. Já a SAPI (Server API) é a camada que conecta o PHP ao ambiente de execução:

  • CLI (Command Line Interface): Usada quando você executa php script.php no terminal. Ideal para scripts automatizados, testes e tarefas de sistema.
  • Web SAPI (mod_php, FPM, CGI): Usada em servidores web (Apache, Nginx). O PHP processa requisições HTTP e gera respostas dinâmicas.

1.3. Diferença entre código-fonte e saída gerada

O código-fonte PHP nunca é enviado ao navegador (a menos que haja um erro de configuração grave). O que o cliente recebe é apenas a saída gerada — HTML, JSON, texto puro, etc.

<?php
// Isso é código-fonte — nunca vaza para o cliente
$titulo = "Meu Site";
?>
<!DOCTYPE html>
<html>
<head>
    <title><?php echo $titulo; ?></title>
</head>
<body>
    <!-- O HTML é saída gerada -->
    <h1>Bem-vindo!</h1>
</body>
</html>

2. Criando e executando seu primeiro script

2.1. Estrutura mínima

Um script PHP começa com <?php e pode (opcionalmente) terminar com ?>. Se o arquivo contiver apenas código PHP, a tag de fechamento é omitida por boas práticas — isso evita o envio acidental de espaços ou linhas em branco após ?>.

<?php
// Código PHP puro — sem tag de fechamento
echo "Olá, mundo!";

2.2. Exemplo prático: hello.php

Crie um arquivo chamado hello.php com o seguinte conteúdo:

<?php
/**
 * Meu primeiro script PHP
 * Autor: Você
 * Data: 2025
 */

// Exibe uma mensagem simples
echo "Olá, mundo!\n";

// Comentário de uma linha
# Outro estilo de comentário

/*
 * Comentário
 * de múltiplas
 * linhas
 */

$nome = "Maria";
echo "Bem-vinda, $nome!\n";
?>

2.3. Executando no terminal

No terminal, navegue até a pasta do arquivo e execute:

php hello.php

Saída esperada:

Olá, mundo!
Bem-vinda, Maria!

Erros comuns:
- Parse error: esquecer ponto e vírgula (;) ao final de uma instrução
- Syntax error: tag <?php escrita como <? em servidores com short_open_tag desabilitado
- Unexpected end of file: esquecer de fechar chaves { } ou aspas

3. Entendendo a saída: echo, print e var_dump

3.1. echo vs. print

Ambos exibem texto, mas com diferenças sutis:

<?php
// echo: não é uma função, é um construtor de linguagem
echo "Olá";           // OK
echo "Olá", " Mundo"; // Aceita múltiplos argumentos

// print: retorna 1, pode ser usado em expressões
$resultado = print "Teste\n"; // $resultado = 1

3.2. var_dump() e print_r() para depuração

Use var_dump() para inspecionar tipos e valores completos:

<?php
$numero = 42;
$texto = "PHP";
$lista = [10, 20, 30];

var_dump($numero);  // int(42)
var_dump($texto);   // string(3) "PHP"
var_dump($lista);   // array(3) { [0]=> int(10) [1]=> int(20) [2]=> int(30) }

print_r($lista);    // Formatação mais legível para arrays/objetos

3.3. Saída mista: intercalando HTML e PHP

<?php $usuario = "João"; ?>
<!DOCTYPE html>
<html>
<body>
    <h1><?php echo "Olá, $usuario!"; ?></h1>
    <p>Hoje é <?php echo date('d/m/Y'); ?></p>
</body>
</html>

4. Variáveis, constantes e escopo no interpretador

4.1. Declaração de variáveis e tipos dinâmicos

No PHP, variáveis começam com $ e não têm tipo fixo:

<?php
$nome = "Ana";      // string
$idade = 25;        // int
$altura = 1.75;     // float
$ativo = true;      // bool
$habilidades = [];  // array

// Tipos dinâmicos: a mesma variável pode mudar de tipo
$valor = "100";     // string
$valor = (int) $valor; // agora é int (cast explícito)

4.2. Constantes e constantes mágicas

<?php
define("PI", 3.14159);
const SITE = "https://exemplo.com";

echo PI;    // 3.14159
echo SITE;  // https://exemplo.com

// Constantes mágicas (mudam conforme o contexto)
echo __FILE__;     // Caminho completo do arquivo atual
echo __LINE__;     // Linha atual do código
echo __DIR__;      // Diretório do arquivo atual
echo __FUNCTION__; // Nome da função atual (se dentro de uma)

4.3. Escopo de variáveis

<?php
$global = "Fora da função";

function teste() {
    $local = "Dentro da função";
    // echo $global; // Erro! Não acessível

    global $global; // Declara uso da variável global
    echo $global;   // Agora funciona
}

teste();

5. Operadores e expressões básicas

5.1. Operadores aritméticos, concatenação e atribuição

<?php
$a = 10;
$b = 3;

echo $a + $b;  // 13 (soma)
echo $a - $b;  // 7 (subtração)
echo $a * $b;  // 30 (multiplicação)
echo $a / $b;  // 3.333... (divisão float)
echo $a % $b;  // 1 (módulo/resto)

// Concatenação
echo "PHP " . "8";  // "PHP 8"

// Atribuição combinada
$x = 5;
$x += 3;  // $x = 8
$x .= " textos";  // $x = "8 textos"

5.2. Comparação: === vs. ==

<?php
$a = "5";  // string
$b = 5;    // int

var_dump($a == $b);   // bool(true)  — compara valor, ignora tipo
var_dump($a === $b);  // bool(false) — compara valor E tipo
var_dump($a != $b);   // bool(false) — diferente (valor)
var_dump($a !== $b);  // bool(true)  — diferente (valor ou tipo)

5.3. Operadores lógicos e precedência

<?php
$idade = 20;
$possuiCarteira = true;

// AND lógico
if ($idade >= 18 && $possuiCarteira) {
    echo "Pode dirigir";
}

// OR lógico
if ($idade < 12 || $idade > 65) {
    echo "Desconto especial";
}

// NOT lógico
if (!$possuiCarteira) {
    echo "Não pode dirigir";
}

6. Estruturas de controle fundamentais

6.1. Condicionais: if, else, elseif

<?php
$nota = 7.5;

if ($nota >= 9) {
    echo "Excelente!";
} elseif ($nota >= 7) {
    echo "Bom";
} else {
    echo "Precisa melhorar";
}

// Sintaxe alternativa (útil em templates)
if ($nota >= 7): ?>
    <p>Aprovado</p>
<?php else: ?>
    <p>Reprovado</p>
<?php endif; ?>

6.2. Laços: for, while, foreach

<?php
// for
for ($i = 1; $i <= 5; $i++) {
    echo "Número: $i\n";
}

// while
$contador = 0;
while ($contador < 3) {
    echo "Volta $contador\n";
    $contador++;
}

// foreach (ideal para arrays)
$cores = ["Vermelho", "Verde", "Azul"];
foreach ($cores as $cor) {
    echo "Cor: $cor\n";
}

// foreach com chave e valor
$pessoa = ["nome" => "Carlos", "idade" => 30];
foreach ($pessoa as $chave => $valor) {
    echo "$chave: $valor\n";
}

6.3. switch e match (PHP 8)

<?php
$opcao = 2;

// switch tradicional
switch ($opcao) {
    case 1:
        echo "Opção 1";
        break;
    case 2:
        echo "Opção 2";
        break;
    default:
        echo "Outra opção";
}

// match (PHP 8+) — mais conciso e seguro
$resultado = match ($opcao) {
    1 => "Opção 1",
    2 => "Opção 2",
    default => "Outra opção",
};
echo $resultado;

7. Inclusão de arquivos e modularização

7.1. include, require, include_once, require_once

<?php
// include: tenta incluir, emite warning se falhar
include "cabecalho.php";

// require: obrigatório, emite fatal error se falhar
require "config.php";

// _once: inclui apenas uma vez (evita redefinições)
require_once "funcoes.php";
include_once "template.php";

7.2. Como o interpretador resolve caminhos

<?php
// Caminho relativo ao arquivo atual
require "includes/funcoes.php";

// Caminho absoluto (recomendado para produção)
require __DIR__ . "/includes/funcoes.php";

// Caminho relativo ao include_path (configuração do php.ini)
require "biblioteca/util.php";

7.3. Boas práticas: separar lógica da apresentação

funcoes.php (lógica):

<?php
function calcularIMC($peso, $altura) {
    return $peso / ($altura * $altura);
}

index.php (apresentação):

<?php require_once "funcoes.php"; ?>
<!DOCTYPE html>
<html>
<body>
    <h1>Calculadora de IMC</h1>
    <p>Seu IMC é: <?php echo calcularIMC(70, 1.75); ?></p>
</body>
</html>

8. Depuração e erros comuns no primeiro script

8.1. Tipos de erro

<?php
// Parse Error: sintaxe inválida (não executa)
// echo "teste  // Faltou fechar aspas

// Fatal Error: função não encontrada, memory exhausted
// funcao_inexistente();

// Warning: problema não fatal (arquivo não encontrado)
include "arquivo_inexistente.php";

// Notice: uso de variável não definida
echo $variavelNaoDefinida;

8.2. Ativando exibição de erros

Para desenvolvimento, coloque no início do script:

<?php
ini_set('display_errors', 1);
ini_set('display_startup_errors', 1);
error_reporting(E_ALL);

8.3. Dicas práticas

<?php
// die() / exit() — interrompe a execução
if (!$conexao) {
    die("Erro de conexão com o banco");
}

// error_log() — registra em log sem exibir ao usuário
error_log("Usuário tentou acessar página restrita");

// Testes simples com var_dump e exit
$dados = obterDados();
var_dump($dados);
exit; // Para a execução para inspecionar

Referências