Perl Components

Describing language—whether coded, written, or spoken, is fundamentally difficult because in order to understand the language components (nouns, verbs, adjectives) you also need to need to understand the semantics that convert those components in isolation into an understandable language that allows you to communicate. Unfortunately, it’s impossible to describe those semantics without giving examples of their use!

As a rule, Perl lets you do what you want, when you want to, and, more or less, how you want to. Perl is far more concerned about letting you develop a solution that works than it is about slotting your chosen solution into a set of standards and a rigid structure.

The core of any program are thevariablesused to hold changeable information. You change the contents of those variables usingoperators,regular expressions, andfunctions.

Statementshelp to control the flow of your program and enable you to declare certain facts about the programs you are running. If you can’t find what you want using the base Perl function set, you can make use of a number ofmodules, which export a list of variables and functions that provide additional information and operations. If you want to work in a structured format, modules also support objects, methods, and object classes. You can, of course, also make your own modules that use your own functions.

We’ll have a quick look at some of the elements and components within Perl that will help when we start to look at these individual items in more detail in future chapters.

Variables

Variables hold variable pieces of information—they are just storage containers for numbers, strings, and compound structures (lists of numbers and strings) that we might want to change at some future point.

Perl supports one basic variable type, the scalar. A scalar holds numbers and strings, so we could rewrite the simple “Hello World” example at the beginning of this chapter as

$message = "Hello World\n";

print $message;

In this example, we’veassignedaliteralto a variable called$message. When you assigna value to a variable, you are just populating that variable with some information.

Aliteralis a piece of static information—in this case it’s a string, but it could have been a number. By the way, when you assign information, you are assigning the value to the

right of theassignation operator(the=sign) to thelvalueon the left. Thelvalueis the name given to a variable or structure that can hold information. Normally this is a variable, but functions and objects are also types of lvalues.

You’ll notice in the preceding example that the variable,$message, has a “funny”

character at the beginning. In this case, it’s a dollar sign, and it identifies the variable as being a scalar. You always use a dollar sign when accessing a scalar value. The way to remember a scalar is that the$sign looks like an “s”, for scalar!

There are also some compound variable types—namely the array and the hash.

The array is a list of scalar variables—thus we can store a list of days using

@days = ('Mon','Tue','Wed','Thu','Fri','Sat','Sun');

The leading character for an array is an@sign (think “a” for array), and you always access an array of one or more values using an@sign. You access the values in an array by the numerical index; the first value is at index 0, so to get the first day of the week from the preceding list, we’d use$days[0]. Note the leading$sign—this is required because we are accessing the scalar value at index 0 from the array.

Perl also supports ahash—this is a list that uses not numerical indices, but instead a string “key” to access each “value”—the so-called key/value pair. Hash variables start with a%sign—think of the two “o” characters in the%as the key and value. Thus we could create a hash that contains month names (as the keys) and the days in that month (as the values):

%months = ('January' => 31, ...

'November' => 30, 'December' => 31);

Now all we need to do when we want to know how many days are in November is access the value in the%monthshash with a key of “November”:

print "Days in November:",$months{'November'},"\n";

Perl also supports some other types of variables, such as filehandles (which allow us to read from and write to files) and typeglobs (which allow us to access a variable via the internal symbol tables). We also use references, which just point to other variables without actually containing a value themselves.

The special characters used to access variables are a vital part of the Perl language—they enable us to identify the variables easily and let the programmer andPerl know what sort of variable we are expecting to use. We’ll see more information on variables in Chapter 4.

FUNDAMENTALS

Operators

Operators perform some sort of operation on a value or variable. For example, the+ operator adds two numbers together:

$sum = 4 + 5;

Other operators allow you to perform other basic math calculations, introduce lists of values (for use with functions and variables), and assign values to variables and subroutines.

There are also operators that enable us to use regular expressions that can “match”

information contained within a string against an expression, or perform a substitution so that we can replace and translate information without having to explicitly define its contents.

We’ll be looking at Perl operators, and the core mechanics of how Perl takes a raw script and interprets the contents, in Chapter 3.

Statements

Statements enable us to control the execution of our script—for example, we might use theifstatement to test the value of a variable or operation so that the script can make an informed decision about what to do next. Other statements include the loops, which allow us to repeat a process on the same piece of data or on a sequence of data. Statements also include declarations, such as those that allow us to define variables and subroutines.

We’ll be covering statements and control structures in Chapter 5.

Subroutines (Functions)

When you want to perform an operation on a variable a number of times, or the same operation on a number of variables, it makes sense to place that sequence of operations into a subroutine or function. Now when you want to perform that operation, you send the variable to the subroutine, and then use the value returned from that subroutine.

Perl includes a number of subroutines that perform different operations—including theprintsubroutine, which sends information to the screen (or to a file). Other sub-routines built into Perl include those for opening and communicating with files, talking over a network, or accessing information about the system. Other built-ins provide simple ways for performing different operations on variables and values.

You can also produce your own subroutines—something we’ll be looking at in Chapter 6.

34

Modules

Once you have a collection of subroutines that you find useful, then you’ll probably want to use them in other scripts and applications that you build with Perl. You could copy them to the new scripts, but a much better solution is to make your own modules.

These are the libraries that extend the functionality of Perl.

Perl comes with its own, quite extensive, set of modules that allow you to communicate over a network (see Chapter 12), develop user interfaces (see Chapter 17), access external databases (see Chapter 13), and provide an interface for communicating with a web server and a client browser when developing web solutions (see Chapter 18).

If you can’t find what you want within the standard Perl distribution, then there is a central repository of modules built by other programmers called CPAN. This contains literally thousands of modules to handle everything from accessing data sources through to handling XML (Extensible Markup Language).

We’ll be looking at how to build our own modules in Chapter 6.