PHP

Ecosistema General

• CMS
• Moodle
• Wordpress
• PHP-mysql-old
• nixonLearningPHPMySQL2021
• apache
• composer

Motores de Plantillas

• motor de plantillas
• mustache
  • Motor de plantillas minimalista que separa completamente lógica y presentación.
  • Útil en entornos donde se busca mantener control estricto sobre la vista sin añadir complejidad adicional.
  • Compatible con múltiples frameworks y sistemas como Moodle.

Frameworks PHP

• laravel
  • Framework moderno con enfoque en productividad, arquitectura limpia (MVC), Eloquent ORM, migraciones, colas, eventos y ecosistema sólido.
  • Ideal para proyectos medianos y grandes con necesidades de escalabilidad y organización.
• CodeIgniter
  • Framework ligero, rápido y muy sencillo.
  • Ideal para proyectos pequeños o APIs simples.
• Symfony
  • Framework robusto y modular.
  • Base de componentes utilizados incluso por laravel.
  • Enfoque empresarial, escalable y orientado a arquitectura limpia.

Testing en PHP

Conceptos

• Testing
  • Pruebas unitarias, de integración, funcionales y end-to-end aplicadas al desarrollo en PHP.
  • Integración con CI/CD y estándares modernos de calidad.
  • Mejores prácticas: alta cobertura, test aislados, mocks, fixtures y uso correcto del ciclo AAA (Arrange–Act–Assert).

PHPUnit

• PHPUnit
  • Framework de testing estándar en PHP.
  • Permite pruebas unitarias, test-driven development (TDD) y mocks integrados.
• Agregar PHPUnit a tu proyecto PHP con composer-agregar-phpunit-a-tu-proyecto-php-con-composer-53f7
  • Guía para integrar PHPUnit mediante composer.
• Repositorio de ejemplo:
  • GitHub - javleds/inicio-php-composer

Debug y Herramientas

• debug
  • Uso común de herramientas como var_dump, dump(), dd() en laravel, o depuración avanzada con Xdebug.
  • Integración con editores y análisis de stack trace.
• PhpStorm
  • IDE completo para desarrollo PHP con integración nativa con Xdebug, PHPUnit, composer, bases de datos y herramientas de refactorización.
  • Facilita la inspección, debugging remoto y estándares de calidad (PSR).

Recursos y Aprendizaje

Videos y Cursos

• videos php
  • 🔥 10 PROYECTOS COMPLETOS CON PHP - YouTube

Guía Completa de PHP en 2025

1. Estado Actual de PHP (2025)

• PHP sigue siendo uno de los lenguajes backend más usados gracias a su enorme ecosistema (Wordpress, Moodle, e-commerce, APIs).

• PHP 8.3/8.4 ofrecen:

  • JIT mejorado.
  • Tipado más estricto y útil.
  • Fibers + coroutines en frameworks modernos.
  • Performance muy superior al PHP 7.
• Composer es el estándar absoluto de gestión de dependencias.

---

2. Fundamentos Modernos de PHP

Sintaxis esencial y buenas prácticas

• Tipos estrictos (declare(strict_types=1)).
• Clases y objetos como estándar de diseño.
• Funciones puras y minimización de efectos secundarios.
• Namespaces obligatorios en cualquier código profesional.
• Estándares PSR:
  • PSR-1/PSR-12: estilo.
  • PSR-4: autoloading.
  • PSR-6/PSR-16: caché.
  • PSR-7/PSR-15: HTTP middleware.

Ejemplo moderno minimalista

<?php
declare(strict_types=1);

namespace App;

class User {
	public function __construct(
		private string $name,
		private int $age
	) {}

	public function greet(): string {
		return "Hola, soy {$this->name}";
	}
}

---

3. Ecosistema y Herramientas

Composer

• Estándar de dependencias.
• Permite autoloading (PSR-4), paquetes, scripts y workflows.

Servidores

• apache + PHP-FPM
• Nginx (mucho más habitual en producción)
• Swoole / RoadRunner para PHP asíncrono (2025 cada vez más usado)

IDE y debugging

• PhpStorm (líder absoluto).
• Xdebug para profiling, tracing y debugging paso a paso.
• Integración con Docker y testing.

---

4. Frameworks Modernos

laravel

• Ecosistema gigante, APIs, colas, broadcasting, migraciones, Eloquent ORM, Horizon, Sail.
• Arquitectura orientada a componentes.

Symfony

• Framework empresarial, modular y base de Laravel.
• Ideal para arquitecturas hexagonales y código mantenible a largo plazo.

CodeIgniter / Slim / Lumen

• Microframeworks para APIs ligeras.

Elección del framework en 2025

• Proyectos grandes: Symfony o Laravel.
• Microservicios/API: Slim, Lumen, Mezzio.
• Moodle/WordPress: desarrollo por plugins → PHP puro + frameworks internos.

---

5. Desarrollo Frontend + PHP en 2025

• PHP sigue siendo backend, pero integra fácilmente:

  • Vue/React/Next.js.
  • Inertia.js (Laravel).
  • Livewire/HTMX para componentes interactivos sin JS complejo.

---

6. Testing en PHP (2025)

Herramientas clave

• PHPUnit (estándar).
• PestPHP (2025: muy popular por su sintaxis minimalista).
• Mockery para mocks avanzados.
• Testing automatizado vía CI/CD (GitHub Actions, GitLab CI).

Ejemplo PHPUnit

<?php
use PHPUnit\Framework\TestCase;

class MathTest extends TestCase {
	public function test_sum() {
		$this->assertSame(10, 5 + 5);
	}
}

---

7. Arquitectura y Buenas Prácticas

Patrones modernos

• DDD (Domain Driven Design)
• CQRS + Event Sourcing
• Patrón repositorio
• Arquitectura hexagonal
• SOLID aplicado realmente

Código limpio en PHP

• Tipos siempre definidos.
• Clases por responsabilidad.
• Evitar funciones globales.
• Tests desde el día uno.
• Documentación con PHPDoc solo cuando es necesario.

---

8. Bases de Datos y ORM

Opciones comunes

• MySQL/MariaDB (PHP-mysql-old si lo necesitas por legacy).
• PostgreSQL (preferido en 2025).
• Redis para caché y colas.
• MongoDB para documentos.

ORM modernos

• Eloquent (Laravel).
• Doctrine ORM (Symfony).

---

9. PHP Asíncrono en 2025

• RoadRunner 3 (muy rápido, producción real).
• Swoole + coroutines.
• Fibers integradas desde PHP 8 para concurrencia controlada.

• Ideal para:

  • websockets
  • scraping masivo
  • microservicios de alto rendimiento

---

10. Seguridad Moderna en PHP

• Escapar siempre salida en HTML (Twig, Blade, mustache).
• Sanitización de entrada.
• Hashing seguro: password_hash().
• CSRF tokens.
• Headers de seguridad: CSP, HSTS.
• Uso obligatorio de HTTPS.
• Validación estricta con DTOs.

---

11. PHP en Producción en 2025

Stack recomendado

• Docker + PHP-FPM + Nginx.

• Supervisión:

  • Prometheus
  • Grafana
  • OpenTelemetry (tracing)

• Caching:

  • Opcache (obligatorio)
  • Redis
• CDNs para assets.

Ejemplo Dockerfile moderno

FROM php:8.3-fpm

RUN apt-get update && apt-get install -y \
	git unzip libpq-dev \
	&& docker-php-ext-install pdo pdo_mysql pdo_pgsql

COPY . /var/www
WORKDIR /var/www

CMD ["php-fpm"]

---

12. PHP Legacy vs PHP Moderno

PHP Legacy

• Código sin namespaces.
• Variables globales.
• Mezcla de HTML + lógica.
• Sin composer.

PHP Moderno (2025)

• PSR-4.
• Code style obligatorio.
• Testing.
• Inyección de dependencias.
• Frameworks actualizados.
• Arquitectura limpia.

---

14. Mini Roadmap de Aprendizaje (2025)

1. Fundamentos del lenguaje (tipado, funciones, OOP).
2. Composer.
3. Framework actual (Laravel o Symfony).
4. Bases de datos y ORM.
5. Testing (PHPUnit / Pest).
6. Arquitectura limpia.
7. Seguridad.
8. Docker + despliegue.
9. Async PHP para tareas avanzadas.

PHP para APIs Modernas (REST, GraphQL, JSON)

• Uso de controladores ligeros orientados a DTOs y validadores.
• Serialización estandarizada con JSON:API.
• GraphQL: resolver dinámico con Lighthouse (Laravel) o API Platform (Symfony).
• Middlewares PSR-7/15 para autenticación, rate limit, logging y trazabilidad.

Autenticación y Autorización en PHP 2025

• JWT con rotación segura de tokens y expiración segmentada.
• OAuth2 y OpenID Connect para SSO corporativo.
• Implementación de roles RBAC y permisos ABAC.
• Sistemas de refresh tokens basados en Redis para invalidez inmediata.

PHP en Arquitecturas Distribuidas y Microservicios

• Integración con colas: RabbitMQ para garantías fuertes, Redis Streams para rapidez.
• Kafka para eventos de alta escala.
• Implementación de patrones: Saga, Outbox, Event Choreography.
• Comunicación interna mediante HTTP lightweight o mensajería asíncrona.

Programación Avanzada en PHP

• Atributos nativos para definir metadata, rutas, validación o acceso a servicios.
• Traits: reutilización controlada sin romper cohesión.
• Enums como reemplazo seguro de constantes.
• Generadores (yield) para procesar millones de registros sin agotar memoria.
• Fibers: concurrencia cooperativa para IO no bloqueante.

CLI Profesional en PHP

• Uso de Symfony Console para crear herramientas internas y scripts de automatización.
• Comandos con autocompletado, prompts interactivos y validación.
• Integración con CRON o supervisores como systemd/dokku.

Ejemplo mínimo de CLI

<?php
use Symfony\Component\Console\Application;

$app = new Application();
$app->add(new MyCommand());
$app->run();

`

PHP para Alta Escala y Performance

• Preloading para cargar clases críticas en memoria compartida.
• Opcache configurado con invalidate manual.
• Uso de Swoole/RoadRunner para servidores sin bloqueo.
• Estrategias de caching multi-capa: Redis, response caching, microcaching en Nginx.

PHP Internals (Nivel Experto)

• Conceptos de zval y reference counting para entender performance real.
• Optimización de opcodes mediante JIT.
• Hooks internos para extensiones personalizadas.
• Ciclo de vida: interpretación, compilación, ejecución y caching.

Observabilidad en PHP con OpenTelemetry

• Instrumentación de inicio-vía-PSR.
• Exportación a Grafana Tempo, Jaeger o Honeycomb.
• Métricas técnicas: tiempo por request, fallas, throughput.
• Logs estructurados en JSON para correlación automática.

Integración de PHP con Infraestructura Moderna

• Uso de Docker multi-stage para builds ligeros.
• Automatización con GitHub Actions o GitLab CI.
• Pipelines con análisis estático (PHPStan, Psalm).
• Deploys blue/green y canary.

Arquitectura y Fundamentos de PHP

Fundamentos Modernos de PHP

PHP 8.3+ establece un lenguaje orientado a tipado estricto, arquitectura limpia y código mantenible.

Tipado y Declaraciones Modernas

• declare(strict_types=1) obligatorio para garantizar integridad.
• Tipos escalares y objetos en parámetros y retornos.
• Tipos compuestos (union types), tipos nullables y enums.
• Promoted properties en constructores para clases concisas.

Estructura del Lenguaje

• Namespaces para evitar colisiones y organizar módulos.
• Autoloading mediante PSR-4 y composer.
• Traits para reutilizar comportamiento sin herencia innecesaria.
• Enums como alternativa segura a constantes.

Buenas Prácticas

• Seguir PSR-12 (estilo), PSR-4 (autoloading) y PSR-3 (logging).
• Utilizar objetos inmuebles donde aplique.
• Uso de interfaces y clases finales para reducir acoplamiento.
• Separación estricta de lógica, datos y presentación.
• Evitar concatenación de strings → usar interpolación y sanitización.

Arquitectura en PHP (2025)

La arquitectura moderna en PHP se centra en la escalabilidad, la desacoplación y la mantenibilidad. La base es combinar PSR, patrones robustos y frameworks sólidos como laravel o Symfony.

Arquitectura en Capas

• Presentación: controladores, vistas (Blade, Twig, Mustache mustache).
• Aplicación: casos de uso y flujos de negocio.
• Dominio: entidades, value objects, servicios de dominio.
• Infraestructura: repositorios, conectores externos, adaptadores.

Arquitectura Hexagonal (Ports & Adapters)

• Los puertos representan interfaces del dominio.
• Los adaptadores conectan el mundo exterior (DB, APIs, colas).
• Aporta independencia del framework y facilita testing.
• Encaja perfectamente con Symfony y Laravel + repositorios.

Domain Driven Design (DDD)

• Modelar el dominio con Entities y Value Objects claros.
• Contextos delimitados (bounded contexts).
• Servicios de dominio puros, sin dependencias externas.
• Evitar “anemia del modelo” → lógica dentro del dominio, no en controladores.

Patrones de Diseño Aplicados

• Repository: desacopla persistencia de dominio.
• Service Layer: orquesta casos de uso.
• Factory: crea objetos complejos.
• Strategy: para reglas de negocio intercambiables.
• Decorator: envolver servicios (cache, logging, tracing).
• Command–Query Separation (CQS): claridad entre escribir y leer.

Ciclo de Datos en PHP Moderno

• Entrada → Request PSR-7.
• Middlewares PSR-15 aplican seguridad, logging y validación.
• Controlador interpreta la acción.
• Caso de uso ejecuta reglas y dominio.
• Repositorio almacena y recupera datos.
• Respuesta estandarizada en JSON/HTML.

Integración con Frameworks

• laravel: arquitectura MVC refinada + servicios, jobs, events.
• Symfony: micro-kernel + servicios DI + componentes desacoplados.
• Adaptable tanto para monolitos modulares como microservicios.

Renderizado y Plantillas

• mustache: plantillas lógicas cero.
• Blade (Laravel): plantillas expresivas.
• Twig (Symfony): seguro y estandarizado.
• Buenas prácticas:
  • Nada de lógica de negocio en las vistas.
  • Solo loops, condiciones básicas, y sanitización.

Testing y Mantenibilidad Arquitectónica

• Tests del dominio sin bases de datos.
• Tests de infraestructura con mocks.
• Pruebas de integración con PHPUnit y entornos containers.
• Contratos claros para evitar dependencias acopladas.

Herramientas Esenciales

• composer para autoloading y dependencias.
• Xdebug para debugging profundo.
• PhpStan / Psalm para análisis estático.
• Monolog para logging estructurado.
• Contenedores de Inversión de Dependencias (DI) propios de frameworks.

Arquitectura de APIs en PHP

• Controladores delgados → lógica fuera del controlador.
• Serialización estándar (JSON:API, DTOs).
• Middlewares para:
  • Autenticación
  • Rate limiting
  • Logging
  • OpenTelemetry (tracing)
• Versionado real: /v1, /v2, o versionado implícito por media-type.

PHP y el Servidor

• PHP-FPM como manejador principal.
• Opcache para performance crítico.
• Extensions y módulos para features (intl, gd, sodium).
• apache o Nginx + PHP-FPM en despliegues modernos.

Ejemplo de Estructura Moderna de Proyecto

src/
	App/
		Domain/
		Application/
		Infrastructure/
		Shared/
config/
tests/
vendor/
public/

`

Ejemplo Base de Clase de Dominio

<?php
declare(strict_types=1);

namespace App\Domain\User;

class User {
	public function __construct(
		private string $id,
		private string $email
	) {}

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

Ejemplo de Controlador Minimalista

<?php

use App\Application\GetUserHandler;

class UserController {
	public function show(string $id, GetUserHandler $handler) {
		$user = $handler->handle($id);
		return ['email' => $user->email()];
	}
}

PHP — Ejemplos de Código y Casos de Uso Práctico

CRUD Básico con PHP Moderno (8.3+)

Ejemplo práctico de un flujo típico: crear, leer, actualizar y eliminar datos usando PDO y tipado estricto.

Conexión a Base de Datos (PDO)

<?php
declare(strict_types=1);

function db(): PDO {
return new PDO('mysql:host=localhost;dbname=app', 'user', 'pass', [
	PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION,
	PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC,
]);
}

`

Crear Usuario

<?php
function createUser(string $email, string $name): int {
$stmt = db()->prepare("INSERT INTO users (email, name) VALUES (:email, :name)");
$stmt->execute(['email' => $email, 'name' => $name]);
return (int) db()->lastInsertId();
}

Obtener Usuario

<?php
function getUser(int $id): ?array {
$stmt = db()->prepare("SELECT * FROM users WHERE id = :id");
$stmt->execute(['id' => $id]);
return $stmt->fetch() ?: null;
}

Actualizar Usuario

<?php
function updateUser(int $id, string $email): bool {
$stmt = db()->prepare("UPDATE users SET email = :email WHERE id = :id");
return $stmt->execute(['email' => $email, 'id' => $id]);
}

Eliminar Usuario

<?php
function deleteUser(int $id): bool {
$stmt = db()->prepare("DELETE FROM users WHERE id = :id");
return $stmt->execute(['id' => $id]);
}

---

API REST Muy Simple (Sin Framework)

Ejemplo realista de endpoint `/users/{id}` usando JSON y enrutamiento básico.

index.php

<?php
declare(strict_types=1);

header('Content-Type: application/json');

// Router muy básico
$path = explode('/', trim($_SERVER['REQUEST_URI'], '/'));
$resource = $path[0] ?? null;
$id = (int) ($path[1] ?? 0);

if ($resource === 'users' && $id !== 0) {
echo json_encode(getUser($id));
exit;
}

http_response_code(404);
echo json_encode(['error' => 'Not found']);

---

Validación de Datos con Objetos de Valor

Mostrar cómo evitar errores y asegurar integridad usando Value Objects.

Email Value Object

<?php
declare(strict_types=1);

class Email {
private string $value;

public function __construct(string $email) {
	if (!filter_var($email, FILTER_VALIDATE_EMAIL)) {
		throw new InvalidArgumentException("Email inválido.");
	}
	$this->value = $email;
}

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

Uso

$email = new Email("demo@ejemplo.com");
echo $email->value();

---

Ejemplo de Servicio de Dominio (Arquitectura Limpia)

Un caso de uso típico: registrar un usuario.

Servicio RegisterUserService

<?php
declare(strict_types=1);

class RegisterUserService {
public function __construct(private UserRepository $repo) {}

public function handle(string $email, string $name): int {
	$user = new User(new Email($email), $name);
	return $this->repo->save($user);
}
}

---

Ejemplo de Repositorio (Interface + Implementación)

<?php
interface UserRepository {
public function save(User $user): int;
public function findById(int $id): ?User;
}

Implementación con PDO

<?php
class PdoUserRepository implements UserRepository {
public function save(User $user): int {
	$db = db();
	$stmt = $db->prepare(
		"INSERT INTO users (email, name) VALUES (:email, :name)"
	);
	$stmt->execute([
		'email' => $user->email()->value(),
		'name' => $user->name()
	]);
	return (int)$db->lastInsertId();
}

public function findById(int $id): ?User {
	$stmt = db()->prepare("SELECT * FROM users WHERE id = :id");
	$stmt->execute(['id' => $id]);
	$data = $stmt->fetch();
	if (!$data) return null;

	return new User(
		new Email($data['email']),
		$data['name']
	);
}
}

---

Caso Real: Enviar Emails Automáticos (SMTP)

<?php
use PHPMailer\PHPMailer\PHPMailer;

$mail = new PHPMailer();
$mail->isSMTP();
$mail->Host = 'smtp.example.com';
$mail->SMTPAuth = true;
$mail->Username = 'user';
$mail->Password = 'pass';
$mail->SMTPSecure = 'tls';
$mail->Port = 587;

$mail->setFrom('noreply@app.com');
$mail->addAddress('cliente@correo.com');
$mail->Subject = "Bienvenido";
$mail->Body = "Gracias por registrarte.";

$mail->send();

---

Caso Real: Consumir una API Externa (Guzzle)

<?php
use GuzzleHttp\Client;

$client = new Client(['base_uri' => 'https://api.externa.com/']);

$response = $client->get('/usuarios');
$data = json_decode($response->getBody()->getContents(), true);

print_r($data);

---

Caso Real: Cola de Trabajos (Jobs) con Redis

Ideal para tareas asíncronas: correos, PDFs, sincronizaciones.

Producer

<?php
$redis = new Redis();
$redis->connect('localhost');

$redis->lPush('jobs', json_encode([
'type' => 'enviar_email',
'email' => 'demo@correo.com'
]));

Worker

<?php
while (true) {
$job = $redis->rPop('jobs');
if ($job) {
	$data = json_decode($job, true);
	if ($data['type'] === 'enviar_email') {
		// lógica de envío
	}
}
sleep(1);
}

---

Caso Real: Login Seguro con PHP

<?php
function login(string $email, string $password): bool {
$stmt = db()->prepare("SELECT * FROM users WHERE email = :email");
$stmt->execute(['email' => $email]);
$user = $stmt->fetch();

if (!$user) return false;
return password_verify($password, $user['password']);
}

---

Caso Real: Generar CSV

<?php
$data = [
['id', 'name', 'email'],
[1, 'Juan', 'juan@mail.com'],
[2, 'Ana', 'ana@mail.com']
];

$fh = fopen('archivo.csv', 'w');

foreach ($data as $row) {
fputcsv($fh, $row);
}

fclose($fh);

PHP — Casos Prácticos Avanzados (Arquitectura 2025)

Introducción

Casos reales de alto nivel utilizados en plataformas empresariales, SaaS complejos y sistemas distribuidos modernos — aplicados específicamente con PHP 8.3/8.4.

---

1. CQRS Completo (Command + Query Separation)

Separación explícita de modelos de lectura/escritura.

Carpeta de comandos

/src
/Command
CreateInvoice.php
/CommandHandler
CreateInvoiceHandler.php
/Query
GetInvoiceById.php
/QueryHandler
GetInvoiceByIdHandler.php

`

Command Handler

final class CreateInvoiceHandler {
    public function __construct(
        private InvoiceRepository $repo,
        private EventBus $events
    ) {}

    public function __invoke(CreateInvoice $cmd): void {
        $invoice = Invoice::create($cmd->customerId, $cmd->items);
        $this->repo->save($invoice);
        $this->events->dispatch(...$invoice->pullEvents());
    }
}

`

Query Handler

final class GetInvoiceByIdHandler {
    public function __construct(private PDO $db) {}

    public function __invoke(GetInvoiceById $query): array {
        $stmt = $this->db->prepare("SELECT * FROM invoices_view WHERE id = ?");
        $stmt->execute([$query->id]);
        return $stmt->fetch(PDO::FETCH_ASSOC);
    }
}

---

2. Snapshotting de Eventos (Event Sourcing optimizado)

Reducir carga reconstruyendo el estado desde snapshots.

class SnapshotRepository {
    public function load(string $aggregateId): ?Snapshot {
        // load from snapshots table
    }
}

class AggregateRebuilder {
    public function rebuild(string $id, Snapshot $snapshot = null): Aggregate {
        $agg = $snapshot?->state ?? new Aggregate();
        $events = $this->eventStore->loadAfter($id, $snapshot?->version ?? null);

        foreach ($events as $event) $agg->apply($event);
        return $agg;
    }
}

---

3. API Hexagonal — Entrada HTTP + Dominio + Adaptadores

Patrón de puertos y adaptadores.

/Application
	UseCase/RegisterUser.php
/Domain
	Entity/User.php
	Repository/UserRepository.php
/Infrastructure
	Http/RegisterUserController.php
	Persistence/UserRepositoryMySQL.php

Controlador (Adaptador de entrada)

class RegisterUserController {
    public function __construct(private RegisterUser $usecase) {}

    public function __invoke(): void {
        $payload = json_decode(file_get_contents('php://input'), true);
        $this->usecase->execute($payload['email']);
        echo json_encode(['status' => 'ok']);
    }
}

Caso de uso (Aplicación)

class RegisterUser {
    public function __construct(private UserRepository $repo) {}

    public function execute(string $email): void {
        $user = User::register($email);
        $this->repo->save($user);
    }
}

---

4. Event Mesh con NATS / Kafka desde PHP

Publicación de eventos en un bus empresarial.

$nats = new Nats();
$nats->connect();

$event = [
    'type' => 'OrderCreated',
    'order_id' => 1001,
    'timestamp' => microtime(true)
];

$nats->publish("orders.created", json_encode($event));

---

5. Microservicio con Consistencia Eventual

Emitir un evento y permitir que otros servicios materialicen su propio estado.

Servicio “Usuarios”

$user = User::create($email);
$this->repo->save($user);

$eventBus->dispatch(new UserRegistered($user->id, $email));

Servicio “Notificaciones”

$eventBus->subscribe(UserRegistered::class, function ($event) {
    Email::send($event->email, "Bienvenido!");
});

---

6. Sagas (Process Managers)

Coordinación de múltiples microservicios.

class CheckoutSaga {
    public function onOrderPlaced(OrderPlaced $e) {
        $this->bus->dispatch(new ReserveStock($e->orderId));
    }

    public function onStockReserved(StockReserved $e) {
        $this->bus->dispatch(new ProcessPayment($e->orderId));
    }

    public function onPaymentCompleted(PaymentCompleted $e) {
        $this->bus->dispatch(new FinalizeOrder($e->orderId));
    }
}

---

7. Multi-Tenancy (SaaS Moderno)

Separación por base de datos según tenant.

Middleware para identificar tenant

class TenantResolver {
    public function __invoke($req, $next) {
        $domain = $_SERVER['HTTP_HOST'];
        $tenant = explode('.', $domain)[0];

        TenantContext::set($tenant);

        return $next($req);
    }
}

Repositorio multi-tenant

class TenantPDOFactory {
    public static function connection(): PDO {
        $tenant = TenantContext::get();
        return new PDO("mysql:dbname=app_$tenant;host=localhost", "root", "");
    }
}

---

8. Pipeline de Enriquecimiento de Eventos

Patrón usado en Data Engineering con PHP como worker.

class Pipeline {
    public function __construct(private array $stages) {}

    public function process(array $event): array {
        foreach ($this->stages as $s) $event = $s($event);
        return $event;
    }
}

$pipeline = new Pipeline([
    fn($e) => array_merge($e, ['ip' => $_SERVER['REMOTE_ADDR']]),
    fn($e) => array_merge($e, ['geo' => geo_lookup($e['ip'])]),
    fn($e) => array_merge($e, ['processed_at' => microtime(true)])
]);

$event = $pipeline->process(['type' => 'login', 'user' => 4]);

---

9. PHP Worker persistente (Swoole / RoadRunner)

Colas, websockets, tareas background.

use Spiral\RoadRunner\Worker;

$worker = Worker::create();

while ($req = $worker->waitPayload()) {
    $data = json_decode($req->body, true);
    // procesar evento
    $worker->respond(json_encode(['done' => true]));
}

---

10. Capa de Anti-Corrupción (ACL)

Aislar tu dominio de sistemas externos.

class ExternalBillingAdapter {
    public function __construct(private BillingApi $api) {}

    public function createInvoice(DomainInvoice $invoice): BillingInvoice {
        return $this->api->createInvoice([
            'amount' => $invoice->total(),
            'items' => $invoice->items(),
        ]);
    }
}

---

11. GraphQL + Domain Services

Exponer dominios complejos con resolución por servicios.

$schema = <<<GRAPHQL
type Query {
    invoice(id: ID!): Invoice
}
GRAPHQL;

$resolvers = [
    'Query' => [
        'invoice' => fn($root, $args) => $invoiceService->getById($args['id'])
    ]
];

---

12. Integración con Service Mesh (mTLS)

PHP hablando con un sidecar Envoy.

$context = stream_context_create([
    "ssl" => [
        "local_cert" => "/etc/certs/client.pem",
        "cafile"     => "/etc/certs/ca.crt"
    ]
]);

$response = file_get_contents("https://orders.internal.svc", false, $context);

---

13. Observabilidad avanzada (OpenTelemetry)

Traza completa de un request.

$tracer = (new TracerProvider(
    new SimpleSpanProcessor(
        new OtlpHttpExporter(endpoint: "http://otel-collector:4318")
    )
))->getTracer("app");

$span = $tracer->spanBuilder("process_order")->startSpan();
// lógica
$span->setAttribute("order.id", 1209);
$span->end();

---

14. Idempotencia distribuida

Evitar procesamientos duplicados en workers.

class Idempotency {
    public function __construct(private Redis $redis) {}

    public function check(string $key): bool {
        return $this->redis->set($key, 1, ['nx', 'ex' => 300]);
    }
}

$id = new Idempotency($redis);

if (!$id->check("payment:$txnId")) {
    exit("Already processed");
}

---

15. Árbol de permisos RBAC dinámico

Control granular con herencia de roles.

class PermissionTree {
    private array $roles = [];

    public function addRole(string $role, array $permissions = [], ?string $parent = null) {
        $this->roles[$role] = compact('permissions', 'parent');
    }

    public function allows(string $role, string $perm): bool {
        if (in_array($perm, $this->roles[$role]['permissions'])) return true;
        $parent = $this->roles[$role]['parent'];
        return $parent ? $this->allows($parent, $perm) : false;
    }
}

$tree = new PermissionTree();
$tree->addRole("viewer", ["read"]);
$tree->addRole("editor", ["write"], "viewer");

$tree->allows("editor", "read"); // true

---

16. Cifrado por campos (Field-level encryption)

Estándar en sistemas con GDPR.

class FieldEncryptor {
    public function __construct(private string $key) {}

    public function encrypt(string $value): string {
        $iv = random_bytes(16);
        $enc = openssl_encrypt($value, "AES-256-GCM", $this->key, 0, $iv, $tag);
        return base64_encode($iv.$tag.$enc);
    }

    public function decrypt(string $payload): string {
        $raw = base64_decode($payload);
        $iv  = substr($raw, 0, 16);
        $tag = substr($raw, 16, 16);
        $enc = substr($raw, 32);
        return openssl_decrypt($enc, "AES-256-GCM", $this->key, 0, $iv, $tag);
    }
}

---

17. Sincronización de proyecciones en paralelo

Materialization pipeline.

$events = $eventStore->loadSince($checkpoint);

parallel\run(function() use ($events) {
    foreach ($events as $e) UserProjection::apply($e);
});

parallel\run(function() use ($events) {
    foreach ($events as $e) BillingProjection::apply($e);
});

---

18. Dominio con reglas complejas (Policy Pattern)

interface Policy { public function check(Order $o): bool; }

class MaxAmountPolicy implements Policy {
    public function check(Order $o): bool { return $o->total <= 5000; }
}

class OnlyVerifiedUsersPolicy implements Policy {
    public function check(Order $o): bool { return $o->user->verified; }
}

class OrderApproval {
    public function __construct(private array $policies) {}

    public function approve(Order $o): bool {
        foreach ($this->policies as $p) {
            if (!$p->check($o)) return false;
        }
        return true;
    }
}

---

19. Precalentamiento de cachés (Startup warmers)

class WarmCache {
    public function __invoke() {
        Cache::set('settings', SettingsRepository::loadAll());
        Cache::set('countries', CountryRepository::all());
    }
}

(new WarmCache())();

---

20. Detección de cambios en dominio (State Diff)

function diff(object $old, object $new): array {
    $changes = [];
    foreach (get_object_vars($new) as $prop => $val) {
        if ($old->$prop !== $val) $changes[$prop] = [$old->$prop, $val];
    }
    return $changes;
}

$changes = diff($productOld, $productNew);

---

PHP Aplicado a Arquitecturas Empresariales (2025)

Introducción

Esta nota describe cómo aplicar PHP en arquitecturas empresariales modernas, incluyendo microservicios, CQRS, Event Sourcing, pipelines, observabilidad y multi-tenant.
Se enfoca en patrones, prácticas y casos reales aplicables en entornos corporativos de alta escala.

---

1. Arquitectura de Microservicios

PHP puede formar parte de un ecosistema de servicios independientes.

Características

• Servicios desacoplados con responsabilidades claras.
• Comunicación asíncrona mediante colas (RabbitMQ, Kafka) o HTTP REST/GraphQL.
• Independencia de base de datos por servicio.
• Implementación de contratos (API-first).

Ejemplo de Microservicio PHP

// Servicio de usuarios
class UserService {
public function register(string $email): User {
	$user = new User($email);
	$this->repository->save($user);
	$this->eventBus->dispatch(new UserRegistered($user->id));
	return $user;
}
}

`

---

2. CQRS y Event Sourcing

Separación de commands (escritura) y queries (lectura), combinada con almacenamiento de eventos.

Patrón CQRS

• Commands: registran cambios de estado.
• Queries: consultan información optimizada.
• Beneficios: escalabilidad, performance y claridad de negocio.

Event Sourcing

• Cada cambio en el dominio se registra como un evento inmutable.
• Permite reconstruir el estado del sistema en cualquier momento.
• Facilita auditoría y reproducibilidad.

class Account {
private array $events = [];
public function deposit(float $amount) {
	$this->events[] = new DepositMade($amount);
	$this->apply($this->events[count($this->events)-1]);
}
private function apply(object $event) { $this->balance += $event->amount; }
}

---

3. Pipelines y Workers Distribuidos

PHP puede ejecutar tareas asíncronas de alto volumen.

Ejemplo: Worker para envío de correos

while ($job = $queue->pop()) {
EmailService::send($job->email, $job->subject, $job->body);
}

Pipeline de procesamiento de eventos

- Enriquecimiento de datos
- Validación
- Persistencia en proyecciones o caches

---

4. Multi-Tenancy

Implementación SaaS con separación de clientes.

Base de datos por tenant

$tenant = TenantContext::get();
$pdo = new PDO("mysql:host=localhost;dbname=app_$tenant", "user", "pass");

Middleware de identificación de tenant

class TenantResolver {
public function __invoke($request, $next) {
	$tenant = explode('.', $_SERVER['HTTP_HOST'])[0];
	TenantContext::set($tenant);
	return $next($request);
}
}

---

5. Observabilidad y Telemetría

Integración con OpenTelemetry, logs estructurados y tracing distribuido.

$tracer = (new TracerProvider(new SimpleSpanProcessor(new OtlpHttpExporter())))
->getTracer("app");

$span = $tracer->spanBuilder("process_order")->startSpan();
$span->setAttribute("order.id", $orderId);
$span->end();

Buenas prácticas

- Logs JSON para sistemas centralizados.
- Métricas de negocio y técnicas.
- Tracing en requests y jobs.

---

6. Seguridad Empresarial

Prácticas recomendadas

• Cifrado a nivel de campo (AES-256-GCM) para datos sensibles.
• Autenticación moderna: OAuth2, JWT rotativos, OpenID Connect.
• Gestión de roles y permisos RBAC dinámico.
• Middleware de validación y protección contra ataques OWASP.

---

7. Integración con Service Mesh y Arquitectura Distribuida

PHP puede integrarse con mTLS y sidecars para seguridad y control de tráfico.

$context = stream_context_create([
"ssl" => [
	"local_cert" => "/etc/certs/client.pem",
	"cafile"     => "/etc/certs/ca.crt"
]
]);
$response = file_get_contents("https://orders.internal.svc", false, $context);

Beneficios

• Descubrimiento de servicios
• Resiliencia y retries automáticos
• Telemetría nativa

---

8. Integración con Legacy y Sistemas Externos

• Adaptadores para sistemas antiguos.
• Anti-Corruption Layer para aislar el dominio.
• Transformación de datos entrantes a objetos de dominio.

class ExternalBillingAdapter {
public function createInvoice(DomainInvoice $invoice) {
	return $this->api->createInvoice([
		'amount' => $invoice->total(),
		'items' => $invoice->items(),
	]);
}
}

---

9. Arquitectura Hexagonal en PHP

Principios

• Puertos: interfaces del dominio.
• Adaptadores: infraestructura, bases de datos, API externas.
• Beneficios: independencia de framework, facilidad de testing.

Ejemplo

// Puerto
interface UserRepository { public function save(User $user); }
// Adaptador
class UserRepositoryMySQL implements UserRepository {
public function save(User $user) { /* persist */ }
}

---

10. Escalabilidad y Performance

Estrategias

• Uso de Swoole/RoadRunner para PHP sin bloqueo.
• Preloading y Opcache optimizado.
• Cache multi-capa: Redis, Memcached, microcaching HTTP.
• Sharding y replicación de datos en grandes sistemas.

---

11. Casos de Uso Empresariales

• Facturación masiva: workers + pipelines + CQRS.
• SaaS multi-tenant: bases de datos separadas, configuración por tenant.
• Procesamiento de eventos: Event Mesh + Event Sourcing.
• Notificaciones masivas: colas y workers asíncronos.
• Auditoría de negocio: Event Sourcing y logs estructurados.
• Integración con ERPs: adaptadores y anti-corruption layers.
• Seguridad y cumplimiento: cifrado, roles dinámicos y autenticación moderna.

---

12. Estructura de Proyecto Empresarial

src/
App/
	Domain/
	Application/
	Infrastructure/
	Shared/
config/
workers/
tests/
vendor/
public/

---

13. Buenas Prácticas para PHP Empresarial

• Seguir PSR (12, 4, 3, 7, 15).
• Separación estricta de dominio, aplicación e infraestructura.
• Tests unitarios, integración y end-to-end.
• Documentación y OpenAPI para APIs.
• Deploy automatizado y pipelines CI/CD.
• Observabilidad y trazabilidad completa de requests y jobs.

PHP — Guía de Tools y Técnicas Modernas (2025)

Introducción

Guía práctica de herramientas y técnicas modernas para desarrollo PHP en entornos profesionales, SaaS, microservicios y arquitecturas empresariales.
Incluye IDE, depuración, testing, pipelines, seguridad, performance y observabilidad.

---

1. IDE y Editor de Código

• PhpStorm: refactorización avanzada, debugging y análisis de código.
• VSCode: extensiones PHP Intelephense, PHP Debug.
• Neovim / Vim: integración con LSP y PHPStan para análisis estático.

Técnicas

• Autocompletado y navegación por clases/métodos.
• Plantillas de código y snippets.
• Integración con Docker y entornos remotos.

---

2. Gestión de Dependencias

• composer: estándar de facto para manejo de paquetes y autoloading.
• Packagist: repositorio público.
• Private repositories: para librerías internas.
• Técnicas:
• Versionamiento semántico (SemVer)
• PSR-4 autoloading
• Dependencias mínimas por microservicio

---

3. Testing y Calidad de Código

Herramientas

• PHPUnit: pruebas unitarias y de integración.
• PestPHP: sintaxis más limpia para tests.
• PHPStan / Psalm: análisis estático, detención de errores en tiempo de desarrollo.
• Mockery / Prophecy: mocks y stubs para pruebas unitarias.

Técnicas

• Test Driven Development (TDD)
• Domain testing (tests centrados en reglas de negocio)
• Cobertura mínima ≥ 80%
• Integración en pipelines CI/CD

---

4. Debugging

• Xdebug: step debugging, profiling y tracing.
• Telescope (Laravel): monitorización de requests y jobs.
• Clockwork: profiling de aplicaciones PHP, integración con browser.

Técnicas

• Debug remoto con IDE
• Breakpoints condicionales
• Análisis de consumo de memoria y tiempo de ejecución
• Dump de variables con var_dump o ray() de Spatie

---

5. Pipelines y CI/CD

• GitHub Actions: workflows automatizados.
• GitLab CI/CD: pipelines YAML.
• Jenkins / Bamboo: integración empresarial.

Técnicas

• Linting y static analysis en cada commit
• Ejecución de tests unitarios y de integración
• Construcción de contenedores y despliegue automatizado
• Canary releases y blue/green deployment

---

6. Contenedores y Orquestación

• Docker: entornos reproducibles.
• Docker Compose: multi-servicios locales.
• Kubernetes: despliegue a escala.
• Helm: gestión de configuraciones.

Técnicas

• Separación de servicios (PHP-FPM, Nginx, Redis, DB)
• Escalabilidad horizontal y replicación
• Multi-tenant en contenedores aislados
• Logs centralizados con EFK stack

---

7. Logging y Observabilidad

• Monolog: logging estructurado.
• OpenTelemetry: tracing y métricas.
• Prometheus + Grafana: métricas de negocio y técnicas.
• Sentry: error tracking.

Técnicas

• Logs JSON y correlación de request-id
• Trazas distribuidas en microservicios
• Métricas personalizadas (latencia, throughput)
• Alertas basadas en SLAs

---

8. Seguridad

• libsodium: cifrado y firmas modernas.
• JWT: autenticación y autorización.
• OAuth2 / OpenID Connect: integración con proveedores.
• OWASP ZAP: testing de vulnerabilidades.

Técnicas

• Validación y sanitización estricta de inputs
• Cifrado de campos sensibles
• Middleware de seguridad (CORS, rate limiting, CSRF)
• Rotación de tokens y claves

---

9. Performance

• Opcache: caching de bytecode.
• Redis / Memcached: cache de datos y sesiones.
• Swoole / RoadRunner: ejecución PHP persistente sin cold start.
• Blackfire: profiling avanzado.

Técnicas

• Preload de clases críticas
• Optimización de queries y índices
• Lazy-loading de dependencias
• Batch jobs para operaciones costosas

---

10. Integración con Sistemas Externos

• Guzzle / Symfony HttpClient: consumo de APIs REST/GraphQL.
• RabbitMQ / Kafka / NATS: colas y mensajería distribuida.
• ETL Pipelines: procesamiento de datos asíncrono.
• Webhooks: integración en tiempo real con servicios externos.

Técnicas

• Retries con backoff exponencial
• Circuit Breakers y fallback patterns
• Adaptadores y Anti-Corruption Layers para sistemas legacy
• Observabilidad en cada integración

---

11. Frameworks Modernos

• laravel: microservicios, jobs, pipelines, Eloquent ORM.
• Symfony: arquitectura hexagonal, DI, reusable bundles.
• CodeIgniter / Slim: micro-frameworks ligeros.
• Techniques:
• Inyección de dependencias
• Event-driven architecture
• Middleware pipelines
• Domain-driven design (DDD)

---

12. Testing en Producción

• Canary deployments y feature flags.
• Smoke tests automáticos.
• Health checks y monitoring en endpoints críticos.
• Integración de logging y tracing con métricas.

---

13. Automatización de Tareas

• Laravel Scheduler / Cron Jobs: ejecución periódica de tareas.
• Supervisor: monitorización de procesos PHP persistentes.
• RoadRunner / Swoole Workers: tareas background asíncronas y persistentes.

---

14. Documentación y API Management

• OpenAPI / Swagger: documentación de endpoints.
• GraphQL Playground / Voyager: exploración de API.
• Postman / Insomnia: testing de endpoints.
• Técnicas:
• Versionado de API (/v1, /v2)
• Contratos claros y consistentes
• Validación de inputs y outputs

---

15. Buenas Prácticas Generales

• Seguir PSR (3, 4, 7, 12, 15)
• Separación estricta de dominio, aplicación e infraestructura
• Automatización completa del ciclo de vida
• Observabilidad y trazabilidad total
• Security-first: cifrado, roles y autenticación robusta
• Performance y caching en todos los niveles
• Testing y CI/CD integrados

---

16. Recursos Complementarios

• PHP-mysql-old
• Testing
• Composer
• laravel
• Symfony
• GitHub - PHP Best Practices
• PHP: The Right Way

PHP — Seguridad Moderna 2025

Introducción

Guía de prácticas, herramientas y técnicas de seguridad modernas en PHP 2025, aplicable a aplicaciones web, APIs y arquitecturas empresariales.
Cubre cifrado, autenticación, autorización, hardening, protección de datos y observabilidad de seguridad.

---

1. Cifrado y Hashing

1.1 Hashing de contraseñas

• Usar password_hash() y password_verify().
• Algoritmo recomendado: PASSWORD_ARGON2ID (PHP 8.3+).

$hash = password_hash($password, PASSWORD_ARGON2ID);
if (password_verify($input, $hash)) {
    // login exitoso
}

`

1.2 Cifrado de datos sensibles

• Uso de libsodium para cifrado moderno.
• Cifrado simétrico AES-GCM para campos sensibles.

$key = random_bytes(SODIUM_CRYPTO_SECRETBOX_KEYBYTES);
$nonce = random_bytes(SODIUM_CRYPTO_SECRETBOX_NONCEBYTES);
$cipher = sodium_crypto_secretbox($data, $nonce, $key);
$plain = sodium_crypto_secretbox_open($cipher, $nonce, $key);

1.3 Encriptación a nivel de campo (Field-Level Encryption)

• Ideal para GDPR/CCPA.
• Cifrado de emails, números de tarjeta, documentos.

class FieldEncryptor {
    public function encrypt(string $value): string { /* AES-256-GCM */ }
    public function decrypt(string $payload): string { /* AES-256-GCM */ }
}

---

2. Autenticación Moderna

2.1 OAuth2 / OpenID Connect

• JWTs rotativos y short-lived.
• Refresh tokens con revocación y control de uso.
• Ejemplo de verificación JWT:

use Firebase\JWT\JWT;
$decoded = JWT::decode($token, $publicKey, ['RS256']);

2.2 Multi-Factor Authentication (MFA)

• Integración TOTP (Google Authenticator, Authy).
• Backup codes y alertas de seguridad.

2.3 Session Management seguro

• Cookies HttpOnly y Secure.
• Regeneración de session_id en login.
• Tiempo de expiración corto y idle timeout.

---

3. Autorización y Roles

3.1 RBAC dinámico

• Roles jerárquicos con permisos heredables.

class PermissionTree {
	public function allows(string $role, string $perm): bool { /* recursivo */ }
}

3.2 ABAC (Attribute-Based Access Control)

• Control basado en atributos de usuario, contexto y recurso.
• Ejemplo: solo usuarios verificados y con país permitido pueden acceder a ciertos endpoints.

---

4. Protección contra ataques comunes

4.1 SQL Injection

• Preparar todas las queries con PDO o ORM.

$stmt = $pdo->prepare("SELECT * FROM users WHERE email = ?");
$stmt->execute([$email]);

4.2 XSS (Cross-Site Scripting)

• Escapar siempre la salida con htmlspecialchars().
• Validación de inputs.

4.3 CSRF (Cross-Site Request Forgery)

• Tokens únicos por formulario/session.

$_SESSION['csrf'] = bin2hex(random_bytes(32));
<input type="hidden" name="csrf" value="<?= $_SESSION['csrf'] ?>">

4.4 Rate Limiting

• Prevenir brute force y abuso de endpoints.

if (!rate_limit($userId, 100, 60)) {
    http_response_code(429);
    exit("Too many requests");
}

---

5. Seguridad en APIs

5.1 Validación de Requests

• JSON Schema o DTOs con Attributes (PHP 8+).

#[Required]
public string $email;

5.2 HMAC / Signatures

• Validación de integridad de webhooks.

$calc = hash_hmac('sha256', $payload, $secret);
hash_equals($calc, $signature);

5.3 Throttling y IP Whitelisting

• Limitar requests por IP o token.

---

6. Hardening de PHP

6.1 Configuración segura

• expose_php = Off
• display_errors = Off en producción
• error_log = /var/log/php_errors.log
• session.cookie_httponly = 1
• session.cookie_secure = 1

6.2 Dependencias y Composer

• Escanear vulnerabilidades con composer audit.
• Mantener paquetes actualizados.
• Evitar librerías abandonadas.

---

7. Observabilidad y Seguridad

7.1 Logging seguro

• Logs estructurados (JSON) sin exponer datos sensibles.
• Correlación de request-id para auditoría.

7.2 Monitoreo y alertas

• Integración con Sentry, Prometheus, OpenTelemetry.
• Detección de comportamientos anómalos (brute force, picos de error).

---

8. Seguridad en Microservicios

8.1 Comunicación segura

• TLS/mTLS entre servicios.
• Validación de certificados.

$context = stream_context_create([
	"ssl" => ["local_cert"=>"/etc/certs/client.pem", "cafile"=>"/etc/certs/ca.crt"]
]);

8.2 Idempotencia y Protección de Jobs

• Evitar duplicados en colas.

if (!$idempotency->check("payment:$txnId")) exit("Already processed");

---

9. Pruebas de Seguridad

9.1 Unit y Integration Security Tests

• Validación de políticas, roles y permisos.
• Tests de endpoints para XSS, CSRF y SQLi.

9.2 Pentesting Automatizado

• OWASP ZAP o Burp Suite.
• Integración en CI/CD pipelines.

---

10. Buenas Prácticas Generales

• Principio de mínimo privilegio.
• Validación y sanitización exhaustiva de todos los inputs.
• Evitar datos sensibles en URLs o logs.
• Monitorización activa de seguridad.
• Actualización constante de PHP y librerías.
• Cifrado de datos en reposo y en tránsito.
• Implementar MFA y autenticación moderna.
• Observabilidad y trazabilidad completa de requests y jobs.

---

11. Recursos y Referencias

• PHP-mysql-old
• composer
• laravel
• OWASP PHP Security
• PHP: The Right Way - Security
• libsodium - PHP Docs

PHP 2025 — Cheatsheet

1. Sintaxis Básica

<?php
echo "Hola mundo";
$variable = 123;
$array = [1, 2, 3];
$assoc = ["clave" => "valor"];

`

---

2. Tipos de Datos

• int, float, string, bool, array, object, null
• PHP 8+: Union types, mixed, static return type

function foo(int|string $param): int|string {
	return $param;
}

---

3. Control de Flujo

if ($x > 0) { ... } elseif ($x < 0) { ... } else { ... }
switch($val) { case 1: ... break; default: ... }
for ($i=0; $i<10; $i++) { ... }
foreach ($array as $key => $val) { ... }
while ($cond) { ... }
do { ... } while ($cond);

---

4. Funciones

function suma(int $a, int $b): int {
	return $a + $b;
}
$suma = fn($a, $b) => $a + $b; // arrow function PHP 7.4+

---

5. Clases y Objetos

class Persona {
	public string $nombre;
	public function __construct(string $nombre) { $this->nombre = $nombre; }
	public function saludar(): string { return "Hola $this->nombre"; }
}

$persona = new Persona("Eduardo");
echo $persona->saludar();

Herencia y Polimorfismo

class Empleado extends Persona {
	public float $salario;
	public function __construct($nombre, $salario) {
		parent::__construct($nombre);
		$this->salario = $salario;
	}
}

---

6. Namespaces y Autoload

namespace App\Models;
class User {}
use App\Models\User;
$user = new User();

• Autoload con composer: PSR-4

---

7. Traits, Interfaces y Enums

trait Logger { public function log($msg){ echo $msg; } }
interface JsonSerializable { public function jsonSerialize(): array; }
enum Status: string { case Active = 'active'; case Inactive = 'inactive'; }

---

8. Arrays y Colecciones

$arr = [1, 2, 3];
array_map(fn($x)=>$x*2, $arr);
array_filter($arr, fn($x)=>$x>1);
array_reduce($arr, fn($carry,$x)=>$carry+$x, 0);

---

9. Superglobals

• $_GET, $_POST, $_COOKIE, $_SESSION, $_FILES, $_SERVER, $_ENV

---

10. Manejo de Strings

$str = "Hola Mundo";
strlen($str);
strpos($str, "Mundo");
substr($str, 0, 4);
str_replace("Hola","Hi",$str);

---

11. Manejo de Fechas

$date = new DateTime("now", new DateTimeZone("Europe/Madrid"));
echo $date->format("Y-m-d H:i:s");

---

12. Archivos y Directorios

file_get_contents("archivo.txt");
file_put_contents("archivo.txt","contenido");
fopen("archivo.txt","r");
fclose($handle);

---

13. Errores y Excepciones

try {
	if($x<0) throw new Exception("Valor negativo");
} catch(Exception $e) {
	echo $e->getMessage();
} finally {
	// cleanup
}

---

14. Funciones Avanzadas

Match Expression

$result = match($status) {
	1 => 'activo',
	2 => 'inactivo',
	default => 'desconocido'
};

Nullsafe Operator

$name = $user?->profile?->name;

Spread Operator en arrays

$arr1 = [1,2]; $arr2 = [...$arr1,3,4];

Named Arguments

function connect($host, $port, $user) {}
connect(host: "localhost", user: "root", port: 3306);

---

15. Seguridad Básica

$passwordHash = password_hash($pass, PASSWORD_ARGON2ID);
if(password_verify($input, $passwordHash)) { ... }

$htmlSafe = htmlspecialchars($input, ENT_QUOTES, 'UTF-8');

---

16. Acceso a Base de Datos

$pdo = new PDO("mysql:host=localhost;dbname=test","root","");
$stmt = $pdo->prepare("SELECT * FROM users WHERE id = ?");
$stmt->execute([$id]);
$user = $stmt->fetch(PDO::FETCH_ASSOC);

---

17. Composer y Dependencias

• Instalar paquete: composer require vendor/package
• Autoload: require 'vendor/autoload.php';
• Actualizar: composer update
• Analizar vulnerabilidades: composer audit

---

18. Testing

use PHPUnit\Framework\TestCase;
class MathTest extends TestCase {
	public function testSuma() { $this->assertEquals(4, 2+2); }
}

---

19. Debugging

• var_dump($var), print_r($var), debug_backtrace()
• Xdebug: breakpoints, stack traces y profiling
• Clockwork / Laravel Telescope para profiling HTTP y jobs

---

20. PHP 2025 Features

• Match expressions
• Nullsafe operator
• Named arguments
• Attributes / Annotations
• Constructor property promotion
• Union types y static return types
• Fibers para concurrencia ligera
• JIT y performance optimizations

---

21. Recursos

• PHP-mysql-old
• composer
• laravel
• PHP: The Right Way
• PHP Manual

PHP Empresarial 2025 — Cheatsheet Avanzado

Introducción

Resumen de herramientas, patrones, técnicas y código práctico para entornos PHP empresariales y arquitecturas modernas (microservicios, CQRS, Event Sourcing, multi-tenant, observabilidad).

---

1. Arquitectura y Patrones

1.1 Microservicios

• Servicios desacoplados, independientes, con su propia DB.
• Comunicación: HTTP REST, GraphQL, gRPC, mensajería (Kafka, NATS, RabbitMQ).

1.2 CQRS (Command/Query Responsibility Segregation)

// Command Handler
class CreateInvoiceHandler {
	public function __invoke(CreateInvoice $cmd) {
		$invoice = Invoice::create($cmd->customerId, $cmd->items);
		$this->repo->save($invoice);
		$this->events->dispatch(...$invoice->pullEvents());
	}
}

`

1.3 Event Sourcing

$account = new Account();
$account->deposit(100);
$events = $account->pullEvents(); // persistir en Event Store

1.4 Arquitectura Hexagonal

• Separación: Domain, Application, Infrastructure

interface UserRepository { public function save(User $user); }
class UserRepositoryMySQL implements UserRepository { /* ... */ }

1.5 Sagas / Process Managers

• Coordinación de microservicios en procesos largos y distribuidos.

---

2. Multi-Tenancy y SaaS

2.1 Tenant Context

$tenant = explode('.', $_SERVER['HTTP_HOST'])[0];
TenantContext::set($tenant);
$pdo = new PDO("mysql:dbname=app_$tenant;host=localhost","user","pass");

2.2 Configuración y cache por tenant

• Redis namespaces
• Configuración dinámica de recursos

---

3. Seguridad Empresarial

3.1 Autenticación y Autorización

• OAuth2 / OpenID Connect
• JWT short-lived y refresh tokens
• RBAC dinámico y ABAC

$tree->allows("editor", "read"); // true

3.2 Cifrado y hashing

• Contraseñas: PASSWORD_ARGON2ID
• AES-256-GCM / libsodium para datos sensibles
• Field-level encryption para GDPR

3.3 Protección contra ataques

• SQLi: PDO prepared statements
• XSS: htmlspecialchars()
• CSRF: tokens por formulario/session
• Rate limiting y throttling

---

4. Observabilidad y Monitoreo

4.1 Tracing distribuido

$span = $tracer->spanBuilder("process_order")->startSpan();
$span->setAttribute("order.id", $orderId);
$span->end();

4.2 Logging estructurado

• JSON logs, correlación de request-id
• Integración con Sentry, Prometheus, Grafana

4.3 Health Checks y Metrics

• Verificación de endpoints críticos
• Métricas de negocio y técnicas

---

5. Colas y Workers

while ($job = $queue->pop()) {
	ProcessJob::handle($job);
}

• Mensajería: RabbitMQ, Kafka, NATS
• Worker persistente: Swoole, RoadRunner
• Idempotencia y retries
• Pipelines de enriquecimiento y proyecciones

---

6. API Empresarial

6.1 REST y GraphQL

• Versionado /v1, /v2
• Validación DTO / JSON Schema
• HMAC/webhooks y throttling

6.2 Contratos y OpenAPI

• Documentación clara
• Mock servers y tests automáticos

---

7. Performance y Escalabilidad

7.1 Opcache y Preload

• PHP JIT y caching de bytecode

7.2 Cache de datos

• Redis / Memcached
• Microcaching HTTP

7.3 Paralelismo

• Fibers para concurrencia ligera
• Workers y pipelines distribuidos
• Sharding de bases de datos y replicación

---

8. Testing Empresarial

8.1 Unit, Integration, E2E

• PHPUnit, PestPHP
• Mocks: Mockery / Prophecy
• Cobertura ≥ 80%

8.2 Security and Compliance Tests

• Validación de roles, permisos y políticas
• Tests automáticos de SQLi, XSS, CSRF
• Integración con CI/CD

---

9. Herramientas Clave

• composer: dependencias y autoload PSR-4
• PHPUnit: pruebas unitarias
• PhpStorm / VSCode + Intelephense
• Sentry / Prometheus / Grafana / OpenTelemetry
• Docker / Docker Compose / Kubernetes
• Swoole / RoadRunner para workers persistentes

---

10. Técnicas Avanzadas

• Snapshotting en Event Sourcing
• Anti-Corruption Layer para sistemas legacy
• Domain Events y Event Mesh
• Canary releases y Blue/Green Deployment
• Multi-tenant con aislamiento completo
• Observabilidad full-stack (request + jobs + eventos)
• Idempotencia distribuida y locks
• Feature flags y experimentación controlada

---

11. Recursos

• PHP-mysql-old
• laravel
• Symfony
• PHP: The Right Way
• GitHub - PHP Best Practices

omnivore PHP

type: list
name: "Notas con #powershell en Omnivore"
order:
  - property: date_saved
    direction: desc
columns:
  - file.name
  - date_saved
filters:
  and:
    - file.inFolder("Omnivore")
    - file.hasTag("php", "PHP", "Php")
views:
  - type: table
    name: Table
    sort:
      - property: file.mtime
        direction: DESC