Programación Reactiva con Streams en PHP: Beyond el Bucle For

La programación reactiva ofrece una alternativa poderosa al procesamiento iterativo tradicional, especialmente cuando se trata de grandes conjuntos de datos o flujos continuos de información. En PHP, podemos simular conceptos de programación reactiva utilizando iteradores, generadores y, más recientemente, bibliotecas dedicadas. Este artículo explora cómo implementar streams en PHP para procesar datos de manera asíncrona y no bloqueante.

<?php

/**
 * Un Stream en PHP basado en generadores.
 */
class Stream
{
    private $generator;

    public function __construct(callable $generatorFunction)
    {
        $this->generator = $generatorFunction();
    }

    public function map(callable $transform): Stream
    {
        $generator = $this->generator;
        return new Stream(function () use ($generator, $transform) {
            foreach ($generator as $item) {
                yield $transform($item);
            }
        });
    }

    public function filter(callable $predicate): Stream
    {
        $generator = $this->generator;
        return new Stream(function () use ($generator, $predicate) {
            foreach ($generator as $item) {
                if ($predicate($item)) {
                    yield $item;
                }
            }
        });
    }

    public function toArray(): array
    {
        return iterator_to_array($this->generator);
    }
}

// Ejemplo de uso:
$data = [1, 2, 3, 4, 5, 6];

$stream = new Stream(function () use ($data) {
    foreach ($data as $item) {
        yield $item;
    }
});

$result = $stream
    ->filter(function ($item) {
        return $item % 2 == 0; // Filtra los números pares
    })
    ->map(function ($item) {
        return $item * 2; // Multiplica por 2
    })
    ->toArray();

print_r($result); // Output: Array ( [0] => 4 [1] => 8 [2] => 12 )

?>
    

Este ejemplo muestra una implementación básica de un Stream en PHP. La clave es el uso de generadores (yield) para producir valores de manera lazy. Las operaciones map y filter no ejecutan el procesamiento inmediatamente, sino que crean nuevas instancias de Stream que encapsulan la lógica de transformación y filtrado. Solo cuando se llama a toArray (o cualquier operación terminal), se recorre el stream y se aplican las transformaciones.

La ventaja de este enfoque es que permite construir pipelines de procesamiento de datos complejos sin necesidad de cargar todo el conjunto de datos en la memoria a la vez. Esto es especialmente útil para archivos grandes, conexiones de bases de datos, o feeds de eventos en tiempo real.

<?php

// Ejemplo con un generador que simula datos de una base de datos
function databaseDataGenerator(int $limit): Generator
{
    for ($i = 1; $i <= $limit; $i++) {
        // Simula la obtención de datos de una base de datos
        yield ['id' => $i, 'value' => rand(1, 100)];
    }
}

$stream = new Stream(function() {
    return databaseDataGenerator(100); // Simula 100 registros de la base de datos
});

$filteredAndProcessedData = $stream
    ->filter(function ($item) {
        return $item['value'] > 50;
    })
    ->map(function ($item) {
        return ['processed_id' => 'P-' . $item['id'], 'processed_value' => $item['value'] * 2];
    })
    ->toArray();

print_r($filteredAndProcessedData);

?>
    

En conclusión, la programación reactiva con streams en PHP, aunque no nativa en el sentido estricto, puede ser simulada eficientemente usando generadores. Este patrón permite procesar grandes cantidades de datos de forma lazy, mejorando el rendimiento y la eficiencia en el uso de la memoria en aplicaciones PHP complejas. Bibliotecas más avanzadas ofrecen operadores adicionales y mayor control sobre el flujo de datos, pero comprender los fundamentos con generadores proporciona una base sólida.