Because grep evaluated in scalar context (as you are doing) returns the number of elements of the input list that satisfy the condition.

grep in scalar context returns the number of matches. To get the first match, you can use the following:

my ($i1) = grep { $array[$_] == 1 } 0..$#array;
my ($i2) = grep { $array[$_] == 2 } 0..$#array;
my ($i3) = grep { $array[$_] == 3 } 0..$#array;
[download]

Might be worth creating a lookup table.

my %lookup = map { $array[$_] => $_ }  0..$#array;

my $i1 = $lookup{1};
my $i2 = $lookup{2};
my $i3 = $lookup{3};
[download]

The second one returns that last index though (because if there are duplicates, each new occurence overwrites the previous one). This is not an issue of course if the values are unique, in which case it might make sense to store them in a hash in the first place.

grep

In scalar context, returns the number of times the expression was true.

and it's $i3 not i3

anyway others may profit from a working solution, just replacing grep with first

use strict;
use warnings;
use List::Util qw/first/;


my @array=(1,2);

my $i1 = first { $array[$_] == 1 } (0..$#array);
my $i2 = first { $array[$_] == 2 } (0..$#array);
my $i3 = first { $array[$_] == 3 } (0..$#array);

print "<$i1> <$i2> <$i3>\n";
[download]

Use of uninitialized value $i3 in concatenation (.) or string at d:/tm
+p/first.pl line 13.
<0> <1> <>
[download]

ikegami shows the way to do it above.

Using List::Util::first works of course but does not add any value at all.

> does not add any value at all.

Not very surprising that you think that way.

Cheers Rolf
_{(addicted to the Perl Programming Language :)
Wikisyntax for the Monastery FootballPerl is like chess, only without the dice}

$type morgon2.pl
use strict;
use warnings;
use List::MoreUtils 'indexes';
my @array=(1,2);

my $i1 = indexes { $array[$_] == 1 } (0..$#array);
my $i2 = indexes { $array[$_] == 2 } (0..$#array);
my $i3 = indexes { $array[$_] == 3 } (0..$#array);

print "<$i1> <$i2> <$i3>\n";


$perl morgon2.pl
Use of uninitialized value $i3 in concatenation (.) or string at morgo
+n2.pl line
 10.
<0> <1> <>
[download]

In this case, the firstidx function in List::MoreUtils may be a better fit, because it provides a simpler syntax:

my $i1 = firstidx { $_ == 1 } @array;
[download]

And it’s faster too:

Read more... (3 kB)

Cheers,

Athanasius <°(((>< contra mundum

Iustus alius egestas vitae, eros Piratica,

Since you are testing the case where all entries are unique, you may want to add benchmarks for hash lookups.

Actually two: there is no doubt that a lookup is way faster, the essential question is if the initialization of the hash needs to be included.

In the later case I'd prefer a hash slice then.

@lookup{@array} = (0.. $#array);

Cheers Rolf
_{(addicted to the Perl Programming Language :)
Wikisyntax for the Monastery FootballPerl is like chess, only without the dice}