#!/usr/bin/perl

use strict;
use warnings;


build_sth( 'set_to_flag' );

sub write_flag{
    print "Success for flag.\n";
}

sub write_sets{print "Success for Set.\n"; }

sub do_nothing{print "Exit Here\n";}

sub build_sth{
    my ($op_code) = @_;
    
    my %Op = (
        set_to_flag => \&write_flag,
        set_tree => \&write_sets,
        default => \&do_nothing
    );
    
    my $op_exec = $Op{$op_code} ;
    if( defined $op_exec ){
        $op_exec->();
    }else{
        print "Oops\n";
    }

}
[download]

I used strict and warning.

And the call of the build_sth('set_to_flag') in another function which is called in the main per script:

(continue with previous code)
sub somecall{
build_sth('set_to_flag')
}

somecall();
[download]

I have checked the previous version where I got trapped. I get the code fail when I move the hash outside of function:

my %Op = (
        set_to_flag => \&write_flag,
        set_tree => \&write_sets,
        default => \&do_nothing
    );
sub build_sth {
    my ($op_code) = @_;
    
    my $op_exec = $Op{$op_code} ;
    if( defined $op_exec ){
        $op_exec->();
    }else{
        print "Oops\n";
    }

}
[download]

why the code fail in this case?

why the code fail in this case?

The only possibly reason is if build_sth('set_to_flag') is called before my %Op = ( ... ); is executed.

Otherwise, it doesn't fail.

sub write_flag { print "write_flag\n"; }
sub set_tree   { print "set_tree\n"; }
sub do_nothing { print "do_nothing\n"; }

... code you provided ...

build_sth('set_to_flag');  # Prints write_flag
[download]

Declare and assign to %Op before trying to call any functions it contains. The subref assignments occur at runtime, so any code that executes before that will find an empty hash.

So that I need to declare a subroutine prototype if I declare the hash outside of the function?

No.

You need to declare the hash before you try to use it.

This will work:

# hash declaration

# sub declarations

# call some sub that uses the hash
[download]

This will not work:

# call some sub that uses the hash

# hash declaration

# sub declarations
[download]

If you want to experiment with this on your own, move all of the code into individual subroutines and call them from main():

# declare this as a file-scoped lexical
my %Op;

main();

# subs follow

sub main
{
    assign_to_Op();
    do_something_else();
}

sub assign_to_Op
{
   %Op = ( ... );
}

sub do_something_else
{
    my $code = $Op{ ... };
    $code->();
}
[download]

$op_exec is a reference to a function and which can be invoked as $op_exec->();

&$op_exec(); works the same.
--
Online Fortune Cookie Search