Chapter 5

Functions

• Example: Using the Parameter Array (@_)
• Example: Passing Parameters by Reference
• Example: Scope of Variables
• Example: Using a List as a Function Parameter
• Example: Nesting Function Calls
• Example: Using a Private Function
• String Functions
  • Example: Changing a String's Value
  • Example: Searching a String
• Array Functions
  • Example: Printing an Associative Array
  • Example: Checking the Existence of an Element
• Summary
• Review Questions
• Review Exercises

This chapter takes a look at functions. Functions are blocks of codes that are given names so that you can use them as needed. Functions help you to organize your code into pieces that are easy to understand and work with. They let you build your program step by step, testing the code along the way.

After you get the idea for a program, you need to develop a program outline-either in your head or on paper. Each step in the outline might be one function in your program. This is called modular programming. Modular programming is very good at allowing you to hide the details so that readers of your source code can understand the overall aim of your program.

For instance, if your program has a function that calculates the area of a circle, the following line of code might be used to call it:

$areaOfFirstCircle = areaOfCircle($firstRadius);

By looking at the function call, the reader knows what the program is doing. Detailed understanding of the actual function is not needed.

Let's look at the function call a little closer. The first thing on the line is a scalar variable and an assignment operator. You already know this means Perl assigns the value on the right of the assignment operator to $areaOfFirstCircle. But, what exactly is on the right?

The first thing you see is the function name areaOfCircle(). The parentheses directly to the right and no $, @, or % beginning the name indicates that this is a function call. Inside the parentheses is a list of parameters or values that get passed to the function. You can think of a parameter just like a football. When passed, the receiver (for example, the function) has several options: run (modify it in some way), pass (call other routines), fumble (call the error handler).

Listing 5.1 shows a short program that calls and defines the areaOfCircle() function.

Assign $areaOfFirstCircle the value that is returned by the functionareaOfCircle().
Print $areaOfFirstCircle.
Define the areaOfCircle() function.
Get the first parameter from the @_ parameter array.
Calculate the area and return the new value.

Listing 5.1  05LST01.PL-Calculating the Area of a Circle

$areaOfFirstCircle = areaOfCircle(5);

print("$areaOfFirstCircle\n");



sub areaOfCircle {

    $radius = $_[0];

    return(3.1415 * ($radius ** 2));

}

This program prints:

78.7375

The fact that something prints tells you that the program flow returned to the print line after calling the areaOfCircle() function.

A function definition is very simple. It consists of:

sub functionName {

}

That's it. Perl function definitions never get any more complex.

The complicated part comes when dealing with parameters. Parameters are values passed to the function (remember the football?). The parameters are specified inside the parentheses that immediately follow the function name. In Listing 5.1, the function call was areaOfCircle(5). There was only one parameter, the number 5. Even though there is only one parameter, Perl creates a parameter array for the function to use.

Inside the areaOfCircle() function, the parameter array is named @_. All parameters specified during the function call are stored in the @_ array so that the function can retrieve them. Our small function did this with the line:

$radius = $_[0];

This line of code assigns the first element of the @_ array to the $radius scalar.

The next line of the function:

return(3.1415 * ($radius ** 2));

calculates the circle's area and returns the newly calculated value. In this case, the returning value is assigned to the $areaOfFirstCircle scalar variable.

You may have used programming languages that distinguish between a function and a subroutine, the difference being that a function returns a value and a subroutine does not. Perl makes no such distinctions. Everything is a function-whether or not it returns a value.

Example: Using the Parameter Array (@_)

All parameters to a function are stored in an array called @_. One side effect of this is that you can find out how many parameters were passed by evaluating @ in a scalar context.

Call the firstSub() function with a variety of parameters.
Define the firstSub() function
Assign $numParameters the number of elements in the array @_.
Print out how any parameters were passed.

firstSub(1, 2, 3, 4, 5, 6);

firstSub(1..3);

firstSub("A".."Z");



sub firstSub {

    $numParameters = @_ ;

    print("The number of parameters is $numParameters\n");

}

This program prints out:

The number of parameters is 6

The number of parameters is 3

The number of parameters is 26

Perl lets you pass any number of parameters to a function. The function decides which parameters to use and in what order. The @_ array is used like any other array.

Let's say that you want to use scalar variables to reference the parameters so you don't have to use the clumsy and uninformative $_ [0] array element notation. By using the assignment operator, you can assign array elements to scalars in one easy step.

Call the areaOfRectangle() function with varying parameters.
Define the areaOfRectangle() function.
Assign the first two elements of @_ to $height and $width respectively.
Calculate the area.
Print the three variables: $height, $width, and $area.

areaOfRectangle(2, 3);

areaOfRectangle(5, 6);



sub areaOfRectangle {

    ($height, $width) = @_ ;



    $area = $height * $width;



    print("The height is $height. The width is $width.

        The area is $area.\n\n");

}

This program prints out:

The height is 2. The width is 3.

        The area is 6.



The height is 5. The width is 6.

        The area is 30.

The statement ($height,$width) = @_; does the array element to scalar assignment. The first element is assigned to $height, and the second element is assigned to $width. After the assignment is made, you can use the scalar variables to represent the parameters.

Example: Passing Parameters by Reference

Using scalar variables inside your functions is a good idea for another reason-besides simple readability concerns. When you change the value of the elements of the @ array, you also change the value of the parameters in the rest of the program. This is because Perl parameters are called by reference. When parameters are called by reference, changing their value in the function also changes their value in the main program. Listing 5.2 shows how this happens.

Create an array with 6 elements.
Print the elements of the array.
Call the firstSub() function.
Print the elements of the array.
Define the firstSub() function.
Change the values of the first two elements of @_.

Listing 5.2  05LST02.PL-Using the @Array to Show Call by Reference

@array = (0..5);

print("Before function call, array = @array\n");

firstSub(@array);

print("After function call, array =  @array\n");



sub firstSub{

    $_[0] = "A";

    $_[1] = "B";

}

This program prints:

Before function call, array =  0 1 2 3 4 5

After function call, array =   A B 2 3 4 5

You can see that the function was able to affect the @array variable in the main program. Generally, this is considered bad programming practice because it does not isolate what the function does from the rest of the program. If you change the function so that scalars are used inside the function, this problem goes away. List-ing 5.3 shows how to redo the program in Listing 5.2 so scalars are used inside the function.

Create an array with 6 elements.
Print the elements of the array.
Call the firstSub() function.
Print the elements of the array.
Define the firstSub() function.
Assign the first two elements of @_ to $firstVar and $secondVar.
Change the values of the scalar variables.

Listing 5.3  05LST03.PL-Using Scalars Instead of the @_ Array Inside Functions

@array = (0..5);

print("Before function call, array = @array\n");

firstSub(@array);

print("After function call, array =  @array\n");



sub firstSub{

    ($firstVar, $secondVar) = @_ ;



    $firstVar = "A";

    $secondVar = "B";

}

This program prints:

Before function call, array =  0 1 2 3 4 5

After function call, array =   0 1 2 3 4 5

This example shows that the original @array variable is left untouched. However, another problem has quietly arisen. Let's change the program a little so the values of $firstVar are printed before and after the function call. Listing 5.4 shows how changing a variable in the function affects the main program.

Assign a value to $firstVar.
Create an array with 6 elements.
Print the elements of the array.
Call the firstSub() function.
Print the elements of the array.
Define the firstSub() function.
Assign the first two elements of @_ to $firstVar and $secondVar.
Change the values of the scalar variables.

Listing 5.4  05LST04.PL-Using Variables in Functions Can Cause Unexpected Results

$firstVar = 10;

@array    = (0..5);



print("Before function call\n");

print("\tfirstVar = $firstVar\n");

print("\tarray    = @array\n");



firstSub(@array);



print("After function call\n");

print("\tfirstVar = $firstVar\n");

print("\tarray    = @array\n");



sub firstSub{

    ($firstVar, $secondVar) = @_ ;



    $firstVar = "A";

    $secondVar = "B";

}

This program prints:

Before function call

        firstVar = 10

        array    = 0 1 2 3 4 5



After function call

        firstVar = A

        array    = 0 1 2 3 4 5

By using the $firstVar variable in the function you also change its value in the main program. By default, all Perl variables are accessible everywhere inside a program. This ability to globally access variables can be a good thing at times. It does help when trying to isolate a function from the rest of your program. The next section shows you how to create variables that can only be used inside functions.

Example: Scope of Variables

Scope refers to the visibility of variables. In other words, which parts of your program can see or use it. Normally, every variable has a global scope. Once defined, every part of your program can access a variable.

It is very useful to be able to limit a variable's scope to a single function. In other words, the variable wil have a limited scope. This way, changes inside the function can't affect the main program in unexpected ways. Listing 5.5 introduces two of Perl's built-in functions that create variables of limited scope. The my() function creates a variable that only the current function can see. The local() function creates a variable that functions the current function calls can see. If that sounds confusing, don't worry. It is confusing; but, Listing 5.5 should clear things up. In this case, it's a listing that is worth a thousand words, not a picture!

Call firstSub() with a two parameters.
Define the firstSub() function.
Assign the first parameter to local variable $firstVar.
Assign the second parameter to my variable $secondVar.
Print the variables.
Call the second function without any parameters.
Print the variables to see what changed.
Define the secondSub() function.
Print the variables.
Assign new values to the variables.
Print the variables to see that the new values were assigned correctly.

Listing 5.5  05LST05.PL-Using the Local and My Functions to Create Local Variables

firstSub("AAAAA", "BBBBB");



sub firstSub{

    local ($firstVar) = $_[0];

    my($secondVar)    = $_[1];



    print("firstSub: firstVar  = $firstVar\n");

    print("firstSub: secondVar = $secondVar\n\n");



    secondSub();



    print("firstSub: firstVar  = $firstVar\n");

    print("firstSub: secondVar = $secondVar\n\n");

}



sub secondSub{

    print("secondSub: firstVar  = $firstVar\n");

    print("secondSub: secondVar = $secondVar\n\n");



    $firstVar  = "ccccC";

    $secondVar = "DDDDD";



    print("secondSub: firstVar  = $firstVar\n");

    print("secondSub: secondVar = $secondVar\n\n");

}

This program prints:

firstSub: firstVar = AAAAA

firstSub: secondVar = BBBBB



secondSub: firstVar  = AAAAA

Use of uninitialized value at test.pl line 19.

secondSub: secondVar =



secondSub: firstVar  = ccccC

secondSub: secondVar = DDDDD



firstSub: firstVar  = ccccC

firstSub: secondVar = BBBBB

The output from this example shows that secondSub() could not access the $secondVar variable that was created with my() inside firstSub(). Perl even prints out an error message that warns about the uninitialized value. The $firstVar variable, however, can be accessed and valued by secondSub().

Actually, the my() function is even more complex than I've said. The easy definition is that it creates variables that only the current function can see. The true definition is that it creates variables with lexical scope. This distinction is only important when creating modules or objects, so let's ignore the complicated definition for now. You'll hear more about it in Chapter 15, "Perl Modules."

If you remember, I mentioned calling parameters by reference. Passing parameters by reference means that functions can change the variable's value, and the main program sees the change. When local() is used in conjunction with assigning the @_ array elements to scalars, then the parameters are essentially being called by value. The function can change the value of the variable, but only the function is affected. The rest of the program sees the old value.

Example: Using a List as a Function Parameter

Now that you understand about the scope of variables, let's take another look at parameters. Because all parameters are passed to a function in one array, what if you need to pass both a scalar and an array to the same function? This next example shows you what happens.

Call the firstSub() function with two parameters: a list and a scalar.
Define the firstSub() function.
Assign the elements of the @_ array to @array and $firstVar.
Print @array and $firstVar.

firstSub((0..10), "AAAA");



sub firstSub{

    local(@array, $firstVar) = @_ ;



    print("firstSub: array    = @array\n");

    print("firstSub: firstVar = $firstVar\n");

}

This program prints:

firstSub: array    = 0 1 2 3 4 5 6 7 8 9 10 AAAA

Use of uninitialized value at test.pl line 8.

firstSub: firstVar =

When the local variables are initialized, the @array variables grab all of the elements in the @ array, leaving none for the scalar variable. This results in the uninitialized value message displayed in the output. You can fix this by merely reversing the order of parameters. If the scalar value comes first, then the function processes the parameters without a problem.

Call the firstSub() function with two parameters: a scalar and a list.
Define the firstSub() function.
Assign the elements of the @_ array to $firstVar and @array.
Print @array and $firstVar.

firstSub("AAAA", (0..10));



sub firstSub{

    local($firstVar, @array) = @_ ;



    print("firstSub: array    = @array\n");

    print("firstSub: firstVar = $firstVar\n");

}

This program prints:

firstSub: array    = 0 1 2 3 4 5 6 7 8 9 10

firstSub: firstVar = AAAA

Example: Nesting Function Calls

Function calls can be nested many levels deep. Nested function calls simply means that one function can call another which in turn can call another. Exactly how many levels you can nest depends on which version of Perl you are running and how your machine is configured. Normally, you don't have to worry about it. If you want to see how many levels your system can recurse, try the following small program:

Call the firstSub() function.
Define the firstSub() function.
Print $count
Increment $count by one.
Call the firstSub() function recursively.

firstSub();



sub firstSub{

    print("$count\n");

    $count++;

    firstSub();

}

My system counts up to 127 before displaying the following message:

Error: Runtime exception

While it is important to realize that there is a limit to the number of times your program can nest functions, you should never run into this limitation unless you are working with recursive mathematical functions.

Example: Using a Private Function

Occasionally, you might want to create a private function. A private function is one that is only available inside the scope where it was defined.

Assign the return value from performCalc() to $temp.
Print $temp.
Define the performCalc() function.
Assign my scalar variables values from the @_ parameter array.
Define the private function referred to by $square.
Return the first element of the @_ parameter array raised to the 2nd power.
Return the value of $firstVar raised to the 2nd power and
$secondVar raised to the 2nd power.

$temp = performCalc(10, 10);

print("temp = $temp\n");



sub performCalc {

    my ($firstVar, $secondVar) = @_;



    my $square = sub {

        return($_[0] ** 2);

    };



    return(&$square($firstVar) + &$square($secondVar));

};

This program prints:

temp = 200

This example is rather trivial, but it serves to show that in Perl it pays to create little helper routines. A fine line needs to be drawn between what should be included as a private function and what shouldn't. I would draw the line at 5 or 6 lines of code. Anything longer probably should be made into its own function. I would also say that a private function should have only one purpose for existence. Performing a calculation and then opening a file is too much functionality for a single private function to have.

The rest of the chapter is devoted to showing you some of the built-in functions of Perl. These little nuggets of functionality will become part of your arsenal of programming weapons.

String Functions

The first set of functions that we'll look at are those that deal with strings. These functions let you determine a string's length, search for a sub-string, and change the case of the characters in the string, among other things. Table 5.1 shows Perl's string functions.

The next few sections demonstrate some of these functions. After seeing some of them work, you'll be able to use the rest of them.

Example: Changing a String's Value

Frequently, I find that I need to change part of a string's value, usually somewhere in the middle of the string. When this need arises, I turn to the substr() function. Normally, the substr() function returns a sub-string based on three parameters: the string to use, the position to start at, and the length of the string to return.

Assign $firstVar the return value from substr().
Print $firstVar.

$firstVar = substr("0123BBB789", 4, 3);

print("firstVar  = $firstVar\n");

This program prints:

firstVar = BBB

The substr() function starts at the fifth position and returns the next three characters. The returned string can be printed like in the above example, as an array element, for string concatention, or any of a hundred other options.

Things become more interesting when you put the substr() function on the left-hand side of the assignment statement. Then, you actually can assign a value to the string that substr() returns.

Initialize $firstVar with a string literal.
Replace the string returned by the substr() function with "AAA".
Print $firstVar.

$firstVar = "0123BBB789";

substr($firstVar, 4, 3) = "AAA";

print("firstVar  = $firstVar\n");

This program prints:

firstVar = 0123AAA789

Example: Searching a String

Another useful thing you can do with strings is search them to see if they have a given sub-string. For example if you have a full path name such as "C:\\WINDOWS \\TEMP\\WSREWE.DAT", you might need to extract the file name at the end of the path. You might do this by searching for the last backslash and then using substr() to return the sub-string.

Assign a string literal to $pathName.
Find the location of the last backslash by starting at the end of the string and working backward using the rindex() function. When the position of the last backslash is found, add one to it so that
$position points at the first character ("W") of the file name.
Use the substr() function to extract the file name and assign it
to $fileName.
Print $fileName.

$pathName = "C:\\WINDOWS\\TEMP\\WSREWE.DAT";

$position = rindex($pathName, "\\") + 1;

$fileName = substr($pathName, $position);

print("$fileName\n");

This program prints:

WSREWE.DAT

If the third parameter-the length-is not supplied to substr(), it simply returns the sub-string that starts at the position specified by the second parameter and continues until the end of the string specified by the first parameter.

Array Functions

Arrays are a big part of the Perl language and Perl has a lot of functions to help you work with them. Some of the actions arrays perform include deleting elements, checking for the existence of an element, reversing all of the the elements in an array, and sorting the elements. Table 5.2 lists the functions you can use with arrays.

As with the string functions, only a few of these functions will be explored. Once you see the examples, you'll be able to handle the rest with no trouble.

Example: Printing an Associative Array

The each() function returns key, value pairs of an associative array one-by-one in a list. This is called iterating over the elements of the array. Iteration is a synonym for looping. So, you also could say that the each() function starts at the beginning of an array and loops through each element until the end of the array is reached. This ability lets you work with key, value pairs in a quick easy manner.

The each() function does not loop by itself. It needs a little help from some Perl control statements. For this example, we'll use the while loop to print an associative array. The while (CONDITION) {} control statement continues to execute any program code surrounded by the curly braces until the CONDITION turns false.

Create an associative with number, color pairs.
Using a while loop, iterate over the array elements.
Print the key, value pair.

%array = ( "100", "Green", "200", "Orange");



while (($key, $value) = each(%array)) {

      print("$key = $value\n");

}

This program prints:

100 = Green

200 = Orange

The each() function returns false when the end of the array is reached. Therefore, you can use it as the basis of the while's condition. When the end of the array is reached, the program continues execution after the closing curly brace. In this example, the program simply ends.

Example: Checking the Existence of an Element

You can use the defined() function to check if an array element exists before you assign a value to it. This ability is very handy if you are reading values from a disk file and don't want to overlay values already in memory. For instance, suppose you have a disk file of customers' addresses and you would like to know if any of them are duplicates. You check for duplicates by reading the information one address at a time and assigning the address to an associative array using the customer name as the key value. If the customer name already exists as a key value, then that address should be flagged for follow up.

Because we haven't talked about disk files yet, we'll need to emulate a disk file with an associative array. And, instead of using customer's address, we'll use customer number and customer name pairs. First, we see what happens when an associative array is created and two values have the same keys.

Call the createPair() function three times to create three key, value pairs in the %array associative array.
Loop through %array, printing each key, value pair.
Define the createPair() function.
Create local variables to hold the key, value pair passed as parameters.
Create an array element to hold the key, value pair.

createPair("100",  "Kathy Jones");

createPair("200",  "Grace Kelly");

createPair("100", "George Orwell");



while (($key, $value) = each %array) {

    print("$key, $value\n");

};



sub createPair{

    my($key, $value) = @_ ;



    $array{$key} = $value;

};

This program prints:

100, George Orwell

200, Grace Kelly

This example takes advantages of the global nature of variables. Even though the %array element is set in the createPair() function, the array is still accessible by the main program. Notice that the first key, value pair (100 and Kathy Jones) are overwritten when the third key, value pair is encountered. You can see that it is a good idea to be able to determine when an associative array element is already defined so that duplicate entries can be handled. The next program does this.

Call the createPair() function three times to create three key, value pairs in the %array associative array.
Loop through %array, printing each key, value pair.
Define the createPair() function.
Create local variables to hold the key, value pair passed as parameters.
If the key, value pair already exists in %array, then increment
the customer number by one. Check to see if the new key, value
pair exists. If so, keep incrementing until a nonexistent
key, value pair is found.
Create an array element to hold the key, value pair.

createPair("100",  "Kathy Jones");

createPair("200",  "Grace Kelly");

createPair("100", "George Orwell");



while (($key, $value) = each %array) {

    print("$key, $value\n");

};



sub createPair{

    my($key, $value) = @_ ;



    while (defined($array{$key})) {

        $key++;

    }



    $array{$key} = $value;

};

This program prints:

100, George Orwell

101, Kathy Jones

200, Grace Kelly

You can see that the customer number for Kathy Jones has been changed to 101. If the array had already had an entry for 101, the Kathy Jones' new customer number would be 102.

Summary

In this chapter you've learned about functions-what they are and how to call them. You saw that you can create your own function or use one of Perl's many built-in functions. Each function can accept any number of parameters which get delivered to the function in the form of the @ array. This array, like any other array in Perl, can be accessed using the array element to access an individual element. ( For instance, $_ [0] accesses the first element in the @ array.) Because Perl parameters are passed by reference, changing the @ array changes the values in the main program as well as the function.

You learned about the scope of variables and how all variables are global by default. Then, you saw how to create variable with local scope using local() and my(). My() is the better choice in almost all situations because it enforces local scope and limits side effects from function to inside the functions.

Then you saw that it was possible to nest function calls, which means that one function can call another, which in turn can call another. You also might call this a chain of function calls. Private functions were introduced next. A private function is one that only can be used inside the function that defines it.

A list of string functions then was presented. These included functions to remove the last character, encrypt a string, find a sub-string, convert array elements into a string, change the case of a string character, and find the length of a string. Examples were shown about how to change a string's characters and how to search a string.

The section on array functions showed that Perl has a large number of functions that deal specifically with arrays. The list of functions included the ability to delete elements, return key, value pairs from associative arrays, reverse an array's elements, and sort an array. Examples were shown for printing an associative array and checking for the existence of an element.

The next chapter, "Statements," goes into detail about what statements are and how you create them. The information that you learned about variables and functions will come into play. You'll see how to link variables and functions together to form expressions and statements.

Review Questions

Answers to Review Questions are in Appendix A.

1. What is a parameter?
2. What two functions are used to create variables with local scope?
3. What does parameter passing by reference mean?
4. What is the @_ array used for?
5. Do Perl variables have global or local scope by default?
6. Why is it hard to pass two arrays to a function?
7. What is the difference between variables created with local() and variables created with my()?
8. What does the map() function do?

Review Exercises

1. Create a function that prints its own parameter list.
2. Create a program that uses three functions to demonstrate function call nesting.
3. Use the chop() function in a program. Print both the returned character and the string that was passed as a parameter.
4. Run the following program to see how many levels of recursion your system configuration supports:
   
   firstSub();
   
   sub firstSub{
   print("$count\n");
   $count++;
   firstSub();
   }
5. Write a function that uses the substr() and uc() functions to change the tenth through twentieth characters to uppercase.
6. Write a function that uses the keys() function to print out the values of an associative array.
7. Create a program that uses a private function to subtract two numbers and multiply the result by four.
8. Write a program that shows what the shift() and unshift() functions do.
9. Write a program that shows what the push() and pop() functions do.