While eval is the method that promises the easiest result, it also makes for ugly security holes and hard to track down bugs. I'd go with storing all the operators and their operations in a hash and then using that to calculate your operations:

my %bin_cmp = {
  'eq' => sub { my ($l,$r) = @_; $l eq $r },
  'ne' => sub { my ($l,$r) = @_; $l ne $r },
  '>' => sub { my ($l,$r) = @_; $l < $r },
  '<' => sub { my ($l,$r) = @_; $l > $r },
};

my $op = 'ne';
my $left = "Hello";
my $right = "World";

if (not exists $bin_cmp{$op}) {
  die "Don't know what to do with '$op'";
};
my $compare = $bin_cmp{$op};
my $result = $compare->($left, $right);
print "$left $op $right is " .
      ($result ? 'true' : 'false');
[download]

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

my $eq_op = 'eq';
my $ne_op = 'ne';
my $foo = '1234';
my $bar = 'abcd';
my %compare = (
    eq => \&eq_compare,
    ne => \&ne_compare,
);
if ( $compare{ $eq_op }->($foo, $bar) ) {
     print "$foo and $bar are the same string\n";
}
if ( $compare{ $ne_op }->($foo, $bar) ) {
     print "$foo and $bar are not the same string\n";
}
sub eq_compare { return $_[0] eq $_[1] }
sub ne_compare { return $_[0] ne $_[1] }
[download]

Here is my offering, attempting to improve the readability. (Untested - this is just a concept):

my %ops =( eq   => sub{shift eq shift},
           '==' => sub{shift == shift},
           'gt' => sub{shift > shift}
         );
sub compare{
  my ($p1, $op, $p2) = @_;
  return $ops{$op}($p1, $p2);
}
# Now you can write stuff like
 if (compare('abc', 'eq', 'ABC'){
   ..action
}
[download]

Of course, there are other ways of doing this, using operator overloading, but I wouldnt go there for this simple case.

Update7/22 Thanks, Anneq: deleted ampersand in front of &$ops... changed sub() to sub{}.

You should probably look at "eval".

An example script would help. but just by naked eye scan, I can see you are not using double =. In fact you should really use eq instead since you are doing character comparison. Secondly,this does not work to my knowledge(without the use of eval as noted above). You should get a scalar found where operator expected error. What are you trying to accomplish? Methods like this often indicate the need to rethink your design.

I am trying to store operators in a variable and then use the variable as the operator

Lisp can do this; Perl cannot. It can, however, store an anonymous *subroutine* in a variable. This is syntactically different from an operator, but it can accomplish the same effect:

$op = sub { $_[0] eq $_[1] };
if($op->($somvar, "some text")){
  #do stuff
}
[download]

Resist the urge to use string eval for this.

Bah. We just need more people to treat perl like lisp. This isn't impossible - it is just difficult.

Perhaps a filter that changes

    EXPR1 ´$binop´ EXPR2
[download]

to

    $The::Module::binops{$binop}->(EXPR1, EXPR2)
[download]

:-)

Some ops won't be fully supported though, like x (see Re: Using x to build data structures considered harmful).

ihb