Guía de PHP: De 0 a 100

¿Qué es PHP?

PHP (PHP: Hypertext Preprocessor) es un lenguaje de programación interpretado, de tipado débil/gradual y multiparadigma, diseñado originalmente para el desarrollo web del lado del servidor. Fue creado por Rasmus Lerdorf en 1994 como un conjunto de scripts Perl para mantener su página personal, evolucionando rápidamente a PHP/FI (Personal Home Page / Forms Interpreter) y luego a una implementación completa con el motor Zend Engine (PHP 4, 2000).

¿Dónde se usa?

• Web (server-side scripting): ~77% de todos los sitios web con servidor conocido usan PHP — WordPress (~43% de toda la web), Laravel, Symfony, Drupal, Joomla
• APIs REST/GraphQL: Laravel con API Resources, Symfony con API Platform, Laravel Sanctum para auth
• E-commerce: Magento (Adobe Commerce), WooCommerce (plugin WordPress), PrestaShop, Shopware
• CMS y portales: WordPress (blog/corporativo), Drupal (gubernamental/educativo), Joomla, TYPO3
• CLI y devops: Composer (gestor de dependencias), PHPUnit (testing), PHPStan/Psalm (análisis estático), Laravel Artisan
• Microservicios: Laravel Lumen, Slim, Flight, Mezzio (ex-Zend Expressive)
• Tiempo real: Ratchet (WebSockets), Swoole (async server), ReactPHP (event loop), amphp

¿Quién lo usa? Facebook (HHVM reemplazó Zend con JIT, aunque ahora usan Hack propio), Wikipedia (PHP + MediaWiki), WordPress.com (.org también), Slack (versión inicial en PHP), Etsy, Mailchimp, Yahoo, Tumblr (versión inicial), Tesla (tienda online en Magento), Pfizer, Adobe (Magento Commerce).

Prerrequisitos

Antes de empezar, necesitas:

• Conocimientos básicos de terminal: navegar directorios, ejecutar comandos, usar un editor de texto
• El lenguaje/herramienta instalado en tu sistema (sigue la sección de Instalación si aún no lo tienes)

Si no cumples algún requisito, no te preocupes: cada sección te guiará paso a paso.

¿Cómo empezar? Instalación en todos los entornos

Windows

1. Descarga el instalador desde windows.php.net/download (versión Thread Safe para Apache, Non-Thread Safe para IIS/CGI)
2. Alternativa todo-en-uno: XAMPP (Apache + PHP + MariaDB + phpMyAdmin) o Laragon (moderno, portable, con Nginx/Apache, MySQL, Redis, Composer incluido)
3. Laragon recomendado: pesa ~40 MB, menú contextual, entornos aislados, Node.js + npm integrado
4. Verifica: abre PowerShell y ejecuta php -v
5. Alternativa vía winget: winget install PHP.PHP.8.3

macOS

• Homebrew (recomendado): brew install php — instala PHP 8.x con extensión mbstring, xml, curl
• Laravel Herd: entorno PHP todo-en-uno con Nginx, PHP 8.x, Composer, DB (brew install herd)
• MAMP: clásico Apache + PHP + MySQL, interfaz gráfica
• Verifica: php -v
• Servidor integrado: php -S localhost:8000

Linux (Debian/Ubuntu)

sudo apt update
sudo apt install php php-cli php-mbstring php-xml php-curl php-mysql php-sqlite3 php-bcmath php-gd php-zip unzip

Para Fedora/RHEL: sudo dnf install php php-cli php-mbstring php-xml php-curl php-mysqlnd php-sqlite3 php-bcmath php-gd php-zip

phpbrew (Linux/macOS/WSL) — versión múltiple

curl -L https://raw.githubusercontent.com/phpbrew/phpbrew/master/phpbrew | bash
# Añade al ~/.bashrc:
echo 'source ~/.phpbrew/bashrc' >> ~/.bashrc
exec $SHELL

phpbrew known                 # Lista versiones disponibles
phpbrew install 8.3 +default  # Compila PHP 8.3 con extensiones por defecto
phpbrew switch 8.3            # Activa PHP 8.3 globalmente

Docker

FROM php:8.3-cli AS base
WORKDIR /app
COPY --from=composer:latest /usr/bin/composer /usr/bin/composer
RUN docker-php-ext-install pdo_mysql mbstring bcmath

FROM base AS dev
RUN pecl install xdebug && docker-php-ext-enable xdebug

FROM base AS prod
COPY . /app
RUN composer install --no-dev --optimize-autoloader
CMD ["php", "public/index.php"]

Usa php:8.3-fpm-alpine para producción con Nginx (~40 MB). Evita php:latest para builds reproducibles.

Alias útiles para el día a día

Añade a tu ~/.bashrc o ~/.zshrc:

alias phpv='php -v'
alias php-serve='php -S localhost:8000'
alias php-repl='php -a'
alias cda='composer dump-autoload -o'
alias cdu='composer update'
alias cdi='composer install'
alias ci='composer init'
alias phpstan='vendor/bin/phpstan analyse src --level=max'
alias pint='vendor/bin/pint'

Escala de aprendizaje: de 0 a 100

Cada nivel incluye lo que debes saber y un proyecto para fijar los conceptos.

Nivel 0–15: Fundamentos absolutos

Qué aprender:

• Sintaxis básica: etiquetas <?php ?>, echo, print, variables con $, tipos (int, float, string, bool, null)
• Tipos de datos escalares y compuestos (ver sección de tipos)
• Condicionales: if/elseif/else, operadores de comparación (==, ===, !=, !==)
• Bucles: for, foreach, while
• Arrays básicos: indexados $arr = [1, 2, 3], asociativos $user = ['nombre' => 'Ana'], count(), isset(), unset()
• Funciones: function, return, parámetros con tipo
• Conceptos clave: PHP es de tipado débil — "1" + 1 da 2 (coerción automática). Usa === para comparación estricta (compara valor Y tipo). Los arrays son tablas hash: isset() es O(1), in_array() es O(n). var_dump() y print_r() para debugging.

Proyecto: Calculadora CLI — el programa pide dos números y una operación (+, -, *, /). Maneja división entre cero y entrada no numérica. Muestra resultado. Reflexión: ¿por qué 0 == "0" da true pero 0 === "0" da false?

Nivel 15–30: Arrays, strings, paradigmas y sistema de archivos

Qué aprender:

• Paradigmas de PHP: imperativo/procedural, POO básico, funcional parcial con closures y arrow functions
• Sistema de archivos: file_get_contents, file_put_contents, fopen/fread/fwrite, fgets, is_file, file_exists, mkdir, scandir, glob
• JSON: json_encode, json_decode
• Array functions: array_map, array_filter, array_reduce, array_merge, array_search, sort/asort/ksort
• Strings: strlen, strpos, substr, str_replace, explode, implode, trim, strtoupper, strtolower
• Funciones variables, funciones anónimas (closures), fn() arrow functions (PHP 7.4+)
• ... spread operator en arrays (PHP 7.4+)
• compact(), extract(), list() / [$a, $b] = $array
• Include/require: require_once, include_once, diferencia y cuándo usar cada uno
• Superglobals: $_GET, $_POST, $_SERVER, $_SESSION, $_COOKIE
• Conceptos clave: isset() vs empty() — empty() devuelve true para "", 0, null, false, []. ?? (null coalescing) vs @ (suppressor) — nunca uses @. Los closures capturan variables con use (&$var). compact() crea array a partir de variables del scope actual.

Proyecto: Gestor de tareas CLI — añadir (php tareas.php add "Comprar leche"), listar (list), completar (done 3), eliminar (rm 3). Persistencia en JSON con file_get_contents/file_put_contents. Usa $_SERVER['argv'] para argumentos.

Nivel 30–45: POO, namespaces, algoritmos y SPL

Qué aprender:

• Clases: class, __construct(), $this, propiedades y métodos
• Visibilidad: public, protected, private
• Constructor promotion (PHP 8.0): function __construct(public string $nombre) {}
• Herencia: extends, parent::, final
• Interfaces: interface, implements
• Traits (PHP 5.4+): trait, use
• Clases abstractas: abstract class, abstract function
• Namespaces: namespace, use, use ... as
• Autoloading PSR-4 con Composer: composer dump-autoload
• Excepciones: try/catch/finally, throw, crear excepciones personalizadas
• Sistema de archivos avanzado: CSV, ZIP, GZ, Fileinfo para MIME, SplFileInfo, SplFileObject
• Algoritmos con SPL: SplStack, SplQueue, SplHeap, SplFixedArray, SplObjectStorage
• Array functions avanzadas: array_intersect, array_diff, array_column, array_walk, array_chunk, array_count_values
• Complejidad Big O de arrays: lookup O(1), búsqueda O(n), sort O(n log n)
• Ordenación personalizada con usort, uasort, uksort
• Conceptos clave: PHP no tiene sobrecarga de métodos (como Java/C++). Los traits resuelven el problema de herencia múltiple sin los problemas del diamante. PSR-4 mapea namespace → directorio: App\Models\User → src/Models/User.php. parent:: llama al método de la clase padre. final impide herencia/override. Las estructuras SPL son más eficientes que arrays nativos para casos concretos.

Proyecto: Sistema de inventario — clases Producto, Inventario con namespaces. Métodos: agregar(), retirar(), buscar(), valor_total(). Persistencia con JSON. Excepciones personalizadas (StockInsuficiente, ProductoNoExiste). Autoloading PSR-4 con Composer.

Nivel 45–60: Testing, análisis estático y empaquetado

Qué aprender:

• PHPUnit: assertSame(), assertInstanceOf(), data providers, setUp, pruebas de excepciones
• Pest PHP: alternativa moderna a PHPUnit con sintaxis más expresiva
• PHPStan: niveles 0–10, PHPDoc con @param, @return, @var
• Psalm: alternativa a PHPStan con detección de código muerto
• Laravel Pint / PHP CS Fixer: formateo automático de código (PSR-12)
• Xdebug: depuración paso a paso, profiling
• Composer scripts: composer run test, composer run phpstan
• Conceptos clave: PHPStan nivel max detecta problemas que no imaginabas. Los type hints PHPDoc son más expresivos que los de PHP nativo (@template, @param class-string, @return Collection<User>). declare(strict_types=1) obligatorio en todos los archivos nuevos.

Proyecto: Calculadora empaquetada — paquete instalable con Composer. Tests con PHPUnit (parametrized, excepciones). PHPStan nivel max. Pint para estilo. GitHub Actions ejecutando composer check.

Nivel 60–75: Web APIs, frameworks y multimedia

Qué aprender:

• Laravel: rutas, controladores, Blade, Eloquent, migraciones, validación, auth
• Symfony: bundles, Doctrine, Twig, Messenger, EventDispatcher
• API Platform: REST/GraphQL automático desde entidades Doctrine
• Laravel API Resources: transformación de respuestas JSON
• JWT / Sanctum: autenticación para APIs
• Logging: Monolog (estándar PSR-3), canales, niveles
• Procesamiento de imágenes con GD y Imagick: redimensionar, recortar, filtros, texto, conversión de formatos
• Video con FFmpeg desde PHP
• Metadatos EXIF de fotos con exif_read_data
• Generación de PDF con TCPDF / FPDF
• Conceptos clave: Service Container (Laravel) / DI Container (Symfony) — no instancies clases manualmente. El patrón Repository desacopla lógica de BD del negocio. Eloquent es Active Record, Doctrine es Data Mapper — elegir según proyecto. GD es nativo pero limitado; Imagick es más potente pero requiere instalación.

Proyecto: API de recetas — Laravel + Eloquent + PostgreSQL o SQLite. CRUD de recetas e ingredientes. Búsqueda por ingrediente. Autenticación con Sanctum. Tests con PHPUnit. Migraciones con schema builder. Validación con Form Request.

Nivel 75–90: Producción, colas y tiempo real

Qué aprender:

• Docker multi-etapa para PHP: php:8.3-fpm-alpine + Nginx, composer install --no-dev
• Docker Compose: app + nginx + mysql + redis + mailpit
• Colas: Laravel Horizon (Redis), Symfony Messenger, RabbitMQ
• Tareas programadas: Laravel Scheduler, cron
• WebSockets: Laravel Echo + Reverb, Soketi, Pusher
• Caché: Redis, Laravel Cache, Symfony Cache
• Monitoreo: Laravel Telescope, Symfony Profiler, clockwork
• Conceptos clave: PHP-FPM tiene un pool de workers — configura pm.max_children según RAM disponible. OpCache es crítico en producción: opcache.enable=1, opcache.revalidate_freq=0. Las colas escalan horizontalmente añadiendo workers.

Proyecto: Dashboard de monitorización — Laravel que recolecta métricas del sistema (CPU, RAM, disco). Redis como cola (Horizon). WebSockets con Laravel Reverb para actualizaciones en vivo. Docker Compose (app + nginx + redis + mysql). Tests de integración.

Nivel 90–100: Arquitectura, alto rendimiento y sistemas distribuidos

Qué aprender:

• CQRS / Event Sourcing con Laravel + Event Sourcing (Spatie) o Ecotone
• Event Driven: RabbitMQ / Kafka, publicación de eventos
• Arquitectura hexagonal / clean architecture en PHP: separación de Domain, Application, Infrastructure
• API Platform: GraphQL, subscripciones, paginación, filtros avanzados
• Swoole / RoadRunner: reemplazar PHP-FPM por servidor persistente (10-50x más requests/segundo)
• Performance: OpCache JIT (PHP 8.0+), preloading, FrankenPHP
• Observabilidad: OpenTelemetry (tracing + metrics + logs), Prometheus + Grafana
• Conceptos clave: PHP-FPM muere después de cada request — Swoole/RoadRunner mantiene el estado en memoria (conexiones BD, caché). El JIT de PHP 8.0+ puede acelerar código CPU-bound hasta 3x. FrankenPHP (escrito en Go) sirve PHP directamente como servidor HTTP/HTTPS.

Proyecto: Sistema de notificaciones distribuidas — microservicios con Laravel + RoadRunner. Event bus con RabbitMQ (usuarios, notificaciones). API Platform para GraphQL BFF. FrankenPHP como servidor. OpenTelemetry para tracing distribuido. Docker Compose + Prometheus + Grafana.

Primeros pasos y configuración del entorno

Si prefieres ver directamente el “Hola Mundo” en PHP, consulta El Atlas del Hola Mundo.

El REPL

PHP incluye un intérprete interactivo. Ejecuta php -a en terminal y escribe directamente:

php > echo "Hola mundo";
php > $suma = 2 + 2;
php > var_dump($suma);
php > $array = [1, 2, 3];
php > array_map(fn($n) => $n ** 2, $array);

Para salir: exit o Ctrl+C.

Servidor integrado para desarrollo

PHP 5.4+ trae un servidor web integrado. Útil para desarrollo y pruebas sin Apache/Nginx:

php -S localhost:8000                    # Servidor simple
php -S 0.0.0.0:8080 -t public/          # Con document root
php -S localhost:8000 router.php        # Con router personalizado

Scripts y estructura de proyecto

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

function main(): void
{
    echo "Hola mundo" . PHP_EOL;
}

main();

Ejecuta: php hola.php

Composer y autoloading (gestor de dependencias)

Composer es el gestor de dependencias de facto en PHP, similar a npm (Node), pip (Python) o cargo (Rust).

# Instalación global
php -r "copy('https://getcomposer.org/installer', 'composer-setup.php');"
php composer-setup.php
php -r "unlink('composer-setup.php');"
mv composer.phar /usr/local/bin/composer

# Iniciar proyecto
composer init --name="usuario/mi-proyecto" --type=project --no-interaction

# Añadir dependencias
composer require laravel/framework
composer require --dev phpunit/phpunit phpstan/phpstan

# PSR-4 autoloading configurado
composer dump-autoload -o  # -o = optimize (genera classmap)

Archivo composer.json básico:

{
    "name": "usuario/mi-proyecto",
    "require": {
        "php": ">=8.2"
    },
    "require-dev": {
        "phpunit/phpunit": "^11.0",
        "phpstan/phpstan": "^1.10"
    },
    "autoload": {
        "psr-4": {
            "App\\": "src/"
        }
    },
    "autoload-dev": {
        "psr-4": {
            "Tests\\": "tests/"
        }
    },
    "scripts": {
        "test": "phpunit",
        "phpstan": "phpstan analyse src --level=max",
        "lint": "vendor/bin/pint",
        "check": ["@lint", "@phpstan", "@test"]
    }
}

Editores recomendados

Los IDEs y editores más usados son VSCode, JetBrains y Neovim. Extensiones y configuraciones recomendadas.

Configuración inicial del proyecto

composer init --name="app/mi-proyecto" --type=project --no-interaction
composer require --dev phpunit/phpunit phpstan/phpstan laravel/pint

Archivo phpstan.neon:

parameters:
    level: max
    paths:
        - src
    checkGenericClassInNonGenericObjectType: true
    checkMissingIterableValueType: true

Archivo phpunit.xml:

<?xml version="1.0" encoding="UTF-8"?>
<phpunit xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:noNamespaceSchemaLocation="vendor/phpunit/phpunit/phpunit.xsd"
         bootstrap="vendor/autoload.php"
         colors="true"
         cacheDirectory=".phpunit.cache">
    <testsuites>
        <testsuite name="Unit">
            <directory>tests/Unit</directory>
        </testsuite>
    </testsuites>
    <source>
        <include>
            <directory>src</directory>
        </include>
    </source>
</phpunit>

Xdebug (depurador paso a paso)

# Linux (PECL)
pecl install xdebug

# Verificar instalación
php -v | grep Xdebug

# Configuración php.ini
zend_extension=xdebug.so
xdebug.mode=develop,debug,profile
xdebug.start_with_request=yes
xdebug.idekey=VSCODE
xdebug.client_host=127.0.0.1
xdebug.client_port=9003

Paradigmas en PHP

PHP es un lenguaje multiparadigma. Puedes (y acabarás) usando varios paradigmas en un mismo proyecto.

Imperativo / Procedural

Es el paradigma original de PHP. La ejecución es secuencial, se usan funciones y variables globales. Fue el estilo dominante hasta PHP 4 (2000) y sigue presente en código legacy y scripts simples.

<?php
$nombre = "Mundo";
echo "Hola, $nombre";

POO (Programación Orientada a Objetos)

PHP 5 (2004) trajo un modelo de objetos completo. PHP 8.x lo ha refinado con constructor promotion, readonly, enums, etc.

<?php
declare(strict_types=1);

interface Logger
{
    public function log(string $msg): void;
}

trait Timestampable
{
    public function timestamp(): string
    {
        return date('Y-m-d H:i:s');
    }
}

abstract class Service
{
    abstract public function handle(): void;
}

class UserService extends Service implements Logger
{
    use Timestampable;

    public function __construct(
        private string $name,
    ) {}

    public function log(string $msg): void
    {
        echo "[{$this->timestamp()}] $msg";
    }

    public function handle(): void
    {
        $this->log("Procesando {$this->name}");
    }
}

Funcional (parcial)

PHP tiene soporte funcional limitado pero útil: closures, arrow functions, y funciones de orden superior.

<?php
$numbers = [1, 2, 3, 4, 5];

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

$cuadrado = fn(int $n): int => $n ** 2;

$pares = array_filter($numbers, fn($n) => $n % 2 === 0);
$doblados = array_map(fn($n) => $n * 2, $numbers);
$suma = array_reduce($numbers, fn($c, $n) => $c + $n, 0);

Declarativo (SQL embebido)

PHP nació para generar HTML con acceso a BD. Históricamente, el SQL se mezclaba directamente con el código PHP.

<?php
$link = mysqli_connect('localhost', 'user', 'pass', 'db');
$result = mysqli_query($link, 'SELECT * FROM usuarios WHERE activo = 1');
while ($row = mysqli_fetch_assoc($result)) {
    echo $row['nombre'];
}

Tipos de datos y variables

Variables

¿Qué es?

En PHP, toda variable empieza por $. No necesitan declaración previa ni tipo explícito — el tipado es dinámico aunque desde PHP 5 se pueden declarar tipos en funciones y desde PHP 7.4 en propiedades. La primera asignación define el tipo y el contenido.

🔗 PHP Manual — Variables

Sintaxis básica

<?php
$nombre = "Ana";        // string
$edad = 28;             // int
$precio = 29.99;        // float
$activo = true;         // bool
$datos = null;          // null

🧪 Cómo probarlo

<?php
// variables.php
$nombre = "Ana";
$edad = 28;
var_dump($nombre); // string(3) "Ana"
var_dump($edad);   // int(28)
echo '$nombre vale ' . $nombre;

// Test con PHPUnit
// vendor/bin/phpunit --filter testVariables
// public function testVariables(): void {
//     $nombre = "Ana";
//     $this->assertSame("Ana", $nombre);
// }

💡 Memoria y rendimiento

• Las variables son contenedores zval que almacenan tipo, valor y refcount
• Copy-on-write: asignar $b = $a no copia hasta que se modifica
• unset() decrementa refcount, el GC libera cuando llega a 0
• Las superglobales ($_GET, $_POST, $_SERVER) existen siempre en request — no las reasignes sin necesidad

✅ Buenas prácticas

• Usa nombres descriptivos en camelCase o snake_case (elige uno y sé consistente)
• ✅ Declara tipos en propiedades y funciones desde PHP 7.4+
• ✅ Inicializa variables explícitamente
• ❌ Nunca uses extract() en datos del usuario — permite inyección de variables
• ❌ No confíes en register_globals (eliminado en PHP 5.4)
• ⚠️ $_GET, $_POST contienen strings — conviértelos explícitamente con (int) o intval()

🏗️ Metodología

Las variables en PHP se usan en todos los paradigmas. En scripts pequeños, las globales son aceptables. En proyectos grandes (>10k líneas), encapsula todo en clases o funciones con inyección de dependencias.

🔗 Para saber más

• PHP Manual — Variable basics
• PHP The Right Way — Variables

Tipos escalares

¿Qué es?

PHP tiene cuatro tipos escalares: int, float, string y bool. Son los bloques básicos sobre los que se construyen todos los demás tipos. Internamente, el Zend Engine los representa como estructuras C dentro del contenedor zval.

🔗 PHP Manual — Scalar Types

Sintaxis básica

<?php
$entero = 42;
$flotante = 3.14;
$texto = "Hola";
$booleano = true;

🧪 Cómo probarlo

php -r 'var_dump(is_int(42), is_float(3.14), is_string("a"), is_bool(true));'

💡 Memoria y rendimiento

✅ Buenas prácticas

• Usa === para comparar escalares (compara tipo y valor)
• Convierte explícitamente: (int) $input, strval(), floatval()
• ⚠️ 0 == "foo" devuelve true en modo débil — usa ===
• Prefiere declare(strict_types=1) en archivos nuevos

🏗️ Metodología

Los escalares son la base de cualquier programa PHP. Úsalos directamente para datos simples. Para datos complejos con validación, envuélvelos en Value Objects.

🔗 Para saber más

• PHP Manual — Integer
• PHP Manual — Float

Strings

¿Qué es?

Los strings en PHP son secuencias de bytes. No hay codificación Unicode nativa — para UTF-8 se necesita la extensión mbstring (multibyte string). PHP soporta 4 sintaxis distintas de strings: comillas simples, dobles, heredoc y nowdoc.

🔗 PHP Manual — Strings

Sintaxis básica

<?php
$nombre = "Ana";
$s1 = 'Hola $nombre';        // literal: "Hola $nombre"
$s2 = "Hola $nombre";        // interpolado: "Hola Ana"
$s3 = <<<TEXT                // heredoc
Línea 1
Línea 2
TEXT;
$s4 = <<<'TEXT'              // nowdoc (sin interpolación)
Línea $nombre
TEXT;

echo mb_strlen('ññ');        // 2 (no 4 como strlen)
echo mb_substr('café', 2);   // 'fé'

🧪 Cómo probarlo

<?php
// strings.php
$nombre = "Ana";
$saludo = "Hola, $nombre";
assert($saludo === "Hola, Ana");

$longitud = mb_strlen('ññ');
assert($longitud === 2);

💡 Memoria y rendimiento

• Las strings son mutables pero la reasignación crea una nueva
• mbstring es ~2x más lento que strlen/substr pero necesario para UTF-8
• Para concatenación masiva, usa implode() o sprintf() en vez de .= en bucles
• Las strings entre comillas dobles se parsean en busca de variables — es marginalmente más lento que comillas simples

✅ Buenas prácticas

• Usa mb_* funciones para cualquier texto con acentos/ñ/emojis
• Prefiere sprintf() o implode() sobre concatenación con .
• ⚠️ strlen('café') da 5 (no 4) porque ‘é’ ocupa 2 bytes en UTF-8
• ❌ No uses $$ para variables variables con strings del usuario

🏗️ Metodología

Las strings en PHP son el tipo más ubicuo — se usan para HTML, SQL, JSON, rutas. Para textos cortos usa comillas simples. Para textos con formato usa heredoc. Para internacionalización, encapsula strings en funciones __() o similar.

🔗 Para saber más

• PHP Manual — String functions
• PHP Manual — mbstring

Arrays

¿Qué es?

Los arrays de PHP son mapas ordenados — internamente son tablas hash que mantienen el orden de inserción. Pueden funcionar como listas, diccionarios, pilas, colas, conjuntos, etc. Es la estructura de datos más versátil y la más usada en PHP.

🔗 PHP Manual — Arrays

Sintaxis básica

<?php
$nums = [1, 2, 3, 4, 5];
$user = ['nombre' => 'Ana', 'edad' => 28];

$cuadrados = array_map(fn($n) => $n ** 2, $nums);
$pares = array_filter($nums, fn($n) => $n % 2 === 0);
$suma = array_reduce($nums, fn($c, $n) => $c + $n, 0);

$merged = array_merge([1, 2], [3, 4]);
$keys = array_keys($user);
$vals = array_values($user);
$pos = array_search(3, $nums);
$existe = in_array(3, $nums);

sort($nums);  rsort($nums);  asort($nums);  ksort($nums);
usort($nums, fn($a, $b) => $a <=> $b);

🧪 Cómo probarlo

<?php
$nums = [1, 2, 3, 4, 5];
$pares = array_filter($nums, fn($n) => $n % 2 === 0);
assert($pares === [2, 4]);

$suma = array_reduce($nums, fn($c, $n) => $c + $n, 0);
assert($suma === 15);

💡 Memoria y rendimiento

Cada array tiene overhead ~56 bytes + 32 bytes por elemento (zval + hash bucket).

✅ Buenas prácticas

• ✅ Usa array_map/array_filter/array_reduce en lugar de foreach para transformaciones
• ✅ isset() es O(1), prefiérelo sobre array_key_exists() con valores null
• ⚠️ foreach con & (referencia) requiere unset() después para evitar efectos laterales
• ❌ No uses extract() — dificulta el seguimiento de variables
• ❌ No mezcles índices numéricos y asociativos en el mismo array

🏗️ Metodología

Los arrays en PHP son todoterreno. Para datos simples: arrays numéricos. Para registros: arrays asociativos. Para colecciones grandes (>100k elementos): SplFixedArray. Para pilas/colas: SplStack/SplQueue. Para conjuntos: usa claves de array como $set[$valor] = true.

🔗 Para saber más

• PHP Manual — Array functions
• PHP Manual — SPL Data Structures

Gestión de memoria en PHP

¿Qué es?

PHP usa el Zend Engine con un administrador de memoria propio que gestiona zval (contenedores de valor), copy-on-write y garbage collection cíclico. Es importante entenderlo para escribir código eficiente y evitar fugas de memoria.

🔗 PHP Manual — GC

Sintaxis básica

<?php
$a = range(1, 1000000);
$b = $a;       // refcount = 2, sin copia (copy-on-write)
$b[0] = 999;   // aquí se copia (separación)
unset($a);     // decrementa refcount

🧪 Cómo probarlo

php -r '
$a = range(1, 1000);
$b = $a;
debug_zval_ref($a);
'

💡 Memoria y rendimiento

• zval: 16 bytes + 8 bytes por valor (tipos simples) + hash bucket (~24 bytes en arrays)
• Copy-on-write: asignar no copia hasta que modificas — ahorra memoria masivamente
• GC cíclico: no existía hasta PHP 5.3; desde PHP 7.3+ está siempre activo
• ⚠️ Referencias circulares: objetos que se apuntan mutuamente no se liberan hasta el GC cíclico
• memory_get_usage() y memory_get_peak_usage() para monitorizar

✅ Buenas prácticas

• ✅ unset() grandes estructuras cuando ya no las necesites
• ✅ Usa SplFixedArray para arrays grandes de tamaño fijo
• ⚠️ Las referencias (&) rompen el copy-on-write
• ⚠️ Los generadores (yield) mantienen memoria constante incluso con datos grandes

🏗️ Metodología

Para scripts pequeños (<1k líneas) no te preocupes por la memoria. Para aplicaciones grandes, usa profiling con Xdebug y monitoriza con memory_get_usage(). Los generadores son la herramienta clave para procesar archivos grandes (logs, CSV) sin agotar memoria.

🔗 Para saber más

• PHP Manual — Reference Counting
• PHP Manual — Memory Management

Control de flujo y modularidad

Condicionales

¿Qué es?

PHP ofrece las estructuras típicas de control: if/elseif/else, switch, y desde PHP 8.0 la expresión match. Las condicionales controlan qué bloques de código se ejecutan según una condición booleana.

🔗 PHP Manual — Control Structures

Sintaxis básica

<?php
$edad = 18;

if ($edad < 12) {
    echo "Niño";
} elseif ($edad < 18) {
    echo "Adolescente";
} else {
    echo "Adulto";
}

switch ($edad) {
    case 18:
        echo "Recién adulto";
        break;
    default:
        echo "Otra edad";
}

$categoria = match (true) {
    $edad < 12 => 'Niño',
    $edad < 18 => 'Adolescente',
    $edad < 65 => 'Adulto',
    default    => 'Senior',
};

🧪 Cómo probarlo

php -r '
$edad = 18;
$cat = match (true) { $edad < 12 => "Niño", $edad < 65 => "Adulto", default => "Senior" };
var_dump($cat);
'

💡 Memoria y rendimiento

• match es tan rápido como switch pero más seguro (tipado estricto)
• if/elseif con muchas ramas (>10) puede beneficiarse de un array mapa en vez de condicionales
• switch con break olvidado es la fuente #1 de bugs en condicionales

✅ Buenas prácticas

• ✅ Prefiere match sobre switch desde PHP 8.0
• ⚠️ Nunca olvides break en switch
• ✅ Usa early returns para evitar anidamiento profundo
• ❌ No uses else después de return — es código muerto

🏗️ Metodología

Para 2-3 ramas usa if/else. Para múltiples valores fijos usa match. Para lógica compleja con side effects usa if con guards. En código funcional, prefiere match como expresión que retorna valor.

🔗 Para saber más

• PHP 8.0 Match Expression RFC
• PHP Manual — Comparison Operators

Bucles

¿Qué es?

PHP soporta 4 tipos de bucles: for, foreach, while y do/while. foreach es el más usado por su sintaxis limpia con arrays. Los bucles pueden anidarse y usar break N para salir de múltiples niveles.

🔗 PHP Manual — Loops

Sintaxis básica

<?php
$nums = [1, 2, 3, 4, 5];

for ($i = 0; $i < count($nums); $i++) {
    echo $nums[$i];
}

foreach ($nums as $valor) {
    echo $valor;
}

foreach ($nums as &$valor) {
    $valor *= 2;
}
unset($valor);

$user = ['nombre' => 'Ana', 'edad' => 28];
foreach ($user as $clave => $valor) {
    echo "$clave: $valor";
}

$i = 0;
while ($i < 5) {
    echo $i++;
}

$i = 0;
do {
    echo $i++;
} while ($i < 5);

for ($i = 0; $i < 10; $i++) {
    for ($j = 0; $j < 10; $j++) {
        if ($i === 2 && $j === 3) break 2;
    }
}

🧪 Cómo probarlo

php -r '
$nums = [1, 2, 3];
$sum = 0;
foreach ($nums as $n) $sum += $n;
var_dump($sum); // int(6)
'

💡 Memoria y rendimiento

• foreach sobre arrays es O(n) — tan eficiente como for
• for ($i = 0; $i < count($arr); $i++) evalúa count() en cada iteración — guarda el tamaño en variable
• foreach con & (referencia) mantiene la referencia después del bucle — siempre usa unset()
• Los generadores (yield) evitan construir el array completo en memoria

✅ Buenas prácticas

• ✅ foreach sobre for para arrays — más legible y seguro
• ⚠️ Siempre unset() la referencia después de foreach (&$v)
• ✅ break 2 para salir de bucles anidados
• ❌ No modifiques el array mientras iteras con foreach

🏗️ Metodología

Usa foreach para recorrer colecciones (95% de los casos). Usa for cuando necesites un índice numérico. Usa while para buques basados en condición (lectura de archivos, streams). Usa do/while cuando necesites ejecutar al menos una vez.

🔗 Para saber más

• PHP Manual — foreach
• PHP Manual — Generators

Excepciones

¿Qué es?

PHP tiene un sistema de excepciones con try/catch/finally. Desde PHP 7.1 puedes capturar múltiples tipos en un mismo catch con pipe (|). Throwable es la interfaz base que implementan Exception y Error.

🔗 PHP Manual — Exceptions

Sintaxis básica

<?php
try {
    if (!file_exists('datos.json')) {
        throw new \RuntimeException('Archivo no encontrado');
    }
    $data = file_get_contents('datos.json');
} catch (\RuntimeException $e) {
    echo "Error: {$e->getMessage()}";
} catch (\Throwable $e) {
    echo "Error inesperado: {$e->getMessage()}";
} finally {
    echo "Limpieza";
}

$nombre = $_GET['name'] ?? throw new \InvalidArgumentException('Name required');

🧪 Cómo probarlo

<?php
// exceptions.php
function dividir(int $a, int $b): float {
    if ($b === 0) throw new \DivisionByZeroError('División por cero');
    return $a / $b;
}

try {
    echo dividir(10, 0);
} catch (\DivisionByZeroError $e) {
    echo "Error: " . $e->getMessage();
}

💡 Memoria y rendimiento

• Lanzar excepciones es lento (~1000x más que un if) — úsalas para errores excepcionales, no para control de flujo
• El bloque finally se ejecuta siempre, incluso si hay return en try
• throw como expresión (PHP 8.0) permite lanzar en lugares donde antes no se podía (operador ternario, null coalescing)

✅ Buenas prácticas

• ✅ Captura excepciones específicas, no \Exception a secas
• ✅ Usa finally para liberar recursos (archivos, BD)
• ⚠️ No uses excepciones para control de flujo normal
• ✅ Personaliza excepciones extendiendo \RuntimeException o \DomainException

🏗️ Metodología

Las excepciones son para situaciones excepcionales. Para validación de input del usuario, prefiere devolver errores. Para errores de infraestructura (BD caída, archivo no encontrado), la excepción es correcta. En APIs, captura en un middleware global.

🔗 Para saber más

• PHP Manual — Exception hierarchy
• PHP The Right Way — Errors

Namespaces y autoloading

¿Qué es?

Los namespaces organizan el código PHP evitando colisiones de nombres. El autoloading carga clases automáticamente sin require manual. PSR-4 es el estándar de la comunidad y Composer lo implementa por defecto.

🔗 PHP Manual — Namespaces

Sintaxis básica

<?php
// src/Models/Usuario.php
namespace App\Models;

use App\Core\Model;
use function array_map;
use const PHP_EOL;

class Usuario extends Model {}

<?php
require_once __DIR__ . '/vendor/autoload.php';
include_once 'config.php';

{
    "autoload": {
        "psr-4": {
            "App\\": "src/"
        },
        "classmap": ["src/Legacy"],
        "files": ["src/helpers.php"]
    }
}

<?php
spl_autoload_register(function (string $class): void {
    $file = __DIR__ . '/src/' . str_replace('\\', '/', $class) . '.php';
    if (file_exists($file)) {
        require_once $file;
    }
});

🧪 Cómo probarlo

# Verifica autoloading
php -r '
require "vendor/autoload.php";
var_dump(class_exists("App\\Models\\Usuario"));
'

💡 Memoria y rendimiento

• Composer genera un classmap optimizado con composer dump-autoload -o
• El autoloading PSR-4 con optimización convierte todo a classmap (O(1) lookup)
• include_once es ligeramente más lento que include por la comprobación
• require es igual de rápido que include pero para errores fatales

✅ Buenas prácticas

• ✅ Sigue PSR-4 estrictamente: App\Models\Usuario → src/Models/Usuario.php
• ✅ Ejecuta composer dump-autoload -o en producción
• ✅ Siempre require __DIR__ . '/vendor/autoload.php' en el entry point
• ❌ No mezcles require, include y autoloading — usa solo Composer

🏗️ Metodología

Para proyectos pequeños (<5 clases), el autoloading manual con spl_autoload_register basta. Para cualquier proyecto que use dependencias externas, Composer es obligatorio. Usa PSR-4 como convención de nombres — es el estándar de la industria.

🔗 Para saber más

• PHP-FIG — PSR-4 Autoloader
• Composer — Autoloading

Conceptos clave explicados a fondo

Tipado débil/gradual y sistema de tipos

PHP tradicionalmente es de tipado dinámico: una variable puede cambiar de tipo en cualquier momento. Sin embargo, desde PHP 7.0 (2015) se introdujeron declaraciones de tipo escalar (int, string, float, bool), y desde PHP 7.4 (2019) typed properties en clases.

PHP 8.0 (2020) trajo union types, mixed, y el atributo #[\\ReturnTypeWillChange]. PHP 8.1 (2021) añadió never, readonly properties, y intersection types (en interfaces). PHP 8.2 (2022) introdujo null como tipo independiente y true/false como tipos independientes.

strict_types — el modo estricto:

<?php
declare(strict_types=1);

function suma(int $a, int $b): int {
    return $a + $b;
}

echo suma(1, 2);    // 3
echo suma("1", 2);  // TypeError: Argument #1 ($a) must be of type int, string given

Sin declare(strict_types=1), PHP coerrea automáticamente: suma("1", 2) devuelve 3 sin error (coerción débil). Con strict types, los tipos se verifican estrictamente.

Tabla de coerciones (modo débil vs estricto):

Tipos disponibles en PHP 8.3+:

• Escalares: int, float, string, bool
• Compuestos: array, object, callable, iterable
• Especiales: mixed (cualquier tipo), never (nunca retorna), void (no retorna valor), null (solo null), true, false
• Uniones: int|string|float, string|null (equivalente a ?string)
• Intersecciones: Countable&ArrayAccess (PHP 8.1+)
• DNF (Disjunctive Normal Form): (Countable&ArrayAccess)|string (PHP 8.2+)

Variables, alcance y variables variables

PHP usa el prefijo $ para todas las variables. No hay declaración explícita: una variable existe desde la primera asignación.

Alcance (scope):

<?php
$global = "soy global";  // Variable global

function test(): void {
    $local = "soy local";  // Variable local a la función
    
    // Para acceder a global dentro de una función:
    global $global;
    echo $global;
    
    // O mediante $GLOBALS:
    echo $GLOBALS['global'];
    
    // Variable estática: persiste entre llamadas
    static $contador = 0;
    $contador++;
    echo $contador;  // 1, 2, 3...
}

test();
echo $local;  // Warning: Undefined variable $local (no accesible fuera)

Variables variables ($$):

<?php
$nombre = "framework";
$$nombre = "Laravel";  // Crea $framework = "Laravel"
echo $framework;       // "Laravel"
echo ${$nombre};       // "Laravel"
echo ${$nombre[0]};    // Accede a $f (primera letra de "framework")

// Útil para acceso dinámico
$tipo = "db";
${$tipo . "_host"} = "localhost";  // Crea $db_host = "localhost"

Por qué PHP usa $?

El $ diferencia variables de funciones/constantes. foo() es una función, $foo es una variable, FOO es una constante. Esto elimina ambigüedades en parsing y permite interpolación directa en strings: "Hola $nombre".

Referencias (&) — paso por referencia:

<?php
function añadir(&$array, $valor): void {
    $array[] = $valor;  // Modifica el array original
}

$nums = [1, 2];
añadir($nums, 3);
print_r($nums);  // [1, 2, 3]

A diferencia de Python (todo pass-by-object-reference), PHP permite paso explícito por referencia con &. Sin referencia, las variables se copian (copy-on-write mediante el zend_value interno).

Arrays: la estructura de datos más versátil de PHP

Los arrays en PHP son mapas ordenados (tablas hash internamente). Pueden funcionar como listas, diccionarios, pilas, colas, conjuntos, etc.

Indexados y asociativos:

<?php
// Indexado (array list)
$numeros = [1, 2, 3, 4, 5];

// Asociativo (hash map)
$usuario = [
    'nombre' => 'Ana',
    'email' => 'ana@email.com',
    'edad' => 28,
];

// Mixto (no recomendado pero posible)
$mixto = [
    'clave' => 'valor',
    0 => 'cero',
    true => 'uno',  // true se convierte a 1
];

// Arrays multidimensionales
$matrix = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9],
];

Array functions esenciales:

<?php
$nums = [1, 2, 3, 4, 5];

// Map, filter, reduce
$cuadrados = array_map(fn($n) => $n ** 2, $nums);
$pares = array_filter($nums, fn($n) => $n % 2 === 0);
$suma = array_reduce($nums, fn($carry, $n) => $carry + $n, 0);

// Búsqueda
$pos = array_search(3, $nums);        // 2 (índice), false si no existe
$existe = in_array(3, $nums);         // true/false
$claves = array_keys($usuario);       // ['nombre', 'email', 'edad']
$valores = array_values($usuario);    // ['Ana', 'ana@email.com', 28]

// Ordenación (modifica el array original)
sort($nums);        // Orden ascendente (valores)
rsort($nums);       // Orden descendente
asort($nums);       // Ordena manteniendo asociación clave-valor
ksort($nums);       // Ordena por claves
usort($nums, fn($a, $b) => $a <=> $b);  // Orden personalizado con spaceship

// Manipulación
$slice = array_slice($nums, 0, 3);      // [1, 2, 3] (no modifica original)
$removed = array_splice($nums, 1, 2);   // Elimina desde índice 1, 2 elementos
$merged = array_merge([1, 2], [3, 4]);  // [1, 2, 3, 4]
$diff = array_diff([1, 2, 3], [2, 4]);  // [1, 3] (valores en primero no en segundo)
$intersect = array_intersect([1, 2, 3], [2, 3, 4]); // [2, 3]

// Comprobar tipo
echo is_array($nums);        // true
echo is_list($nums);         // true si índices son 0, 1, 2... secuenciales (PHP 8.1+)
echo array_is_list($nums);   // mismo que is_list

// Spread operator en arrays (PHP 7.4+)
$part1 = [1, 2];
$part2 = [3, 4];
$completo = [...$part1, ...$part2];  // [1, 2, 3, 4]

ArrayAccess y Traversable (objetos como arrays):

<?php
class Coleccion implements ArrayAccess, Countable, Iterator {
    private array $items = [];
    
    public function offsetExists(mixed $offset): bool {
        return isset($this->items[$offset]);
    }
    
    public function offsetGet(mixed $offset): mixed {
        return $this->items[$offset] ?? null;
    }
    
    public function offsetSet(mixed $offset, mixed $value): void {
        if ($offset === null) {
            $this->items[] = $value;
        } else {
            $this->items[$offset] = $value;
        }
    }
    
    public function offsetUnset(mixed $offset): void {
        unset($this->items[$offset]);
    }
    
    public function count(): int {
        return count($this->items);
    }
    
    public function current(): mixed {
        return current($this->items);
    }
    
    public function next(): void {
        next($this->items);
    }
    
    public function key(): mixed {
        return key($this->items);
    }
    
    public function valid(): bool {
        return current($this->items) !== false;
    }
    
    public function rewind(): void {
        reset($this->items);
    }
}

$col = new Coleccion();
$col[] = 'PHP';
$col[] = 'Python';
echo $col[0];  // 'PHP' (via offsetGet)
echo count($col);  // 2 (via count)

foreach ($col as $key => $value) {
    echo "$key: $value";  // 0: PHP, 1: Python
}

SplFixedArray — array de tamaño fijo más eficiente:

<?php
// Más rápido y ocupa menos memoria que array normal
$arr = SplFixedArray::fromArray([1, 2, 3, 4, 5]);
echo $arr[0];      // 1
echo $arr->count(); // 5
$arr->setSize(10);  // Redimensiona (rellena con null)

Complejidad de arrays en PHP (son tablas hash internamente):

POO: clases, interfaces, traits, namespaces y autoloading

PHP tiene un modelo de objetos muy completo desde PHP 5 (2004). PHP 7+ y 8+ han añadido características modernas.

Clases básicas y constructor promotion (PHP 8.0):

<?php
declare(strict_types=1);

namespace App\Models;

enum Status: string {
    case Active = 'active';
    case Inactive = 'inactive';
    case Archived = 'archived';
}

class Usuario
{
    // Constructor property promotion (PHP 8.0)
    // Crea las propiedades y las asigna automáticamente
    public function __construct(
        private string $nombre,
        private string $email,
        private int $edad,
        private Status $status = Status::Active,
    ) {}
    
    // Getter (tipado de retorno)
    public function nombre(): string
    {
        return $this->nombre;
    }
    
    // Setter con validación
    public function setEdad(int $edad): static
    {
        if ($edad < 0 || $edad > 150) {
            throw new \InvalidArgumentException("Edad inválida: $edad");
        }
        $this->edad = $edad;
        return $this;  // fluent interface
    }
    
    public function esMayorDeEdad(): bool
    {
        return $this->edad >= 18;
    }
}

Interfaces y traits:

<?php
// Interfaz: define un contrato
interface Exportable
{
    public function toArray(): array;
    public function toJson(): string;
}

// Trait: reutilización horizontal de métodos (PHP 5.4+)
trait Timestampable
{
    private \DateTimeImmutable $createdAt;
    private ?\DateTimeImmutable $updatedAt = null;
    
    public function initializeTimestamps(): void
    {
        $this->createdAt = new \DateTimeImmutable();
    }
    
    public function markAsUpdated(): void
    {
        $this->updatedAt = new \DateTimeImmutable();
    }
    
    public function createdAt(): \DateTimeImmutable
    {
        return $this->createdAt;
    }
    
    public function updatedAt(): ?\DateTimeImmutable
    {
        return $this->updatedAt;
    }
}

// Clase abstracta
abstract class Entidad implements Exportable
{
    use Timestampable;
    
    public function __construct(
        private int $id,
    ) {
        $this->initializeTimestamps();
    }
    
    public function id(): int
    {
        return $this->id;
    }
    
    // Método abstracto: las subclases deben implementarlo
    abstract public function validar(): bool;
}

// Implementación concreta
class Producto extends Entidad
{
    public function __construct(
        int $id,
        private string $nombre,
        private float $precio,
    ) {
        parent::__construct($id);
    }
    
    public function validar(): bool
    {
        return $this->precio > 0 && strlen($this->nombre) > 0;
    }
    
    public function toArray(): array
    {
        return [
            'id' => $this->id(),
            'nombre' => $this->nombre,
            'precio' => $this->precio,
        ];
    }
    
    public function toJson(): string
    {
        return json_encode($this->toArray());
    }
}

Herencia múltiple con traits (MRO):

<?php
trait A {
    public function foo(): string { return 'A'; }
}

trait B {
    public function foo(): string { return 'B'; }
}

class MiClase {
    use A, B {
        B::foo insteadof A;  // Usa foo de B en lugar de A
        A::foo as fooA;      // Alias para acceder a foo de A
    }
}

$obj = new MiClase();
echo $obj->foo();   // 'B'
echo $obj->fooA();  // 'A'

Namespaces y autoloading PSR-4:

<?php
// src/Controllers/UsuarioController.php
namespace App\Controllers;

use App\Models\Usuario;
use App\Repositories\UsuarioRepository;

class UsuarioController
{
    public function __construct(
        private UsuarioRepository $repo,
    ) {}
    
    public function index(): array
    {
        return array_map(
            fn(Usuario $u) => $u->toArray(),
            $this->repo->findAll(),
        );
    }
}

Composer autoload (PSR-4) mapea App\\ al directorio src/. Cualquier clase en src/Controllers/ con namespace App\Controllers\ se carga automáticamente. Ya no necesitas require_once.

Final y readonly (PHP 8.1):

<?php
// Final: no se puede extender la clase ni sobrescribir el método
final class Configuracion
{
    // Readonly: propiedad que solo se asigna una vez (PHP 8.1)
    // Con PHP 8.2, readonly permite asignación en __clone
    public readonly string $dbUrl;
    
    public function __construct()
    {
        $this->dbUrl = getenv('DATABASE_URL') ?: 'mysql://localhost:3306/db';
    }
}

// Error: Cannot inherit from final class Configuracion
// class ConfigHija extends Configuracion {}

Type hints, uniones, match expression y enums

Union types, nullable y mixed:

<?php
declare(strict_types=1);

// Nullable: ?Type = Type|null
function buscar(?int $id): ?string
{
    if ($id === null) {
        return null;
    }
    return "Resultado para $id";
}

// Union type (PHP 8.0+)
function procesar(int|string $valor): string|int
{
    return match (true) {
        is_int($valor) => $valor * 2,
        is_string($valor) => strtoupper($valor),
    };
}

// Mixed (cualquier tipo, PHP 8.0+)
function debug(mixed $valor): void
{
    var_dump($valor);
}

// Never (nunca retorna, PHP 8.1+)
function abortar(string $mensaje): never
{
    echo $mensaje . PHP_EOL;
    exit(1);
}

Nullsafe operator (?->) (PHP 8.0):

<?php
// Antes (cadenas de null checks):
$ciudad = null;
if ($usuario !== null) {
    $direccion = $usuario->direccion;
    if ($direccion !== null) {
        $ciudad = $direccion->ciudad;
    }
}

// PHP 8.0+ nullsafe:
$ciudad = $usuario?->direccion?->ciudad;

// Null coalescing (??) y null coalescing assignment (??=)
$nombre = $_GET['nombre'] ?? 'Invitado';  // Si no existe, usa default
$usuario['avatar'] ??= 'default.png';     // Asigna solo si es null o no existe

match expression (PHP 8.0):

<?php
// match es una expresión (devuelve valor), no una sentencia como switch
// No necesita break, es exhaustivo (lanza UnhandledMatchError si no hay match)

$statusCode = 404;

$mensaje = match ($statusCode) {
    200, 201 => 'Éxito',
    301, 302 => 'Redirección',
    400, 422 => 'Error de validación',
    401 => 'No autenticado',
    403 => 'Prohibido',
    404 => 'No encontrado',
    500 => 'Error del servidor',
    default => 'Código desconocido',
};

// match con condiciones booleanas
$edad = 25;
$categoria = match (true) {
    $edad < 13 => 'Niño',
    $edad < 18 => 'Adolescente',
    $edad < 65 => 'Adulto',
    default => 'Senior',
};

Enums nativos (PHP 8.1):

<?php
// Enum puro (sin valor asociado)
enum Status
{
    case Draft;
    case Published;
    case Archived;
    
    // Métodos en enums
    public function label(): string
    {
        return match ($this) {
            Status::Draft => 'Borrador',
            Status::Published => 'Publicado',
            Status::Archived => 'Archivado',
        };
    }
}

// Backed enum (con valor string o int)
enum Rol: string
{
    case Admin = 'admin';
    case Editor = 'editor';
    case Viewer = 'viewer';
    
    public function permisos(): array
    {
        return match ($this) {
            Rol::Admin => ['create', 'read', 'update', 'delete'],
            Rol::Editor => ['create', 'read', 'update'],
            Rol::Viewer => ['read'],
        };
    }
}

// Uso
$rol = Rol::Admin;
echo $rol->name;      // 'Admin'
echo $rol->value;     // 'admin'
echo $rol->permisos(); // ['create', 'read', 'update', 'delete']
echo Rol::from('editor'); // Rol::Editor
echo Rol::tryFrom('xyz');  // null (no lanza excepción)

First-class callable syntax (PHP 8.1):

<?php
// Antes (PHP 8.0 y anterior):
$callback = [$this, 'metodo'];
$callback2 = 'strtoupper';

// PHP 8.1:
$callback = $this->metodo(...);
$callback2 = strtoupper(...);

// Especialmente útil con array_map/array_filter:
$nombres = ['ana', 'luis', 'pedro'];
$mayusculas = array_map(strtoupper(...), $nombres);

Named arguments y attributes (PHP 8.0)

Named arguments:

<?php
// Permite pasar argumentos por nombre, no solo por posición
function crearUsuario(
    string $nombre,
    string $email,
    int $edad = 18,
    bool $activo = true,
    array $roles = ['user'],
): array {
    return compact('nombre', 'email', 'edad', 'activo', 'roles');
}

// Llamada tradicional (posicional)
$u1 = crearUsuario('Ana', 'ana@email.com', 28, true, ['admin', 'user']);

// Llamada con named arguments (solo especificas los que cambian)
$u2 = crearUsuario(
    nombre: 'Luis',
    email: 'luis@email.com',
    roles: ['editor'],
    // $edad y $activo usan valores por defecto
);

// Orden arbitrario, saltar defaults
$u3 = crearUsuario(email: 'a@b.com', nombre: 'Pe');

Attributes (PHP 8.0):

<?php
// Los atributos son metadatos estructurados para clases, métodos, propiedades
// Similar a anotaciones en Java o decoradores en Python (pero no ejecutan código)

#[Attribute(Attribute::TARGET_PROPERTY | Attribute::TARGET_PARAMETER)]
class Validar
{
    public function __construct(
        public string $regla,
        public ?int $min = null,
        public ?int $max = null,
    ) {}
}

#[Attribute(Attribute::TARGET_CLASS)]
class Ruta
{
    public function __construct(
        public string $path,
        public string $method = 'GET',
    ) {}
}

// Uso
#[Ruta('/usuarios')]
class UsuarioController
{
    public function __construct(
        #[Validar('email')]
        private string $email,
        
        #[Validar('string', min: 3, max: 100)]
        private string $nombre,
    ) {}
}

// Leer atributos en runtime (reflection)
$ref = new ReflectionClass(UsuarioController::class);
$rutaAttr = $ref->getAttributes(Ruta::class)[0] ?? null;
if ($rutaAttr) {
    $ruta = $rutaAttr->newInstance();
    echo "{$ruta->method} {$ruta->path}";  // "GET /usuarios"
}

$propRef = $ref->getProperty('email');
$validarAttr = $propRef->getAttributes(Validar::class)[0]?->newInstance();
echo $validarAttr->regla;  // 'email'

Fibers (PHP 8.1) — concurrencia cooperativa:

<?php
// Fibers son corutinas a nivel de sistema: permiten pausar y reanudar
// una función en un punto específico, similar a async/await pero sin event loop

$fiber = new Fiber(function (): void {
    $valor = Fiber::suspend('retorno inicial');
    echo "Recibido: $valor";
});

$resultado = $fiber->start();
echo $resultado;  // 'retorno inicial'

$fiber->resume('mensaje desde fuera');
// Output: "Recibido: mensaje desde fuera"

Excepciones: try/catch/finally y custom exceptions

<?php
declare(strict_types=1);

// Excepción personalizada
class UsuarioNoEncontrado extends \RuntimeException
{
    public function __construct(
        int $id,
        string $message = '',
        int $code = 404,
        ?\Throwable $previous = null,
    ) {
        if ($message === '') {
            $message = "Usuario con ID {$id} no encontrado";
        }
        parent::__construct($message, $code, $previous);
    }
}

// Excepción de validación
class ValidacionException extends \InvalidArgumentException
{
    /** @var array<string, string[]> */
    private array $errores;
    
    public function __construct(array $errores)
    {
        parent::__construct('Error de validación', 422);
        $this->errores = $errores;
    }
    
    public function errores(): array
    {
        return $this->errores;
    }
}

// Throw expression (PHP 8.0+): throw se puede usar en expresiones
$nombre = $_GET['nombre'] ?? throw new \InvalidArgumentException('Nombre requerido');

// Uso completo
function buscarUsuario(int $id): array
{
    // Simulación de búsqueda
    if ($id <= 0) {
        throw new \InvalidArgumentException('ID inválido');
    }
    
    if ($id !== 1) {
        throw new UsuarioNoEncontrado($id);
    }
    
    return ['id' => 1, 'nombre' => 'Ana'];
}

// Try/catch/finally
try {
    $usuario = buscarUsuario(5);
    echo $usuario['nombre'];
} catch (UsuarioNoEncontrado $e) {
    echo "Error: {$e->getMessage()}";  // "Error: Usuario con ID 5 no encontrado"
    
    // try/catch anidados con throw
    throw $e;
} catch (\InvalidArgumentException $e) {
    echo "Datos inválidos: {$e->getMessage()}";
} catch (\Throwable $e) {
    // Captura cualquier error o excepción
    echo "Error inesperado: {$e->getMessage()}";
    throw $e;  // Re-lanzar si no podemos manejarlo
} finally {
    // Siempre se ejecuta, haya o no excepción
    echo "Limpiando recursos...";
}

Genéricos (no nativos, con PHPDoc/Psalm/PHPStan)

PHP no tiene genéricos nativos en runtime (a diferencia de Java, C# o TypeScript). Sin embargo, las herramientas de análisis estático como PHPStan (nivel max) y Psalm soportan genéricos en PHPDoc:

<?php
/**
 * @template T
 * @implements \IteratorAggregate<int, T>
 */
class Coleccion implements \IteratorAggregate
{
    /** @var array<int, T> */
    private array $items = [];
    
    /**
     * @param T $item
     */
    public function añadir(mixed $item): void
    {
        $this->items[] = $item;
    }
    
    /**
     * @return T|null
     */
    public function primero(): mixed
    {
        return $this->items[0] ?? null;
    }
    
    /**
     * @return \ArrayIterator<int, T>
     */
    public function getIterator(): \ArrayIterator
    {
        return new \ArrayIterator($this->items);
    }
}

/**
 * @template TEntity
 */
interface Repositorio
{
    /**
     * @param int $id
     * @return TEntity|null
     */
    public function find(int $id): ?object;
    
    /**
     * @return Coleccion<TEntity>
     */
    public function findAll(): Coleccion;
}

/**
 * @implements Repositorio<Usuario>
 */
class UsuarioRepository implements Repositorio
{
    public function find(int $id): ?Usuario
    {
        // PHPStan sabe que retorna Usuario|null
    }
    
    public function findAll(): Coleccion
    {
        // PHPStan sabe que retorna Coleccion<Usuario>
    }
}

Para PHP 8.3+ no hay planes concretos para genéricos en runtime. La comunidad usa PHPDoc + PHPStan/Psalm.

Composer: Packagist, autoload y scripts

Composer es el gestor de dependencias de PHP. Análogo a npm (Node), pip (Python), cargo (Rust).

Packagist — el repositorio de paquetes:

packagist.org es el registro oficial, equivalente a PyPI (Python) o npmjs.com. Alberga >400,000 paquetes.

{
    "require": {
        "laravel/framework": "^11.0",
        "monolog/monolog": "^3.0",
        "guzzlehttp/guzzle": "^7.0"
    }
}

Autoload PSR-4:

{
    "autoload": {
        "psr-4": {
            "App\\": "src/",
            "App\\Domain\\": "src/Domain/",
            "App\\Infrastructure\\": "src/Infrastructure/"
        }
    },
    "autoload-dev": {
        "psr-4": {
            "Tests\\": "tests/"
        }
    }
}

Scripts de Composer:

{
    "scripts": {
        "dev": "php -S localhost:8000 -t public/",
        "test": "phpunit",
        "test:coverage": "phpunit --coverage-html coverage/",
        "phpstan": "phpstan analyse src --level=max",
        "psalm": "psalm",
        "lint": "pint",
        "fix": "pint --preset=laravel",
        "check": [
            "@lint",
            "@phpstan",
            "@test"
        ],
        "post-create-project-cmd": [
            "php artisan key:generate"
        ]
    }
}

Comandos esenciales:

Generadores (yield) e iteradores SPL

<?php
// Generador: función que produce múltiples valores sin crear un array completo
// Similar a los generadores de Python

function numerosPares(int $limite): \Generator
{
    for ($i = 0; $i <= $limite; $i += 2) {
        // yield pausa la ejecución y retorna el valor
        // La próxima llamada a next() continúa desde aquí
        yield $i;
    }
}

foreach (numerosPares(10) as $num) {
    echo "$num ";  // 0 2 4 6 8 10
}

// Generador con claves (yield key => value)
function mapeoLetras(): \Generator
{
    yield 'a' => 1;
    yield 'b' => 2;
    yield 'c' => 3;
}

// Generador delegado (yield from)
function combinado(): \Generator
{
    yield 1;
    yield from numerosPares(6);  // 0, 2, 4, 6
    yield 99;
}

// Generadores para leer archivos grandes (memoria constante)
function leerPorLineas(string $path): \Generator
{
    $handle = fopen($path, 'r');
    while (($line = fgets($handle)) !== false) {
        yield trim($line);
    }
    fclose($handle);
}

// SPL Iterators
$iterator = new \DirectoryIterator(__DIR__);
foreach ($iterator as $file) {
    if ($file->isFile()) {
        echo $file->getFilename() . PHP_EOL;
    }
}

// Composición de iteradores
$arr = [1, 2, 3, 4, 5];
$filter = new \CallbackFilterIterator(
    new \ArrayIterator($arr),
    fn($item) => $item % 2 === 0,
);
foreach ($filter as $item) {
    echo $item;  // 2, 4
}

Sistema de archivos

Operaciones básicas

¿Qué es?

PHP tiene un sistema de archivos muy completo, heredado de C y ampliado con wrappers de stream. Ofrece funciones para leer, escribir, copiar, mover, eliminar y recorrer archivos y directorios.

🔗 PHP Manual — Filesystem

Sintaxis básica

<?php
$contenido = file_get_contents('archivo.txt');
file_put_contents('copia.txt', $contenido);

$lineas = file('datos.csv');
foreach ($lineas as $linea) {
    echo trim($linea);
}

$handle = fopen('archivo.txt', 'r');
while (($line = fgets($handle)) !== false) {
    echo $line;
}
fclose($handle);

echo file_exists('archivo.txt');
echo is_file('archivo.txt');
echo is_dir('uploads');
echo filesize('archivo.txt');
echo filemtime('archivo.txt');

mkdir('nueva-carpeta', 0755, true);
rmdir('nueva-carpeta');
$archivos = scandir('uploads');
$glob = glob('uploads/*.jpg');

$info = new SplFileInfo('archivo.txt');
echo $info->getFilename();
echo $info->getExtension();
echo $info->getSize();

$file = new SplFileObject('datos.csv');
$file->setFlags(SplFileObject::READ_CSV);
foreach ($file as $row) {
    print_r($row);
}

🧪 Cómo probarlo

php -r '
file_put_contents("test.txt", "Hola Mundo");
echo file_get_contents("test.txt");
unlink("test.txt");
'

💡 Memoria y rendimiento

• file_get_contents() carga todo en memoria — para archivos >100MB usa fopen() + fgets() o SplFileObject
• file() también carga todo en un array — igual que file_get_contents pero divide en líneas
• glob() escanea el disco — para búsquedas repetitivas cachea resultados
• SplFileObject con READ_CSV es eficiente para archivos CSV grandes

✅ Buenas prácticas

• ✅ Siempre verifica file_exists() antes de leer
• ✅ Usa LOCK_EX en file_put_contents() para escritura concurrente
• ✅ Cierra handles con fclose() — PHP lo hace al finalizar el request pero no confíes en ello
• ⚠️ Los paths relativos dependen del CWD — usa __DIR__ para paths absolutos
• ❌ No confíes en $_FILES['file']['type'] — valida siempre el MIME real con finfo

🏗️ Metodología

Para archivos pequeños (<10MB), file_get_contents() + file_put_contents() es suficiente. Para archivos grandes (>100MB), procesa línea por línea. Para archivos remotos, usa streams con contexto (stream_context_create). Para archivos compartidos entre requests, considera usar una BD o Redis.

🔗 Para saber más

• PHP Manual — Streams
• PHP Manual — SplFileObject

Formatos estructurados

¿Qué es?

PHP tiene soporte nativo para JSON, CSV, ZIP, GZIP, y mediante extensiones para YAML, XML y más formatos. JSON es el más usado para APIs y almacenamiento.

🔗 PHP Manual — JSON

Sintaxis básica

<?php
$data = ['nombre' => 'Ana', 'edad' => 28];

// JSON
$json = json_encode($data, JSON_PRETTY_PRINT | JSON_UNESCAPED_UNICODE);
file_put_contents('data.json', $json);
$decoded = json_decode(file_get_contents('data.json'), true);

// CSV
$handle = fopen('datos.csv', 'w');
fputcsv($handle, ['Nombre', 'Edad']);
fputcsv($handle, ['Ana', 28]);
fclose($handle);

$handle = fopen('datos.csv', 'r');
while ($row = fgetcsv($handle)) {
    print_r($row);
}
fclose($handle);

// ZIP
$zip = new ZipArchive();
if ($zip->open('archive.zip', ZipArchive::CREATE) === true) {
    $zip->addFile('archivo.txt', 'carpeta/archivo.txt');
    $zip->addFromString('nota.txt', 'Contenido');
    $zip->close();
}

// GZIP
$data = gzencode($contenido, 9);
file_put_contents('datos.gz', $data);
$original = gzdecode(file_get_contents('datos.gz'));

// MIME
$finfo = new finfo(FILEINFO_MIME_TYPE);
echo $finfo->file('imagen.jpg');

🧪 Cómo probarlo

php -r '
echo json_encode(["nombre" => "Ana"]);
echo json_last_error_msg();
'

💡 Memoria y rendimiento

• json_decode() sin true (objeto stdClass) es más rápido que con true (array)
• CSV con fgetcsv() es eficiente para archivos grandes — no carga todo en memoria
• ZIP en compresión almacenada (store) es rápido pero no reduce tamaño
• GZIP nivel 9 es el máximo comprimido pero más lento — nivel 6 es el balance óptimo

✅ Buenas prácticas

• ✅ Siempre verifica json_last_error() después de json_decode()
• ✅ Usa JSON_THROW_ON_ERROR (PHP 7.3+) para excepciones
• ✅ Para CSV con caracteres UTF-8, añade BOM al inicio: "\xEF\xBB\xBF"
• ⚠️ json_decode() devuelve null para JSON inválido — no se puede distinguir del string “null”
• ❌ No uses serialize() para datos que necesites leer desde otros lenguajes

🏗️ Metodología

JSON para APIs y config. CSV para import/export con hojas de cálculo. ZIP para backups y descargas múltiples. GZIP para logs comprimidos. Para config YAML, usa la extensión yaml o Symfony YAML component.

🔗 Para saber más

• PHP Manual — CSV
• PHP Manual — ZipArchive

Algoritmos

Ordenación

¿Qué es?

PHP tiene funciones de ordenación que modifican el array original (sort, rsort, asort, ksort) y variantes con callback (usort, uasort, uksort). Internamente usan Quicksort.

🔗 PHP Manual — Array Sorting

Sintaxis básica

<?php
$nums = [5, 3, 8, 1, 9, 2];

sort($nums);     // [1, 2, 3, 5, 8, 9]
rsort($nums);    // [9, 8, 5, 3, 2, 1]

$user = ['edad' => 28, 'nombre' => 'Ana', 'id' => 1];
asort($user);    // ordena por valor, mantiene keys
ksort($user);    // ordena por key
natsort($user);  // orden natural

usort($nums, fn($a, $b) => $b <=> $a);
uasort($user, fn($a, $b) => $a <=> $b);
uksort($user, fn($a, $b) => $a <=> $b);

shuffle($nums);
$clave = array_rand($nums);

🧪 Cómo probarlo

php -r '
$nums = [5, 3, 8, 1];
sort($nums);
var_dump($nums === [1, 3, 5, 8]);
'

💡 Memoria y rendimiento

Todos modifican el array original — no crean copia. Para arrays grandes (>100k), son eficientes pero consumen memoria extra para la recursión.

✅ Buenas prácticas

• ✅ Usa el spaceship <=> para ordenación ascendente y $b <=> $a para descendente
• ✅ Siempre pasa SORT_NUMERIC o SORT_STRING como flag para rendimiento
• ⚠️ $array = sort($array) asigna true (sort devuelve bool) — error común
• ❌ No uses shuffle() si necesitas reproducibilidad — pasa srand() primero

🏗️ Metodología

Para arrays pequeños (<1000), cualquier función sirve. Para grandes volúmenes, prefiere sort() sobre usort(). Si necesitas ordenación estable, usa array_multisort(). Para ordenación natural de strings (img1.jpg, img2.jpg, img10.jpg), usa natsort().

🔗 Para saber más

• PHP Manual — Sorting
• Wikipedia — Quicksort

Búsqueda y comparación

¿Qué es?

Funciones para buscar elementos en arrays: in_array(), array_search(), array_key_exists(). También para comparar arrays: array_diff(), array_intersect(), array_unique().

<?php
$nums = [1, 2, 3, 4, 5];

$pos = array_search(3, $nums);           // 2
$existe = in_array(3, $nums);            // true
$tieneKey = array_key_exists('edad', $user);

$unicos = array_unique([1, 2, 2, 3, 3]);

$intersect = array_intersect([1, 2, 3], [2, 3, 4]);
$diff = array_diff([1, 2, 3], [2, 3, 4]);

💡 Memoria y rendimiento

• in_array() y array_search() son O(n) — búsqueda lineal
• isset($arr[$key]) es O(1) — mucho más rápido para verificar existencia
• array_unique() es O(n) internamente
• array_intersect() / array_diff() usan tablas hash — O(n + m)

✅ Buenas prácticas

• ✅ Para verificar si una clave existe: isset($arr[$key]) o array_key_exists()
• ⚠️ in_array() con true (strict mode) compara tipos — más seguro
• ✅ En arrays grandes, convierte a SplFixedArray para acceso más rápido

Transformación

¿Qué es?

array_map(), array_filter() y array_reduce() son las funciones de orden superior (map/filter/reduce) que permiten transformar colecciones sin bucles explícitos.

<?php
$nums = [1, 2, 3, 4, 5];
$users = [
    ['name' => 'Ana', 'edad' => 28],
    ['name' => 'Luis', 'edad' => 35],
];

$cuadrados = array_map(fn($n) => $n ** 2, $nums);
$pares = array_filter($nums, fn($n) => $n % 2 === 0);
$suma = array_reduce($nums, fn($c, $n) => $c + $n, 0);

array_walk($nums, fn(&$n) => $n *= 2);

$nombres = array_column($users, 'name');

$chunks = array_chunk($nums, 2);
$slice = array_slice($nums, 0, 3);
array_splice($nums, 1, 2, ['a', 'b']);

$frecuencias = array_count_values([1, 1, 2, 3, 1]);

💡 Memoria y rendimiento

array_map() preserva keys numéricas pero reindexa las asociativas — usa array_map(null, $keys, $values) para conservar ambas.

✅ Buenas prácticas

• ✅ array_map + arrow functions para transformaciones simples
• ✅ array_filter sin callback elimina valores falsy: array_filter([0, 1, null, 2]) → [1, 2]
• ⚠️ compact() es útil pero crea variables implícitas — difícil de debuggear
• ❌ extract() está deprecado moralmente — nunca lo uses con datos del usuario

SPL — Estructuras de datos

¿Qué es?

SPL (Standard PHP Library) provee estructuras de datos eficientes: pilas (SplStack), colas (SplQueue), heaps (SplMaxHeap, SplMinHeap, SplPriorityQueue), arrays fijos (SplFixedArray), y más.

<?php
$stack = new SplStack();
$stack->push('a');
$stack->push('b');
echo $stack->pop();  // 'b'

$queue = new SplQueue();
$queue->enqueue('a');
$queue->enqueue('b');
echo $queue->dequeue();  // 'a'

$heap = new SplMaxHeap();
$heap->insert(10);
$heap->insert(5);
$heap->insert(20);
echo $heap->extract();  // 20

$pq = new SplPriorityQueue();
$pq->insert('baja', 1);
$pq->insert('alta', 10);
echo $pq->extract();  // 'alta'

$list = new SplDoublyLinkedList();
$list->push('a');
$list->push('b');
echo $list->shift();  // 'a'

💡 Memoria y rendimiento

SplFixedArray es ~30% más rápido que array para acceso indexado y ocupa menos memoria. Útil para grandes matrices de tamaño fijo.

✅ Buenas prácticas

• ✅ Usa SplPriorityQueue en lugar de usort() + array cuando necesites extraer ordenadamente
• ✅ SplObjectStorage es ideal para asociar metadatos a objetos
• ⚠️ SplFixedArray no tiene [] para añadir — usa $fa[$i] = $val con índice conocido

Tabla de complejidad Big O

Ejemplo completo de POO en PHP

Este ejemplo une todos los conceptos de POO explicados arriba en un sistema realista de biblioteca multimedia. Léelo de arriba a abajo: cada clase añade una capa.

<?php
declare(strict_types=1);

namespace App\Media;

// ── Enum y DTOs (modelos de datos) ──

enum VideoFormat: string
{
    case MP4 = 'mp4';
    case WEBM = 'webm';
    case AVI = 'avi';
    case MKV = 'mkv';
}

enum MediaType: string
{
    case Audio = 'audio';
    case Video = 'video';
    case Podcast = 'podcast';
}

class Metadata
{
    public function __construct(
        public readonly string $title,
        public readonly int $durationSeconds,
        public readonly \DateTimeImmutable $createdAt = new \DateTimeImmutable(),
        public array $tags = [],
    ) {}

    public function formattedDuration(): string
    {
        $minutes = intdiv($this->durationSeconds, 60);
        $seconds = $this->durationSeconds % 60;
        return sprintf('%d:%02d', $minutes, $seconds);
    }

    public function __toString(): string
    {
        return sprintf('%s (%s)', $this->title, $this->formattedDuration());
    }
}

// ── Interfaz base ──

interface ContentInterface
{
    public function metadata(): Metadata;
    public function play(): string;
    public function info(): string;
    public function plays(): int;
}

// ── Trait reutilizable ──

trait Playable
{
    private int $plays = 0;

    public function play(): string
    {
        $this->plays++;
        return sprintf('▶️ Reproduciendo %s...', $this->metadata()->title);
    }

    public function plays(): int
    {
        return $this->plays;
    }
}

// ── Clase abstracta base ──

abstract class Content implements ContentInterface
{
    use Playable;

    public function __construct(
        protected Metadata $metadata,
    ) {}

    public function metadata(): Metadata
    {
        return $this->metadata;
    }

    abstract protected function typeLabel(): string;

    public function __toString(): string
    {
        return sprintf('[%s] %s', (new \ReflectionClass($this))->getShortName(), $this->metadata);
    }
}

// ── Herencia simple ──

class Audio extends Content
{
    public function __construct(
        Metadata $metadata,
        public readonly int $bitrateKbps,
    ) {
        parent::__construct($metadata);
    }

    public function info(): string
    {
        return sprintf(
            '🎵 %s | %s | %dkbps | %d reproducciones',
            $this->metadata->title,
            $this->metadata->formattedDuration(),
            $this->bitrateKbps,
            $this->plays,
        );
    }

    protected function typeLabel(): string
    {
        return 'Audio';
    }
}

class Video extends Content
{
    private bool $subtitles = false;

    public function __construct(
        Metadata $metadata,
        public readonly string $resolution,
        public readonly VideoFormat $format,
    ) {
        parent::__construct($metadata);
    }

    public function hasSubtitles(): bool
    {
        return $this->subtitles;
    }

    public function enableSubtitles(): static
    {
        $this->subtitles = true;
        return $this;
    }

    public function disableSubtitles(): static
    {
        $this->subtitles = false;
        return $this;
    }

    public function info(): string
    {
        return sprintf(
            '🎬 %s | %s | %s | %s',
            $this->metadata->title,
            $this->resolution,
            $this->format->value,
            $this->subtitles ? 'CC' : 'Sin subtítulos',
        );
    }

    protected function typeLabel(): string
    {
        return 'Video';
    }
}

// ── Interfaz adicional y herencia múltiple con traits ──

interface Exportable
{
    public function toArray(): array;
    public function toJson(): string;
}

trait JsonExportable
{
    public function toJson(): string
    {
        return json_encode($this->toArray(), JSON_PRETTY_PRINT | JSON_UNESCAPED_UNICODE);
    }
}

class Podcast extends Audio implements Exportable
{
    use JsonExportable;

    public function __construct(
        Metadata $metadata,
        int $bitrateKbps,
        public readonly int $episode,
        public readonly string $host,
    ) {
        parent::__construct($metadata, $bitrateKbps);
    }

    public function info(): string
    {
        return sprintf(
            '🎙️ Ep.%d: %s | con %s | %s',
            $this->episode,
            $this->metadata->title,
            $this->host,
            parent::info(),
        );
    }

    public function toArray(): array
    {
        return [
            'type' => 'podcast',
            'episode' => $this->episode,
            'host' => $this->host,
            'title' => $this->metadata->title,
            'duration' => $this->metadata->formattedDuration(),
            'bitrate' => $this->bitrateKbps,
            'plays' => $this->plays,
            'tags' => $this->metadata->tags,
        ];
    }

    protected function typeLabel(): string
    {
        return 'Podcast';
    }
}

// ── Composición: un objeto contiene otros objetos ──

class Playlist implements \IteratorAggregate, \Countable
{
    /** @var Content[] */
    private array $items = [];

    public function __construct(
        public readonly string $name,
    ) {}

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

    public function remove(int $index): void
    {
        if (isset($this->items[$index])) {
            array_splice($this->items, $index, 1);
        }
    }

    /** @return string[] */
    public function playAll(): array
    {
        return array_map(fn(Content $c) => $c->play(), $this->items);
    }

    /** @return string[] */
    public function allInfo(): array
    {
        return array_map(fn(Content $c) => $c->info(), $this->items);
    }

    public function count(): int
    {
        return count($this->items);
    }

    public function getIterator(): \ArrayIterator
    {
        return new \ArrayIterator($this->items);
    }

    public function __toString(): string
    {
        return sprintf('📋 %s (%d items)', $this->name, count($this->items));
    }
}

// ── Uso del sistema ──

// Crear contenido de distintos tipos
$song = new Audio(
    new Metadata('Bohemian Rhapsody', 354, tags: ['rock', 'clásico']),
    bitrateKbps: 320,
);

$movie = new Video(
    new Metadata('Inception', 8880, tags: ['ciencia ficción', 'thriller']),
    resolution: '4K',
    format: VideoFormat::MKV,
);
$movie->enableSubtitles();

$podcast = new Podcast(
    new Metadata('El futuro de la IA', 2700, tags: ['tecnología', 'IA']),
    bitrateKbps: 128,
    episode: 42,
    host: 'Ana López',
);

// Polimorfismo: cada uno implementa info() a su manera
foreach ([$song, $movie, $podcast] as $content) {
    echo $content->info() . PHP_EOL;
}

// Composición
$playlist = new Playlist('Favoritos');
$playlist->add($song);
$playlist->add($movie);
$playlist->add($podcast);
echo $playlist . PHP_EOL;  // 📋 Favoritos (3 items)
print_r($playlist->playAll());
print_r($playlist->allInfo());

// Exportación vía interfaz + trait
echo $podcast->toJson() . PHP_EOL;

// Countable + IteratorAggregate
echo count($playlist) . PHP_EOL;  // 3
foreach ($playlist as $item) {
    echo "  - {$item->metadata()->title}" . PHP_EOL;
}