Subroutine aus Variable (solved) (Allgemeines zu Perl)

[thread]18405[/thread]

Subroutine aus Variable [solved]

Tags: perl5 Similar Threads

Readers: 18

Articles: hide open all | hide show old branches

+5 replies

rc27

2013-06-26 09:39

User since
2013-06-18
14 articles
BenutzerIn
[default_avatar]

Hallo!

Ich habe einige Ordner in denen sich jeweils ein paar Dateien befinden. Je nach Ordner sollen bestimmte und z.T. gleiche Subroutinen ausgeführt werden. Für jeden Ordner möchte ich eine ini anlegen, die später in ein Array eingelesen und dann abgearbeitet wird.

Z.B.

Code: (dl )

#ini1.ini
default
sub1
sub2

oder

Code: (dl )

1
2
3

#ini2.ini 
sub1
sub3

Wenn ich jetzt folgendes ausführe scheitert das am strict (Can't use string ("sub1") as a subroutine ref while "strict refs"). Ohne gehts.

Code: (dl )

my @subs = ( 'default', 'sub1', 'sub2');

foreach my $sub (@subs)
{

   &{$sub};
}

+2 replies
rc27

2013-06-26 10:30
User since
2013-06-18
14 articles
BenutzerIn
Ich bin jetzt schon etwas weiter. Beim Syntax fehlts noch ein bißchen. Wie bekommt man \&sub1 über die Ini in ein Array eingelesen, ohne das strict meckert.
Code: (dl )

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

my @subs; my $ini = 'test.ini'; use Config::IniFiles; my $cfg = Config::IniFiles->new( -file => "$ini" ) || die "Error: Probleme beim Lesen der Ini-Datei"; foreach ($cfg->Parameters('do')) { push (@subs, $cfg->val('do', $_ )); } foreach (@subs) { $_->(); } sub1 ...
Code: (dl )

1 2 3 4 5 6

# test.ini [do] subroutine = sub1 subroutine = sub2 subroutine = sub3
Direkt zugewiesen funktioniert es, nur eben nicht dynamisch über die ini.
Code: (dl )

1 2 3 4 5 6 7 8 9

my $test = "sub3"; my @subs1 = (\&sub1, \&sub2, \&$test); push (@subs1, \&sub4); foreach (@subs1) { $_->(); }
Last edited: 2013-06-26 10:37:57 +0200 (CEST)
- Muffi
  
  2013-06-26 10:50
  User since
  2012-07-18
  1465 articles
  BenutzerIn
  Es gibt da 2 (wie immer bei Perl, wenn man sich anstrengt auch mehr) Möglichkeiten:
  
  1. UNIVERSAL::can(), das liefert, z.B. mit Class->can('subname'); eine Referenz auf die sub, die du dann mit $sub_ref->() aufrufen kannst.
  
  2. Und die Lösung find ich weit schöner:
  Du baust dir einen Hash mit:
  
  Code (perl): (dl )
  
  1 2 3 4 5 6
  
  my %subs = ( 'fuer_irgendwas' => sub { say 'HALLO' }, 'fuer_was_anderes' => sub { say 'WELT' }, ); $subs{'fuer_irgendwas'}->();
  
  Find ich schöner, weil dus dann sauber getrennt hast und das Zeugs nicht als sub irgendwo unkenntlich im Source verstreut ist
  Last edited: 2013-06-26 10:51:50 +0200 (CEST)
  1 + 1 = 10
+2 replies

topeg

2013-06-26 10:58

User since
2006-07-10
2611 articles
BenutzerIn

user image

Im allgemeinen ist es eine schlechte Idee Stings als Funktionsnamen zu benutzen. Die Fähigkeit von Perl stammt noch aus Zeiten als es dafür keine Alternativen gab. Das Problem ist nämlich das du keine Kontrolle darüber hast welche Funktionen benutzt werden dürfen. so kann aus jedem importieren Modul jede Funktion benutzt werden. Damit lässt sich einigen schaden

Besser ist es du benutzt einen Hash mit Funktionsreferenzen oder anonymen Funktionen um das zu lösen. Etwa so:

Code (perl): (dl )

#!/usr/bin/perl
use strict;
use warnings;

my %funktions=(
  default => \&do_default,
  sub1    => \&do_sub1,
  sub2    => \&do_sub2,
  sub3    => \&do_sub3,
);

open(my $fh, '<', $file) or die( "ERROR OPEN $file ($!)\n" );
while(my $cmd=<$fh>)
{
  chomp($cmd);
  # Kommenatre entfernen
  next if($cmd=~/^\s*#/);

  # Error wenn eine Unbekannter Aufruf kommt:
  die("CMD:$cmd FILE:$file LINE:$. Not implemented!") unless exists $funktions{$cmd};

  $funktions{$cmd}->();
}
close($fh);

##############################
sub do_default { print "DOING DEFAULT\n" }
sub do_sub1 { print "DOING SUB1\n" }
sub do_sub2 { print "DOING SUB2\n" }
sub do_sub3 { print "DOING SUB3\n" }

Wenn es dir aber egal ist welche Funktionen aufgerufen werden können kannst du es so machen:

Code (perl): (dl )

#!/usr/bin/perl
use strict;
use warnings;

open(my $fh, '<', $file) or die( "ERROR OPEN $file ($!)\n" );
while(my $cmd=<$fh>)
{
  chomp($cmd);
  # Kommenatre entfernen
  next if($cmd=~/^\s*#/);

  my $fref=main->can($cmd);

  # Error wenn eine Unbekannter Aufruf kommt:
  die("CMD:$cmd FILE:$file LINE:$. Not implemented!") unless $fref;

  $fref->();
}
close($fh);

##############################
sub do_default { print "DOING DEFAULT\n" }
sub do_sub1 { print "DOING SUB1\n" }
sub do_sub2 { print "DOING SUB2\n" }
sub do_sub3 { print "DOING SUB3\n" }

can testet ob eine Funktion im angebenden Namespace existiert. Hier wird halt getestet ob ein Passender Funktionsname in "main", dem default Namespace von Perl, existiert. Zurück gegeben wird eine refenzen auf die angefragte Funktion oder undef.

Willst du auf jede Mögliche Funktion in allen Namespaces zugreifen können musst du das Perl mitteilen:

Code (perl): (dl )

#!/usr/bin/perl
use strict;
use warnings;

open(my $fh, '<', $file) or die( "ERROR OPEN $file ($!)\n" );
while(my $cmd=<$fh>)
{
  chomp($cmd);
  # Kommenatre entfernen
  next if($cmd=~/^\s*#/);

  {
    no strict 'refs';
    &$cmd();
  }
}
close($fh);

##############################
sub do_default { print "DOING DEFAULT\n" }
sub do_sub1 { print "DOING SUB1\n" }
sub do_sub2 { print "DOING SUB2\n" }
sub do_sub3 { print "DOING SUB3\n" }

rc27

2013-06-26 13:35

User since
2013-06-18
14 articles
BenutzerIn

Das mit dem Hash leuchtet ein. Vielen Dank!!!

Grüße

View all threads created 2013-06-26 09:39.