Khi nào tôi nên sử dụng AUTOLOAD của Perl?

Question

Trong "Perl Best Practices" dòng đầu tiên trong phần trên Autoload là:

Không sử dụng Autoload

Tuy nhiên tất cả các trường hợp ông mô tả đang đối phó với OO hoặc Modules.

Tôi có một tập lệnh độc lập trong đó một số công tắc dòng lệnh kiểm soát phiên bản của các chức năng cụ thể được xác định. Bây giờ tôi biết tôi chỉ có thể lấy các điều kiện và evals và dính chúng trần truồng ở trên cùng của tập tin của tôi trước khi mọi thứ khác, nhưng tôi thấy nó thuận tiện và sạch hơn để đặt chúng trong AUTOLOAD ở phần cuối của tập tin.

Thực tiễn/phong cách này có tệ không? Nếu bạn nghĩ vậy tại sao, và có cách nào khác để làm điều đó không?

Theo yêu cầu của brian của

Tôi đang sử dụng về cơ bản này để làm biên soạn có điều kiện dựa trên công tắc dòng lệnh.

Tôi không quan tâm đến một số lời chỉ trích mang tính xây dựng.

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

Nếu lý do duy nhất của bạn để sử dụng AUTOLOAD là di chuyển khối đến cuối, tại sao không đặt nó ở cuối chương trình con, và sau đó gọi nó ngay sau khi biến phụ thuộc của nó được xác định?

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 

Vẫn còn tốt hơn, nếu các hình cầu không cần thiết ở nơi khác, chỉ cần chuyển giá trị cho compile làm đối số.

Answer 2

Tôi nghĩ một kịch bản độc lập cách tiếp cận này là OK. Bạn có thể tạo các chương trình con đang chạy để tăng tốc các cuộc gọi tiếp theo, ví dụ:

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 
} 

Tự động nạp là khó khăn khi sản xuất cây thừa kế.

Answer 3

Một chiến lược thay thế sẽ là viết tập lệnh dưới dạng mô-đun App :: * và có tùy chọn dòng lệnh chọn lớp cần tải để cung cấp bất kỳ chức năng nào mà plugin có thể cắm tùy thuộc vào tùy chọn. Bạn sẽ require rằng lớp học chỉ trong thời gian khi bạn biết nó là gì. Đó là một công việc phía trước nhiều hơn một chút, nhưng nếu bạn có ý định duy trì kịch bản trong một thời gian dài, tôi đặt cược nó sẽ trả hết. Vài năm qua đã thấy việc tạo ra một số công cụ cực kỳ hay để tạo các tập lệnh có chức năng thực sự tồn tại trong các mô-đun, bao gồm App::Cmd, MooseX::Getopt và the bastard offspring of both.