PHP e páginas dinâmicas com base de dados

Ao receber quantidade=2, o servidor precisa de distinguir uma string válida de um parâmetro ausente, de 2x ou de um array. O PHP faz essa verificação antes de alterar o stock. Corre a cada pedido, e o cliente recebe apenas a saída. Variáveis locais não sobrevivem ao pedido; a base de dados e a sessão conservam o estado necessário.

Valores, strings e arrays

Uma variável começa por $; o valor tem um tipo em execução. === compara valor e tipo, enquanto == admite conversões. Se uma função devolve uma nota de 0 a 20 ou null quando o aluno não existe, verifica !== null. O teste if ($nota) também rejeitaria a nota válida 0.

<?php
$nota = 0;
var_dump($nota !== null); // bool(true)
var_dump((bool) $nota);   // bool(false)
echo 'Nota: ' . $nota;    // Nota: 0

A concatenação usa ., não +. Strings com aspas duplas podem interpolar variáveis; aspas simples tratam o texto mais literalmente, com exceções para a barra e a própria aspa. strlen mede bytes, por isso um caráter UTF-8 pode ocupar mais de uma unidade. Não o confundas com a quantidade de letras visíveis.

Um array PHP é um mapa ordenado de chaves para valores. Pode funcionar como lista ou como registo:

<?php
$livro = ['titulo' => 'Redes', 'preco' => 18];
$nomes = ['Redes', 'SQL'];
$nomes[] = 'Algoritmos';
foreach ($nomes as $indice => $nome) {
    echo $indice, ': ', $nome, "\n";
}

A saída tem as linhas 0: Redes, 1: SQL, 2: Algoritmos. count conta entradas. array_map transforma valores e array_filter escolhe-os; alguns métodos conservam chaves, por isso uma lista filtrada pode não ter índices consecutivos.

Três testes respondem a perguntas diferentes. isset($x) é falso se $x não existe ou vale null. array_key_exists distingue uma chave existente com valor null de uma chave ausente. empty também considera vazios valores como 0 e a string '0', por isso não serve para aceitar um zero válido.

strpos('Redes', 'Red') devolve 0; strpos('Redes', 'SQL') devolve false. A procura deve usar !== false, porque a posição zero é uma correspondência válida. explode(',', 'Redes,SQL') divide numa lista; implode(' / ', $nomes) junta os valores com esse separador.

sort ordena valores e renumera chaves; asort ordena valores conservando as chaves; ksort ordena pelas chaves. As três alteram o array recebido.

Depois de array_filter, usa array_values se precisas de uma lista com índices consecutivos, por exemplo para emitir um array JSON. Sem essa chamada, um filtro que remove a posição 0 conserva a chave 1, e json_encode emite um objeto como {"1":"SQL"}. Com array_values, as chaves voltam a 0 e o resultado é ["SQL"].

Funções, tipos e erros

As funções têm o seu âmbito. Passar um array por valor permite alterá-lo localmente sem alterar o do chamador; um parâmetro com & passa por referência. Objetos têm outra semântica: duas variáveis podem referir o mesmo objeto.

<?php
declare(strict_types=1);
function total(int $preco, int $quantidade = 1): int {
    return $preco * $quantidade;
}
echo total(1250, 2); // 2500

strict_types altera a aceitação de argumentos escalares nas chamadas feitas por esse ficheiro. Não valida parâmetros HTTP nem altera todos os operadores de conversão. Em modo estrito, chamar esta função com '2' em vez de 2 gera TypeError.

Por isso valida e converte a entrada na fronteira antes de chamar funções do domínio. ?int admite inteiro ou null.

Uma classe junta estado e operações. private limita o acesso à classe que declara o membro; protected permite também o acesso nas subclasses; public expõe-o. $this identifica o objeto atual; uma operação static pertence à classe e não tem $this. extends herda de uma única classe e implements declara um contrato de interface. Não precisas de uma classe para cada página: usa-a quando representa um conceito e reúne operações relacionadas.

<?php
class Reserva {
    private int $quantidade;
    public function __construct(int $quantidade) {
        if ($quantidade < 1) throw new InvalidArgumentException('Quantidade inválida');
        $this->quantidade = $quantidade;
    }
    public function unidades(): int { return $this->quantidade; }
}
echo (new Reserva(2))->unidades(); // 2

Para chamar um método estático, usa Classe::metodo(); uma propriedade estática usa Classe::$propriedade. Dentro de métodos, self:: resolve a classe onde o código foi definido, parent:: a classe pai e static:: a classe usada na chamada, respeitando a herança. Uma classe abstract não pode ser instanciada e pode exigir métodos sem implementação; uma interface declara métodos que a classe deve cumprir. final impede estender a classe ou substituir o método marcado.

throw interrompe o percurso normal. Um catch apropriado trata a exceção; finally corre no fim, incluindo quando houve exceção. Distingue um erro de entrada que podes explicar ao utilizador de um erro interno que deves registar sem revelar caminhos, SQL ou segredos ao cliente.

Receber um pedido

$_GET contém parâmetros da query string. $_POST contém parâmetros de corpos codificados como formulário, não qualquer corpo de um POST. Para JSON, lê php://input e usa json_decode. $_SERVER['REQUEST_METHOD'] indica o método.

Um parâmetro enviado pelo cliente pode faltar, ser uma string inesperada ou ser um array, por exemplo quantidade[]=2. No exemplo executável, a entrada é o corpo HTTP; parse_str faz explicitamente o trabalho de descodificar o formulário:

<?php
$entrada = file_get_contents('php://input');
parse_str($entrada, $dados);
$bruto = $dados['quantidade'] ?? null;
$quantidade = is_string($bruto)
    ? filter_var($bruto, FILTER_VALIDATE_INT, ['options' => ['min_range' => 1, 'max_range' => 3]])
    : false;
if ($quantidade === false) {
    echo "Quantidade inválida.
";
    exit;
}
$precoCentimos = 1250;
echo 'Total: ', $quantidade * $precoCentimos, " cêntimos
";

Com quantidade=2 obténs Total: 2500 cêntimos; com quantidade=0, quantidade=2x, corpo vazio ou quantidade[]=2, obténs Quantidade inválida.. Primeiro confirmamos que o valor é string; depois verificamos inteiro entre 1 e 3, porque testar apenas intval('2x') aceitaria 2 e perderia o lixo da entrada.

Numa ação real de formulário, usa $bruto = $_POST['quantidade'] ?? null, verifica o método e devolve um estado de erro adequado. Usa inteiros em cêntimos quando queres contas exatas de dinheiro; números de vírgula flutuante podem introduzir arredondamento.

SQLite e consultas preparadas

O PDO dá uma interface para a base de dados. A conexão escolhe o driver; uma consulta preparada mantém os valores separados do texto SQL:

A consulta pode ser estudada primeiro sem PHP. O ficheiro de apoio cria os mesmos três livros; o filtro conserva os preços inferiores a 20 e a ordenação põe SQL antes de Redes.

SELECT titulo, preco FROM livro WHERE preco < 20 ORDER BY preco;

CREATE TABLE livro (
    id INTEGER PRIMARY KEY,
    titulo TEXT NOT NULL,
    preco INTEGER NOT NULL
);
INSERT INTO livro (titulo, preco) VALUES
    ('Redes', 18), ('Algoritmos', 25), ('SQL', 12);

No programa PHP, a consulta tem um parâmetro :limite. O driver recebe o valor 20 separadamente do texto SQL:

<?php
$db = new PDO('sqlite::memory:');
$db->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
$db->setAttribute(PDO::ATTR_DEFAULT_FETCH_MODE, PDO::FETCH_ASSOC);
$db->exec('CREATE TABLE livro (id INTEGER PRIMARY KEY, titulo TEXT NOT NULL, preco INTEGER NOT NULL)');
$inserir = $db->prepare('INSERT INTO livro (titulo, preco) VALUES (?, ?)');
foreach ([['Redes', 18], ['Algoritmos', 25], ['SQL', 12]] as $livro) {
    $inserir->execute($livro);
}
$consulta = $db->prepare('SELECT titulo, preco FROM livro WHERE preco < :limite ORDER BY preco');
$consulta->execute(['limite' => 20]);
foreach ($consulta->fetchAll() as $livro) {
    echo $livro['titulo'], ': ', $livro['preco'], "
";
}

O programa cria uma base em memória, insere três livros e consulta preços abaixo de 20. Obténs SQL: 12 e Redes: 18, por ordem de preço crescente.

prepare analisa uma instrução com marcadores; execute fornece os valores. fetch obtém uma linha ou false quando não há mais; fetchAll obtém as restantes. PDO::FETCH_ASSOC permite aceder por nomes de colunas, e o modo de exceção torna os erros SQL explícitos.

Para persistir entre pedidos, usa uma base em ficheiro e um caminho estável, por exemplo new PDO('sqlite:' . __DIR__ . '/../database/biblioteca.db'). O processo do servidor precisa de permissão para aceder à base; não a coloques numa pasta pública que permita o download.

Alterar dados de forma consistente

Uma reserva pode exigir reduzir stock e criar uma linha. Uma transação faz com que as alterações sejam confirmadas em conjunto ou anuladas. Este excerto pressupõe a conexão $db, entrada já validada e autenticação e CSRF já verificados:

$db->beginTransaction();
try {
    $stmt = $db->prepare('UPDATE livro SET stock = stock - :q WHERE id = :id AND stock >= :q');
    $stmt->execute(['q' => $quantidade, 'id' => $livroId]);
    if ($stmt->rowCount() !== 1) {
        throw new RuntimeException('Stock insuficiente');
    }
    $stmt = $db->prepare('INSERT INTO reserva (utilizador_id, livro_id, quantidade) VALUES (?, ?, ?)');
    $stmt->execute([$utilizadorId, $livroId, $quantidade]);
    $db->commit();
} catch (Throwable $erro) {
    if ($db->inTransaction()) $db->rollBack();
    throw $erro;
}

Para reservar duas unidades de um livro com stock 3, os estados dentro da transação são:

O commit confirma as duas alterações em conjunto. Se outro pedido tentar reservar duas unidades quando o stock já é 1, a condição stock >= :q falha: o UPDATE não altera linhas e a exceção impede o INSERT. Ler o stock antes e atualizar depois sem condição deixaria uma janela entre os passos. As restrições da base, como chaves estrangeiras, completam a validação; em SQLite, ativa PRAGMA foreign_keys = ON em cada conexão quando dependes delas.

Páginas, ações e templates

Uma página consulta e apresenta. Uma ação recebe entrada, valida, altera dados e redireciona. O template produz HTML a partir de dados já calculados. Coloca a conexão e as consultas numa camada própria, para não repetir SQL nos templates.

Os delimitadores permitem alternar entre PHP e HTML. O texto fora deles é enviado diretamente; <?= ... ?> escreve o valor da expressão. Este exemplo completo recebe os dados numa lista antes de começar a saída:

<?php
$livros = [['titulo' => 'Redes & Web'], ['titulo' => '<SQL>']];
?>
<ul>
<?php foreach ($livros as $livro) { ?>
  <li><?= htmlspecialchars($livro['titulo'], ENT_QUOTES | ENT_SUBSTITUTE, 'UTF-8') ?></li>
<?php } ?>
</ul>

O HTML enviado contém Redes & Web e <SQL>. O navegador apresenta os títulos originais como texto. O ciclo abre num bloco PHP e fecha noutro, envolvendo um li por livro. Guardar o título como texto e escapar ao apresentar permite reutilizá-lo em contextos diferentes.

<?php
require_once __DIR__ . '/../database/livros.php';
require_once __DIR__ . '/../templates/livros.php';
$livros = procurarLivros($db, $termo);
mostrarLivros($livros);

Este é um excerto de organização, com funções definidas nesses ficheiros. require falha quando falta um ficheiro necessário; include pode continuar com aviso. A variante _once evita inclusões repetidas. __DIR__ dá a pasta do ficheiro atual, evitando depender da pasta de execução.

Ao apresentar texto em HTML, usa htmlspecialchars($texto, ENT_QUOTES | ENT_SUBSTITUTE, 'UTF-8'). Uma string válida na base de dados ainda precisa do escape apropriado ao contexto de saída.

header('Location: /reservas/', true, 303);
exit;

header deve correr antes de saída que envie os cabeçalhos. O redirecionamento instrui o cliente; não pára o PHP, por isso usamos exit. Após um POST, 303 leva o navegador a fazer um GET ao destino. Isso evita repetir o POST ao atualizar a página de confirmação.

Sessões e autenticação

HTTP não guarda automaticamente a identidade entre pedidos. session_start() recupera ou cria estado no servidor; um cookie contém habitualmente o identificador da sessão. Não guarda a palavra-passe nem todo o conteúdo de $_SESSION no navegador.

No registo, guarda password_hash($palavraPasse, PASSWORD_DEFAULT). No login, consulta o utilizador pelo identificador e verifica o resumo com password_verify. Este excerto pressupõe $utilizador obtido por consulta preparada:

session_start();
if ($utilizador && password_verify($palavraPasse, $utilizador['password_hash'])) {
    session_regenerate_id(true);
    $_SESSION['utilizador_id'] = $utilizador['id'];
    header('Location: /reservas/', true, 303);
    exit;
}

Segue dois pedidos. No login, o servidor verifica a palavra-passe, regenera o identificador para combater fixação de sessão e guarda utilizador_id no estado do servidor. No pedido seguinte, o navegador envia apenas o identificador no cookie, e o servidor recupera o utilizador a partir dele.

Regenerar o identificador após autenticar é obrigatório nesse percurso. Configura cookies com HttpOnly, Secure em HTTPS e uma política SameSite adequada. Usa um destino fixo ou validado; não confies cegamente no Referer recebido.

Autenticar identifica o utilizador. Autorizar verifica o que ele pode fazer. Uma ação de edição deve confirmar a sessão e a propriedade do registo, mesmo que o botão só apareça para o dono. No logout, limpa $_SESSION, destrói a sessão e remove o cookie quando aplicável. A segurança web explica as defesas que completam estas ações.

Âmbito global e captura de uma variável

Uma função nomeada não recebe automaticamente as variáveis globais. Em precoLocal, a $taxa definida no corpo é local e vale 1; a global começa em 2. global $taxa em mudarTaxa liga o nome local à variável global, permitindo alterá-la.

Uma closure explicita o que conserva do ambiente. use ($taxa) captura o valor quando a função é criada. use (&$taxa) conserva uma referência à variável. Depois de mudar a global para 5, essas duas funções já não usam a mesma taxa:

<?php
$taxa = 2;
function precoLocal(int $base): int {
    $taxa = 1;
    return $base + $taxa;
}
function mudarTaxa(int $nova): void {
    global $taxa;
    $taxa = $nova;
}
$fixa = function (int $base) use ($taxa): int {
    return $base + $taxa;
};
$atual = function (int $base) use (&$taxa): int {
    return $base + $taxa;
};
mudarTaxa(5);
echo precoLocal(10), "\n";
echo $fixa(10), "\n";
echo $atual(10), "\n";
echo $taxa, "\n";

Os nomes iguais não juntam âmbitos diferentes. Sem a declaração local nem global, ler $taxa numa função nomeada não a vai procurar no ficheiro exterior: no PHP 8 gera um aviso de variável indefinida. Os exemplos históricos podem mostrar um aviso menos grave em versões anteriores; não uses essa leitura como passagem de argumentos.

$_POST, $_GET e $_SESSION são superglobais e estão acessíveis dentro de funções sem global. Isso não transforma as variáveis habituais em superglobais. Para uma função de cálculo, passar a taxa como argumento torna a dependência visível na chamada e evita alterar estado global.

Terminar uma referência de foreach

O & em foreach ($notas as &$nota) permite alterar cada posição do array. No fim do ciclo, $nota continua ligada à última posição visitada. O fim das chavetas não termina essa referência:

<?php
$notas = [12, 15, 18];
foreach ($notas as &$nota) {
    ++$nota;
}
$nota = 0;
echo json_encode($notas), "\n";
unset($nota);

$notas = [12, 15, 18];
foreach ($notas as &$nota) {
    ++$nota;
}
unset($nota);
$nota = 0;
echo json_encode($notas), "\n";

No primeiro percurso, incrementar dá [13,16,19], mas $nota = 0 altera a última posição e a saída passa a [13,16,0]. No segundo, unset($nota) desfaz a ligação antes dessa atribuição. O array conserva [13,16,19]; o novo $nota é uma variável independente.

unset aqui remove o nome que ficou como referência, não o último elemento do array. Para só ler notas, usa foreach ($notas as $nota) sem &. Se precisas de as transformar sem esse vínculo posterior, podes atribuir por índice ou criar outra lista com array_map. Não deixes uma referência pendente que o código seguinte possa alterar sem intenção.