1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
script1.pl
sub main{
require "script2.pl" if ( -e "script2.pl) ;
&fsub1
&fsub2
...
}
sub fsub1 {}
sub fsub2 {}
...
script2.pl
sub fsub1 {}
sub fsub2 {}
1 2 3 4 5 6 7 8 9
sub main { my ($ok,$ref1,$ref2)=(0,\&fsub1,\&fsub2); $ok=require "script2.pl" if ( -e "script2.pl); #... (*fsub1,*fsub2)=($ref2,$ref2) if($ok); }
Quoteich habe mich für die OO-Lösung entschieden
2011-03-25T19:19:52 markyHallo, genau meine Rede - man kann nicht alles haben und die Lauffähigkeit hat oberste Prio und die Performance.
QuoteProblem an Perl ist, dass es im standard einfach zu wenig OO-Möglichkeiten bietet
Quoteeine Lösung kann nicht sein x-Module zu laden, das geht gegen die Performance.
QuoteUnd ich bin kein PHP-Fan - aber man muss klar sagen, dass es im OO Bereich jetzt um längen vor Perl liegt,
QuoteAber ich werde solange Perl machen, bis man dies am Markt nicht mehr unterbringen kann, erst dann werde ich umsteigen und mich ins Herr der Millionen PHP-Amateure einreihen :-)
QuoteMit OO meine ich die 2. Lösung ganz unten, das zu includiere File als Package und die EInbindung per EXPORT und Import im Zielmodul.
2011-03-25T20:03:41 markyUnd der Vergleich mit PHP war bezogen auf die Core-Fähigkeiten.
Quotefalsch verstanden.aber man muss klar sagen, dass es im OO Bereich jetzt um längen vor Perl liegt, mal abgesehen von den ganzen Buildfunktionen
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34
sub plugin_start { my $self=shift; my $plugin_file=shift; my $plugin_name=$self->plugin_name_create($plugin_file); return (undef,"No valid plugin_name") unless($plugin_name); my $package_name="my_script::plugin::$plugin_name"; my $load_ok=0; my $code; if(my $fcode=$self->plugin_filtered_load($package_name,$plugin_file)) { $load_ok=1; $code=$fcode; } else { $code=$self->plugin_raw_load($plugin_file); $code=$self->plugin_code_filter($code,$package_name); } my $start_ok=eval($code); my $error; my $plugin_obj; if($start_ok) { $plugin_obj=$pakage_name->new(); $self->plugin_filtered_save($code,$pakage_name) unless($load_ok); } else { $error=$@; } return ($plugin_obj,$error); }
2011-03-27T09:08:35 markyIn diesem ganzen Thema ist PHP leider extrem weit nach vorne gegangen, das es mir fast schon weh tut, wenn ich sehen muss, wie das hier umsetzen muss.
2011-03-27T09:08:35 markyDie Standard-OO von Perl 5 ist wirklich nicht das beste...Die haben jetzt richtig geniale Autoload-Funktionen und das OO-Thema ist echt gut umgesetzt, wenn sich die gängigen Design-Pattern anschaut und vergleicht, wie man das in beiden Sprachen jeweils umsetzt, dann ist teilweise wirklich nicht gut in Perl.
2011-03-27T09:08:35 markySchonmal Role::Basic angeschaut? Ist zwar kein Core-Modul, ist aber Pure-Perl... Damit kann man sehr einfach Interfaces realisieren.Was das grosse Problem ist, ist dass interface nur schwer umzusetzen sind. Normal programmierst Du so Plugins nur gegen ein interface, das interface schreibt vor, welche Subs dann Plugin haben muss und welche Variablen eine Sub haben muss mit Typ. Dadurch ist das nicht mehr so problematisch.
2011-03-27T13:01:28 markyWas am meisten im Core fehlt, sind ... private Funktionen und Vars ...
Quote(Perl) would prefer that you stayed out of its living room because you weren't invited, not because it has a shotgun.
2011-03-27T09:08:35 markyHallo, Deine erste Aussage stimmt nicht, genau das ist ja der Vorteil auch von require, es wird eben nur einmal reingezogen, egal wie oft es im Code steht
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30
#!/usr/bin/perl use strict; use warnings; use Data::Dumper; package my; use Carp; sub test{ croak 'UNIMPLEMENTED '.( caller(0) )[3]; } package main; for my $num (0..9) { open(my $fh, '>', 'my.pm'); print $fh <<EOC; package my; sub test{ $num } 1; EOC close($fh); if(require 'my.pm') { print my::test()."\n"; delete($INC{'my.pm'}); } }
2011-03-27T09:08:35 marky"Note that the file will not be included twice under the same specified name."
2011-03-27T09:08:35 markyDas Problem mit den Plugins ist klar - aber das ist doch grundsätzlich ein OO-Vererbung Problem, wenn Du Dich nicht an den In- und Output hälst, dann geht der ganze quatsch nicht mehr. Das ist aber normal, da muss man halt aufpassen und genau schauen, was die Funktion macht, die man ersetzt. Aber es gibt einfach keine andere Möglichkeit core-Funktionen zu ersetzen und den Code update-fähig zu halten.
Ich habe mir ja jetzt für die Modul-methode entschieden, dann muss man wenigstens im EXPORT genau festlegen, was man überschreiben will.
Aber ich gebe zu, dass das ein Problem ist, aber ein allgemeines, wenn man überschreiben von Methoden durch einfach vererbungserweiterung zulässt, was aber heute die normale Vorgehensweise darstellt.
Die andere Möglichkeit sind HOOKs, was auch viele machen, da kannst Du aber halt nur ein bestimmten stellen bestimmte Dinge tun, zb. einen Hook nach dem Login etc.
2011-03-27T09:08:35 markyIn diesem ganzen Thema ist PHP leider extrem weit nach vorne gegangen, das es mir fast schon weh tut, wenn ich sehen muss, wie das hier umsetzen muss. Die haben jetzt richtig geniale Autoload-Funktionen und das OO-Thema ist echt gut umgesetzt, wenn sich die gängigen Design-Pattern anschaut und vergleicht, wie man das in beiden Sprachen jeweils umsetzt, dann ist teilweise wirklich nicht gut in Perl.
2011-03-27T09:08:35 markyWas das grosse Problem ist, ist dass interface nur schwer umzusetzen sind. Normal programmierst Du so Plugins nur gegen ein interface, das interface schreibt vor, welche Subs dann Plugin haben muss und welche Variablen eine Sub haben muss mit Typ. Dadurch ist das nicht mehr so problematisch.
2011-03-27T08:55:54 markyWas Du mit 00 meinst ist eher strict, ...
1 2
my $o = bless {}, 'main'; # erstelle ein Object in Class main print $o->can('foo'); # teste, ob sub 'foo' in main definiert ist