Können Perl-Methodenaufrufe abgefangen werden?

Question

Können Sie einen Methodenaufruf in Perl abfangen, etwas mit den Argumenten tun und dann ausführen?

Answer 1

Ja, Sie können Perl-Unterprogrammaufrufe abfangen. Ich habe ein ganzes Kapitel über diese Art von Dingen in Mastering Perl. Schauen Sie sich das Modul Hook::LexWrap an, mit dem Sie das tun können, ohne alle Details durchgehen zu müssen. Perls Methoden sind nur Subroutinen.

Sie können auch eine Unterklasse erstellen und die Methode überschreiben, die Sie abfangen möchten. Das ist ein etwas besserer Weg, weil das objektorientierte Programmieren so machen will. Manchmal schreiben jedoch Leute Code, der es Ihnen nicht erlaubt, dies richtig zu machen. Es gibt mehr darüber in Mastering Perl auch.

Answer 2

Das sieht nach einem Job für Moose aus! Moose ist ein Objektsystem für Perl, das das und noch viel mehr kann. Die docs wird viel besser erklären, als ich kann, aber was Sie wahrscheinlich wollen, ist ein Method Modifier, speziell before.

Answer 3

Um kurz zu beschreiben, Perl hat die Fähigkeit, Symboltabelle zu ändern. Sie rufen ein Unterprogramm (Methode) über die Symboltabelle des Pakets auf, zu dem die Methode gehört. Wenn Sie die Symboltabelle ändern (und dies wird nicht als sehr schmutzig betrachtet), können Sie die meisten Methodenaufrufe durch Aufrufen der anderen von Ihnen angegebenen Methoden ersetzen. Dies zeigt die Vorgehensweise:

# The subroutine we'll interrupt calls to 
sub call_me 
{ 
    print shift,"\n"; 
} 

# Intercepting factory 
sub aspectate 
{ 
    my $callee = shift; 
    my $value = shift; 
    return sub { $callee->($value + shift); }; 
} 
my $aspectated_call_me = aspectate \&call_me, 100; 

# Rewrite symbol table of main package (lasts to the end of the block). 
# Replace "main" with the name of the package (class) you're intercepting 
local *main::call_me = $aspectated_call_me; 

# Voila! Prints 105! 
call_me(5); 

Dies zeigt auch, dass, wenn schon jemand anhand des Unterprogramms nimmt und ruft sie über den Bezug, können Sie nicht mehr solche Anrufe beeinflussen.

Ich bin mir ziemlich sicher, dass es Frameworks gibt, die Aspiration in Perl durchführen, aber das, hoffe ich, zeigt den Ansatz.

Answer 4

Ja.

Sie brauchen drei Dinge:

Die Argumente für ein Gespräch in @_, die nur ein weiteres dynamisch scoped Variable ist.

Dann unterstützt goto ein Reference-Sub-Argument, das die aktuelle @_ erhält, aber einen anderen (Tail-) Funktionsaufruf macht.

Schließlich kann local verwendet werden, um lexikalisch begrenzte globale Variablen zu erstellen, und die Symboltabellen sind in %:: eingebettet.

So haben Sie bekam:

sub foo { 
    my($x,$y)=(@_); 
    print "$x/$y = " . ((0.0+$x)/$y)."\n"; 
} 
sub doit { 
    foo(3,4); 
} 
doit(); 

die natürlich druckt:

3/4 = 0.75 

Wir foo local verwenden ersetzen können und gehen:

my $oldfoo = \&foo; 
local *foo = sub { (@_)=($_[1], $_[0]); goto $oldfoo; }; 
doit(); 

Und jetzt bekommen wir :

4/3 = 1.33333333333333 

Wenn Sie wollen *foo ändern, ohne seinen Namen zu verwenden, und Sie wollten nicht eval verwenden, dann könnte man es ändern, indem %::, zum Beispiel der Manipulation:

$::{"foo"} = sub { (@_)=($_[0], 1); goto $oldfoo; }; 
doit(); 

Und wir bekommen jetzt:

3/1 = 3 

Answer 5

Sie können, und Pavel beschreibt eine gute Möglichkeit, es zu tun, aber Sie sollten wahrscheinlich erarbeiten, warum Sie dies in erster Linie tun möchten.

Wenn Sie nach erweiterten Möglichkeiten suchen, Aufrufe an beliebige Subroutinen abzufangen, dann funktioniert das Hantieren mit Symboltabellen für Sie, aber wenn Sie Funktionalität zu Funktionen hinzufügen möchten, die vielleicht in den Namensraum exportiert werden, in dem Sie gerade arbeiten, Dann müssen Sie möglicherweise wissen, wie Sie Funktionen aufrufen können, die in anderen Namespaces vorhanden sind.

Zum Beispiel exportiert Data :: Dumper normalerweise die Funktion 'Dumper' in den aufrufenden Namespace, aber Sie können diese überschreiben oder deaktivieren und eine eigene Dumper-Funktion bereitstellen, die dann das Original über den vollständig qualifizierten Namen aufruft.

z.B.

Wieder ist dies eine alternative Lösung, die je nach dem ursprünglichen Problem besser geeignet sein kann. Es kann viel Spaß gemacht werden, wenn man mit der Symboltabelle spielt, aber es kann übertrieben sein und dazu führen, dass Code schwer zu pflegen ist, wenn man ihn nicht braucht.