# Setup
my @ok;
++$ok[$_] for 1, 2, 3;

# Sample usage
if ($ok[$variable]) {
   ...
}
[download]

# Setup
my %fruit;
++$fruit{$_} for qw( apple banana orange );

# Sample usage
if ($fruit{$object}) {
   ...
}
[download]

# Setup
my %dispatch = (
   colour => \&area_fill,
   scale  => \&scale_image,
   warp   => \&warp_image,
);

# Sample usage
if ($handler = $dispatch{$command}) {
   $handler->();
} else {
   die("Invalid command $command\n");
}
[download]

Update: Keep in mind that 1, 2, 3 can be written as 1..3

use List::MoreUtils;
if (any { $variable == $_ } (1, 2, 3)) {
  ...
}
[download]

With the disadvantage of using an extra module, but with the advantage of not testing every single value after the first successful one (if the list is big, it's probably a better alternative).

if (grep { $variable == $_ } (1, 2, 3)) {
  ...
}
[download]

This unfortunately is significantly longer to execute than the boolean OR. The grep has to test every value, whereas the if statement uses short-circuit boolean logic to stop testing values as soon as a match is found.

"significantly"? Maybe a significant factor longer, but if the OP was even considering writing it in a long || ... || ... ||, there aren't enough elements to make it significant in absolute terms.

This may do it for you:

use strict;
use warnings;

my $variable = 3;

if ($variable =~ /\b(?:1|2|3)\b/)
  {
  print "case 1, 2 or 3\n"
  }
[download]

Prints:

case 1, 2 or 3
[download]

sub in_list {
    my $needle = shift || q{}; # or croak, your choice.
    croak 'expecting haystack' if not @_;
    return grep m/^$needle$/, @_;
}

if (in_list($var, qw(A B C))) {
    ...
}
[download]

or return grep $_ eq $needle, @_; rather.

if ( any( 1, 2, 3 ) eq $n ) { ...
[download]

Hey, it looks like the Perl6 people have been reading up on Fortran 90...(although it's quite possible any was adapted to Fortran90 from some other language).

Fortran 90's any statement returns true of false if any element in an array meets a test condition, e.g.,

integer,dimension(6) :: ar

ar = (/1,3,4,5,6,7/)
if(any(ar > 4) then # returns true if any element of ar is greater tha
+n 4
  call a_miracle_happens_here
endif
[download]

I'm still wondering why everybody was using regex for the test; it looks like a numerical comparison to me.

emc

Visit Netlib

You might also consider populating a hash and using exists to check for a match.

use YAML ();

$items = YAML::Load( <<EOT );
a: 1
b: 1
c: 1
EOT

if( exists $items->{ $variable } ) {
  # . . .
}
[download]

Is that really how you populate your hashes?

$items = {
    a => 1,
    b => 2,
    c => 3,      
};

if ( exists $items->{ $variable } ) {
    # . . .
}
[download]

    -Bryan

Depends. If the list were relatively static I probably would keep it inline in the source like you've shown. If it were more dynamic or dependent on something outside the script I'd leave it external with a quick change from YAML::Load to YAML::LoadFile (granted I'd probably use a YAML sequence rather than a hash, but the idea is the same). It also could move to the bottom of the file after an __END__ marker and remain with the script but be more segregated from the flow of code.

List::MoreUtils' any() sub is one good way that someone mentioned. Another is a hashtable. But if the values are all contiguous, and you don't mind that floating point values could fall between '1' and '2', you could do it this way too:

if( $variable >= 1 and $variable <= 3 ) {
    #...
[download]

If your condition is going to be predictably in a numerical range like that, this may work.

if($variable >= $lower_limit && $variable <= $upper_limit)
{
miraculous_stuff;
}
[download]

If your requirement is to do something when $variable is an integer, vs something else when it isn't, or when $variable is being tested against values in an array, this probably would not be appropriate, but if it's a regular as what I read at 10:46pm EST 14 Dec 2005, my suggestion may be appropriate.

Here is an another possible way...

For single numeric values:

For two or more numeric values:

Also, take a look at perlrequick

Regards
Franklin

these will work even if it is a double digit in $var (ie: 1 and 10 will both succeed for the first example) but if you only want one digit in range maybe something like:

print $& if $var =~ /^[1-3]$/;
[download]

or ... better yet ... if you are going to be doing this alot and with strings as well as digits ...

sub look_into {
   my $archetype= shift;
   eval 'sub { $_[0] =~ /$archetype/o; }'
}

my $is_text_am_too_red     = look_into q/\b(am|too|red)\b/;
my $single_digit_in_range  = look_into q/^[1-5]$/;
my $double_digit_in_set    = look_into q/^[5-7][49]$/;
# etc.

if($is_text_am_too_red    ->($_)){ print "get some sleep!" }
if($single_digit_in_range ->($_)){ print "single digit in range!" }
if($double_digit_in_set   ->($_)){ print "double digit in set!" }
#etc.
[download]

Using $& can slow down regexps elsewhere in the program, so replace
print $& if ($variable=~/[123]/);
with
print $1 if ($variable=~/([123])/);

sub any {
  my $var = shift;
  for (@_) { return 1 if $var == $_ }
}
if (any($var,1..2000)) { print "Var is between 1 and 2000 inclusive\n"
+ }
[download]

Think I like this one best. I'm sure it'll bench fastest as well. Firing up the regexp engine to compare will have a noticeable overhead.

    use feature '~~';
    if ($variable ~~ [1,2,3]) { ... }
[download]

(I'm backporting the Perl 6 "smart match" operator to Perl 5.)

I'd recommend trying this vs seperate elsif statements on a large file and seeing if it makes a difference.

6 weeks ago I was optimising a process reading in a daily network syslog file of approx 1200 MB using 5.8.0 on an overworked Ultra 2 running Solaris 2.6.

The script had been using next if (/abc|cde|fgh|/) which *looks* most concise, but I found (to my and my workmate's surprise) that replacing it with the equivalent elsif statements made it take about 30 seconds less (it had been taking >2 minutes to read the file in).

it depends on what you're going to do after knowing if it's equal to or not , This may help

my @array = qw/1 2 3 4/;
my $matched;
foreach (@array){
if($variable == $_){
$matched = $_;}
}
[download]

it's not the best way but it may be helpful i think

$variable=1;

if ($variable =~/[1,2,3]/)
{
    print "Did it!\n";
}
[download]

/[1,2,3]/ is same as /[,123]/. Please refer to earlier suggestion for correct usage.