¿Cuándo debería usar AUTOLOAD de Perl? En

Question

"Perl Best Practices" la primera línea en la sección sobre AUTOLOAD es:

No utilice AUTOLOAD

Sin embargo, todos los casos que se describen están tratando con OO o módulos.

Tengo un script independiente en el que algunos modificadores de línea de comando controlan qué versiones de funciones particulares se definen. Ahora sé que podría tomar los condicionales y las evaluaciones y pegarlos desnudos en la parte superior de mi archivo antes que cualquier otra cosa, pero me parece conveniente y más limpio ponerlos en AUTOLOAD al final del archivo.

¿Es esta mala práctica/estilo? Si piensas así, ¿por qué? ¿Hay otra forma de hacerlo?

Según la petición de Brian

Soy básicamente usando esto para hacer la compilación condicional en base a parámetros de línea de comandos.

No me importa una crítica constructiva.

sub AUTOLOAD { 
    our $AUTOLOAD; 

    (my $method = $AUTOLOAD) =~ s/.*:://s; # remove package name 
    if ($method eq 'tcpdump' && $tcpdump) { 
     eval q(
     sub tcpdump { 
      my $msg = shift; 
      warn gf_time()." Thread ".threads->tid().": $msg\n"; 
     } 
     ); 
    } elsif ($method eq 'loginfo' && $debug) { 
     eval q(
     sub loginfo { 
      my $msg = shift; 
      $msg =~ s/$CRLF/\n/g; 
      print gf_time()." Thread ".threads->tid().": $msg\n"; 
     } 
     ); 
    } elsif ($method eq 'build_get') { 
     if ($pipelining) { 
      eval q(
      sub build_get { 
       my $url = shift; 
       my $base = shift; 
       $url = "http://".$url unless $url =~ /^http/; 
       return "GET $url HTTP/1.1${CRLF}Host: $base$CRLF$CRLF"; 
      }  
      ); 
     } else { 
      eval q( 
      sub build_get { 
       my $url = shift; 
       my $base = shift; 
       $url = "http://".$url unless $url =~ /^http/; 
       return "GET $url HTTP/1.1${CRLF}Host: $base${CRLF}Connection: close$CRLF$CRLF"; 
      }  
      ); 
     }  
    } elsif ($method eq 'grow') { 
     eval q{ require Convert::Scalar qw(grow); }; 
     if ($@) { 
      eval q(sub grow {}); 
     } 
     goto &$method; 
    } else { 
     eval "sub $method {}"; 
     return; 
    } 
    die $@ if $@; 
    goto &$method; 
} 

Answer 1

Si su única razón para usar AUTOLOAD es reubicar el bloque hasta el final, ¿por qué no ponerlo al final en una subrutina, y luego llamarlo tan pronto como se definan sus variables dependientes?

sub tcpdump; # declare your subs if you want to call without parens 

# define the parameters 

compile(); 

# code that uses new subs 

sub compile { 
    *tcpdump = $tcpdump ? sub { 
     my $msg = shift; 
     warn gf_time()." Thread ".threads->tid().": $msg\n"; 
    } : sub {}; 
    # ... 
} 
# EOF 

Mejor aún, si las variables globales no son necesarios en otro lugar, sólo tiene que pasar a los valores compile como argumentos.

Answer 2

Creo que para una secuencia de comandos independiente, este enfoque está bien. Puede crear subrutinas sobre la marcha para acelerar las llamadas posteriores, por ejemplo .:

sub AUTOLOAD { 
    (my $name = our $AUTOLOAD) =~ s/.*:://; 
    no strict 'refs'; # allow symbolic references 

    *$AUTOLOAD = sub { print "$name subroutine called\n" };  
    goto &$AUTOLOAD; # jump to the new sub 
} 

carga automática es difícil cuando la producción de árboles de herencia.

Answer 3

Una estrategia alternativa sería escribir el script como un módulo App :: * y tener la opción de línea de comando elegir qué clase cargar para proporcionar cualquier funcionalidad que sea conectable dependiendo de la opción. Usted podría require esa clase just-in-time una vez que sepa cuál es. Es un trabajo un poco más adelantado, pero si tiene la intención de mantener el guión durante mucho tiempo, apuesto a que valdría la pena. En los últimos años se ha visto la creación de algunas herramientas extrañas para crear scripts cuya funcionalidad realmente se encuentra en módulos, incluidos App::Cmd, MooseX::Getopt y the bastard offspring of both.