क्या मैं गतिशील रूप से किसी भी पर्ल मॉड्यूल से फ़ंक्शंस या फ़ंक्शन नामों की सूची प्राप्त कर सकता हूं?

Question

मैं अपने सिस्टम पर उपलब्ध किसी भी मनमानी पर्ल मॉड्यूल से किसी भी फ़ंक्शन नाम (स्ट्रिंग्स) या फ़ंक्शन संदर्भों की गतिशील रूप से एक सूची प्राप्त करना चाहता हूं। इसमें मॉड्यूल शामिल होंगे जो हो सकता है या नहीं, उदाहरण के लिए, वैश्विक नाम @EXPORT_OK सरणी अपने नामस्थान में। क्या ऐसा कोई काम संभव है? अगर ऐसा होता है तो इसे कैसे खींचता है?

संपादित करें:perlmod पढ़ने से, मुझे लगता है कि %Some::Module::Some::Module के लिए एक प्रतीक तालिका के रूप में कार्य करता है। क्या यह देखने के लिए सही जगह है? यदि हां, तो मैं तालिका को Some::Module में फ़ंक्शन नामों पर कैसे छोटा कर सकता हूं?

Answer 1

आप पर हैं दायीं पटरी। सिर्फ बाद के चरणों के लिए पूर्ण प्रतीक तालिका नीचे wittle करने के लिए, कुछ इस तरह किया जा सकता है (हैट टिप "मास्टरिंग पर्ल", Ch 8, इस का मुख्य पैकेज संस्करण के लिए):

use strict; # need to turn off refs when needed 
package X; 

sub x {1;}; 
sub y {1;}; 
our $y = 1; 
our $z = 2; 

package main; 

foreach my $entry (keys %X::) { 
    no strict 'refs'; 
    if (defined &{"X::$entry"}) { 
     print "sub $entry is defined\n" ; 
    } 
} 

# OUTPUT 
sub y is defined 
sub x is defined 

Answer 2

आप काम इस सरल स्क्रिप्ट मिल सकता है: यदि आप उत्पादन कोड में यह कर रहे हैं,

#!/usr/bin/env perl 
use strict; 
use warnings;  
use Data::Dumper; 

# dump of object's symbol table: 
foreach my $className (@ARGV) 
{ 
    print "symbols in $className:"; 

    eval "require $className"; 
    die "Can't load $className: $@" if $@; 

    no strict 'refs'; 
    print Dumper(\%{"main::${className}::"}); 
} 

लेकिन, मुझे Package::Stash बजाय का उपयोग करेंगे:

my @subs_in_foo = Package::Stash->new('Foo')->list_all_symbols('CODE'); 

Answer 3

मैं पर्ल 5.20 उपयोग कर रहा हूँ । यह मेरी मशीन पर काम करता है:

use strict; 

package foo; 
    our $some_var; 
    sub func1 { return 'func1'} 
    sub func2 { return 'func2'} 

package main; 
    sub callable { 
     my ($x) = @_; 
     return defined(&$x); 
    } 

    while (my ($k, $v) = each(%foo::)) { 
     if (callable($v)) { 
     print("$k\n"); 
     } 
    } 

    # output: 
    # func1 
    # func2