Subroutines (Perl Cookbook, 2nd Edition)

# Chapter 10. Subroutines

#### Contents:

Introduction
Accessing Subroutine Arguments
Making Variables Private to a Function
Creating Persistent Private Variables
Determining Current Function Name
Passing Arrays and Hashes by Reference
Detecting Return Context
Passing by Named Parameter
Skipping Selected Return Values
Returning More Than One Array or Hash
Returning Failure
Prototyping Functions
Handling Exceptions
Saving Global Values
Redefining a Function
Trapping Undefined Function Calls with AUTOLOAD
Nesting Subroutines
Writing a Switch Statement
Program: Sorting Your Mail

> W. H. Auden, "Three Songs for St Cecilia's Day"

> Composing mortals with immortal fire.

## 10.0. Introduction

To avoid the dangerous practice of copying and pasting code, larger programs reuse chunks of code as subroutines and functions. We'll use the terms subroutine and function interchangeably because Perl doesn't distinguish between the two. Even object-oriented methods are just subroutines that are called using a special syntax, described in Chapter 13.

A subroutine is declared with the `sub` keyword. Here's a simple subroutine definition:

>     sub hello {
>         $greeted++;          # global variable
>         print "hi there!\n";
>     }

The typical way of calling that subroutine is:

>     hello( );                 # call subroutine hello with no arguments/parameters

Because Perl compiles your program before executing it, it doesn't matter where subroutines are declared. Definitions don't have to be in the same file as your main program. They can be pulled in from other files using the `do`, `require`, or `use` operators, as described in Chapter 12. They can even be created on the fly using `eval` or AUTOLOAD, or generated using closures, which can act as function templates.

If you are familiar with other programming languages, several characteristics of Perl's functions may surprise you if you're unprepared for them. Most recipes in this chapter illustrate how to be aware of—and to take advantage of—these properties.

- Perl functions have no formal, named parameters, but this is not necessarily a bad thing. See Recipe 10.1 and Recipe 10.7.

- All variables are global unless declared otherwise. See Recipe 10.2, Recipe 10.3, and Recipe 10.13 for details.

- Passing or returning more than one array or hash normally causes them to lose their separate identities. See Recipe 10.5, Recipe 10.8, Recipe 10.9, and Recipe 10.11 to avoid this.

- A function can know in which context it was called, how many arguments it was called with, and even which other function called it. See Recipe 10.4 and Recipe 10.6 to find out how.

- Perl's `undef` value can be used to signal an error return from the function because no valid string, number, or reference ever has that value. Recipe 10.10 covers subtle pitfalls with `undef` you should avoid, and Recipe 10.12 shows how to deal with other catastrophic conditions.

- Perl supports interesting operations on functions that you might not see in other languages, such as anonymous functions, creating functions on the fly, and calling them indirectly using function pointers. See Recipe 10.14 and Recipe 10.16 for these esoteric topics.

- Calling a function as `$x` `=` `&func;` does not supply any arguments, but rather provides direct access to its caller's `@_` array! If you omit the ampersand and use either `func( )` or `func`, then a new and empty `@_` is provided instead.

- Historically, Perl hasn't provided a construct like C's `switch` or the shell's `case` for multiway branching. The `switch` function shown in Recipe 10.17 takes care of that for you.

Copyright © 2003 O'Reilly & Associates. All rights reserved.