use Switch;

    switch ($val) {

            case 1          { print "number 1" }
            case "a"        { print "string a" }
            case [1..10,42] { print "number in list" }
            case (@array)   { print "number in list" }
            case /\w+/      { print "pattern" }
            case qr/\w+/    { print "pattern" }
            case (%hash)    { print "entry in hash" }
            case (\%hash)   { print "entry in hash" }
            case (\&sub)    { print "arg to subroutine" }
            else            { print "previous case not true" }
    }
[download]

Update: Here's an example similar to yours that might get you started. However, as talexb and japhy both mentioned, using coderefs in your hash might be a cleaner way of doing this.

use strict;
use warnings;

use Switch;

my %house = ('CC' => 'My Name',
             'AB' => 'AB Name',
             'CD' => 'My friend',
             'EF' => 'Who?');

foreach my $person (keys %house)
{
    print "$person: ";
    switch($person)
    {
        case 'AB'   { print "Mine!\n" }
        case 'CC'   { print "Yours!\n" }
        case 'CD'   { print "Friend!\n" }
        case %house { print "in house, but don't know him!\n" }
        else        { print "I don't know what to do!\n" }
    }
}
[download]

As a word of caution, Switch is *not* a great module; yes, it replicates what C has, but it's not efficient nor impervious to bugs. As I believe the lastest word on Perl 6 from Larry has implied, the lack of a good switch block in Perl 5 is very much apparent.

Keep this in mind when working with this. Switch might work, but be prepared to find weird things happening if you ask it for too much.

-----------------------------------------------------
Dr. Michael K. Neylon - mneylon-pm@masemware.com || "You've left the lens cap of your mind on again, Pinky" - The Brain
"I can see my house from here!"
It's not what you know, but knowing how to find it if you don't know that's important

Thanks... Will it be faster using the switch statement or will it be just the same?

my %actions = (
  CC => sub { print "My name "; p_CC(); },
  AB => sub { print "AB "; p_AB(); },
  CD => sub { print "My friend "; p_CD(); },
);

for (keys %house) {
  $actions{$_}->();
}
[download]

_____________________________________________________
Jeff[japhy]Pinyan: Perl, regex, and perl hacker.
s++=END;++y(;-P)}y js++=;shajsj<++y(p-q)}?print:??;

SWITCH:
 foreach (keys %house){   #Note: the key is stuffed in $_
     /^person$/ and do {
        print "My name "; #Note: the Regex works on $_
        p_CC();
        next SWITCH; }    
    /^AB$/ and do {
        print "AB ";
        p_AB();
        next SWITCH;}
  }
[download]

Thanksss

Hi Grep... I want ask about the switch statement that you have suggested.. About the speed... will it be just the same with:

If(...=~...){ do something }
elsif(....=~)( do some other thing }
...
else {...}
[download]

Since it also compares the $_ with /.../. Thanks...

Straight comparisions ('eq' or '==') will always be faster than regexp's. (You can try to make your regexp's faster by anchoring and using literials)

The main focus should not be speed at the cost of maintainibilty. If it looks cleaner and reads well go with that solution. Ovid has written an excellent post about Premature Optimization.

grep

grep> cd pub grep> more beer

However, your code looks like you could use a loop and some kind of data structure.

  my @Data = 
  (
    {person => "CC", who => "My name ", func => \&p_CC },
    {person => "AB", who => "AB ",      func => \&p_AB },
    {person => "CD", who => "friend",   func => \&p_CD },
  );

PERSON:
  foreach $person ( keys %house )
  {
    foreach ( @Data )
    {
      if ( $_->{ person } eq $person )
      {
        print $_->{ who };
        &{ $_ }->{ func }();

        next PERSON;
      }
    }
    #  Handle else here.
  }
[download]

And I would put the most likely array elements near the top (if possible) in order to reduce the execution time.

That's it!

--t. alex

"Of course, you realize that this means war." -- Bugs Bunny.