$ php -v          # confere a versão instalada (use 8.2 ou superior)
$ php -S localhost:8000   # inicia um servidor na pasta atual

<?php

echo "Olá, mundo! Meu primeiro código PHP.";

<?php

$nome = "Maria";
$idade = 28;
$salarioDesejado = 4500.50;
$empregada = false;

echo "Nome: $nome, idade: $idade";

<?php

const SALARIO_MINIMO = 1518.00; // não pode ser alterada depois
define('EMPRESA', 'TechBR');    // forma alternativa

echo SALARIO_MINIMO;

<?php

// Aritméticos
$soma = 10 + 5;      // 15
$resto = 10 % 3;     // 1  (resto da divisão — cai em entrevista!)
$potencia = 2 ** 10; // 1024

// Concatenação de strings usa PONTO
$nome = "Ana";
$frase = "Olá, " . $nome . "!";

// Atribuição composta
$pontos = 10;
$pontos += 5;  // agora vale 15
$pontos .= "" ; // também existe para strings

// Comparação
var_dump(5 == "5");   // true  — compara só o VALOR
var_dump(5 === "5");  // false — compara valor E tipo

<?php

// Comentário de uma linha

/*
 * Comentário de
 * várias linhas
 */

$x = 1; # também funciona, mas é raro

<?php

$nota = 7.5;

if ($nota >= 7) {
    echo "Aprovado!";
} elseif ($nota >= 5) {
    echo "Recuperação";
} else {
    echo "Reprovado";
}

<?php

$idade = 20;
$status = ($idade >= 18) ? "maior" : "menor";

// Null coalescing (??): usa o valor da direita se o da esquerda for null
$apelido = $usuario['apelido'] ?? "visitante";

<?php

$perfil = "editor";

// switch: o clássico
switch ($perfil) {
    case "admin":
        echo "Acesso total";
        break;
    case "editor":
        echo "Pode editar conteúdo";
        break;
    default:
        echo "Somente leitura";
}

// match (PHP 8+): mais moderno, retorna valor e compara com ===
$permissao = match ($perfil) {
    "admin"  => "Acesso total",
    "editor" => "Pode editar conteúdo",
    default  => "Somente leitura",
};
echo $permissao;

<?php

// while: repete ENQUANTO a condição for verdadeira
$i = 1;
while ($i <= 5) {
    echo "Linha $i\n";
    $i++;
}

// for: quando você sabe quantas vezes repetir
for ($i = 0; $i < 10; $i++) {
    echo $i . " ";
}

// foreach: o mais usado no dia a dia — percorre arrays
$frutas = ["maçã", "banana", "uva"];
foreach ($frutas as $fruta) {
    echo "Fruta: $fruta\n";
}

// break interrompe o laço; continue pula para a próxima volta
foreach ([1, 2, 3, 4, 5] as $n) {
    if ($n === 3) continue; // pula o 3
    if ($n === 5) break;    // para antes do 5
    echo $n; // imprime 1 2 4
}

<?php

$linguagens = ["PHP", "JavaScript", "Python"];

echo $linguagens[0];        // PHP (índices começam em 0!)
$linguagens[] = "Go";       // adiciona no final
echo count($linguagens);    // 4

<?php

$vaga = [
    "titulo"   => "Dev PHP Júnior",
    "salario"  => 3800,
    "remoto"   => true,
    "stack"    => ["PHP 8", "Laravel", "MySQL"],
];

echo $vaga["titulo"];      // Dev PHP Júnior
echo $vaga["stack"][1];    // Laravel (array dentro de array!)

foreach ($vaga as $campo => $valor) {
    // percorre chave e valor ao mesmo tempo
}

<?php

$precos = [100, 250, 80, 400];

// array_map: aplica uma função a cada item
$comDesconto = array_map(fn($p) => $p * 0.9, $precos);

// array_filter: mantém só o que passa no teste
$caros = array_filter($precos, fn($p) => $p > 100);

echo array_sum($precos);            // 830
echo implode(" | ", $precos);       // 100 | 250 | 80 | 400

<?php

$email = "  ANA.silva@Empresa.COM  ";

$limpo = trim($email);                    // remove espaços das pontas
$minusculo = strtolower($limpo);          // ana.silva@empresa.com
echo strlen($minusculo);                  // tamanho da string
echo str_contains($minusculo, "@");      // true (PHP 8+)
echo str_replace("empresa", "tech", $minusculo);
echo ucfirst("olá");                      // Olá
echo mb_strtoupper("ação");              // AÇÃO (mb_* respeita acentos!)

// sprintf: formatação profissional
$preco = 1234.5;
echo sprintf("Total: R$ %.2f", $preco);  // Total: R$ 1234.50
echo number_format($preco, 2, ",", "."); // 1.234,50 (formato brasileiro)

<?php

function calcularFrete(float $peso, string $uf): float
{
    $base = 15.00;
    $porKg = ($uf === "SP") ? 2.50 : 4.00;
    return $base + ($peso * $porKg);
}

echo calcularFrete(3.5, "SP"); // 23.75

<?php

// Valor padrão
function saudar(string $nome, string $saudacao = "Olá"): string
{
    return "$saudacao, $nome!";
}
echo saudar("Ana");                  // Olá, Ana!
echo saudar("Ana", "Bem-vinda");     // Bem-vinda, Ana!

// Argumentos nomeados (PHP 8+)
echo saudar(saudacao: "E aí", nome: "João");

// Variádicos: aceita qualquer quantidade de argumentos
function somar(int ...$numeros): int
{
    return array_sum($numeros);
}
echo somar(1, 2, 3, 4); // 10

<?php

// Função anônima guardada em variável
$dobrar = function (int $n): int {
    return $n * 2;
};

// Arrow function: sintaxe curta, captura variáveis de fora automaticamente
$taxa = 1.1;
$comTaxa = fn(float $preco) => $preco * $taxa;

echo $dobrar(21);      // 42
echo $comTaxa(100);    // 110

<?php

$mensagem = "externa";

function testar(): void
{
    // echo $mensagem; // ERRO! Variáveis de fora não entram sozinhas
}

// ?string = "string OU null"
function buscarApelido(int $id): ?string
{
    return ($id === 1) ? "aninha" : null;
}

<?php
// Acessível em: form.php?nome=Ana
$nome = $_GET['nome'] ?? 'visitante';
?>
<form method="POST" action="processa.php">
  <input type="text" name="email" placeholder="Seu e-mail">
  <input type="password" name="senha" placeholder="Senha">
  <button type="submit">Entrar</button>
</form>

<?php

if ($_SERVER['REQUEST_METHOD'] === 'POST') {
    $email = trim($_POST['email'] ?? '');
    $senha = $_POST['senha'] ?? '';

    if (!filter_var($email, FILTER_VALIDATE_EMAIL)) {
        exit('E-mail inválido.');
    }

    echo "Recebido: " . htmlspecialchars($email);
}

<?php
session_start(); // SEMPRE antes de qualquer saída

// ...após validar e-mail e senha no banco:
$_SESSION['usuario_id'] = 42;
$_SESSION['nome'] = 'Ana';

header('Location: painel.php'); // redireciona
exit;

<?php
session_start();

if (!isset($_SESSION['usuario_id'])) {
    header('Location: login.php');
    exit;
}

echo "Bem-vinda, " . htmlspecialchars($_SESSION['nome']);

// Para sair (logout.php):
// session_destroy();

<?php

class Produto
{
    // Promoção de propriedades no construtor (PHP 8+): declara e atribui de uma vez
    public function __construct(
        private string $nome,
        private float $preco,
        private int $estoque = 0,
    ) {}

    public function getNome(): string
    {
        return $this->nome;
    }

    public function precoFormatado(): string
    {
        return "R$ " . number_format($this->preco, 2, ",", ".");
    }

    public function vender(int $quantidade): void
    {
        if ($quantidade > $this->estoque) {
            throw new InvalidArgumentException("Estoque insuficiente.");
        }
        $this->estoque -= $quantidade;
    }
}

$notebook = new Produto("Notebook", 3499.90, 10);
echo $notebook->getNome();          // Notebook
echo $notebook->precoFormatado();   // R$ 3.499,90
$notebook->vender(2);

<?php

class Funcionario
{
    public function __construct(
        protected string $nome,
        protected float $salarioBase,
    ) {}

    public function calcularSalario(): float
    {
        return $this->salarioBase;
    }
}

class Gerente extends Funcionario
{
    public function calcularSalario(): float
    {
        // Sobrescreve o método do pai e o reutiliza
        return parent::calcularSalario() + 2000; // bônus de gestão
    }
}

$dev = new Funcionario("Ana", 5000);
$gerente = new Gerente("Bruno", 5000);

echo $dev->calcularSalario();     // 5000
echo $gerente->calcularSalario(); // 7000 — polimorfismo em ação!

<?php

interface Pagavel
{
    public function pagar(float $valor): string;
}

class Pix implements Pagavel
{
    public function pagar(float $valor): string
    {
        return "Pagos R$ $valor via Pix (instantâneo).";
    }
}

class Boleto implements Pagavel
{
    public function pagar(float $valor): string
    {
        return "Boleto de R$ $valor gerado (compensa em 2 dias).";
    }
}

// A função aceita QUALQUER classe que cumpra o contrato:
function processarPagamento(Pagavel $metodo, float $valor): void
{
    echo $metodo->pagar($valor);
}

processarPagamento(new Pix(), 100);
processarPagamento(new Boleto(), 100);

<?php

class Config
{
    // static: pertence à CLASSE, não ao objeto
    public static function versao(): string
    {
        return "1.0.0";
    }
}
echo Config::versao(); // acesso com :: sem precisar de new

// Enum (PHP 8.1+): conjunto fechado de valores
enum StatusPedido: string
{
    case Pendente = 'pendente';
    case Pago     = 'pago';
    case Enviado  = 'enviado';
}
$status = StatusPedido::Pago;
echo $status->value; // "pago"

// Trait: reaproveita código entre classes sem herança
trait TemTimestamps
{
    public function criadoEm(): string
    {
        return date('d/m/Y H:i');
    }
}
class Post { use TemTimestamps; }

$ composer init                     # cria o composer.json do projeto
$ composer require vlucas/phpdotenv # instala uma biblioteca
$ composer install                  # instala tudo listado no composer.json

{
    "autoload": {
        "psr-4": {
            "App\\": "src/"
        }
    }
}

<?php

namespace App\Model;

class Produto
{
    // A classe App\Model\Produto DEVE estar em src/Model/Produto.php
}

<?php

require __DIR__ . '/vendor/autoload.php'; // único require do projeto!

use App\Model\Produto;

$p = new Produto();

<?php

function dividir(float $a, float $b): float
{
    if ($b === 0.0) {
        throw new InvalidArgumentException("Divisão por zero não permitida.");
    }
    return $a / $b;
}

try {
    echo dividir(10, 0);
} catch (InvalidArgumentException $e) {
    echo "Erro de argumento: " . $e->getMessage();
} catch (Throwable $e) {
    // Throwable pega qualquer erro/exceção — último recurso
    echo "Erro inesperado: " . $e->getMessage();
} finally {
    echo "\nSempre executa (fechar conexões, liberar recursos...).";
}

<?php

class EstoqueInsuficienteException extends RuntimeException {}

// Uso:
// throw new EstoqueInsuficienteException("Só restam 2 unidades.");
// Vantagem: o catch consegue diferenciar SEU erro de negócio
// de erros genéricos do sistema.

DB_HOST=localhost
DB_NAME=loja
DB_USER=root
DB_PASS=segredo123

<?php
require __DIR__ . '/vendor/autoload.php';

$dotenv = Dotenv\Dotenv::createImmutable(__DIR__);
$dotenv->load();

$host = $_ENV['DB_HOST'];

CREATE DATABASE loja CHARACTER SET utf8mb4;

USE loja;

CREATE TABLE produtos (
    id INT AUTO_INCREMENT PRIMARY KEY,
    nome VARCHAR(120) NOT NULL,
    preco DECIMAL(10,2) NOT NULL,
    estoque INT NOT NULL DEFAULT 0,
    criado_em TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

-- As 4 operações (CRUD):
INSERT INTO produtos (nome, preco, estoque) VALUES ('Teclado', 199.90, 15);
SELECT * FROM produtos WHERE preco < 500 ORDER BY nome;
UPDATE produtos SET estoque = 20 WHERE id = 1;
DELETE FROM produtos WHERE id = 1;

<?php

function conectar(): PDO
{
    $dsn = "mysql:host=localhost;dbname=loja;charset=utf8mb4";

    return new PDO($dsn, "root", "", [
        // Lança exceções em erros (essencial!)
        PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION,
        // Resultados como array associativo
        PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC,
    ]);
}

<?php
require 'conexao.php';

$pdo = conectar();

// CREATE — repare nos placeholders (?): NUNCA concatene valores no SQL
$stmt = $pdo->prepare("INSERT INTO produtos (nome, preco, estoque) VALUES (?, ?, ?)");
$stmt->execute(["Mouse Gamer", 149.90, 30]);
$novoId = $pdo->lastInsertId();

// READ — todos
$produtos = $pdo->query("SELECT * FROM produtos")->fetchAll();
foreach ($produtos as $p) {
    echo "{$p['nome']} — R$ {$p['preco']}\n";
}

// READ — um, com placeholder nomeado
$stmt = $pdo->prepare("SELECT * FROM produtos WHERE id = :id");
$stmt->execute(['id' => $novoId]);
$produto = $stmt->fetch();

// UPDATE
$stmt = $pdo->prepare("UPDATE produtos SET preco = :preco WHERE id = :id");
$stmt->execute(['preco' => 129.90, 'id' => $novoId]);

// DELETE
$stmt = $pdo->prepare("DELETE FROM produtos WHERE id = ?");
$stmt->execute([$novoId]);

echo "Linhas afetadas: " . $stmt->rowCount();

<?php
// Ex.: transferência — debitar de um e creditar em outro deve ser atômico

try {
    $pdo->beginTransaction();

    $pdo->prepare("UPDATE contas SET saldo = saldo - 100 WHERE id = 1")->execute();
    $pdo->prepare("UPDATE contas SET saldo = saldo + 100 WHERE id = 2")->execute();

    $pdo->commit();   // confirma as duas
} catch (Throwable $e) {
    $pdo->rollBack(); // desfaz tudo se qualquer uma falhar
    throw $e;
}

CREATE TABLE pedidos (
    id INT AUTO_INCREMENT PRIMARY KEY,
    produto_id INT NOT NULL,
    quantidade INT NOT NULL,
    FOREIGN KEY (produto_id) REFERENCES produtos(id)
);

-- Junta as duas tabelas pelo relacionamento:
SELECT pedidos.id, produtos.nome, pedidos.quantidade
FROM pedidos
INNER JOIN produtos ON produtos.id = pedidos.produto_id;

<?php

$produto = ["id" => 1, "nome" => "Teclado", "preco" => 199.9];

$json = json_encode($produto);           // array → JSON
$dados = json_decode($json, true);       // JSON → array (true = assoc.)

echo $json; // {"id":1,"nome":"Teclado","preco":199.9}

<?php
require 'conexao.php';

header('Content-Type: application/json; charset=utf-8');

$pdo    = conectar();
$metodo = $_SERVER['REQUEST_METHOD'];
$uri    = parse_url($_SERVER['REQUEST_URI'], PHP_URL_PATH);

// extrai o id de /produtos/5, se houver
preg_match('#^/produtos/?(\d+)?$#', $uri, $m);
$id = $m[1] ?? null;

if (!isset($m[0])) {
    http_response_code(404);
    echo json_encode(['erro' => 'Rota não encontrada']);
    exit;
}

match (true) {
    // GET /produtos → lista todos
    $metodo === 'GET' && $id === null => print(json_encode(
        $pdo->query("SELECT * FROM produtos")->fetchAll()
    )),

    // GET /produtos/5 → busca um
    $metodo === 'GET' => (function () use ($pdo, $id) {
        $stmt = $pdo->prepare("SELECT * FROM produtos WHERE id = ?");
        $stmt->execute([$id]);
        $produto = $stmt->fetch();

        if (!$produto) {
            http_response_code(404);
            echo json_encode(['erro' => 'Produto não encontrado']);
            return;
        }
        echo json_encode($produto);
    })(),

    // POST /produtos → cria
    $metodo === 'POST' => (function () use ($pdo) {
        $corpo = json_decode(file_get_contents('php://input'), true);

        if (empty($corpo['nome']) || !isset($corpo['preco'])) {
            http_response_code(400);
            echo json_encode(['erro' => 'nome e preco são obrigatórios']);
            return;
        }

        $stmt = $pdo->prepare("INSERT INTO produtos (nome, preco) VALUES (?, ?)");
        $stmt->execute([$corpo['nome'], $corpo['preco']]);

        http_response_code(201);
        echo json_encode(['id' => (int) $pdo->lastInsertId()]);
    })(),

    // DELETE /produtos/5
    $metodo === 'DELETE' && $id !== null => (function () use ($pdo, $id) {
        $pdo->prepare("DELETE FROM produtos WHERE id = ?")->execute([$id]);
        http_response_code(204); // sem conteúdo
    })(),

    default => (function () {
        http_response_code(405);
        echo json_encode(['erro' => 'Método não permitido']);
    })(),
};

<?php
// Exemplo real: consultar CEP na API pública ViaCEP

$cep = "01310100";
$json = file_get_contents("https://viacep.com.br/ws/{$cep}/json/");
$dados = json_decode($json, true);

echo $dados['logradouro']; // Avenida Paulista

// Com cURL (mais controle: timeout, headers, POST...):
$ch = curl_init("https://viacep.com.br/ws/{$cep}/json/");
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT        => 10,
]);
$resposta = curl_exec($ch);
$status   = curl_getinfo($ch, CURLINFO_HTTP_CODE);
curl_close($ch);

if ($status === 200) {
    $dados = json_decode($resposta, true);
}

<?php
// VULNERÁVEL — nunca faça isso:
$sql = "SELECT * FROM usuarios WHERE email = '{$_POST['email']}'";
// Se o atacante enviar: ' OR '1'='1  → retorna TODOS os usuários

// SEGURO:
$stmt = $pdo->prepare("SELECT * FROM usuarios WHERE email = ?");
$stmt->execute([$_POST['email'] ?? '']);

<?php
$comentario = '<script>roubarCookies()</script>';

// VULNERÁVEL:
echo $comentario; // o script EXECUTA no navegador da vítima

// SEGURO — vira texto inofensivo na tela:
echo htmlspecialchars($comentario, ENT_QUOTES, 'UTF-8');

<?php

// No CADASTRO:
$hash = password_hash($_POST['senha'], PASSWORD_DEFAULT);
// salve $hash no banco — algo como $2y$10$N9qo8uLOickgx2ZMRZoMye...
// Impossível de reverter; cada hash é único mesmo para senhas iguais.

// No LOGIN:
$stmt = $pdo->prepare("SELECT id, senha_hash FROM usuarios WHERE email = ?");
$stmt->execute([$_POST['email'] ?? '']);
$usuario = $stmt->fetch();

if ($usuario && password_verify($_POST['senha'], $usuario['senha_hash'])) {
    session_start();
    session_regenerate_id(true); // previne fixação de sessão
    $_SESSION['usuario_id'] = $usuario['id'];
} else {
    echo "Credenciais inválidas."; // mensagem genérica de propósito
}

<?php
session_start();

// Ao gerar o formulário:
$_SESSION['csrf'] = $_SESSION['csrf'] ?? bin2hex(random_bytes(32));
?>
<form method="POST">
  <input type="hidden" name="csrf" value="<?= $_SESSION['csrf'] ?>">
  <button>Excluir conta</button>
</form>

<?php
// Ao processar:
if (!hash_equals($_SESSION['csrf'] ?? '', $_POST['csrf'] ?? '')) {
    http_response_code(403);
    exit('Token CSRF inválido.');
}

$ composer create-project laravel/laravel minha-loja
$ cd minha-loja
$ php artisan serve   # http://localhost:8000

<?php

use App\Http\Controllers\ProdutoController;
use Illuminate\Support\Facades\Route;

Route::get('/', fn() => view('welcome'));

Route::get('/produtos', [ProdutoController::class, 'index']);
Route::get('/produtos/{id}', [ProdutoController::class, 'show']);

$ php artisan make:controller ProdutoController

<?php

namespace App\Http\Controllers;

use App\Models\Produto;

class ProdutoController extends Controller
{
    public function index()
    {
        $produtos = Produto::orderBy('nome')->get();

        return view('produtos.index', ['produtos' => $produtos]);
    }

    public function show(int $id)
    {
        $produto = Produto::findOrFail($id); // 404 automático!

        return view('produtos.show', compact('produto'));
    }
}

$ php artisan make:model Produto -m   # -m já cria a migration junto

<?php

public function up(): void
{
    Schema::create('produtos', function (Blueprint $table) {
        $table->id();
        $table->string('nome', 120);
        $table->decimal('preco', 10, 2);
        $table->integer('estoque')->default(0);
        $table->timestamps(); // created_at e updated_at automáticos
    });
}

$ php artisan migrate   # cria a tabela no banco configurado no .env

<?php

use App\Models\Produto;

// CREATE
$p = Produto::create(['nome' => 'Mouse', 'preco' => 89.9, 'estoque' => 10]);
// (requer: protected $fillable = ['nome', 'preco', 'estoque']; no Model)

// READ
$todos   = Produto::all();
$baratos = Produto::where('preco', '<', 100)->orderBy('preco')->get();
$um      = Produto::find(1);

// UPDATE
$um->preco = 79.9;
$um->save();

// DELETE
$um->delete();

// Relacionamentos (no Model Pedido):
// public function produto() { return $this->belongsTo(Produto::class); }
// Uso: $pedido->produto->nome

@extends('layouts.app')

@section('conteudo')
  <h1>Produtos</h1>

  @forelse ($produtos as $produto)
    <p>{{ $produto->nome }} — R$ {{ number_format($produto->preco, 2, ',', '.') }}</p>
  @empty
    <p>Nenhum produto cadastrado.</p>
  @endforelse
@endsection

<?php
// No controller:
public function store(Request $request)
{
    $dados = $request->validate([
        'nome'  => 'required|string|max:120',
        'preco' => 'required|numeric|min:0',
    ]);

    Produto::create($dados);

    return redirect('/produtos')->with('sucesso', 'Produto criado!');
}

<?php

use App\Http\Controllers\Api\ProdutoApiController;

Route::apiResource('produtos', ProdutoApiController::class);
// Uma linha cria: GET /api/produtos, GET /api/produtos/{id},
// POST, PUT/PATCH e DELETE — tudo mapeado para métodos do controller.

<?php

namespace App\Http\Controllers\Api;

use App\Http\Controllers\Controller;
use App\Models\Produto;
use Illuminate\Http\Request;

class ProdutoApiController extends Controller
{
    public function index()
    {
        return Produto::paginate(15); // JSON automático, com paginação!
    }

    public function store(Request $request)
    {
        $dados = $request->validate([
            'nome'  => 'required|max:120',
            'preco' => 'required|numeric',
        ]);

        return response()->json(Produto::create($dados), 201);
    }

    public function show(Produto $produto)  // route model binding: 404 automático
    {
        return $produto;
    }

    public function update(Request $request, Produto $produto)
    {
        $produto->update($request->validate([
            'nome'  => 'sometimes|max:120',
            'preco' => 'sometimes|numeric',
        ]));

        return $produto;
    }

    public function destroy(Produto $produto)
    {
        $produto->delete();

        return response()->noContent(); // 204
    }
}