Dodaj nową metodę do istniejącego obiektu w perlu

Question

Mam ten obiekt perla. Po utworzeniu obiektu próbuję dodać nową metodę do obiektu w metodzie programu ładującego, którą można później wywołać.

Próbowałem całej masy rzeczy, które nie działały. Przykłady obejmują:

sub loader { 
    my ($self) = @_; 

    sub add_me { 
     my ($self, $rec) = @_ 

     warn "yayyyyyy"; 
     return $rec; 
    } 

    #here are the things I've tried that dont work: 
    # &{$self->{add_me}} = \&add_me; 
    # \&{$self->{add_me}} = \&add_me; 
    # assuming the class definition is in Holder::Class try to add it to symblol table 
    # *{Holder::Class::add_me} = \&add_me; 

} 

EDIT:

Dlatego, że muszę zrobić to Dodaję hak w moim kodu, gdzie użytkownik mojego oprogramowania będą mogli wstrzyknąć własnych podrzędny, aby edytować strukturę danych, tak jak będą.

Aby to zrobić, będą mogli edytować plik wtórnego, który będzie zawierał tylko jeden sub i uzyskać strukturę danych w pytaniu przeszedł w, więc coś takiego:

sub inject_a_sub { 
    my ($self, $rec) = @_; 

    #do stuff to $rec 

    return $rec; 
} 

następnie wewnątrz mojego oryginalnego obiektu na jego wystąpienie, sprawdzam, czy istnieje wyżej wymieniony plik, a jeśli tak, przeczytaj jego zawartość i przeanalizuj je. Na koniec chcę utworzyć kod eval'd, który jest tylko subem, metodą mojego obiektu. Mówiąc dokładniej, mój obiekt dziedziczy już metodę o nazwie do_something i chcę, aby sub-read został wprowadzony przez eval nadpisać dziedziczoną metodę do_something, tak aby po wywołaniu sub z pliku zewnętrznego działała.

Jego dziwny błąd:/

i boli mnie :(

Obi-Wan Kenobi jesteś moją jedyną nadzieją

Cheers

Answer 1

jeśli po prostu chcesz dołączyć! do określonego obiektu i nie potrzebujesz dziedziczenia, możesz zapisać referencję kodu w obiekcie i wywołać go.

# Store the code in the object, putting it in its own 
# nested hash to reduce the chance of collisions. 
$obj->{__actions}{something} = sub { ... }; 

# Run the code 
my @stuff = $obj->{__actions}{something}->(@args); 

Problem polega na tym, że należy sprawdzić, czy $obj->{__actions}{something} zawiera odwołanie do kodu. Sugerowałbym owinięcie metody wokół tej procedury.

sub add_action { 
    my($self, $action, $code) = @_; 

    $self->{__actions}{$action} = $code; 

    return; 
} 

sub take_action { 
    my($self, $action, $args) = @_; 

    my $code = $self->{__actions}{$action}; 
    return if !$code or ref $code ne 'CODE'; 

    return $code->(@$args); 
} 

$obj->add_action("something", sub { ... }); 
$obj->take_action("something", \@args); 

---

Jeśli już znasz nazwę klasy, którą chcesz wprowadzić do metody, napisać podprogram jako normalne, ale używać pełnej nazwy.

sub Some::Class::new_method { 
    my $self = shift; 

    ... 
} 

pamiętać, że wszelkie globalne wewnątrz tego podprogramu będzie w otaczającym pakietu nie w Some :: Klasy. Jeśli chcesz używać zmiennych trwałych, użyj podprogramu state wewnątrz podprogramu lub my poza podprogramem.

---

Jeśli nie znasz nazwy w czasie kompilacji, będziesz musiał wstrzyknąć podprogram do tablicy symboli, więc byłaś blisko z tym ostatnim.

sub inject_method { 
    my($object, $method_name, $code_ref) = @_; 

    # Get the class of the object 
    my $class = ref $object; 

    { 
     # We need to use symbolic references. 
     no strict 'refs'; 

     # Shove the code reference into the class' symbol table. 
     *{$class.'::'.$method_name} = $code_ref; 
    } 

    return; 
} 

inject_method($obj, "new_method", sub { ... }); 

Metody w języku Perl są powiązane z klasą, a nie z obiektem. Aby przypisać metodę do pojedynczego obiektu, musisz umieścić ten obiekt we własnej klasie.Podobnie do powyższego, ale musisz utworzyć podklasę dla każdej instancji.

my $instance_class = "_SPECIAL_INSTANCE_CLASS_"; 
my $instance_class_increment = "AAAAAAAAAAAAAAAAAA"; 
sub inject_method_into_instance { 
    my($object, $method_name, $code_ref) = @_; 

    # Get the class of the object 
    my $old_class = ref $object; 

    # Get the special instance class and increment it. 
    # Yes, incrementing works on strings. 
    my $new_class = $instance_class . '::' . $instance_class_increment++; 

    { 
     # We need to use symbolic references. 
     no strict 'refs'; 

     # Create its own subclass 
     @{$new_class.'::ISA'} = ($old_class); 

     # Shove the code reference into the class' symbol table. 
     *{$new_class.'::'.$method_name} = $code_ref; 

     # Rebless the object to its own subclass 
     bless $object, $new_class; 
    } 

    return; 
} 

Pominąłem kod, aby sprawdzić, czy instancja ma już tego leczenia przez sprawdzenie, czy jego klasa pasuje /^${instance_class}::/. Zostawiam to jako ćwiczenie dla ciebie. Tworzenie nowej klasy dla każdego obiektu nie jest tanie i kosztuje pamięć.

---

Istnieją ku temu ważne powody, ale są wyjątkowe. Naprawdę, naprawdę powinieneś zastanowić się, czy powinieneś robić tego rodzaju monkey patching. Ogólnie należy unikać stosowania action at a distance.

Czy możesz zrobić to samo, używając podklasy, delegacji lub roli?

Istnieje już system Perl OO, który zrobi to za Ciebie i znacznie więcej. Powinieneś używać jednego. Moose, Moo (poprzez Role::Tiny) i Mouse mogą wszystkie dodać role do instancji.