Normally, the function will return a list that contains less elements then the original list (i.e. a sublist of the original list).

In this short free tutorial I’ll spend a bit of time to show you a few quick examples about how you can use the Perl grep function in your Perl script.

grep BLOCK LIST
grep (EXPR, LIST)

• BLOCK – contains one ore more statements delimitated by braces; the last statement in the block determines whether the block will be evaluated true or false. The block will be evaluated for each element of the list and if the result is true, that element will be added to the returned list. If you need to apply a more sophisticated filter that consists of multiple code lines, you may consider to use the Perl grep function with a block.
• EXPR – represents any expression that supports $_, in particular a regular expression. The expression is applied against each element of the list and if the result of evaluation is true, the current element will be appended to the returned list.
• LIST – is a list of elements or an array

How does it work? Well, the Perl grep function iterates through the elements of the list and for each iteration step:

• sets $_ to the current element of the list
• evaluates the BLOCK or EXPR against $_
• if the result of evaluation is true, in list context adds the value of $_ to the output list and in scalar context increments the count of matched elements

The Perl grep function is very convenient to use any time you need to loop through a list in order to extract a subset of elements from the list, elements that match a certain condition.

Please look at the following simple example of using Perl grep function:

#!/usr/bin/perl

use strict;
use warnings;

# initialize an array
my @array = qw(3 4 5 6 7 8 9);

# first syntax form:
my @subArray = grep { $_ & 1 } @array;

# second syntax form
#my @subArray = grep $_ & 1, @array; 

print "@subArray\n";
# displays: 3 5 7 9

Instead of using Perl grep function, the same thing could be accomplished with a foreach loop as well:

#!/usr/bin/perl

use strict;
use warnings;

# initialize an array
my @array = qw(3 4 5 6 7 8 9);

my @subArray = ();
foreach (@array) {
  push @subArray, $_ if $_ & 1;
}
print "@subArray\n";
# displays: 3 5 7 9

The following code snippets will show you some ways to use the Perl grep function.

#!/usr/bin/perl

use strict;
use warnings;

# initialize an array
my @words = qw(John has selected red blue bed);
my $count = grep /ed$/, @words;

print "\$count = $count\n"; 

$count = 3

#!/usr/bin/perl

use strict;
use warnings;

# initialize an array
my @operators = ('+', ' -', '*', '/', '+=', 
                 '-=', '*=', '/=', '**=');
my $count = grep /\Q**=/, @operators;
print "found operator **=\n" if $count>0;

If you leave \Q out, and your code line will be respectively:

my $count = grep /**=/, @operators;

Quantifier follows nothing in regex; marked by 
    <-- HERE in m/* <-- HERE *=/ at … 

found operator **=

#!/usr/local/bin/perl

use strict;
use warnings;

# initialize an array
my @array = qw(a b c d e f g h i);

my $flag = 0;
my @array1 = grep { $flag ^= 1 } @array;
$flag = 1;
my @array2 = grep { $flag ^= 1 } @array;

print "\@array1 = @array1\n";
print "\@array2 = @array2\n";

The ^= operator represents the XOR operator combined with the assignment operator and in our code $flag ^= 1 means $flag = $flag ^ 1.

In the above example the code within the grep block toggles between true (1) and false (0) at each iteration of the Perl grep function.

The output produced is as follows:

@array1 = a c e g i
@array2 = b d f h 

# initialize an array
my @array = qw(1 21 3 3 3 3 7 21 1 5 5 9);

print "Occur once: @{getNumbers(\@array, 1)}\n";
print "Occur twice: @{getNumbers(\@array, 2)}\n";


sub getNumbers
{
  my ($newArray, $n) = (shift, shift);
  my %count = (); 

  my @tempArray = grep {$count{$_} == $n}
                      grep {++$count{$_} == 1} 
                           @$newArray;
  
  # print the %count hash
  print "\%count:\n";
  while ( my ($key, $value) = each(%count) ) {
        print "$key => $value\n";
  }

  return \@tempArray; 
}

%count:
1 => 2
21 => 2
3 => 4
7 => 1
9 => 1
5 => 2
Occur once: 7 9
%count:
1 => 2
21 => 2
3 => 4
7 => 1
9 => 1
5 => 2
Occur twice: 1 21 5

print "Occur once: @{getNumbers(\@array, 1)}\n";

Please note that applying the subroutine with the second argument 1 it will give you the unique elements of the array (they occur just once).

Next I’ll say some words about the code within the body of the getNumbers subroutine.

We used shift function to discard the two arguments from @_ and we initialized the %count hash that we use in our algorithm. The %count hash will contain pairs of ($key, $value) where $key represents an element of the @array and $value the number of times this element occurs. To see how it works, I printed the %count hash.

The next two code lines:

                      grep {++$count{$_} == 1} 
                           @$newArray;

Next, the first grep will extract from this list only those elements that occur $n times and will store them in @tempArray. After printing the %count hash, the subroutine will return a reference to @tempArray.

Printing the %count hash is not necessary within the subroutine body but I made it to show you how the algorithm works.

As a conclusion, you can use grep anytime you need to select elements from a list or an array.

If you want to download the Perl grep script with all the above examples included, please click here: Script download