🐘 PHP

Introdução ao PHP

A linguagem que roda no servidor e dá vida ao back-end da web. Sim, o elefante é a mascote.

🐘 O que é PHP e sua história

PHP significa PHP: Hypertext Preprocessor. Sim, o nome é uma sigla… que contém a própria sigla dentro dela. Isso se chama acrônimo recursivo, e sim, é exatamente tão hilário quanto parece. A comunidade PHP tem senso de humor assim.

🐘

PHP é como aquele amigo que todo mundo fala mal mas ainda chama na hora de construir uma casa. Todo desenvolvedor já ouviu "PHP é coisa do passado" — e todo desenvolvedor já abriu um WordPress, um Laravel ou um e-commerce rodando PHP no servidor de produção.

Como tudo começou

Em 1994, um cara chamado Rasmus Lerdorf estava cansado de escrever scripts CGI em C para rastrear quem visitava o seu currículo online. Então ele criou um conjunto de ferramentas simples chamado "Personal Home Page tools" — apelidado de PHP/FI. A ideia era pequena, pragmática e, bem… não tinha pretensão nenhuma de virar uma das linguagens mais usadas do mundo.

1994

PHP/FI nasce — Rasmus cria scripts pessoais para rastrear visitas ao seu currículo. Ninguém imagina o que isso vai virar.

1997

PHP 3 — Zeev Suraski e Andi Gutmans reescrevem o motor do zero. O PHP para de ser ferramenta pessoal e vira linguagem de verdade.

2000

PHP 4 — Motor Zend Engine 1. Adoção explode. PHP começa a dominar o back-end da web.

2004

PHP 5 — OOP de verdade chega. Classes, interfaces, exceções. A linguagem cresce como plataforma séria.

2015

PHP 7 — Performance 2x maior que o PHP 5. Type hints, operador ?? (null coalescing). O elefante acelerou.

2020

PHP 8 — JIT (Just-In-Time compiler), match expression, named arguments, union types. PHP entrou de vez na era moderna.

Quem usa PHP hoje?

Segundo as estatísticas mais recentes, cerca de 77% de todos os sites da web com back-end identificado usam PHP. Isso inclui gigantes como:

WordPress — mais de 40% de todos os sites do mundo rodam nele
Wikipedia — sim, a enciclopédia da humanidade
Facebook — usou PHP por anos e criou o Hack (dialeto próprio de PHP)
Laravel, Symfony, CodeIgniter — frameworks modernos e robustos
Drupal, Joomla, Magento — CMSs e e-commerces

Onde PHP se encaixa no fluxo da web

PHP vive no servidor. Quando alguém acessa um site, o PHP processa a lógica, consulta o banco de dados e monta o HTML que o browser vai exibir.

🌐 Browser — usuário digita a URL —

↓

HTTP Request GET /pagina.php

↓

🖥️ Servidor (Apache / Nginx)

↓

Motor PHP executa o arquivo .php

↓

🗄️ Banco de Dados (MySQL) consulta, insere, atualiza dados

↓

PHP monta HTML dinamicamente

↓

HTTP Response HTML puro — o browser não vê PHP

↓

🌐 Browser renderiza a página

💡

Ponto chave: o browser nunca vê o código PHP. Ele recebe apenas o HTML gerado. PHP fica 100% no servidor — por isso é chamado de linguagem server-side.

🌐 Como PHP se relaciona com a Web

JavaScript roda no browser. PHP roda no servidor. Essa é a diferença mais importante. Quando você abre uma página PHP, o servidor executa todo o código e te manda de volta um HTML prontinho — como um restaurante que prepara o prato na cozinha e entrega pronto na mesa.

HTML estático vs página PHP dinâmica

📄 HTML Estático

Arquivo .html — sempre o mesmo conteúdo. Todo mundo que abre vê a mesma coisa.

html

<p>Olá, visitante!</p>
<p>Hoje é... sei lá qual dia.</p>

🐘 Página PHP Dinâmica

Arquivo .php — conteúdo muda conforme lógica, dados do banco, hora do dia, usuário logado etc.

php

<p>Olá, <?= $nomeUsuario ?>!</p>
<p>Hoje é <?= date('d/m/Y') ?>.</p>

A stack LAMP

Historicamente, o ambiente mais clássico para rodar PHP é chamado de LAMP:

Linux

Sistema operacional do servidor. Gratuito, confiável, onipresente em servidores web.

Apache

Servidor web que recebe as requisições HTTP e passa os arquivos .php pro motor PHP processar.

MySQL

Banco de dados relacional. Guarda usuários, posts, produtos — todos os dados da aplicação.

PHP

A linguagem que processa a lógica, consulta o banco e gera o HTML que o browser vai receber.

🛠️

Ambiente local: Para rodar PHP na sua máquina sem configurar nada complexo, use XAMPP (Windows/Mac/Linux) ou Laragon (Windows). Eles instalam Apache + PHP + MySQL de uma vez com alguns cliques.

Tags PHP e como misturar com HTML

O PHP usa a tag <?php para abrir e ?> para fechar. Você pode misturar código PHP com HTML normalmente — o servidor processa as partes PHP e deixa o HTML passar intacto.

php

<!DOCTYPE html>
<html>
<body>

  <!-- PHP misturado com HTML -->
  <?php
    $nome = "Maria";
    $hora = date("H");

    if ($hora < 12) {
        $saudacao = "Bom dia";
    } elseif ($hora < 18) {
        $saudacao = "Boa tarde";
    } else {
        $saudacao = "Boa noite";
    }
  ?>

  <h1><?= $saudacao ?>, <?= $nome ?>!</h1>
  <p>São <?= date("H:i") ?> horas.</p>

</body>
</html>

A tag curta <?= é atalho para <?php echo — perfeita para exibir valores dentro do HTML sem escrever muito.

✏️ Sintaxe básica

PHP tem uma sintaxe bem acessível para quem já viu um pouco de programação. Mas tem algumas regras que você vai esquecer no começo e levar sustos — então vamos cobrir todas elas.

Tags e comentários

php

<?php

// Comentário de uma linha

# Também comentário de uma linha (estilo shell)

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

// Tag curta de saída — atalho para echo
?>
<p>Olá, <?= "mundo" ?>!</p>

Variáveis — sempre com $

Todo nome de variável em PHP começa com o sinal de dólar $. Sem o $, não é variável. Simples assim — e impossível de esquecer depois do terceiro erro de sintaxe.

php

<?php

// Variáveis: sempre começam com $
$nome       = "João";       // string
$idade      = 28;           // integer
$altura     = 1.75;         // float
$ativo      = true;         // boolean
$nada       = null;         // null

// Convenções de nomenclatura
$nomeCompleto     = "camelCase";    // mais comum em variáveis
$nome_completo    = "snake_case";   // também aceito

// Exibir com echo
echo $nome;            // João
echo "Olá, " . $nome;  // ponto (.) concatena strings

// Erro comum: esquecer o $
// echo nome;  ← ERRO! PHP vai procurar uma constante chamada 'nome'

⚠️

Ponto e vírgula é obrigatório! Cada instrução em PHP termina com ;. Esquecer o ponto e vírgula é um dos erros mais clássicos de iniciante. O PHP não vai adivinhar onde a linha termina.

echo vs print

php

<?php

// echo: aceita múltiplos valores, levemente mais rápido
echo "Olá";
echo "Olá", " mundo";  // múltiplos argumentos separados por vírgula

// print: retorna 1 (pode ser usado em expressões), só aceita um valor
print "Olá mundo";

// Concatenação com ponto (.)
$cidade = "São Paulo";
echo "Bem-vindo a " . $cidade . "!";

// Na prática: echo é o mais usado no dia a dia

Case sensitivity — onde importa e onde não importa

php

<?php

// Variáveis são case-sensitive — CUIDADO!
$nome = "Ana";
// echo $Nome;  ← ERRO! $Nome e $nome são variáveis diferentes

// Funções NÃO são case-sensitive — tanto faz
echo("oi");
ECHO("oi");   // funciona igual
strlen("oi");
STRLEN("oi");  // também funciona

📦 Tipos de Dados

PHP é uma linguagem de tipagem dinâmica — você não precisa declarar o tipo da variável, o PHP descobre sozinho. Isso é ótimo para agilidade e pode ser uma fonte de surpresas se você não prestar atenção.

Os tipos principais

Tipo	Exemplo	Descrição
`string`	`"olá"`, `'mundo'`	Texto
`integer`	`42`, `-7`	Número inteiro
`float`	`3.14`, `-0.5`	Número decimal
`boolean`	`true`, `false`	Verdadeiro ou falso
`null`	`null`	Ausência de valor
`array`	`[1, 2, 3]`	Coleção de valores
`object`	`new Classe()`	Instância de classe

var_dump() e gettype() para debugar

php

<?php

$preco = 29.90;
$ativo = true;
$nome  = "Produto X";

// var_dump: mostra tipo + valor (essencial para debug)
var_dump($preco);   // float(29.9)
var_dump($ativo);   // bool(true)
var_dump($nome);    // string(9) "Produto X"

// gettype: retorna o nome do tipo como string
echo gettype($preco);  // double (PHP usa 'double' pra float)
echo gettype($nome);   // string

Aspas simples vs aspas duplas

Uma das diferenças mais importantes para iniciantes PHP:

php

<?php

$nome = "João";

// Aspas DUPLAS: interpolação de variáveis! PHP substitui a variável.
echo "Olá, $nome!";          // Olá, João!
echo "Olá, {$nome}!";        // Olá, João! (chaves deixam mais claro)

// Aspas SIMPLES: texto literal. PHP não interpola nada.
echo 'Olá, $nome!';          // Olá, $nome! (literal)

// Regra prática: use duplas quando precisar de variáveis,
// simples quando for texto puro (levemente mais rápido)

Heredoc e Nowdoc

php

<?php

$usuario = "Maria";

// Heredoc: como aspas duplas, mas para textos longos
$html = <<<EOT
    <div>
        <h1>Bem-vinda, $usuario!</h1>
        <p>Interpolação funciona aqui.</p>
    </div>
EOT;

// Nowdoc: como aspas simples, sem interpolação
$codigo = <<<'EOT'
    echo $variavel; // isso não é interpolado
EOT;

Type casting — convertendo tipos

php

<?php

$valor = "42";          // string

$inteiro = (int) $valor;    // 42 (integer)
$flutuante = (float) $valor; // 42.0 (float)
$texto = (string) 99;        // "99" (string)
$bool = (bool) 0;             // false
$bool2 = (bool) 1;            // true

// intval(), floatval(), strval() são alternativas funcionais
$n = intval("10px");   // 10 — extrai o número do início da string

Funções de string essenciais

strlen($str)

Retorna o número de caracteres da string.

strtolower / strtoupper

Converte para minúsculas ou maiúsculas.

str_replace($old,$new,$str)

Substitui ocorrências de um texto por outro.

substr($str, $start, $len)

Extrai parte de uma string a partir de um índice.

trim($str)

Remove espaços (e outros caracteres) do início e fim.

explode($sep, $str)

Divide string em array. Como split() em outras linguagens.

implode($sep, $arr)

Une array em string. O inverso do explode.

str_contains / str_starts_with

PHP 8: verifica se string contém ou começa com outro texto.

🔀 Condicionais e Loops

Condicionais decidem o que acontece. Loops repetem o que precisa ser repetido. Juntos, eles são o coração de qualquer lógica de programação.

if / elseif / else

php

<?php

$logado = true;
$perfil = "admin";

if ($logado && $perfil === "admin") {
    echo "Bem-vindo, administrador!";
} elseif ($logado) {
    echo "Bem-vindo, usuário!";
} else {
    echo "Por favor, faça login.";
}

// Operador ternário: condição ? valor_se_true : valor_se_false
$msg = $logado ? "Olá!" : "Faça login";

// Null coalescing (PHP 7+): retorna o primeiro valor não-null
$nome = $_GET['nome'] ?? "visitante";

switch

php

<?php

$diaSemana = 3;

switch ($diaSemana) {
    case 1:
        echo "Segunda-feira";
        break;
    case 2:
        echo "Terça-feira";
        break;
    case 3:
        echo "Quarta-feira";
        break;
    default:
        echo "Outro dia";
}

match — o switch moderno (PHP 8)

php 8

<?php

$status = "aprovado";

// match usa comparação estrita (===), não precisa de break,
// e retorna um valor diretamente — muito mais limpo que switch
$msg = match($status) {
    "aprovado"  => "✅ Pedido aprovado!",
    "pendente"  => "⏳ Aguardando aprovação...",
    "recusado"  => "❌ Pedido recusado.",
    default     => "Status desconhecido",
};

echo $msg; // ✅ Pedido aprovado!

Loops

php

<?php

// for: quando você sabe quantas vezes vai repetir
for ($i = 0; $i < 5; $i++) {
    echo "Iteração: $i<br>";
}

// while: enquanto a condição for verdadeira
$contador = 0;
while ($contador < 3) {
    echo "Contando: $contador<br>";
    $contador++;
}

// do...while: executa pelo menos uma vez antes de checar
do {
    echo "Pelo menos uma vez!<br>";
    $contador++;
} while ($contador < 1);

// foreach: perfeito para percorrer arrays
$produtos = ["Tênis", "Camiseta", "Boné"];

foreach ($produtos as $produto) {
    echo "- $produto<br>";
}

// break: interrompe o loop
// continue: pula para a próxima iteração
for ($i = 0; $i < 10; $i++) {
    if ($i === 5) break;       // para ao chegar em 5
    if ($i % 2 === 0) continue; // pula números pares
    echo $i;                    // exibe: 1, 3
}

⚙️ Funções

Funções são blocos de código reutilizáveis. Em vez de escrever a mesma lógica dez vezes, você escreve uma vez, dá um nome, e chama quando precisar. Essa é a base da programação que não te faz querer largar tudo.

Definindo e chamando funções

php

<?php

// Definição básica
function saudacao($nome) {
    return "Olá, $nome!";
}

echo saudacao("Pedro"); // Olá, Pedro!

// Parâmetro com valor padrão
function boasVindas($nome = "visitante") {
    return "Bem-vindo, $nome!";
}

echo boasVindas();         // Bem-vindo, visitante!
echo boasVindas("Ana");    // Bem-vindo, Ana!

Type hints — PHP 7+

A partir do PHP 7, você pode (e deve!) declarar os tipos esperados dos parâmetros e do retorno. Isso previne bugs e torna o código muito mais legível.

php 7+

<?php

// Type hints: tipo do parâmetro : tipo do retorno
function soma(int $a, int $b): int {
    return $a + $b;
}

echo soma(3, 4);  // 7
// soma("oi", 4);  ← TypeError em strict mode

// Nullable type: aceita o tipo ou null
function buscarUsuario(int $id): ?string {
    // Retorna nome ou null se não encontrar
    return $id === 1 ? "Admin" : null;
}

// Union types (PHP 8): aceita mais de um tipo
function formatar(int|float $valor): string {
    return "R$ " . number_format($valor, 2, ',', '.');
}

Escopo de variáveis

php

<?php

$total = 100;  // variável global

function calcularDesconto($pct) {
    // $total não existe aqui! Escopo local.
    // echo $total;  ← undefined variable

    // Para acessar a global, use a keyword global:
    global $total;
    return $total * (1 - $pct / 100);
}

echo calcularDesconto(10); // 90

// Dica: prefira passar como parâmetro em vez de usar global

Funções nativas que você vai usar todo dia

date($format)

Retorna a data/hora atual formatada. Ex: date('d/m/Y')

rand($min, $max)

Número aleatório entre dois valores. Essencial para testes.

isset($var)

Retorna true se a variável existe e não é null. Muito usado com formulários.

empty($var)

Retorna true se a variável está vazia ("", 0, [], null, false).

is_array($var)

Verifica se a variável é um array. Existem funções is_* para todos os tipos.

array_map($fn, $arr)

Aplica uma função em cada elemento do array e retorna um novo array.

array_filter($arr, $fn)

Filtra elementos do array baseado em uma função de callback.

count($arr)

Conta quantos elementos há no array (ou string).

📚 Arrays

Arrays em PHP são superpoderes. Ao contrário de outras linguagens onde arrays e dicionários são coisas separadas, em PHP tudo é array — indexado por número ou por string. Versátil até demais.

Array indexado

php

<?php

// Array indexado (índices numéricos, começa em 0)
$frutas = ["maçã", "banana", "laranja"];

echo $frutas[0];  // maçã
echo $frutas[2];  // laranja

// Adicionar elementos
$frutas[] = "uva";              // adiciona no final
array_push($frutas, "manga");  // equivalente

// Remover último elemento
$ultima = array_pop($frutas);

// Contar elementos
echo count($frutas);  // 4

Array associativo

php

<?php

// Array associativo: chaves personalizadas (como objeto/dicionário)
$usuario = [
    "nome"  => "João",
    "idade" => 25,
    "email" => "joao@email.com",
    "ativo" => true,
];

echo $usuario["nome"];   // João
echo $usuario["idade"];  // 25

// Modificar um valor
$usuario["idade"] = 26;

// foreach com chave => valor
foreach ($usuario as $chave => $valor) {
    echo "$chave: $valor<br>";
}
// nome: João
// idade: 26
// email: joao@email.com
// ativo: 1

Array multidimensional

php

<?php

// Array de arrays — muito comum para representar tabelas/listas
$produtos = [
    ["nome" => "Tênis",    "preco" => 299.90, "estoque" => 15],
    ["nome" => "Camiseta", "preco" => 79.90,  "estoque" => 42],
    ["nome" => "Boné",     "preco" => 49.90,  "estoque" => 8],
];

// Acessar elemento específico
echo $produtos[0]["nome"];   // Tênis
echo $produtos[1]["preco"];  // 79.9

// Percorrer e exibir
foreach ($produtos as $p) {
    echo "{$p['nome']} — R$ {$p['preco']} ({$p['estoque']} em estoque)<br>";
}

Funções de array mais usadas

php

<?php

$numeros = [5, 3, 8, 1, 9, 2];
$frutas  = ["maçã", "banana"];
$legumes = ["cenoura", "brócolis"];

// Ordenar
sort($numeros);   // [1, 2, 3, 5, 8, 9] — ordena in-place

// Ordenação customizada
usort($produtos, function($a, $b) {
    return $a["preco"] <=> $b["preco"]; // operador spaceship
});

// Mesclar arrays
$alimentos = array_merge($frutas, $legumes);

// Verificar se valor existe
if (in_array("banana", $frutas)) {
    echo "Tem banana!";
}

// Obter só as chaves ou só os valores
$chaves  = array_keys($usuario);
$valores = array_values($usuario);

// array_map: transforma cada elemento
$maiusculas = array_map('strtoupper', $frutas);
// ["MAÇÃ", "BANANA"]

// array_filter: filtra elementos (mantém os que passam no callback)
$caros = array_filter($produtos, function($p) {
    return $p["preco"] > 100;
});

// Spread operator (PHP 8) — espalhar array em argumentos
$extra   = ["uva", "manga"];
$todasFrutas = ["maçã", ...$extra]; // ["maçã", "uva", "manga"]

📬 PHP e Formulários HTML

Uma das coisas mais práticas do PHP é processar formulários HTML. O usuário preenche, clica em enviar, o PHP recebe, valida, e faz o que precisar. É a base de 99% dos sites com interação.

$_GET vs $_POST — quando usar cada um

$_GET

Dados aparecem na URL: pagina.php?nome=João&id=5

Bom para buscas e filtros
Pode ser salvo nos favoritos
Visível na URL — não use para senhas
Limite de tamanho pela URL (~2KB)

$_POST

Dados enviados no corpo da requisição HTTP — invisíveis na URL.

Bom para login, cadastro, formulários
Não aparece na URL
Mais seguro para dados sensíveis
Suporta dados maiores e arquivos

Exemplo completo: formulário de contato

O HTML do formulário:

html (contato.html)

<form action="processar.php" method="post">

  <label>Nome:</label>
  <input type="text" name="nome" required>

  <label>E-mail:</label>
  <input type="email" name="email" required>

  <label>Mensagem:</label>
  <textarea name="mensagem" rows="5"></textarea>

  <button type="submit">Enviar</button>

</form>

O PHP que processa (processar.php):

php (processar.php)

<?php

$erros = [];

// 1. Verificar se o formulário foi enviado via POST
if ($_SERVER['REQUEST_METHOD'] === 'POST') {

    // 2. Sanitizar: limpar os dados antes de usar
    $nome     = trim(htmlspecialchars($_POST['nome'] ?? ''));
    $email    = trim(htmlspecialchars($_POST['email'] ?? '')));
    $mensagem = trim(strip_tags($_POST['mensagem'] ?? ''));

    // 3. Validar: checar se os dados fazem sentido
    if (empty($nome)) {
        $erros[] = "Nome é obrigatório.";
    }

    if (!filter_var($email, FILTER_VALIDATE_EMAIL)) {
        $erros[] = "E-mail inválido.";
    }

    if (strlen($mensagem) < 10) {
        $erros[] = "Mensagem muito curta (mínimo 10 caracteres).";
    }

    // 4. Processar se não houver erros
    if (empty($erros)) {
        // Aqui você enviaria e-mail, salvaria no banco etc.
        echo "<p>✅ Mensagem recebida! Obrigado, $nome.</p>";
    } else {
        // Exibir erros
        foreach ($erros as $erro) {
            echo "<p style='color:red'>❌ $erro</p>";
        }
    }
}
?>

🔒

REGRA DE OURO DA SEGURANÇA: NUNCA confie em dados vindos do usuário sem validar e sanitizar. Um usuário mal-intencionado pode enviar qualquer coisa em um formulário — scripts, SQL malicioso, código HTML. Sempre use htmlspecialchars(), strip_tags(), trim() e filter_var() antes de usar qualquer dado do $_POST ou $_GET.

Funções de validação e sanitização

php

<?php

$email = "usuario@exemplo.com";
$idade = "25";
$url   = "https://exemplo.com";

// filter_var: validação
filter_var($email, FILTER_VALIDATE_EMAIL);  // string ou false
filter_var($idade, FILTER_VALIDATE_INT);    // int ou false
filter_var($url,   FILTER_VALIDATE_URL);    // string ou false

// filter_var: sanitização (limpa o valor)
$emailLimpo = filter_var($email, FILTER_SANITIZE_EMAIL);
$numLimpo   = filter_var("R$ 29,90", FILTER_SANITIZE_NUMBER_FLOAT, FILTER_FLAG_ALLOW_FRACTION);

// htmlspecialchars: converte caracteres especiais em entidades HTML
// Evita XSS (Cross-Site Scripting)
$input = '<script>alert("XSS")</script>';
echo htmlspecialchars($input);
// &lt;script&gt;alert("XSS")&lt;/script&gt; — inofensivo!

// strip_tags: remove todas as tags HTML do texto
echo strip_tags("<b>Texto</b> normal"); // Texto normal

Superglobais — uma visão geral

Superglobal

$_POST

Dados enviados via método POST (formulários, APIs). Mais seguro para dados sensíveis.

Superglobal

$_GET

Parâmetros da URL. Ex: ?busca=php → $_GET['busca']

Superglobal

$_REQUEST

Mistura de $_GET, $_POST e $_COOKIE. Prático, mas prefira ser específico.

Superglobal

$_SERVER

Informações do servidor: IP do cliente, método HTTP, URL atual, headers etc.

Superglobal

$_SESSION

Armazena dados entre requisições. Perfeito para manter usuário logado. Use session_start().

Superglobal

$_COOKIE

Acessa cookies enviados pelo browser. Use setcookie() para criar.

Superglobal

$_FILES

Dados de arquivos enviados via upload (type="file"). Contém nome, tipo, tamanho e caminho temporário.

$_SESSION — mantendo o usuário logado

php

<?php
// session_start() DEVE ser a primeira coisa do arquivo
session_start();

// Salvar dados na sessão (após login bem-sucedido)
$_SESSION['usuario_id']   = 42;
$_SESSION['usuario_nome'] = "Maria";
$_SESSION['logado']       = true;

// Verificar se está logado em outra página
if (isset($_SESSION['logado']) && $_SESSION['logado'] === true) {
    echo "Bem-vinda, {$_SESSION['usuario_nome']}!";
} else {
    // Redirecionar para login
    header("Location: login.php");
    exit;
}

// Destruir sessão (logout)
session_destroy();

🍪

Sessão vs Cookie: A sessão guarda os dados no servidor — o browser só guarda um ID de sessão num cookie pequeno. Cookies ficam no browser do usuário — ótimos para lembrar preferências, mas nunca guarde dados sensíveis neles, pois o usuário pode ver e editar cookies.

🐘 Resumo do módulo PHP

PHP é uma linguagem server-side: roda no servidor, gera HTML, o browser nunca vê o código
Arquivos têm extensão .php, código fica entre <?php e ?> (ou <?= para exibir)
Toda variável começa com $ — e ponto e vírgula é obrigatório no fim de cada instrução
Aspas duplas interpolam variáveis; aspas simples são texto literal
PHP 7+ trouxe type hints; PHP 8 trouxe JIT, match, named args e union types
Arrays em PHP são tanto indexados (numérico) quanto associativos (chave => valor)
Formulários enviam dados via $_POST ou $_GET — sempre valide e sanitize antes de usar
htmlspecialchars(), strip_tags() e filter_var() são seus escudos contra XSS e dados inválidos
Sessões ($_SESSION) permitem manter estado entre requisições — base do sistema de login
O ecossistema PHP é enorme: WordPress, Laravel, Symfony, Drupal — há framework pra tudo