Perl grep FunctionNEW!!! Check my new resource: Perl How To Tutorial eBooks 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. To begin, let’s start with the syntax forms of the Perl grep function: where:
How does it work? Well, the Perl grep function iterates through the elements of the list and for each iteration step:
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: The above script extracts from @array a subset that contains the odd numbers only. The Perl grep function will iterate through @array and at each iteration step it will store the current element of the array in $_; than it will evaluate the condition $_ & 1 and if the result is true (i.e. the number is odd), the element stored in $_ will be appended to @subArray. Instead of using Perl grep function, the same thing could be accomplished with a foreach loop as well: You can note that Perl grep function is somehow a shorthand (you don’t need to explicitly iterate through the array), but keep in mind that a foreach loop in some circumstances could be faster, however benchmark it if you are not sure. The following snippet codes will show you some ways to use the Perl grep function.
As I told you before, in a scalar context, the Perl grep function returns a count of the elements that match the pattern. To illustrate this, look at the following code: It produces the output: and represents the number of words that end in ed.
First, look at the following example: In our example we initialize @operators array with a few Perl operators. The Perl grep function counts how many times the exponentiation assignment operator (**=) was found in our list. Because * is a metacharacter for regex (it causes the precedent character to be matched 0 or more times), one way to do this is by using the \Q sequence. I remind you that \Q tells Perl where to start escaping special characters and the \E tells where to stop. In our example we don’t need to use \E sequence. If you leave \Q out, and your code line will be respectively: you’ll get an error message like the next one: Going back to our script, the given output is as follows:
Please look at the following code: The output produced is as follows: In the above code you could change the line my $flag = 0; with my $flag = 1; and modify the next two lines accordingly: The output is the same as before.
I’ll write a subroutine for this. Look at the following example: And the output: The getNumbers subroutine has 2 arguments: a reference to an array and the number of times each element of the array can occur. It returns a reference to a subarray that contains the elements that occur the given number of times. For instance, the code line; will print: Occur once: 7 9, i.e the elements of the @array that occur once. The first argument passed to the subroutine is a reference to @array (i.e. \@array), and the second argument is the number 1. Because our subroutine returns a reference to the array with the selected elements, in order to print its element we need to dereference it so we used the @ sign and we embraced our reference with curly brackets. 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: represent the second argument of the first grep (the first argument of the first grep is the block {$count{$_} == $n}), so they will be evaluated in a list context, i.e the second grep will return a list. Thus the two above lines will create the %count hash completely and will return a list (because of the list context) with the unique elements of the @newArray, i.e (1, 21, 3, 7, 5, 9). 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. I hope I was clear enough with my notes, if not keep looking at the code, test and modify it and you will understand how it works. As a conclusion, you can use grep anytime you need to select elements from a list or an array. NEW!!! Do you want more information about the basic Perl topics? Check my new "Perl How To" Tutorial eBooks page where I'll answer the most frequent questions regarding some topics : Table of Contents: A Perl Script Install Perl Running Perl Perl Data Types Perl Variables Perl Operators Perl Lists Perl Arrays Array Size Array Length Perl Hashes Perl Statements Perl if Perl unless Perl switch Perl while Perl do-while Perl until Perl do-until Perl for Perl foreach Built-in Perl Functions Functions by Category String Functions Array Functions Functions in alphabetical order chomp chop chr crypt defined grep hex index join lc lcfirst length oct ord pack pop push reverse rindex shift split substr uc undef unshift return from Perl grep Function to Perl Basics Hit the Alarm Clock! 
|
