¿Puede una subrutina Perl devolver datos pero seguir procesando?

Question

¿Hay alguna manera de hacer que una subrutina envíe datos de vuelta mientras se está procesando? Por ejemplo (este ejemplo se usa simplemente para ilustrar): una subrutina lee un archivo. Mientras lee el archivo, si se cumple alguna condición, entonces "devuelva" esa línea y siga procesando. Sé que hay quienes responderán, ¿por qué querrías hacer eso? y ¿por qué no solo ...?, pero realmente me gustaría saber si esto es posible.

Answer 1

Una forma común de implementar este tipo de funcionalidad es una función de devolución de llamada:

{ 
    open my $log, '>', 'logfile' or die $!; 
    sub log_line {print $log @_} 
} 

sub process_file { 
    my ($filename, $callback) = @_; 
    open my $file, '<', $filename or die $!; 
    local $_; 
    while (<$file>) { 
     if (/some condition/) { 
      $callback->($_) 
     } 
     # whatever other processing you need .... 
    } 
} 

process_file 'myfile.txt', \&log_line; 

o sin siquiera nombrar a la devolución de llamada:

process_file 'myfile.txt', sub {print STDERR @_}; 

Answer 2

Si realmente quieres hacer esto, puedes usar el enhebrado. Una opción sería bifurcar un hilo separado que lea el archivo y cuando encuentre una cierta línea, colóquelo en una matriz que se comparte entre hilos. Luego, el otro hilo podría tomar las líneas, tal como se encuentran, y procesarlas. Aquí hay un ejemplo que lee un archivo, busca una 'X' en la línea de un archivo y realiza una acción cuando se encuentra.

use strict; 
use threads; 
use threads::shared; 

my @ary : shared; 

my $thr = threads->create('file_reader'); 

while(1){ 
    my ($value); 
    { 
     lock(@ary); 
     if ($#ary > -1){ 
      $value = shift(@ary); 
      print "Found a line to process: $value\n"; 
     } 
     else{ 
      print "no more lines to process...\n"; 
     }    
    } 

    sleep(1); 
    #process $value 
} 


sub file_reader{ 

      #File input 
    open(INPUT, "<test.txt"); 
    while(<INPUT>){ 
     my($line) = $_; 
     chomp($line); 

     print "reading $line\n"; 

     if ($line =~ /X/){ 
      print "pushing $line\n"; 
      lock(@ary); 
      push @ary, $line; 
     } 
     sleep(4) 
    } 
    close(INPUT); 
} 

Prueba este código como el archivo test.txt:

line 1 
line 2X 
line 3 
line 4X 
line 5 
line 6 
line 7X 
line 8 
line 9 
line 10 
line 11 
line 12X 

Answer 3

Algunos lenguajes ofrecen este tipo de función por medio de "generators" o "coroutines", pero Perl no. La página del generador vinculada anteriormente tiene ejemplos en Python, C# y Ruby (entre otros).

Answer 4

La manera más fácil de hacer esto en Perl es probablemente con una solución de tipo iterador. Por ejemplo, aquí tenemos una subrutina que forma una closure durante un gestor de archivo:

open my $fh, '<', 'some_file.txt' or die $!; 
my $iter = sub { 
    while(my $line = <$fh>) { 
     return $line if $line =~ /foo/; 
    } 

    return; 
} 

Los sub itera a través de las líneas hasta que encuentra uno que coincida con el patrón /foo/ y luego lo devuelve, o si no devuelve nada. (undef en contexto escalar.) Debido a que el identificador de archivo $fh se define fuera del alcance del sub, permanece residente en la memoria entre las llamadas. Lo que es más importante, se conserva su estado, incluida la posición de búsqueda actual en el archivo. De modo que cada llamada a la subrutina se reanuda leyendo el archivo donde se dejó por última vez.

Para utilizar el iterador:

while(defined(my $next_line = $iter->())) { 
    # do something with each line here 
} 

Answer 5

Si su idioma admite cierres, puede hacer algo como esto:

Por cierto, la función no continuaría procesando el archivo, se ejecutaría justo cuando lo llames, por lo que puede que no sea lo que necesitas.

(Este es un javascript como pseudo-código)

function fileReader (filename) { 
    var file = open(filename); 

    return function() { 
     while (s = file.read()) { 
      if (condition) { 
       return line; 
      } 
     } 
     return null; 
    }  
} 

a = fileReader("myfile"); 
line1 = a(); 
line2 = a(); 
line3 = a(); 

Answer 6

Qué pasa con un sub recursiva? Re-open Los manejadores de archivos existentes no restablecen el número de línea de entrada, por lo que continúa desde donde se dejó.

Aquí hay un ejemplo donde la subrutina process_file imprime párrafos "\n\n" separados por línea en blanco que contienen foo.

sub process_file { 

    my ($fileHandle) = @_; 
    my $paragraph; 

    while (defined(my $line = <$fileHandle>) and not eof(<$fileHandle>)) { 

     $paragraph .= $line; 
     last unless length($line); 
    } 

    print $paragraph if $paragraph =~ /foo/; 
    goto &process_file unless eof($fileHandle); 
     # goto optimizes the tail recursion and prevents a stack overflow 
     # redo unless eof($fileHandle); would also work 
} 

open my $fileHandle, '<', 'file.txt'; 
process_file($fileHandle); 

Answer 7

El módulo Coro parece que sería útil para este problema, aunque no tengo ni idea de cómo funciona y ni idea de si lo hace lo que anuncia.