 |
Picking Up Perl
Copyright 1998, 1999, 2001 Bradley M. Kuhn.
Permission is granted to copy, distribute and/or modify this document under
the terms of the GNU Free Documentation License, Version 1.1 or any later
version published by the Free Software Foundation; with Invariant Sections being
"The GNU Free Documentation License", with no Front-Cover Texts, and
with no Back-Cover Texts. A copy of the license is included in the section
entitled "GNU Free Documentation License" (see GNU
Free Documentation License).
Node:Top, Next:Preface, Previous:(dir), Up:(dir)
Node:Preface, Next:Getting Started, Previous:Top, Up:Top
Preface
Node:Purpose of this Book,
Next:Acknowledgments, Previous:Preface, Up:Preface
Purpose of this Book
This book has been created for a number of reasons. The primary reason is to
provide a freely redistributable tutorial for the Perl language. In writing this
freely redistributable tutorial, it is our hope that the largest number of
people can have access to it and share it.
In the Perl community, we have discovered ways to save time by writing Perl
programs that make our jobs and lives easier. Surely, Perl is not a panacea, but
it has certainly made our lives a little bit better. It is hoped that you can
use Perl to make your jobs and lives easier, too.
Node:Acknowledgments, Next:Obtaining the Most Recent Version, Previous:Purpose of this Book, Up:Preface
Acknowledgments
Thanks to all those who sent grammar fixes and feedback over the years. There
are far too many of you to name here, but I have tried to list you all in the
THANKS file that comes with the transparent copy of this book.
Node:Obtaining the Most Recent
Version, Next:Audience, Previous:Acknowledgments, Up:Preface
Obtaining the Most Recent Version
This book is still under development. The most recent version can be obtained
at http://www.ebb.org/PickingUpPerl.
Node:Audience, Next:Material Covered, Previous:Obtaining the Most Recent Version, Up:Preface
Audience
This book does not that assume any prior knowledge of Perl. However, a reader
familiar with standard computer science concepts such as abstraction, stacks,
queues, and hash tables will definitely find her1 way through this book with ease. In other words,
anyone with a knowledge equivalent to a first-year of college computer science
courses should find this book very basic. Those of less experience may find this
book challenging.
Node:Material Covered, Next:Conventions Used in this Book, Previous:Audience, Up:Preface
Material Covered
The material covered in this book is designed to prepare the reader to enter
the world of Perl programming. This book covers the basic data and control
structures of Perl, as well as the philosophies behind Perl programming. The
native search patterns used in Perl, called regular expressions, are introduced
and discussed.
These concepts are introduced through the use of examples. It is hoped that
readers find these examples fun.
Node:Conventions Used in this
Book, Previous:Material Covered, Up:Preface
Conventions Used in this Book
In this text, a variety of conventions are used to explain the material.
Certain typographical and display elements are used for didactic purposes.
Any Perl code that is included directly in flowing text appears like this:
$x = 5. Any operating system commands discussed in flowing text
appear like this: program. Operating system files that are
discussed directly in the flowing text appear like this: file. When
a technical term of particular importance is first introduced and explained, it
appears in emphasized text, like this: an important term.
When Perl code examples or operating system commands need to be separated
away from the flowing text for emphasis, or because the code is long, it appears
like this: my $x = "foo"; # This is a Perl assignment
print $x, "\n"; # Print out "foo" and newline
All Perl code shown in this manner will be valid in Perl, version
5.6.0. In most cases, you can paste code from one of these sections
into a Perl program, and the code should work, even under use
strict and use warnings.
Sometimes, it will be necessary to include code that is not valid Perl. In
this case, a comment will appear right after the invalid statement indicating
that it is not valid, like this: $x = "foo; # INVALID: a " character is missing
When code that we set aside forms an entire Perl program that is
self-contained, and not simply a long example code section, it will appear like
this: #!/usr/bin/perl
use warnings;
use strict;
print "Hello World\n";
Finally, when text is given as possible output that might be given as error
messages when perl is run, they will appear like this: Semicolon seems to be missing
syntax error
Keep these standards in mind as you read this book.
Node:Getting Started, Next:Working with Scalars, Previous:Preface, Up:Top
Getting Started
This chapter begins the introduction to Perl by giving a simple code example.
We do not expect the reader to understand this example completely (yet). We
present this example to ease the reader into Perl's syntax and semantics.
Node:A First Perl Program,
Next:Expressions, Previous:Getting Started, Up:Getting Started
A First Perl Program
So, to begin our study of Perl, let us consider a small Perl program. Do not
worry that you are not familiar with all the syntax used here. The syntax will
be introduced more formally as we continue on through this book. Just try to
infer the behavior of the constructs below as best you can.
For our first Perl program, we will ask the user their username, and print
out a message greeting the user by name. #!/usr/bin/perl
use strict; # important pragma
use warnings; # another important pragma
print "What is your username? "; # print out the question
my $username; # "declare" the variable
$username = <STDIN>; # ask for the username
chomp($username); # remove "new line"
print "Hello, $username.\n"; # print out the greeting
# Now we have said hello to our user
Let us examine this program line by line to ascertain its meaning. Some
hand-waving will be necessary, since some of the concepts will not be presented
until later. However, this code is simple enough that you need not yet
understand completely what each line is doing.
The first line is how the program is identified as a Perl program. All Perl
programs should start with a line like #!/path/perl.
Usually, it is just #!/usr/bin/perl. You should put this line at
the top of each of your Perl programs.
In the lines that follow, halfway through each line, there is a
# character. Everything from the # character until the
end of the line is considered a comment. You are not required to
comment each line. In fact, commenting each line is rare. However, you will find
in this text that we frequently put comments on every line, since we are trying
to explain to the reader exactly what each Perl statement is doing. When you
write Perl programs, you should provide comments, but you need not do so as
verbosely as we do in this text.
Note, too, that comments can also occur on lines by themselves. The last line
of the program above is an example of that.
Now, consider the code itself, ignoring everything that follows a
# character. Notice that each line (ignoring comments) ends with a
;. This is the way that you tell Perl that a statement
is complete. We'll talk more about statements soon; for now, just consider a
statement to be a single, logical command that you give to Perl.
The first line, use strict, is called a pragma in
Perl. It is not something that "explicitly" gets executed, from your point of
view as the programmer. Instead, a pragma specifies (or changes) the rules that
Perl uses to understand the code that follows. The use strict;
pragma enforces the strictest possible rules for compiling the code. You should
always use this pragma while you are still new to Perl, as it will help you find
the errors in your code more easily.
The second line is another pragma, use warnings. This pragma
tells Perl that you'd like to be warned as much as possible when you write code
that might be questionable. Certain features of Perl can confuse new (and
sometimes even seasoned) Perl programmers. The use warnings pragma,
like use strict, is a way to tell Perl that you'd like to be warned
at run-time when certain operations seem questionable.
So, you might wonder why two separate pragmas are needed. The reason is that
they are enforced by Perl at different times. The use strict pragma
enforces compile-time constraints on the program source code. You can even test
them without running the program by using perl -c
filename, where filename is the file containing
your program. That option does not run your program, it merely checks that they
syntax of your program is correct. (To remember this, remember that the letter
c in -c stands for "check the program".)
By contrast, the use warnings pragma controls run-time behavior.
With use warnings, messages could be printed while your program
runs, if Perl notices something wrong. In addition, different inputs to the
program can cause different messages to be printed (or suppress such messages
entirely).
The third line is the first statement of the program the performs an action
directly. It is a call to Perl's built-in print function. In this
case, it is taking a string (enclosed in double quotes) as its argument, and
sending that string to the standard output, which is, by default, the terminal,
window, or console from which the program is run.
The next line is a variable declaration. When in
strict mode (set by the use strict pragma), all
variables must be declared. In this case, Perl's my keyword is
used to declare the variable $username. A variable like
$username that starts with a $ is said to be a
scalar variable. For more information on scalar variables, see Working
with Scalars. For now, just be aware that scalar variables can hold strings.
The next line, $username = <STDIN> is an assignment
statement, which is denoted by the =. The left hand side of the
assignment is that scalar variable, $username, that we declared in
the line before it. Since $username is on the left hand side of the
=, that indicates $username will be assigned a new
value by this assignment statement.
The right hand side of the assignment is a construct that allows us to get
input from the keyboard, the default standard input. STDIN is
called a file handle that represents the standard input. We will
discuss more about file handles later. For now, just remember that the construct
<STDIN>, when assigned to a scalar variable, places the next
line of standard input into that scalar variable.
Thus, at this point, we have the next line of the input (which is hopefully
the username that we asked for), in the $username variable. Since
we got the contents of $username from the standard input, we know
that the user hit return after typing her username. The return key inserts a
special character, called newline, at the end of the line. The
$username variable contains the full contents of the line, which is
not just the user's name, but also that newline character.
To take care of this, the next thing we do is chomp($username).
Perl's built-in function, chomp, removes any newline characters
that are on the end of a variable. So, after the chomp operation,
the variable $username
The final statement is another print statement. It uses the
value of the $username variable to greet the user with her name.
Note that it is acceptable to use $username inside of the string to
be printed, and the contents of that scalar are included.
This ends our discussion of our small Perl program. Now that you have some
idea of what Perl programs look like, we can begin to look at Perl, its data
types, and its constructs in detail.
Node:Expressions, Previous:A First Perl Program, Up:Getting Started
Expressions, Statements, and Side-Effects
Before we begin introduce more Perl code examples, we want to explain the
ideas of an expression and a statement, and how each looks
in Perl.
Any valid "chunk" of Perl code can be considered an expression.
That expression always evaluates to some value. Sometimes, the value to which
expression evaluates is of interest to us, and sometimes it is not. However, we
always must be aware that each expression has some "value" that is the
evaluation of that expression.
Zero or more expressions to make a statement in Perl. Statements in
Perl end with a semi-colon. For example, in the Perl code we saw before, we
turned the expression, chomp($userName), into a statement,
chomp($userName); by adding a ; to the end. If it
helps, you can think about the ;s as separating sets of expressions
that you want Perl to evaluate and execute in order.
Given that every expression, even when combined into statements, evaluate to
some value, you might be tempted to ask: What does the expression
chomp($userName) evaluate to? It turns out that expression
evaluates to the total number of characters removed from the end of the variable
$userName. This is actually one of those cases where we are not
particularly interested in the evaluation result of the code. In this case, we
were instead interested in what is called the side-effect of the
expression.
The side-effect of an expression is some change that occurs as a
result of that expression's evaluation. Often, a side-effect causes some change
in the state of the running program, such as changing the value of a variable.
In the expression chomp($userName), the side-effect is that any
newline characters are removed from the end of the variable,
$username.
Let's now consider a slightly more complex statement, and look for the the
expressions and side-effect. Consider the statement, $username =
<STDIN>; from our first program. In this case, we used the
expression, <STDIN> as part of a larger expression, namely
$username = <STDIN>. The expression,
<STDIN> evaluated to a scalar value, namely a string that
represented a line from the standard input. It was of particular interest to us
the value to which <STDIN> evaluated, because we wanted to
save that value in the variable, $username.
To cause that assignment to take place, we used the larger expression,
$username = <STDIN>. The side-effect of that larger
expression is that $username contains the value that
<STDIN> evaluated to. That side-effect is what we wanted in
this case, and we ignore the value to which $username =
<STDIN> evaluates. (It turns out that it evaluates to the value
contained in $username after the assignment took place.)
The concepts of statements, expressions and side-effects will become more
clear as we continue. When appropriate, we'll point out various expression and
discuss what they evaluate to, and indicate what side-effects are of interest to
us.
Node:Working with Scalars,
Next:Arrays, Previous:Getting Started, Up:Top
Working with Scalars
Scalar data are the most basic in Perl. Each scalar datum is logically a
single entity. Scalars can be strings of characters or numbers. In Perl, you
write literal scalar strings like this:
For example, the strings "foobar" and 'baz' are
scalar data. The numbers 3, 3.5 and -1
are also scalar data.
Strings are always enclosed in some sort of quoting, the most common of which
are single quotes, '', and and double quotes, "".
We'll talk later about how these differ, but for now, you can keep in mind that
any string of characters inside either type of quotes are scalar string data.
Numbers are always written without quotes. Any numeric sequence without
quotes are scalar number data.
In this chapter, we will take a look at the variety of scalar data available
in Perl, the way to store them in variables, how to operate on them, and how to
output them.
Node:Strings, Next:Numbers, Previous:Working with Scalars, Up:Working with Scalars
Strings
Any sequence of ASCII characters put together as one unit, is
a string. So, the word the is a string. This sentence is a string.
Even this entire paragraph is a string. In fact, you could consider the text of
this entire book as one string.
Strings can be of any length and can contain any characters, numbers,
punctuation, special characters (like !, #, and
%), and even characters in natural languages besides English In
addition, a string can contain special ASCII formatting
characters like newline, tab, and the "bell" character. We will discuss special
characters more later on. For now, we will begin our consideration of strings by
considering how to insert literal strings into a Perl program.
To begin our discussion of strings in Perl, we will consider how to work with
"string literals" in Perl. The word literal here refers to the fact
that these are used when you want to type a string directly to Perl. This can be
contrasted with storing a string in a variable.
Any string literal can be used as an expression. We will find this useful
when we want to store string literals in variables. However, for now, we will
simply consider the different types of string literals that one can make in
Perl. Later, we will learn how to assign these string literals to variables (see
Scalar
Variables).
Node:Single-quoted Strings,
Next:A Digression---The print Function, Previous:Strings, Up:Strings
Single-quoted Strings
String literals can be represented in primarily three ways in Perl. The first
way is in single quotes. Single quotes can be used to make sure that nearly all
special characters that might be interpreted differently are taken at "face
value". If that concept is confusing to you, just think about single quoted
strings as being, for the most part, "what you see is what you get". Consider
the following single-quoted string: 'i\o'; # The string 'i\o'
This represents a string consisting of the character i, followed
by \, followed by o. However, it is probably easier
just to think of the string as i\o. Some other languages require
you think of strings not as single chunks of data, but as some aggregation of a
set of characters. Perl does not work this way. A string is a simple, single
unit that can be as long as you would like.2
Note in our example above that 'i\o' is an expression. Like all
expressions, it evaluates to something. In this case, it evaluates to the string
value, i\o. Note that we made the expression 'i\o'
into a statement, by putting a semi-colon at the end ('i\o';). This
particular statement does not actually perform any action in Perl, but it is
still a valid Perl statement nonetheless.
Node:Special
Characters in Single-quoted Strings, Next:Newlines in Single-quoted Strings, Previous:Single-quoted Strings, Up:Single-quoted Strings
Special Characters in Single-quoted Strings
There are two characters in single quoted strings that do not always
represent themselves. This is due to necessity, since single-quoted strings
start and end with the ' character. We need a way to express inside
a single-quoted string that we want the string to contain a '
character.
The solution to this problem is to preceded any ' characters we
actually want to appear in the string itself with the backslash (\
character). Thus we have strings like this: 'xxx\'xxx'; # xxx, a single-quote character, and then xxx
We have in this example a string with 7 characters exactly. Namely, this is
the string: xxx'xxx. It can be difficult at first to become
accustomed to the idea that two characters in the input to Perl actually produce
only one character in the string itself. 3 However, just keep in mind the rules and you will
probably get used to them quickly.
Since we have used the \ character to do something special with
the ' character, we must now worry about the special cases for the
backslash character itself. When we see a \ character in a
single-quoted string, we must carefully consider what will happen.
Under most circumstances, when a \ is in a single-quoted string,
it is simply a backslash, representing itself, as most other characters do.
However, the following exceptions apply:
- The sequence
\' yields the character ' in the
actual string. (This is the exception we already discussed above).
- The sequence
\\ yields the character \ in the
actual string. In other words, two backslashes right next to each other
actually yield only one backslash.
- A backslash, by itself, cannot be placed at the end of a the single-quoted
string. This cannot happen because Perl will think that you are using the
\ to escape the closing '.
The following examples exemplify the various exceptions, and use them
properly: 'I don\'t think so.'; # Note the ' inside is escaped with \
'Need a \\ (backslash) or \?'; # The \\ gives us \, as does \
'You can do this: \\'; # A single backslash at the end
'Three \\\'s: "\\\\\"'; # There are three \ chars between ""
In the last example, note that the resulting string is Three \'s:
"\\\". If you can follow that example, you have definitely mastered how
single-quoted strings work!
Node:Newlines in Single-quoted
Strings, Next:Examples of Invalid Single-quoted Strings, Previous:Special Characters in Single-quoted Strings, Up:Single-quoted Strings
Newlines in Single-quoted Strings
Note that there is no rule against having a single-quoted string span several
lines. When you do this, the string has newline characters embedded in
it.
A newline character is a special ASCII character that indicates that a new
line should be started. In a text editor, or when printing output to the screen,
this usually indicates that the cursor should move from the end of the current
line to the first position on the line following it.
Since Perl permits the placement of these newline characters directly into
single quoted strings, we are permitted to do the following: 'Time to
start anew.'; # Represents the single string composed of:
# 'Time to' followed by a newline, followed by
# 'start anew.'
This string has a total of twenty characters. The first seven are Time
to. The next character following that is a newline. Then, the eleven
characters, start anew. follow. Note again that this is one
string, with a newline as its eighth character.
Further, note that we are not permitted to put a comment in the middle of the
string, even though we are usually allowed to place a # anywhere on
the line and have the rest of the line be a comment. We cannot do this here,
since we have yet to terminate our single-quoted string with a ',
and thus, any # character and comment following it would actually
become part of the single-quoted string! Remember that single-quotes strings are
delimited by ' at the beginning, and ' at the end, and
everything in between is considered part of the string, included newlines,
# characters and anything else.
Node:Examples of
Invalid Single-quoted Strings, Previous:Newlines in Single-quoted Strings, Up:Single-quoted Strings
Examples of Invalid Single-quoted Strings
In finishing our discussion of singled-quoted strings, consider these
examples of strings that are not legal because they violate the
exceptions we talked about above: 'You cannot do this: \'; # INVALID: the ending \ cannot be alone
'It is 5 o'clock!' # INVALID: the ' in o'clock should be escaped
'Three \'s: \\\\\'; # INVALID: the final \ escapes the ', thus
# the literal is not terminated
'This is my string; # INVALID: missing close quote
Sometimes, when you have invalid string literals such as in the example
above, the error message that Perl gives is not particularly intuitive. However,
when you see error messages such as: (Might be a runaway multi-line '' string starting on line X)
Bareword found where operator expected
Bareword "foo" not allowed while "strict subs" in use
It is often an indication that you have runaway or invalid strings. Keep an
eye out for these problems. Chances are, you will forget and violate one of the
rules for single-quoted strings eventually, and then need to determine why you
are unable to run your Perl program.
Node:A Digression---The print
Function, Next:Double-quoted Strings, Previous:Single-quoted Strings, Up:Strings
A Digression--The print Function
Before we move on to our consideration of double-quoted strings, it is
necessary to first consider a small digression. We know how to represent strings
in Perl, but, as you may have noticed, the examples we have given thus far do
not do anything interesting. If you try placing the statements that we listed as
examples in Single-quoted
Strings, into a full Perl program, like this: #!/usr/bin/perl
use strict;
use warnings;
'Three \\\'s: "\\\\\"'; # There are three \ chars between ""
'xxx\'xxx'; # xxx, a single-quote character, and then xxx
'Time to
start anew.';
you probably noticed that nothing of interest happens. Perl gladly runs this
program, but it produces no output.
Thus, to begin to work with strings in Perl beyond simple hypothetical
considerations, we need a way to have Perl display our strings for us. The
canonical way of accomplishing this in Perl is to use the print
function.
The print function in Perl can be used in a variety of ways. The
simplest form is to use the statement print STRING;, where
STRING is any valid Perl string.
So, to reconsider our examples, instead of simply listing the strings, we
could instead print each one out: #!/usr/bin/perl
use strict;
use warnings;
print 'Three \\\'s: "\\\\\"'; # Print first string
print 'xxx\'xxx'; # Print the second
print 'Time to
start anew.
'; # Print last string, with a newline at the end
This program will produce output. When run, the output goes to what is called
the standard output. This is usually the terminal, console or window
in which you run the Perl program. In the case of the program above, the output
to the standard output is as follows: Three \'s: "\\\"xxx'xxxTime to
start anew.
Note that a newline is required to break up the lines. Thus, you need to put
a newline at the end of every valid string if you want your string to be the
last thing on that line in the output.
Note that it is particularly important to put a newline on the end of the
last string of your output. If you do not, often times, the command prompt for
the command interpreter that you are using may run together with your last line
of output, and this can be very disorienting. So, always
remember to place a newline at the end of each line, particularly on your last
line of output.
Finally, you may have noticed that formatting your code with newlines in the
middle of single-quoted strings hurts readability. Since you are inside a
single-quoted string, you cannot change the format of the continued lines within
the print statement, nor put comments at the ends of those lines because that
would insert data into your single-quoted strings. To handle newlines more
elegantly, you should use double-quoted strings, which are the topic of the next
section.
Node:Double-quoted Strings,
Previous:A Digression---The print Function, Up:Strings
Double-quoted Strings
Double-quoted strings are another way of representing scalar string literals
in Perl. Like single-quoted strings, you place a group of ASCII
characters between two delimiters (in this case, our delimiter is
"). However, something called interpolation happens when
you use a double-quoted string.
Node:Interpolation in
Double-quoted Strings, Next:Examples of Interpolation, Previous:Double-quoted Strings, Up:Double-quoted Strings
Interpolation in Double-quoted Strings
Interpolation is a special process whereby certain special strings written in
ASCII are replaced by something different. In Single-quoted
Strings, we noted that certain sequences in single-quoted strings (namely,
\\ and \') were treated differently. This is very
similar to what happens with interpolation. For example, in interpolated
double-quoted strings, various sequences preceded by a \ character
act different.
Here is a chart of the most common of these:
| String
| Interpolated As
|
\\
| an actual, single backslash character
|
\$
| a single $ character
|
\@
| a single @ character
|
\t
| tab
|
\n
| newline
|
\r
| hard return
|
\f
| form feed
|
\b
| backspace
|
\a
| alarm (bell)
|
\e
| escape
|
\033
| character represented by octal value, 033
|
\x1b
| character represented by hexadecimal value, 1b
|
Node:Examples of Interpolation,
Next:Examples of Interpolation (ASCII Octal Values), Previous:Interpolation in Double-quoted Strings, Up:Double-quoted Strings
Examples of Interpolation
Let us consider an example that uses a few of these characters: #!/usr/bin/perl
use strict;
use warnings;
print "A backslash: \\\n";
print "Tab follows:\tover here\n";
print "Ring! \a\n";
print "Please pay bkuhn\@ebb.org \$20.\n";
This program, when run, produces the following output on the screen: A backslash: \
Tab follows: over here
Ring!
Please pay bkuhn@ebb.org $20.
In addition, when running, you should hear the computer beep. That is the
output of the \a character, which you cannot see on the screen.
However, you should be able to hear it.
Notice that the \n character ends a line. \n should
always be used to end a line. Those students familiar with the C language will
be used to using this sequence to mean newline. When writing Perl,
the word newline and the \n character are roughly
synonymous.
Node:Examples
of Interpolation (ASCII Octal Values), Next:Examples of Interpolation (ASCII Hex Values), Previous:Examples of Interpolation, Up:Double-quoted Strings
Examples of Interpolation (ASCII Octal Values)
With the exception of \n, you should note that the interpolated
sequences are simply shortcuts for actually ASCII characters that
can be expressed in other ways. Specifically, you are permitted to use the
actual ASCII codes (in octal or hexadecimal) to represent
characters. To exemplify this, consider the following program: #!/usr/bin/perl
use strict;
use warnings;
print "A backslash: \134\n";
print "Tab follows:\11over here\n";
print "Ring! \7\n";
print "Please pay bkuhn\100ebb.org \04420.\n";
This program generates exactly the same output as the program we first
discussed in this section. However, instead of using the so-called "shortcuts"
for the ASCII values, we wrote each character in question using
the octal value of that character. Comparing the two programs should provide
some insight into the use of octal values in double-quoted strings.
Basically, you simply write \XYZ, where XYZ is the
octal number of the ASCII character desired. Note that you don't
always need to write all three digits. Namely, notice that the double-quoted
string, "Ring! \7\n", did not require all the digits. This is
because in the string, the octal value is immediately followed by another
\, and thus Perl could figure out what we meant. This is one of the
many cases where you see Perl trying to "do the right thing" when you do
something that is technically not completely legal.
However, note that, in the last string, the three digits are required for the
sequence ("\04420"), because the 20 immediately
following the octal code could be easily confused with the octal value preceding
it. The point, however, is that as long as you obey the rules for doing so, you
can often add characters to your double-quoted strings by simply using the
ASCII value.
Node:Examples of
Interpolation (ASCII Hex Values), Next:Characters Requiring Special Consideration, Previous:Examples of Interpolation (ASCII Octal Values), Up:Double-quoted Strings
Examples of Interpolation (ASCII Hex Values)
You need not use only the octal values when interpolating
ASCII characters into double-quoted strings. You can also use the
hexadecimal values. Here is our same program using the hexadecimal values this
time instead of the octal values: #!/usr/bin/perl
use strict;
use warnings;
print "A backslash: \x5C\n";
print "Tab follows:\x09over here\n";
print "Ring! \x07\n";
print "Please pay bkuhn\x40ebb.org \x2420.\n";
As you can see, the theme of "there's more than one way to do it" is really
playing out here. However, we only used the ASCII codes as a
didactic exercise. Usually, you should use the single character sequences (like
\a and \t), unless, of course, you are including an
ASCII character that does not have a shortcut, single character
sequence.
Node:Characters
Requiring Special Consideration, Previous:Examples of Interpolation (ASCII Hex Values), Up:Double-quoted Strings
Characters Requiring Special Consideration
The final issue we have yet to address with double-quoted strings is the use
of $ and @. These two characters must always be
quoted. The reason for this is not apparent now, but be sure to keep this rule
in mind until we learn why this is needed. For now, it is enough to remember
that in double-quoted strings, Perl does something special with $
and @, and thus we must be careful to quote them. (If you cannot
wait to find out why, you should read Scalar
Interpolation and Array
Interpolation.
Node:Numbers, Next:Scalar Variables, Previous:Strings, Up:Working with Scalars
Numbers
Perl has the ability to handle both floating point and integer numbers in
reasonable ranges4.
Node:Numeric Literals, Previous:Numbers, Up:Numbers
Numeric Literals
Numeric literals are simply constant numbers. Numeric literals are much
easier to comprehend and use than string literals. There are only a few basic
ways to express numeric literals.
The numeric literal representations that Perl users are similar to those used
in other languages such as C, Ada, and Pascal. The following are a few common
examples: 42; # The number 42
12.5; # A floating point number, twelve and a half
101873.000; # 101,873
.005 # five thousandths
5E-3; # same number as previous line
23e-100; # 23 times 10 to the power of -100 (very small)
2.3E-99; # The same number as the line above!
23e6; # 23,000,000
23_000_000; # The same number as line above
# The underscores are for readability only
As you can see, there are three basic ways to express numeric literals. The
most simple way is to write an integer value, without a decimal point, such as
42. This represents the number forty-two.
You can also write numeric literals with a decimal point. So, you can write
numbers like 12.5, to represent numbers that are not integral
values. If you like, you can write something like 101873.000, which
really simply represents the integral value 101,873. Perl does not mind that you
put the extra 0's on the end.
Probably the most complex method of expressing a numeric literal is using
what is called exponential notation. These are numbers of the form b
* 10^x , where b is some decimal number, positive or negative, and x is some
integer, positive or negative. Thus, you can express very large numbers, or very
small numbers that are mostly 0s (either to the right or left of the decimal
point) using this notation. However, when you write such a number as a literal
in Perl, you must write it in the from bEx, where b
and x are the desired base and exponent, but E is the
actual character, E (or e, if you prefer). The
examples of 5E-3, 23e-100, 2.3E-99, and
23e6 in the code above show how the exponential notation can be
used.
Finally, if you write out a very large number, such as 23000000,
you can place underscores inside the number to make it more readable. 5 Thus, 23000000 is exactly the same
as
23_000_000.
Node:Printing Numeric Literals,
Previous:Numeric Literals, Up:Numeric Literals
Printing Numeric Literals
As with string literals, you can also use the print function in
Perl to print numerical literals. Consider this program: #!/usr/bin/perl
use strict;
use warnings;
print 2E-4, ' ', 9.77E-5, " ", 100.00, " ", 10_181_973, ' ', 9.87E9,
" ", 86.7E14, "\n";
which produces the output: 0.0002 9.77e-05 100 10181973 9870000000 8.67e+15
First of all, we have done something new here with print.
Instead of giving print one argument, we have given it a
number of arguments, separated by commas. Arguments are simply the parameters on
which you wish the function to operate. The print function, of
course, is used to display whatever arguments you give it.
In this case, we gave a list of arguments that included both string and
numeric literals. That is completely acceptable, since Perl can usually tell the
difference! The string literals are simply spaces, which we are using to
separate our numeric literals on the output. Finally, we put the newline at the
end of the output.
Take a close look at the numeric literals that were output. Notice that Perl
has made some formatting changes. For example, as we know, the _'s
are removed from 10_181_973. Also, those decimals and large
integers in exponential notation that were relatively reasonable to expand were
expanded by Perl. In addition, Perl only printed 100 for
100.00, since the decimal portion was zero. Of course, if you do
not like the way that Perl formats numbers by default, we will later learn a way
to have Perl format them differently (see Output
of Scalar Data).
Node:Scalar Variables, Next:Operators, Previous:Numbers, Up:Working with Scalars
Scalar Variables
Since we have now learned some useful concepts about strings and numbers in
Perl, we can consider how to store them in variables. In Perl, both
numeric and string values are stored in scalar variables.
Scalar variables are storage areas that you can use to store any scalar
value. As we have already discussed, scalar values are strings or numbers, such
as the literals that we discussed in previous sections.
You can always identify scalar variables because they are in the form
$NAME, where NAME is any string of alphanumeric
characters and underscores starting with a letter, up to 255 characters total.
Note that NAME will be case sensitive, thus
$xyz is a different variable than $xYz.
Note that the first character in the name of any scalar variable must be
$. All variables that begin with $ are always scalar.
Keep this in mind as you see various expressions in Perl. You can remember that
anything that begins with $ is always scalar.
As we discussed (see A
First Perl Program), it is best to always declare variables with the
my function. You do not need to do this if you are not using
strict, but you should always use strict until you
are an experienced Perl programmer.
The first operation we will consider with scalar variables is
assignment. Assignment is the way that we give a value from some
scalar expression to a scalar variable.
The assignment operator in Perl is =. On the left hand side of
the =, we place the scalar variable whose value we wish to change.
On the right side of the =, we place the scalar expression. (Note
that so far, we have learned about three types of scalar expressions: string
literals, numeric literals, and scalar variables).
Consider the following code segment: use strict;
my $stuff = "My data"; # Assigns "My data" to variable $stuff
$stuff = 3.5e-4; # $stuff is no longer set to "My data";
# it is now 0.00035
my $things = $stuff; # $things is now 0.00035, also.
Let us consider this code more closely. The first line does two operations.
First, using the my function, it declares the variable
$stuff. Then, in the same statement, it assigns the variable
$stuff with the scalar expression, "My data".
The next line uses that same variable $stuff. This time, it is
replacing the value of "My data" with the numeric value of
0.00035. Note that it does not matter that $stuff once
contained string data. We are permitted to change and assign it with a different
type of scalar data.
Finally, we declare a new variable $things (again, using the
my function), and use assignment to give it the value of the scalar
expression $stuff. What does the scalar expression,
$stuff evaluate to? Simply, it evaluates to whatever scalar value
is held by $stuff. In this case, that value is
0.00035.
Node:Scalar Interpolation, Next:Undefined Variables, Previous:Scalar Variables, Up:Scalar Variables
Scalar Interpolation
Recall that when we discussed double-quotes strings (see Double-quoted
Strings), we noted that we had to backslash the $ character
(e.g., "\$"). Now, we discuss the reason that this was necessary.
Any scalar variable, when included in a double-quoted string
interpolates.
Interpolation of scalar variables allows us to insert the value of a scalar
variable right into a double-quoted string. In addition, since Perl largely does
all data conversion necessary, we can often use variables that have integer and
float values and interpolate them right into strings without worry. In most
cases, Perl will do the right thing.
Consider the following sample code: use strict;
my $friend = 'Joe';
my $greeting = "Howdy, $friend!";
# $greeting contains "Howdy, Joe!"
my $cost = 20.52;
my $statement = "Please pay \$$cost.\n";
# $statement contains "Please pay $20.52.\n"
my $debt = "$greeting $statement";
# $debt contains "Howdy, Joe! Please pay $20.52.\n"
As you can see from this sample code, you can build up strings by placing
scalars inside double-quotes strings. When the double-quoted strings are
evaluated, any scalar variables embedded within them are replaced with the value
that each variable holds.
Note in our example that there was no problem interpolating
$cost, which held a numeric scalar value. As we have discussed,
Perl tries to do the right thing when converting strings to numbers and numbers
to strings. In this case, it simply converted the numeric value of
20.52 into the string value '20.52' to interpolate
$cost into the double-quoted string.
Interpolation is not only used when assigning to other scalar variables. You
can use a double-quoted string and interpolate it in any context where a scalar
expression is appropriate. For example, we could use it as part of the
print statement. #!/usr/bin/perl
use strict;
use warnings;
my $owner = 'Elizabeth';
my $dog = 'Rex';
my $amount = 12.5;
my $what = 'dog food';
print "${owner}'s dog, $dog, ate $amount pounds of $what.\n";
This example produces the output: Elizabeth's dog, Rex, ate 12.5 pounds of dog food.
Notice how we are able to build up a large string using four variables, some
text, and a newline character, all contained within one interpolated
double-quoted string. We needed only to pass one argument to
print! Recall that previously (see Printing
Numeric Literals) we had to separate a number of scalar arguments by commas
to pass them to print. Thus, using interpolation, it is very easy to build up
smaller scalars into larger, combined strings. This is a very convenient and
frequently used feature of Perl.
You may have noticed by now that we did something very odd with
$owner in the example above. Instead of using $owner,
we used ${owner}. We were forced to do this because following a
scalar variable with the character ' would confuse Perl. 6 To make it clear to Perl that we wanted to use
the scalar with name owner, we needed to enclose owner
in curly braces ({owner}).
In many cases when using interpolation, Perl requires us to do this. Certain
characters that follow scalar variables mean something special to Perl. When in
doubt, however, you can wrap the name of the scalar in curly braces (as in
${owner}) to make it clear to Perl what you want.
Note that this can also be a problem when an interpolated scalar variable is
followed by alpha-numeric text or an underscore. This is because Perl cannot
tell where the name of the scalar variable ends and where the literal text you
want in the string begins. In this case, you also need to use the curly braces
to make things clear. Consider: use strict;
my $this_data = "Something";
my $that_data = "Something Else ";
print "_$this_data_, or $that_datawill do\n"; # INVALID: actually refers
# to the scalars $this_data_
# and $that_datawill
print "_${this_data}_, or ${that_data}will do\n";
# CORRECT: refers to $this_data and $that_data,
# using curly braces to make it clear
Node:Undefined Variables,
Previous:Scalar Interpolation, Up:Scalar Variables
Undefined Variables
You may have begun to wonder: what value does a scalar variable have if you
have not given it a value? In other words, after: use strict;
my $sweetNothing;
what value does $sweetNothing have?
The value that $sweetNothing has is a special value in Perl
called undef. This is frequently expressed in English by saying
that $sweetNothing is undefined.
The undef value is a special one in Perl. Internally, Perl keeps
track of which variables your program has assigned values to and which remain
undefined. Thus, when you use a variable in any expression, Perl can inform you
if you are using an undefined value.
For example, consider this program: #!/usr/bin/perl
use strict;
use warnings;
my $hasValue = "Hello";
my $hasNoValue;
print "$hasValue $hasNoValue\n";
When this program is run, it produces the following output: Use of uninitialized value at line 8.
Hello
What does this mean? Perl noticed that we used the uninitialized (i.e.,
undefined) variable, $hasNoValue at line 8 in our program. Because
we were using warnings, Perl warned us about that use of the
undefined variable.
However, Perl did not crash the program! Perl is nice enough not to make
undefined variables a hassle. If you use an undefined variable and Perl expected
a string, Perl uses the empty string, "", in its place. If Perl
expected a number and gets undef, Perl substitutes 0
in its place.
However, when using warnings, Perl will always warn you when you
have used an undefined variable at run-time. The message will print to the
standard error (which, by default, is the screen) each time Perl encounters a
use of a variable that evaluates to undef. If you do not use
warnings, the warnings will not print, but you should probably wait
to turn off warnings until you are an experienced Perl programmer.
Besides producing warning messages, the fact that unassigned variables are
undefined can be useful to us. The first way is that we can explicitly test to
see if a variable is undefined. There is a function that Perl provides called
defined. It can be used to test if a variable is defined or not.
In addition, Perl permits the programmer to assign a variable the value
undef. The expression undef is a function provided by
Perl that we can use in place of any expression. The function undef
is always guaranteed to return an undefined value. Thus, we can take a variable
that already has a value and make it undefined.
Consider the following program: #!/usr/bin/perl
use strict;
use warnings;
my $startUndefined;
my $startDefined = "This one is defined";
print "defined \$startUndefined == ",
defined $startUndefined,
", defined \$startDefined == ",
defined $startDefined, "\n";
$startUndefined = $startDefined;
$startDefined = undef;
print "defined \$startUndefined == ",
defined $startUndefined,
", defined \$startDefined == ",
defined $startDefined, "\n";
Which produces the output: defined $startUndefined == , defined $startDefined == 1
defined $startUndefined == 1, defined $startDefined ==
Notice a few things. First, since we first declared
$startUndefined without giving it a value, it was set to
undef. However, we gave $startDefined a value when it
was declared, thus it started out defined. These facts are exemplified by the
output.
To produce that output, we did something that you have not seen yet. First,
we created some strings that "looked" like the function calls so our output
would reflect what the values of those function calls were. Then, we simply used
those functions as arguments to the print function. This is
completely legal in Perl. You can use function calls as arguments to other
functions.
When you do this, the innermost functions are called first, in their argument
order. Thus, in our print statements, first defined
$startUndefined is called, followed by defined
$startDefined. These two functions each evaluate to some value. That
value then becomes the argument to the print function.
So, what values did defined return? We can determine the answer
to this question from the printed output. We can see that when we called
defined on the variable that we started as undefined,
$startUndefined, we got no output for that call (in fact,
defined returned an empty string, ""). When we called
defined on the value that we had assigned to,
$startDefined, we got the output of 1.
Thus, from the experiment, we know that when its argument is not defined,
defined returns the value "", otherwise known as the
empty string (which, of course, prints nothing to the standard output when given
as an argument to print).
In addition, we know that when a variable is defined, defined
returns the value 1.
Hopefully, you now have some idea of what an undef value is,
and what defined does. It might not yet be clear why
defined returns an empty string or 1. If you are
particularly curious now, see A
Digression--Truth Values.
Node:Operators, Next:Output of Scalar Data, Previous:Scalar Variables, Up:Working with Scalars
Operators
There are a variety of operators that work on scalar values and variables.
These operators allow us to manipulate scalars in different ways. This section
discusses the most common of these operators.
Node:Numerical Operators, Next:Comparison Operators, Previous:Operators, Up:Operators
Numerical Operators
The basic numerical operators in Perl are like others that you might see in
other high level languages. In fact, Perl's numeric operators were designed to
mimic those in the C programming language.
First, consider this example: use strict;
my $x = 5 * 2 + 3; # $x is 13
my $y = 2 * $x / 4; # $y is 6.5
my $z = (2 ** 6) ** 2; # $z is 4096
my $a = ($z - 96) * 2; # $a is 8000
my $b = $x % 5; # 3, 13 modulo 5
As you can see from this code, the operators work similar to rules of
algebra. When using the operators there are two rules that you have to keep in
mind--the rules of precedence and the rules of
associativity.
Precedence involves which operators will get evaluated first when the
expression is ambiguous. For example, consider the first line in our example,
which includes the expression, 5 * 2 + 3. Since the multiplication
operator (*) has precedence over the addition operator
(+), the multiplication operation occurs first. Thus, the
expression evaluates to 10 + 3 temporarily, and finally evaluates
to 13. In other words, precedence dictates which operation occurs
first.
What happens when two operations have the same precedence? That is when
associativity comes into play. Associativity is either left or right 7. For example, in the expression 2 * $x /
4 we have two operators with equal precedence, * and
/. Perl needs to make a choice about the order in which they get
carried out. To do this, it uses the associativity. Since multiplication and
division are left associative, it works the expression from left to right, first
evaluating to 26 / 4 (since $x was 13),
and then finally evaluating to 6.5.
Briefly, for the sake of example, we will take a look at an operator that is
left associative, so we can contrast the difference with right associativity.
Notice when we used the exponentiation (**) operator in the example
above, we had to write (2 ** 6) ** 2, and not 2 ** 6 **
2.
What does 2 ** 6 ** 2 evaluate to? Since **
(exponentiation) is right associative, first the 6 **
2 gets evaluated, yielding the expression 2 ** 36, which
yields 68719476736, which is definitely not 4096!
Here is a table of the operators we have talked about so far. They are listed
in order of precedence. Each line in the table is one order of precedence.
Naturally, operators on the same line have the same precedence. The higher an
operator is in the table, the higher its precedence.
| Operator
| Associativity
| Description
|
| **
| right
| exponentiation
|
| *, /, %
| left
| multiplication, division, modulus
|
| +, -
| left
| addition, subtraction
|
Node:Comparison Operators, Next:Auto-Increment and Decrement, Previous:Numerical Operators, Up:Operators
Comparison Operators
Comparing two scalars is quite easy in Perl. The numeric
comparison operators that you would find in C, C++, or Java are available.
However, since Perl does automatic conversion between strings and numbers for
you, you must differentiate for Perl between numeric and string comparison. For
example, the scalars "532" and "5" could be compared
two different ways--based on numeric value or ASCII string value.
The following table shows the various comparison operators and what they do.
Note that in Perl "", 0 and undef are
false and anything else as true. (This is an over-simplified definition of true
and false in Perl. See A
Digression--Truth Values, for a complete definition.)
The table below assumes you are executing $left <OP>
$right, where <OP> is the operator in question.
| Operation
| Numeric Version
| String Version
| Returns
|
| less than
| <
| lt
| 1 iff. $left is less than $right
|
| less than or equal to
| <=
| le
| 1 iff. $left is less than or equal to $right
|
| greater than
| >
| gt
| 1 iff. $left is greater than $right
|
| greater than or equal to
| >=
| ge
| 1 iff. $left is greater than or equal to
$right
|
| equal to
| ==
| eq
| 1 iff. $left is the same as $right
|
| not equal to
| !=
| ne
| 1 iff. $left is not the same as $right
|
| compare
| <=>
| cmp
| -1 iff. $left is less than $right, 0 iff.
$left is equal to $right 1 iff.
$left is greater than $right
|
Here are a few examples using these operators. use strict;
my $a = 5; my $b = 500;
$a < $b; # evaluates to 1
$a >= $b; # evaluates to ""
$a <=> $b; # evaluates to -1
my $c = "hello"; my $d = "there";
$d cmp $c; # evaluates to 1
$d ge $c; # evaluates to 1
$c cmp "hello"; # evaluates to ""
Node:Auto-Increment and Decrement,
Next:String Operators, Previous:Comparison Operators, Up:Operators
Auto-Increment and Decrement
The auto-increment and auto-decrement operators in Perl work almost
identically to the corresponding operators in C, C++, or Java. Here are few
examples: use strict;
my $abc = 5;
my $efg = $abc-- + 5; # $abc is now 4, but $efg is 10
my $hij = ++$efg - --$abc; # $efg is 11, $abc is 3, $hij is 8
Node:String Operators, Previous:Auto-Increment and Decrement, Up:Operators
String Operators
The final set of operators that we will consider are those that operate
specifically on strings. Remember, though, that we can use numbers with them, as
Perl will do the conversions to strings when needed.
The string operators that you will see and use the most are .
and x. The . operator is string concatenation, and the
x operator is string duplication. use strict;
my $greet = "Hi! ";
my $longGreet = $greet x 3; # $longGreet is "Hi! Hi! Hi! "
my $hi = $longGreet . "Paul."; # $hi is "Hi! Hi! Hi! Paul."
Assignment with Operators
It should be duly noted that it is possible to concatenate, like in C, an
operator onto the assignment statement to abbreviate using the left hand side as
the first operand. For example, use strict;
my $greet = "Hi! ";
$greet .= "Everyone\n";
$greet = $greet . "Everyone\n"; # Does the same operation
# as the line above
This works for any simple, binary operator.
Node:Output of Scalar Data,
Next:Special Variables, Previous:Operators, Up:Working with Scalars
Output of Scalar Data
To output a scalar, you can use the print and
printf built-in functions. We have already seen examples of the
print command, and the printf command is very close to
that in C or C++. Here are a few examples: use strict;
my $str = "Howdy, ";
my $name = "Joe.\n";
print $str, $name; # Prints out: Howdy, Joe.<NEWLINE>
my $f = 3e-1;
printf "%2.3f\n", $f; # Prints out: 0.300<NEWLINE>
Node:Special Variables, Next:Summary of Scalar Operators, Previous:Output of Scalar Data, Up:Working with Scalars
Special Variables
It is worth noting here that there are some variables that are considered
"special" by Perl. These variables are usually either read-only variables that
Perl sets for you automatically based on what you are doing in the program, or
variables you can set to control the behavior of how Perl performs certain
operations.
Use of special variables can be problematic, and can often cause unwanted
side effects. It is a good idea to limit your use of these special variables
until you are completely comfortable with them and what they do. Of course, like
anything in Perl, you can get used to some special variables and not others, and
use only those with which you are comfortable.
Node:Summary of Scalar Operators,
Previous:Special Variables, Up:Working with Scalars
Summary of Scalar Operators
In this chapter, we have looked at a number of different scalar operators
available in the Perl language. Earlier, we gave a small chart of the operators,
ordered by their precedence. Now that we have seen all these operators, we
should consider a list of them again, ordered by precedence. Note that some
operators are listed as "nonassoc". This means that the given operator is not
associative. In other words, it simply does not make sense to consider
associative evaluation of the given operator.
| Operator
| Associativity
| Description
|
++, --
| nonassoc
| auto-increment and auto-decrement
|
**
| right
| exponentiation
|
*, /, %
| left
| multiplication, division, modulus
|
+, -, .
| left
| addition, subtraction, concatenation
|
<, >, <=,
>=, lt, gt, le,
ge
| nonassoc
| comparison operators
|
==, !=, <=>,
eq, ne, cmp
| nonassoc
| comparison operators
|
This list is actually still quite incomplete, as we will learn more operators
later on. However, you can always find a full list of all operators in Perl in
the perlop documentation page, which you can get to on most systems
with Perl installed by typing perldoc perlop.
Node:Arrays, Next:Control Structures, Previous:Working with Scalars, Up:Top
Arrays
Now that we have a good understanding of the way scalar data and variables
work and what can be done with them in Perl, we will look into the most basic of
Perl's natural data structures--arrays.
Node:The Semantics of Arrays,
Next:List Literals, Previous:Arrays, Up:Arrays
The Semantics of Arrays
The arrays in Perl are semantically closest to lists in Lisp or Scheme (sans
cons cells), however the syntax that is used to access arrays is closer to
arrays in C. In fact, one can often treat Perl's arrays as if they were simply C
arrays, but they are actually much more powerful than that.
Perl arrays grow and shrink dynamically as needed. The more data you put into
a Perl list, the bigger it gets. As you remove elements from the list, the list
will shrink to the right size. Note that this is inherently different from
arrays in the C language, where the programmer must keep track and control the
size of the array.
However, Perl arrays are accessible just like C arrays. So, you can subscript
to anywhere within a given list at will. There is no need to process through the
first four elements of the list to get the fifth element (as in Scheme). In this
manner, you get the advantages of both a dynamic list, and a static-size array.
The only penalty that you pay for this flexibility is that when an array is
growing very large very quickly, it can be a bit inefficient. However, when this
must occur, Perl allows you to pre-build an array of certain size. We will show
how to do this a bit later.
A Perl array is always a list of scalars. Of course, since Perl makes no
direct distinction between numeric and string values, you can easily mix
different types of scalars within the same array. However, everything in the
array must be a scalar8.
Note the difference in terminology that is used here. Arrays refer to
variables that store a list of scalar values. Lists can be written as
literals (see List
Literals) and used in a variety of ways. One of the ways that list literals
can be used is to assign to array variables (see Array
Variables). We will discuss both list literals and array variables in this
chapter.
Node:List Literals, Next:Array Variables, Previous:The Semantics of Arrays, Up:Arrays
List Literals
Like scalars, it is possible to write lists as literals right in your code.
Of course, as with inserting string literals in your code, you must use proper
quoting.
There are two primary ways to quote list literals that we will discuss here.
One is using (), and the other is using what is called a quoting
operator. The quoting operator for lists is qw. A quoting operator
is always followed by a single character, which is the "stop character". It will
eat up all the following input until the next "stop character". In the case of
qw, it will use each token that it finds as an element in a list
until the second "stop character" is reached. The advantage of the
qw operator is that you do not need to quote strings in any
additional way, since qw is already doing the quoting for you.
Here are a few examples of some list literals, using both () and
the qw operator. (); # this list has no elements; the empty list
qw//; # another empty list
("a", "b", "c",
1, 2, 3); # a list with six elements
qw/hello world
how are you today/; # another list with six elements
Note that when we use the (), we have to quote all strings, and
we need to separate everything by commas. The qw operator does not
require this.
Finally, if you have any two scalar values where all the values between them
can be enumerated, you can use an operator called the .. operator
to build a list. This is most easily seen in an example: (1 .. 100); # a list of 100 elements: the numbers from 1 to 100
('A' .. 'Z'); # a list of 26 elements: the uppercase letters From A to Z
('01' .. '31'); # a list of 31 elements: all possible days of a month
# with leading zeros on the single digit days
You will find the .. operator particularly useful with slices,
which we will talk about later in this chapter.
Node:Array Variables, Next:Manipulating Arrays and Lists, Previous:List Literals, Up:Arrays
Array Variables
As with scalars, what good are literals if you cannot have variables? So,
Perl provides a way to make array variables.
Node:Using Array Variables,
Next:Associated Scalars, Previous:Array Variables, Up:Array Variables
Array Variables
Each variable in Perl starts with a special character that identifies what
type of variable it is. We saw that scalar variables always start with a
$. Similarly, all array variables start with the character,
@, under the same naming rules that are used for scalar variables.
Of course, we cannot do much with a variable if we cannot assign things to
it, so the assignment operator works as perfectly with arrays as it did with
scalars. We must be sure, though, to always make the right hand side of the
assignment a list, not a scalar! Here are a few examples: use strict;
my @stuff = qw/a b c/; # @stuff a three element list
my @things = (1, 2, 3, 4); # @things is a four element list
my $oneThing = "all alone";
my @allOfIt = (@stuff, $oneThing,
@things); # @allOfIt has 8 elements!
Note the cute thing we can do with the () when assigning
@allOfIt. When using (), Perl allows us to insert
other variables in the list. These variables can be either scalar or array
variables! So, you can quickly build up a new list by "concatenating" other
lists and scalar variables together. Then, that new list can be assigned to a
new array, or used in any other way that list literals can be used.
Node:Associated Scalars, Previous:Using Array Variables, Up:Array Variables
Associated Scalars
Every time an array variable is declared, a special set of scalar variables
automatically springs into existence, and those scalars change along with
changes in the array with which they are associated.
First of all, for an array, @array, of n elements. There are
scalar variables $array[0], $array[1],
..., $array[n-1] that contain first, second, third,
..., nth elements in the array, respectively. The variables in
this format are full-fledged scalar variables. This means that anything you can
do with a scalar variable, you can do with these elements. This provides a way
to access array elements by subscript. In addition, it provides a way to change,
modify and update individual elements without actually using the
@array variable.
Another scalar variable that is associated to any array variable,
@array, is $#array. This variable always contains the
subscript of the last element in the array. In other words,
$array[$#array] is always the last element of the array. The length
of the array is always $#array + 1. Again, you are permitted to do
anything with this variable that you can normally do with any other scalar
variable; however, you must always make sure to leave the value as an integer
greater than or equal to -1. In fact, if you know an array is going to grow very
large quickly, you probably want to set this variable to a very high value. When
you change the value of $#array, you not only resize the array for
your use, you also direct Perl to allocate a specific amount of space for
@array.
Here are a few examples that use the associated scalar variables for an
array: use strict;
my @someStuff = qw/Hello and
welcome/; # @someStuff: an array of 3 elements
$#someStuff = 0; # @someStuff now is simply ("Hello")
$someStuff[1] = "Joe"; # Now @someStuff is ("Hello", "Joe")
$#someStuff = -1; # @someStuff is now empty
@someStuff = (); # does same thing as previous line
Node:Manipulating Arrays and
Lists, Previous:Array Variables, Up:Arrays
Manipulating Arrays and Lists
Clearly, arrays and lists are very useful. However, there are a few more
things in Perl you can use to make arrays and lists even more useful.
Node:It Slices!, Next:Functions, Previous:Manipulating Arrays and Lists, Up:Manipulating Arrays and Lists
It Slices!
Sometimes, you may want to create a new array based on some subset of
elements from another array. To do this, you use a slice. Slices use a subscript
that is itself a list of integers to grab a list of elements from an array. This
looks easier in Perl than it does in English: use strict;
my @stuff = qw/everybody wants a rock/;
my @rock = @stuff[1 .. $#stuff]; # @rock is qw/wants a rock/
my @want = @stuff[ 0 .. 1]; # @want is qw/everybody wants/
@rock = @stuff[0, $#stuff]; # @rock is qw/everybody rock/
As you can see, you can use both the .. operator and commas to
build a list for use as a slice subscript. This can be a very useful feature for
array manipulation.
Node:Functions, Next:The Context (List vs. Scalar), Previous:It Slices!, Up:Manipulating Arrays and Lists
Functions
Perl also provides quite a few functions that operate on arrays. As you learn
more and more Perl, you will see lots of interesting functions that work with
arrays.
Now, we'll discuss a few of these functions that work on arrays:
push, pop, shift, and
unshift.
The names shift and unshift are an artifact of the
Unix shells that used them to "shift around" incoming arguments.
Node:Arrays as Stacks, Next:Arrays as Queues, Previous:Functions, Up:Functions
Arrays as Stacks
What more is a stack than an unbounded array of things? This attitude is seen
in Perl through the push and pop functions. These
functions treat the "right hand side" (i.e., the end) of the array as the top of
the stack. Here is an example: use strict;
my @stack;
push(@stack, 7, 6, "go"); # @stack is now qw/7 6 go/
my $action = pop @stack; # $action is "go", @stack is (7, 6)
my $value = pop(@stack) +
pop(@stack); # value is 6 + 7 = 13, @stack is empty
Node:Arrays as Queues, Previous:Arrays as Stacks, Up:Functions
Arrays as Queues
If we can do stacks, then why not queues? You can build a queue in Perl by
using the unshift and pop functions together.9 Think of the unshift function as
"enqueue" and the pop function as "dequeue".
Here is an example: use strict;
my @queue;
unshift (@queue, "Customer 1"); # @queue is now ("Customer 1")
unshift (@queue, "Customer 2"); # @queue is now ("Customer 2" "Customer 1")
unshift (@queue, "Customer 3");
# @queue is now ("Customer 3" "Customer 2" "Customer 1")
my $item = pop(@queue); # @queue is now ("Customer 3" "Customer 2")
print "Servicing $item\n"; # prints: Servicing Customer 1\n
$item = pop(@queue); # @queue is now ("Customer 3")
print "Servicing $item\n"; # prints: Servicing Customer 2\n
This queue example works because unshift places items onto the
front of the array, and pop takes items from the end of the array.
However, be careful using more than two arguments on the unshift
when you want to process an array as a queue. Recall that unshift
places its arguments onto the array in order as they are listed in the
function call. Consider this example: use strict;
my @notAqueue;
unshift(@notAqueue, "Customer 0", "Customer 1");
# @queue is now ("Customer 0", "Customer 1")
unshift (@notAqueue, "Customer 2");
# @queue is now ("Customer 2", "Customer 0", "Customer 1")
Notice that this variable, @notAqueue, is not really a queue, if
we use pop to remove items. The moral here is to be careful when
using unshift in this manner, since it places it arguments on the
array in order.
Node:The Context (List vs.
Scalar), Next:Array Interpolation, Previous:Functions, Up:Manipulating Arrays and Lists
The Context--List vs. Scalar
It may have occurred to you by now that in certain places we can use a list,
and in other places we can use a scalar. Perl knows this as well, and decides
which is permitted by something called a context.
The context can be either list context or scalar context. Many operations do
different things depending on what the current context is.
For example, it is actually valid to use an array variable, such as
@array, in a scalar context. When you do this, the array variable
evaluates to the number of elements in the array. Consider this example: use strict;
my @things = qw/a few of my favorite/;
my $count = @things; # $count is 5
my @moreThings = @things; # @moreThings is same as @things
Note that Perl knows not to try and stuff @things into a scalar,
which does not make any sense. It evaluates @things in a scalar
context and given the number of elements in the array.
You must always be aware of the context of your operations. Assuming the
wrong context can cause a plethora of problems for the new Perl programmer.
Node:Array Interpolation,
Previous:The Context (List vs. Scalar), Up:Manipulating Arrays and Lists
Array Interpolation
Array variables can also be evaluated through interpolation into a
double-quoted string. This works very much like the interpolation of scalars
into double-quoted strings (see Scalar
Interpolation). When an array variable is encountered in a double-quoted
string, Perl will join the array together, separating each element by spaces.
Here is an example: use strict;
my @saying = qw/these are a few of my favorite/;
my $statement = "@saying things.\n";
# $statement is "these are a few of my favorite things.\n"
my $stuff = "@saying[0 .. 1] @saying[$#saying - 1, $#saying] things.\n"
# $stuff is "these are my favorite things.\n"
Note the use of slices when assigning $stuff. As you can see,
Perl can be very expressive when we begin to use the interaction of different,
interesting features.
Node:Control Structures, Next:Associative Arrays (Hashes), Previous:Arrays, Up:Top
Control Structures
The center of any imperative programming language is control structures.
Although Perl is not purely an imperative programming language, it has ancestors
that are very much imperative in nature, and thus Perl has inherited those same
control structures. It also has added a few of its own.
As you begin to learn about Perl's control structures, realize that a good
number of them are syntactic sugar. You can survive using only a subset of all
the control structures that are available in Perl. You should use those with
which you are comfortable. Obey the "hubris" of Perl, and write code that is
readable. But, beyond that, do not use any control structures that you do not
think you need.
Node:Blocks, Next:A Digression---Truth Values, Previous:Control Structures, Up:Control Structures
Blocks
The first tool that you need to begin to use control structures is the
ability to write code "blocks". A block of code could be any of the code
examples that we have seen thus far. The only difference is, to make them a
block, we would surround them with {}. use strict;
{
my $var;
Statement;
Statement;
Statement;
}
Anything that looks like that is a block. Blocks are very simple, and are
much like code blocks in languages like C, C++, and Java. However, in Perl, code
blocks are decoupled from any particular control structure. The above code
example is a valid piece of Perl code that can appear just about anywhere in a
Perl program. Of course, it is only particularly useful for those functions and
structures that use blocks.
Note that any variable declared in the block (in the example,
$var) lives only until the end of that block. With variables
declared my, normal lexical scoping that you are familiar with in
C, C++, or Java applies.
Node:A Digression---Truth Values,
Next:The if/unless Structures, Previous:Blocks, Up:Control Structures
A Digression--Truth Values
We have mentioned truth and "true and false" a few times now; however, we
have yet to give a clear definition of what truth values are in Perl.
Every expression in Perl has a truth value. Usually, we ignore the truth
value of the expressions we use. In fact, we have been ignoring them so far!
However, now that we are going to begin studying various control structures that
rely on the truth value of a given expression, we should look at true and false
values in Perl a bit more closely.
The basic rule that most Perl programmers remember is that 0,
the empty string and undef are false, and everything else is true.
However, it turns out that this rule is not actually completely accurate.
The actual rule is as follows:
Everything in Perl is true, except:
- the strings
"" (the empty string) and "0" (the
string containing only the character, 0), or any string expression that
evaluates to either "" (the empty string) or "0".
- any numeric expression that evaluates to a numeric
0.
- any value that is not defined (i.e., equivalent to
undef).
If that rule is not completely clear, the following table gives some example
Perl expressions and states whether they are true or not:
| Expression
| String/Number?
| Boolean value
|
| 0
| number
| false
|
| 0.0
| number
| false
|
| 0.0000
| number
| false
|
| ""
| string
| false
|
| "0"
| string
| false
|
| "0.0"
| string
| true
|
| undef
| N/A
| false
|
| 42 - (6 * 7)
| number
| false
|
| "0.0" + 0.0
| number
| false
|
| "foo"
| string
| true
|
There are two expressions above that easily confuse new Perl programmers.
First of all, the expression "0.0" is true. This is true because it
is a string that is not "0". The only string that is not empty that
can be false is "0". Thus, "0.0" must be true.
Next, consider "0.0" + 0.0. After what was just stated, one
might assume that this expression is true. However, this expression is
false. It is false because + is a numeric
operator, and as such, "0.0" must be turned into its numeric
equivalent. Since the numeric equivalent to "0.0" is
0.0, we get the expression 0.0 + 0.0, which evaluates
to 0.0, which is the same as 0, which is false.
Finally, it should be noted that all references are true. The topic of Perl
references is beyond the scope of this book. However, if we did not mention it,
we would not be giving you the whole truth story.
Node:The if/unless Structures,
Next:The while/until Structures, Previous:A Digression---Truth Values, Up:Control Structures
The if/unless Structures
The if and unless structures are the simplest
control structures. You are no doubt comfortable with if statements
from C, C++, or Java. Perl's if statements work very much the same.
use strict;
if (expression) {
Expression_True_Statement;
Expression_True_Statement;
Expression_True_Statement;
} elsif (another_expression) {
Expression_Elseif_Statement;
Expression_Elseif_Statement;
Expression_Elseif_Statement;
} else {
Else_Statement;
Else_Statement;
Else_Statement;
}
There are a few things to note here. The elsif and the
else statements are both optional when using an if. It
should also be noted that after each if (expression) or elsif
(expression), a code block is required. These means that the
{}'s are mandatory in all cases, even if you have only one
statement inside.
The unless statement works just like an if
statement. However, you replace if with unless, and
the code block is executed only if the expression is false rather
than true.
Thus unless (expression) { } is functionally equivalent to
if (! expression) { }.
Node:The while/until Structures,
Next:The do while/until Structures, Previous:The if/unless Structures, Up:Control Structures
The while/until Structures
The while structure is equivalent to the while
structures in Java, C, or C++. The code executes while the expression remains
true. use strict;
while (expression) {
While_Statement;
While_Statement;
While_Statement;
}
The until (expression) structure is functionally equivalent
while (! expression).
Node:The do while/until
Structures, Next:The for Structure, Previous:The while/until Structures, Up:Control Structures
The do while/until Structures
The do/while structure works similar to the while
structure, except that the code is executed at least once before the condition
is checked. use strict;
do {
DoWhile_Statement;
DoWhile_Statement;
DoWhile_Statement;
} while (expression);
Again, using until (expression) is the same as using while
(! expression).
Node:The for Structure, Next:The foreach Structure, Previous:The do while/until Structures, Up:Control Structures
The for Structure
The for structure works similarly to the for
structure found in C, C++ or Java. It is really syntactic sugar for the
while statement.
Thus: use strict;
for(Initial_Statement; expression; Increment_Statement) {
For_Statement;
For_Statement;
For_Statement;
}
is equivalent to: use strict;
Initial_Statement;
while (expression) {
For_Statement;
For_Statement;
For_Statement;
Increment_Statement;
}
Node:The foreach Structure,
Previous:The for Structure, Up:Control Structures
The foreach Structure
The foreach control structure is the most interesting in this
chapter. It is specifically designed for processing of Perl's native data types.
The foreach structure takes a scalar, a list and a block, and
executes the block of code, setting the scalar to each value in the list, one at
a time. Consider an example: use strict;
my @collection = qw/hat shoes shirts shorts/;
foreach my $item (@collection) {
print "$item\n";
}
This will print out each item in collection on a line by itself. Note that
you are permitted to declare the scalar variable right with the
foreach. When you do this, the variable lives only as long as the
foreach does.
You will find foreach to be one of the most useful looping
structures in Perl. Any time you need to do something to each element in the
list, chances are, using a foreach is the best choice.
Node:Associative Arrays (Hashes),
Next:Regular Expressions, Previous:Control Structures, Up:Top
Associative Arrays (Hashes)
This chapter will introduce the third major Perl abstract data type,
associative arrays. Also known as hashes, associative arrays provide native
language support for one of the most useful data structures that programmers
implement--the hash table.
Node:What Is It?, Next:Hash Variables, Previous:Associative Arrays (Hashes), Up:Associative Arrays (Hashes)
What Is It?
Associative arrays, also frequently called hashes, are the third
major data type in Perl after scalars and arrays. Hashes are named as such
because they work very similarly to a common data structure that programmers use
in other languages--hash tables. However, hashes in Perl are actually a direct
language supported data type.
Node:Hash Variables, Next:Hash Literals, Previous:What Is It?, Up:Associative Arrays (Hashes)
Variables
We have seen that each of the different native data types in Perl has a
special character that identify that the variable is of that type. Hashes always
start with a %.
Accessing a hash works very similar to accessing arrays. However, hashes are
not subscripted by numbers. They can be subscripted by an arbitrary scalar
value. You simply use the {} to subscript the value instead of
[] as you did with arrays. Here is an example: use strict;
my %table;
$table{'schmoe'} = 'joe';
$table{7.5} = 2.6;
In this example, our hash, called, %table, has two entries. The
key 'schmoe' is associated with the value 'joe', and
the key 7.5 is associated with the value 2.6.
Just like with array elements, hash elements can be used anywhere a scalar
variable is permitted. Thus, given a %table built with the code above, we
can do the following: print "$table{'schmoe'}\n"; # outputs "joe\n"
--$table{7.5}; # $table{7.5} now contains 1.6
Another interesting fact is that all hash variables can be evaluated in the
list context. When done, this gives a list whose odd elements are the keys of
the hash, and whose even elements are the corresponding values. Thus, assuming
we have the same %table from above, we can execute: my @tableListed = %table; # @tableListed is qw/schmoe joe 7.5 1.6/
If you happen to evaluate a hash in scalar context, it will give you
undef if no entries have yet been defined, and will evaluate to
true otherwise. However, evaluation of hashes in scalar context is not
recommended. To test if a hash is defined, use defined(%hash).
Node:Hash Literals, Next:Hash Functions, Previous:Hash Variables, Up:Associative Arrays (Hashes)
Literals
"Hash literals" per se do not exist. However, remember that when we evaluate
a hash in the list context, we get the pairs of the hash unfolded into the list.
We can exploit this to do hash literals. We simply write out the list pairs that
we want placed into the hash. For example: use strict;
my %table = qw/schmoe joe 7.5 1.6/;
would give us the same hash we had in the previous example.
Node:Hash Functions, Next:Slices, Previous:Hash Literals, Up:Associative Arrays (Hashes)
Functions
You should realize that any function you already know that works on arrays
will also work on hashes, since you can always evaluate a hash in the list
context and get the pair list. However, there are a variety of functions that
are specifically designed and optimized for use with hashes.
Node:Keys and Values, Next:Each, Previous:Hash Functions, Up:Hash Functions
Keys and Values
When we evaluate a hash in a list context, Perl gives us the paired list that
can be very useful. However, sometimes we may only want to look at the list of
keys, or the list of values. Perl provides two optimized functions for doing
this: keys and values. use strict;
my %table = qw/schmoe joe smith john simpson bart/;
my @lastNames = keys %table; # @lastNames is: qw/schmoe smith simpson/
my @firstNames = values %table; # @firstNames is: qw/joe john bart/
Node:Each, Previous:Keys and Values, Up:Hash Functions
Each
The each function is one that you will find particularly useful
when you need to go through each element in the hash. The each
function returns each key-value pair from the hash one by one as a list of two
elements. You can use this function to run a while across the hash:
use strict;
my %table = qw/schmoe joe smith john simpson bart/;
my($key, $value); # Declare two variables at once
while ( ($key, $value) = each(%table) ) {
# Do some processing on $key and $value
}
This while terminates because each returns
undef when all the pairs have been exhausted. However, be careful.
Any change in the hash made will "reset" the each function for that
hash.
So, if you need to loop and change values in the hash, use the following
foreach across the keys: use strict;
my %table = qw/schmoe joe smith john simpson bart/;
foreach my $key (keys %table) {
# Do some processing on $key and $table{$key}
}
Node:Slices, Next:Context Considerations, Previous:Hash Functions, Up:Associative Arrays (Hashes)
Slices
It turns out you can slice hashes just like you were able to slice arrays.
This can be useful if you need to extract a certain set of values out of a hash
into a list. use strict;
my %table = qw/schmoe joe smith john simpson bart/;
my @friends = @table{'schmoe', 'smith'}; # @friends has qw/joe john/
Note the use of the @ in front of the hash name. This shows that
we are indeed producing a normal list, and you can use this construct in any
list context you would like.
Node:Context Considerations,
Previous:Slices, Up:Associative Arrays (Hashes)
Context Considerations
We have now discussed all the different ways you can use variables in list
and scalar context. At this point, it might be helpful to review all the ways we
have used variables in different contexts. The table that follows identifies
many of the ways variables are used in Perl.
| Expression
| Context
| Variable
| Evaluates to
|
$scalar
| scalar
| $scalar, a scalar
| the value held in $scalar
|
@array
| list
| @array, an array
| the list of values (in order) held in @array
|
@array
| scalar
| @array, an array
| the total number of elements in @array (same as
$#array + 1)
|
$array[$x]
| scalar
| @array, an array
| the ($x+1)th element of @array
|
$#array
| scalar
| @array, an array
| the subscript of the last element in @array (same as
@array -1)
|
@array[$x, $y]
| list
| @array, an array
| a slice, listing two elements from @array (same as
($array[$x], $array[$y]))
|
"$scalar"
| scalar (interpolated)
| $scalar, a scalar
| a string containing the contents of $scalar
|
"@array"
| scalar (interpolated)
| @array, an array
| a string containing the elements of @array, separated by
spaces
|
%hash
| list
| %hash, a hash
| a list of alternating keys and values from %hash
|
$hash{$x}
| scalar
| %hash, a hash
| the element from %hash with the key of $x
|
@hash{$x, $y}
| list
| %hash, a hash
| a slice, listing two elements from %hash (same as
($hash{$x}, $hash{$y})
|
Node:Regular Expressions, Next:Subroutines, Previous:Associative Arrays (Hashes), Up:Top
Regular Expressions
One of Perl's original applications was text processing (see A
Brief History of Perl). So far, we have seen easy manipulation of scalar and
list data is in Perl, but we have yet to explore the core of Perl's text
processing construct--regular expressions. To remedy that, this chapter is
devoted completely to regular expressions.
Node:The Theory Behind It All,
Next:The Simple, Previous:Regular Expressions, Up:Regular Expressions
The Theory Behind It All
Regular expressions are a concept borrowed from automata theory. Regular
expressions provide a a way to describe a "language" of strings.
The term, language, when used in the sense borrowed from automata
theory, can be a bit confusing. A language in automata theory is
simply some (possibly infinite) set of strings. Each string (which can be
possibly empty) is composed of a set of characters from a fixed, finite set. In
our case, this set will be all the possible ASCII characters10.
When we write a regular expression, we are writing a description of some set
of possible strings. For the regular expression to have meaning, this set of
possible strings that we are defining should have some meaning to us.
Regular expressions give us extreme power to do pattern matching on text
documents. We can use the regular expression syntax to write a succinct
description of the entire, infinite class of strings that fit our specification.
In addition, anyone else who understands the description language of regular
expressions, can easily read out description and determine what set of strings
we want to match. Regular expressions are a universal description for matching
regular strings.
When we discuss regular expressions, we discuss "matching". If a regular
expression "matches" a given string, then that string is in the class we
described with the regular expression. If it does not match, then the string is
not in the desired class.
Node:The Simple, Next:Pattern Matching, Previous:The Theory Behind It All, Up:Regular Expressions
The Simple
We can start our discussion of regular expression by considering the simplest
of operators that can actually be used to create all possible regular
expressions 11. All the other regular expression operators can
actually be reduced into a set of these simple operators.
Node:Simple Characters, Next:The * Special Character, Previous:The Simple, Up:The Simple
Simple Characters
In regular expressions, generally, a character matches itself. The only
exceptions are regular expression special characters. To match one of these
special characters, you must put a \ before the character.
For example, the regular expression abc matches a set of strings
that contain abc somewhere in them. Since * happens to
be a regular expression special character, the regular expression
\* matches any string that contains the * character.
Node:The * Special Character,
Next:The . Character, Previous:Simple Characters, Up:The Simple
The * Special Character
As we mentioned * is a regular expression special character. The
* is used to indicate that zero or more of the previous characters
should be matched. Thus, the regular expression a* will match any
string that contains zero or more a's.
Note that since a* will match any string with zero or more
a's, a* will match all strings, since all
strings (including the empty string) contain at least zero a's. So,
a* is not a very useful regular expression.
A more useful regular expression might be baa*. This regular
expression will match any string that has a b, followed by one or
more a's. Thus, the set of strings we are matching are those that
contain ba, baa, baaa, etc. In other
words, we are looking to see if there is any "sheep speech" hidden in our text.
Node:The . Character, Next:The | Character, Previous:The * Special Character, Up:The Simple
The . Character
The next special character we will consider is the . character.
The . will match any valid character. As an example, consider the
regular expression a.c. This regular expression will match any
string that contains an a and a c, with any possible
character in between. Thus, strings that contain abc,
acc, amc, etc. are all in the class of strings that
this regular expression matches.
Node:The | Character, Next:Grouping with ()s, Previous:The . Character, Up:The Simple
The | Character
The | special character is equivalent to an "or" in regular
expressions. This character is used to give a choice. So, the regular expression
abc|def will match any string that contains either abc
or def.
Node:Grouping with ()s, Next:The Anchor Characters, Previous:The | Character, Up:The Simple
Grouping with ()s
Sometimes, within regular expressions, we want to group things together.
Doing this allows building of larger regular expressions based on smaller
components. The ()'s are used for grouping.
For example, if we want to match any string that contains abc or
def, zero or more times, surrounded by a xx on either
side, we could write the regular expression xx(abc|def)*xx. This
applies the * character to everything that is in the parentheses.
Thus we can match any strings such as xxabcxx,
xxabcdefxx, etc.
Node:The Anchor Characters,
Previous:Grouping with ()s, Up:The Simple
The Anchor Characters
Sometimes, we want to apply the regular expression from a defined point. In
other words, we want to anchor the regular expression so it is not permitted to
match anywhere in the string, just from a certain point.
The anchor operators allow us to do this. When we start a regular expression
with a ^, it anchors the regular expression to the beginning of the
string. This means that whatever the regular expression starts with must
be matched at the beginning of the string. For example, ^aa*
will not match strings that contain one or more a's; rather it
matches strings that start with one or more a's.
We can also use the $ at the end of the string to anchor the
regular expression at the end of the string. If we applied this to our last
regular expression, we have ^aa*$ which now matches only
those strings that consist of one or more a's. This makes it clear
that the regular expression cannot just look anywhere in the string, rather the
regular expression must be able to match the entire string exactly, or it will
not match at all.
In most cases, you will want to either anchor a regular expression to the
start of the string, the end of the string, or both. Using a regular expression
without some sort of anchor can also produce confusing and strange results.
However, it is occasionally useful.
Node:Pattern Matching, Next:Regular Expression Shortcuts, Previous:The Simple, Up:Regular Expressions
Pattern Matching
Now that you are familiar with some of the basics of regular expressions, you
probably want to know how to use them in Perl. Doing so is very easy. There is
an operator, =~, that you can use to match a regular expression
against scalar variables. Regular expressions in Perl are placed between two
forward slashes (i.e., //). The whole $scalar =~ //
expression will evaluate to 1 if a match occurs, and
undef if it does not.
Consider the following code sample: use strict;
while ( defined($currentLine = <STDIN>) ) {
if ($currentLine =~ /^(J|R)MS speaks:/) {
print $currentLine;
}
}
This code will go through each line of the input, and print only those lines
that start with "JMS speaks:" or "RMS speaks:".
Node:Regular Expression Shortcuts,
Previous:Pattern Matching, Up:Regular Expressions
Regular Expression Shortcuts
Writing out regular expressions can be problematic. For example, if we want
to have a regular expression that matches all digits, we have to write: (0|1|2|3|4|5|6|7|8|9)
It would be terribly annoying to have to write such things out. So, Perl
gives an incredible number of shortcuts for writing regular expressions. These
are largely syntactic sugar, since we could write out regular expressions in the
same way we did above. However, that is too cumbersome.
For example, for ranges of values, we can use the brackets,
[]'s. So, for our digit expression above, we can write
[0-9]. In fact, it is even easier in perl, because \d
will match that very same thing.
There are lots of these kinds of shortcuts. They are listed in the
perlre online manual. They are listed in many places, so there is
no need to list them again here.
However, as you learn about all the regular expression shortcuts, remember
that they can all be reduced to the original operators we discussed above. They
are simply short ways of saying things that can be built with regular
characters, *, (), and |.
Node:Subroutines, Next:Background of Perl, Previous:Regular Expressions, Up:Top
Subroutines
Until now, all the Perl programs that we have written have simply a set of
instructions, line by line. Like any good language, Perl allows one to write
modular code. To do this, at the very least, the language must allow the
programmer to set aside subroutines of code that can be reused. Perl, of course,
provides this feature.
Note that many people call Perl subroutines "functions". We prefer to use the
term "functions" for those routines that are built in to Perl, and "subroutines"
for code written by the Perl programmer. This is not standard terminology, so
you may hear others use subroutines and functions interchangeably, but that will
not be the case in this book. We feel that it is easier to make the distinction
if we have two different terms for functions and subroutines.
Note that user subroutines can be used anywhere it is valid to use a native
Perl function.
Node:Defining Subroutines, Next:Returning Values, Previous:Subroutines, Up:Subroutines
Defining Subroutines
Defining a subroutine is quite easy. You use the keyword sub,
followed by the name of your subroutine, followed by a code block. This friendly
subroutine can be used to greet the user: use strict;
sub HowdyEveryone {
print "Hello everyone.\nWhere do you want to go with Perl today?\n";
}
Now, anywhere in the code where we want to greet the user, we can simply say:
&HowdyEveryone;
and it will print that message to the user. In fact, in most cases, the
& for invoking subroutines is optional.
Node:Returning Values, Next:Using Arguments, Previous:Defining Subroutines, Up:Subroutines
Returning Values
Perhaps we did not want our new subroutine to actually print the message.
Instead, we would like it to return the string of the message, and then we will
call print on it.
This is very easy to do with the return statement. use strict;
sub HowdyEveryone {
return "Hello everyone.\nWhere do you want to go with Perl today?\n";
}
print &HowdyEveryone;
Node:Using Arguments, Previous:Returning Values, Up:Subroutines
Using Arguments
A subroutine is not much good if you cannot give it input on which to
operate. Of course, Perl allows you to pass arguments to subroutines just like
you would to native Perl functions.
At the start of each subroutine, Perl sets a special array variable,
@_, to be the list of arguments sent into the subroutine. By
standard convention, you can access these variables through $_[0 ..
$#_]. However, it is a good idea to instead immediately declare a list of
variables and assign @_ to them. For example, if we want to greet a
particular group of people, we could do the following: use strict;
sub HowdyEveryone {
my($name1, $name2) = @_;
return "Hello $name1 and $name2.\n" .
"Where do you want to go with Perl today?\n";
}
print &HowdyEveryone("bart", "lisa");
Note that since we used my, and we are in a new block, the
variables we declared will live only as long as the subroutine execution.
This subroutine leaves a bit to be desired. It would be nice if we could have
a custom greeting, instead of just "Hello". In addition, we would like to greet
as many people as we want to, not just two. This version fixes those two
problems: use strict;
sub HowdyEveryone {
my($greeting, @names) = @_;
my $returnString;
foreach my $name (@names) {
$returnString .= "$greeting, $name!\n";
}
return $returnString .
"Where do you want to go with Perl today?\n";
}
print &HowdyEveryone("Howdy", "bart", "lisa", "homer", "marge", "maggie");
We use two interesting techniques in this example. First of all, we use a
list as the last parameter when we accept the arguments. This means that
everything after the first argument will be put into @names. Note
that had any other variables followed @names, they would have
remained undefined. However, scalars before the array (like
$greeting) do receive values out of @_. Thus, it is
always a good idea to only make the array the last argument.
Node:Background of Perl, Next:GNU Free Documentation License, Previous:Subroutines, Up:Top
Background of Perl
In this appendix, we introduce a brief historical, sociological and
psychological reasons for why Perl works the way it does. We also include a
brief history of Perl.
When learning a new language, it is often helpful to learn the history,
motivations, and origins of that language. In natural languages such as English,
this helps us understand the culture and heritage of the language. Such
understanding leads to insight into the minds of those who speak the language.
This newly found insight, obtained through learning culture and heritage,
assists us in learning the new language.
This philosophy of language instruction can often be applied to programming
languages as well. Although programming languages grow from a logical or
mathematical basis, they are rarely purely mathematical. Often, the people who
design, implement and use the language influence the language, based on their
own backgrounds. Because of the influence the community has upon programming
languages, it is useful, before learning a programming language, to understand
its history, motivations, and culture. To that end, this chapter examines the
history, culture, and heritage of the Perl language.
Node:A Brief History of Perl,
Next:Perl as a Natural Language, Previous:Background of Perl, Up:Background of Perl
A Brief History of Perl
Larry Wall, the creator of Perl, first posted Perl to the
comp.sources Usenet newsgroup in late 1987. Larry had created Perl
as a text processing language for Unix-like operating systems. Before Perl,
almost all text processing on Unix-like systems was done with a conglomeration
of tools that included AWK, sed, the various shell programming
languages, and C programs. Larry wanted to fill the void between "manipulexity"
(the ability of languages like C to "get into the innards of things") and
"whipuptitude" (the property of programming languages like AWK or
sh that allows programmers to quickly write useful programs).
Thus, Perl, the Practical Extraction and Report Language 12, was born. Perl filled a niche that no other tool
before that date had. For this reason, users flocked to Perl.
Over the next four years or so, Perl began to evolve. By 1992, Perl version 4
had become very stable and was a "standard" Unix programming language. However,
Perl was beginning to show its limitations. Various aspects of the language were
confusing at best, and problematic at worst. Perl worked well for writing small
programs, but writing large software applications in Perl was unwieldy.
The designers of the Perl language, now a group, but still under Larry's
guidance, took a look around at the other languages that people were using. They
seemed to ask themselves: "Why are people choosing other languages over Perl?"
The outcome of this self-inspection was Perl, version 5.
The first release of version 5 came in late 1994. Many believed that version
5 made Perl "complete". Gone were the impediments and much of the confusion that
were prevalent in version 4. With version 5, Perl was truly a viable, general
purpose programming language and no longer just a convenient tool for system
administrators.
Node:Perl as a Natural Language,
Next:The Slogans, Previous:A Brief History of Perl, Up:Background of Perl
Perl as a Natural Language
Natural languages, languages (such as English) that people use on a daily
basis to communicate with each other, are rich and complete. Most natural
languages allow the speaker to express themselves succinctly and clearly.
However, most natural languages are also full of arcane constructs that carry
over from the language's past. In addition, for a given natural language, it is
impossible to fully master the vocabulary and grammar because they are very
large, extremely complex, and always changing.
You may wonder what these facts about natural languages have to do with a
programming language like Perl. Surprising to most newcomers to Perl, the
parallels between Perl and a natural language like English are striking. Larry
Wall, the father of Perl, has extensive scholastic training as a linguist. Larry
applied his linguistic knowledge to the creation of Perl, and thus, to the new
student of Perl, a digression into these language parallels will give the
student insight into the fundamentals of Perl.
Natural languages have the magnificent ability to provide a clear
communication system for people of all skill levels and backgrounds. The same
natural language can allow a linguistic neophyte (like a three-year-old child)
to communicate herself nearly completely to others, while having only a minimal
vocabulary. The same language also provides enough flexibility and clarity for
the greatest of philosophers to write their works.
Perl is very much the same. Small Perl programs are easy to write and can
perform many tasks easily. Even the newest student of Perl can write useful Perl
programs. However, Perl is a rich language with many features. This allows the
creation of simple programs that use a "limited" Perl vocabulary, and the
creation of large, complicated programs that seem to work magic.
When studying Perl, it is helpful to keep the "richness" of Perl in mind.
Newcomers find Perl frustrating because subtle changes in syntax can produce
deep changes in semantics. It can even be helpful to think of Perl as another
natural language rather than another programming language. Like in a natural
language, you should feel comfortable writing Perl programs that use only the
parts of Perl you know. However, you should be prepared to have a reference
manual in hand when you are reading code written by someone else.
The fact that one cannot read someone else's code without a manual handy and
the general "natural language" nature of Perl have been frequently criticized.
These arguments are well taken, and Perl's rich syntax and semantics can be
confusing to the newcomer. However, once the initial "information overload"
subsides, most programmers find Perl exciting and challenging. Discovering new
ways to get things done in Perl can be both fun and challenging! Hopefully, you
will find this to be the case as well.
Node:The Slogans, Previous:Perl as a Natural Language, Up:Background of Perl
The Slogans
Clearly, Perl is a unique language. This uniqueness has brought forth a
community and an ideology that is unprecedented with other languages. One does
not have to be a member of this community or agree with this ideology to use
Perl, but it helps to at least understand the ideology to get the most out of
Perl.
The common Perl slogans have become somewhat famous. These slogans make up
the "Perl ethic"--the concepts that guide the way Perl itself is built, and the
way most Perl programs are written.
"There's more than one way to do it". This slogan, often abbreviated
TMTOWTDI (pronounced TIM-toady), is common among many
programmers, but Perl takes this idea to its logical conclusion. Perl is rich
with non-orthogonality and shortcuts. Most major syntactic constructs in Perl
have two or three exact equivalents. This can be confusing to newcomers, but if
you try to embrace this diversity rather than be frustrated by it, having "more
than one way to do it" can be fun.
"The Swiss Army chain-saw". This is the somewhat "less friendly" summary of
the previous term. Sometimes, all these diverse, powerful features of Perl make
it appear that there are too many tools that are too powerful to be useful all
together on one "Swiss Army knife". However, eventually, most Perl users find
all these different "chain-saw"-style tools on one "Swiss Army" knife are a help
rather than a hindrance.
"Perl makes easy jobs easy, and the hard jobs possible." This is a newer
phrase in the Perl community, although it was originated by Alan Kay decades
ago, but it is quite valid. Most easy tasks are very straightforward in Perl. As
the saying goes, most programmers find that there are very few jobs that Perl
cannot handle well. However, despite what the saying might indicate, Perl is not
a panacea; the programmer should always choose the right tool for the job, and
that right tool may not always be Perl.
"Perl promotes laziness, impatience and hubris." These seem like strange
qualities to be promoting, but upon further analysis, it becomes clear why they
are important.
Lazy programmers do not like to write the same code more than once. Thus, a
lazy programmer is much more likely to write code to be reusable and as
applicable in as many situations as possible.
Laziness fits well with impatience. Impatient programmers do not like to do
things that they know very well the computer could do for them. Thus, impatient
programmers (who are also lazy) will write programs to do things that they do
not want to have to do themselves. This makes these programs more usable for
more tasks.
Finally, laziness and impatience are insufficient without hubris. If
programmers have hubris, they are much less likely to write unreadable code. A
good bit of hubris is useful--it makes programmers want to write code that they
can show off to friends. Thus, hubris, when practiced in the conjunction with
laziness and impatience, causes programmers to write reusable, complete and
readable code. In other words, it is possible to exploit these three "bad"
traits to obtain a "good" outcome.
Node:GNU Free Documentation
License, Next:General Index, Previous:Background of Perl, Up:Top
GNU Free Documentation License
Version 1.1, March 2000 Copyright 2000 Free Software Foundation, Inc.
59 Temple Place, Suite 330, Boston, MA 02111-1307, USA
Everyone is permitted to copy and distribute verbatim copies
of this license document, but changing it is not allowed.
- PREAMBLE
The purpose of this License is to make a manual, textbook, or other written
document free in the sense of freedom: to assure everyone the
effective freedom to copy and redistribute it, with or without modifying it,
either commercially or noncommercially. Secondarily, this License preserves
for the author and publisher a way to get credit for their work, while not
being considered responsible for modifications made by others.
This License is a kind of "copyleft", which means that derivative works of
the document must themselves be free in the same sense. It complements the GNU
General Public License, which is a copyleft license designed for free
software.
We have designed this License in order to use it for manuals for free
software, because free software needs free documentation: a free program
should come with manuals providing the same freedoms that the software does.
But this License is not limited to software manuals; it can be used for any
textual work, regardless of subject matter or whether it is published as a
printed book. We recommend this License principally for works whose purpose is
instruction or reference.
- APPLICABILITY AND DEFINITIONS
This License applies to any manual or other work that contains a notice
placed by the copyright holder saying it can be distributed under the terms of
this License. The "Document", below, refers to any such manual or work. Any
member of the public is a licensee, and is addressed as "you".
A "Modified Version" of the Document means any work containing the Document
or a portion of it, either copied verbatim, or with modifications and/or
translated into another language.
A "Secondary Section" is a named appendix or a front-matter section of the
Document that deals exclusively with the relationship of the publishers or
authors of the Document to the Document's overall subject (or to related
matters) and contains nothing that could fall directly within that overall
subject. (For example, if the Document is in part a textbook of mathematics, a
Secondary Section may not explain any mathematics.) The relationship could be
a matter of historical connection with the subject or with related matters, or
of legal, commercial, philosophical, ethical or political position regarding
them.
The "Invariant Sections" are certain Secondary Sections whose titles are
designated, as being those of Invariant Sections, in the notice that says that
the Document is released under this License.
The "Cover Texts" are certain short passages of text that are listed, as
Front-Cover Texts or Back-Cover Texts, in the notice that says that the
Document is released under this License.
A "Transparent" copy of the Document means a machine-readable copy,
represented in a format whose specification is available to the general
public, whose contents can be viewed and edited directly and straightforwardly
with generic text editors or (for images composed of pixels) generic paint
programs or (for drawings) some widely available drawing editor, and that is
suitable for input to text formatters or for automatic translation to a
variety of formats suitable for input to text formatters. A copy made in an
otherwise Transparent file format whose markup has been designed to thwart or
discourage subsequent modification by readers is not Transparent. A copy that
is not "Transparent" is called "Opaque".
Examples of suitable formats for Transparent copies include plain
ascii without markup, Texinfo input format, LaTeX input format,
SGML or XML using a publicly available
DTD, and standard-conforming simple HTML
designed for human modification. Opaque formats include PostScript,
PDF, proprietary formats that can be read and edited only by
proprietary word processors, SGML or XML for
which the DTD and/or processing tools are not generally
available, and the machine-generated HTML produced by some word
processors for output purposes only.
The "Title Page" means, for a printed book, the title page itself, plus
such following pages as are needed to hold, legibly, the material this License
requires to appear in the title page. For works in formats which do not have
any title page as such, "Title Page" means the text near the most prominent
appearance of the work's title, preceding the beginning of the body of the
text.
- VERBATIM COPYING
You may copy and distribute the Document in any medium, either commercially
or noncommercially, provided that this License, the copyright notices, and the
license notice saying this License applies to the Document are reproduced in
all copies, and that you add no other conditions whatsoever to those of this
License. You may not use technical measures to obstruct or control the reading
or further copying of the copies you make or distribute. However, you may
accept compensation in exchange for copies. If you distribute a large enough
number of copies you must also follow the conditions in section 3.
You may also lend copies, under the same conditions stated above, and you
may publicly display copies.
- COPYING IN QUANTITY
If you publish printed copies of the Document numbering more than 100, and
the Document's license notice requires Cover Texts, you must enclose the
copies in covers that carry, clearly and legibly, all these Cover Texts:
Front-Cover Texts on the front cover, and Back-Cover Texts on the back cover.
Both covers must also clearly and legibly identify you as the publisher of
these copies. The front cover must present the full title with all words of
the title equally prominent and visible. You may add other material on the
covers in addition. Copying with changes limited to the covers, as long as
they preserve the title of the Document and satisfy these conditions, can be
treated as verbatim copying in other respects.
If the required texts for either cover are too voluminous to fit legibly,
you should put the first ones listed (as many as fit reasonably) on the actual
cover, and continue the rest onto adjacent pages.
If you publish or distribute Opaque copies of the Document numbering more
than 100, you must either include a machine-readable Transparent copy along
with each Opaque copy, or state in or with each Opaque copy a
publicly-accessible computer-network location containing a complete
Transparent copy of the Document, free of added material, which the general
network-using public has access to download anonymously at no charge using
public-standard network protocols. If you use the latter option, you must take
reasonably prudent steps, when you begin distribution of Opaque copies in
quantity, to ensure that this Transparent copy will remain thus accessible at
the stated location until at least one year after the last time you distribute
an Opaque copy (directly or through your agents or retailers) of that edition
to the public.
It is requested, but not required, that you contact the authors of the
Document well before redistributing any large number of copies, to give them a
chance to provide you with an updated version of the Document.
- MODIFICATIONS
You may copy and distribute a Modified Version of the Document under the
conditions of sections 2 and 3 above, provided that you release the Modified
Version under precisely this License, with the Modified Version filling the
role of the Document, thus licensing distribution and modification of the
Modified Version to whoever possesses a copy of it. In addition, you must do
these things in the Modified Version:
- Use in the Title Page (and on the covers, if any) a title distinct from
that of the Document, and from those of previous versions (which should, if
there were any, be listed in the History section of the Document). You may
use the same title as a previous version if the original publisher of that
version gives permission.
- List on the Title Page, as authors, one or more persons or entities
responsible for authorship of the modifications in the Modified Version,
together with at least five of the principal authors of the Document (all of
its principal authors, if it has less than five).
- State on the Title page the name of the publisher of the Modified
Version, as the publisher.
- Preserve all the copyright notices of the Document.
- Add an appropriate copyright notice for your modifications adjacent to
the other copyright notices.
- Include, immediately after the copyright notices, a license notice
giving the public permission to use the Modified Version under the terms of
this License, in the form shown in the Addendum below.
- Preserve in that license notice the full lists of Invariant Sections and
required Cover Texts given in the Document's license notice.
- Include an unaltered copy of this License.
- Preserve the section entitled "History", and its title, and add to it an
item stating at least the title, year, new authors, and publisher of the
Modified Version as given on the Title Page. If there is no section entitled
"History" in the Document, create one stating the title, year, authors, and
publisher of the Document as given on its Title Page, then add an item
describing the Modified Version as stated in the previous sentence.
- Preserve the network location, if any, given in the Document for public
access to a Transparent copy of the Document, and likewise the network
locations given in the Document for previous versions it was based on. These
may be placed in the "History" section. You may omit a network location for
a work that was published at least four years before the Document itself, or
if the original publisher of the version it refers to gives permission.
- In any section entitled "Acknowledgments" or "Dedications", preserve the
section's title, and preserve in the section all the substance and tone of
each of the contributor acknowledgments and/or dedications given therein.
- Preserve all the Invariant Sections of the Document, unaltered in their
text and in their titles. Section numbers or the equivalent are not
considered part of the section titles.
- Delete any section entitled "Endorsements". Such a section may not be
included in the Modified Version.
- Do not retitle any existing section as "Endorsements" or to conflict in
title with any Invariant Section.
If the Modified Version includes new front-matter sections or appendices
that qualify as Secondary Sections and contain no material copied from the
Document, you may at your option designate some or all of these sections as
invariant. To do this, add their titles to the list of Invariant Sections in
the Modified Version's license notice. These titles must be distinct from any
other section titles.
You may add a section entitled "Endorsements", provided it contains nothing
but endorsements of your Modified Version by various parties--for example,
statements of peer review or that the text has been approved by an
organization as the authoritative definition of a standard.
You may add a passage of up to five words as a Front-Cover Text, and a
passage of up to 25 words as a Back-Cover Text, to the end of the list of
Cover Texts in the Modified Version. Only one passage of Front-Cover Text and
one of Back-Cover Text may be added by (or through arrangements made by) any
one entity. If the Document already includes a cover text for the same cover,
previously added by you or by arrangement made by the same entity you are
acting on behalf of, you may not add another; but you may replace the old one,
on explicit permission from the previous publisher that added the old one.
The author(s) and publisher(s) of the Document do not by this License give
permission to use their names for publicity for or to assert or imply
endorsement of any Modified Version.
- COMBINING DOCUMENTS
You may combine the Document with other documents released under this
License, under the terms defined in section 4 above for modified versions,
provided that you include in the combination all of the Invariant Sections of
all of the original documents, unmodified, and list them all as Invariant
Sections of your combined work in its license notice.
The combined work need only contain one copy of this License, and multiple
identical Invariant Sections may be replaced with a single copy. If there are
multiple Invariant Sections with the same name but different contents, make
the title of each such section unique by adding at the end of it, in
parentheses, the name of the original author or publisher of that section if
known, or else a unique number. Make the same adjustment to the section titles
in the list of Invariant Sections in the license notice of the combined work.
In the combination, you must combine any sections entitled "History" in the
various original documents, forming one section entitled "History"; likewise
combine any sections entitled "Acknowledgments", and any sections entitled
"Dedications". You must delete all sections entitled "Endorsements."
- COLLECTIONS OF DOCUMENTS
You may make a collection consisting of the Document and other documents
released under this License, and replace the individual copies of this License
in the various documents with a single copy that is included in the
collection, provided that you follow the rules of this License for verbatim
copying of each of the documents in all other respects.
You may extract a single document from such a collection, and distribute it
individually under this License, provided you insert a copy of this License
into the extracted document, and follow this License in all other respects
regarding verbatim copying of that document.
- AGGREGATION WITH INDEPENDENT WORKS
A compilation of the Document or its derivatives with other separate and
independent documents or works, in or on a volume of a storage or distribution
medium, does not as a whole count as a Modified Version of the Document,
provided no compilation copyright is claimed for the compilation. Such a
compilation is called an "aggregate", and this License does not apply to the
other self-contained works thus compiled with the Document, on account of
their being thus compiled, if they are not themselves derivative works of the
Document.
If the Cover Text requirement of section 3 is applicable to these copies of
the Document, then if the Document is less than one quarter of the entire
aggregate, the Document's Cover Texts may be placed on covers that surround
only the Document within the aggregate. Otherwise they must appear on covers
around the whole aggregate.
- TRANSLATION
Translation is considered a kind of modification, so you may distribute
translations of the Document under the terms of section 4. Replacing Invariant
Sections with translations requires special permission from their copyright
holders, but you may include translations of some or all Invariant Sections in
addition to the original versions of these Invariant Sections. You may include
a translation of this License provided that you also include the original
English version of this License. In case of a disagreement between the
translation and the original English version of this License, the original
English version will prevail.
- TERMINATION
You may not copy, modify, sublicense, or distribute the Document except as
expressly provided for under this License. Any other attempt to copy, modify,
sublicense or distribute the Document is void, and will automatically
terminate your rights under this License. However, parties who have received
copies, or rights, from you under this License will not have their licenses
terminated so long as such parties remain in full compliance.
- FUTURE REVISIONS OF THIS LICENSE
The Free Software Foundation may publish new, revised versions of the GNU
Free Documentation License from time to time. Such new versions will be
similar in spirit to the present version, but may differ in detail to address
new problems or concerns. See http://www.gnu.org/copyleft/.
Each version of the License is given a distinguishing version number. If
the Document specifies that a particular numbered version of this License "or
any later version" applies to it, you have the option of following the terms
and conditions either of that specified version or of any later version that
has been published (not as a draft) by the Free Software Foundation. If the
Document does not specify a version number of this License, you may choose any
version ever published (not as a draft) by the Free Software Foundation.
ADDENDUM: How to use this License for your documents
To use this License in a document you have written, include a copy of the
License in the document and put the following copyright and license notices just
after the title page: Copyright (C) year your name.
Permission is granted to copy, distribute and/or modify this document
under the terms of the GNU Free Documentation License, Version 1.1
or any later version published by the Free Software Foundation;
with the Invariant Sections being list their titles, with the
Front-Cover Texts being list, and with the Back-Cover Texts being list.
A copy of the license is included in the section entitled ``GNU
Free Documentation License''.
If you have no Invariant Sections, write "with no Invariant Sections" instead
of saying which ones are invariant. If you have no Front-Cover Texts, write "no
Front-Cover Texts" instead of "Front-Cover Texts being list";
likewise for Back-Cover Texts.
If your document contains nontrivial examples of program code, we recommend
releasing these examples in parallel under your choice of free software license,
such as the GNU General Public License, to permit their use in free software.
Node:General Index, Previous:GNU Free Documentation License, Up:Top
General Index
#: A
First Perl Program
;: A
First Perl Program
- <>, the file handle operator: A
First Perl Program
- Alan Kay: The
Slogans
- associativity: Numerical
Operators
- comments: A
First Perl Program
- easy jobs, made easy by Perl: The
Slogans
- exponential notation: Numeric
Literals
- expression: Expressions
- FDL, GNU Free Documentation License: GNU
Free Documentation License
- floating point: Numbers
- functions, chomp: A
First Perl Program
- functions, defined: Undefined
Variables
- functions, each: Each
- functions, keys: Keys
and Values
- functions, my: A
First Perl Program
- functions, pop: Arrays
as Stacks
- functions, print: A
Digression---The print Function, A
First Perl Program
- functions, push: Arrays
as Stacks
- functions, shift: Arrays
as Queues
- functions, undef: Undefined
Variables
- functions, unshift: Arrays
as Queues
- functions, values: Keys
and Values
- hard jobs, made possible by Perl: The
Slogans
- hubris: The
Slogans
- impatience: The
Slogans
- integer: Numbers
- interpolation: Interpolation
in Double-quoted Strings
- interpolation, scalar: Scalar
Interpolation
- Kay, Alan: The
Slogans
- languages, natural: Perl
as a Natural Language, Background
of Perl
- laziness: The
Slogans
- literals, numeric: Numeric
Literals
- literals, string: Strings
- newlines, removing with
chomp: A
First Perl Program
- numbers: Numbers
- operators: Operators
- operators, numeric: Numerical
Operators
- options, -c: A
First Perl Program
- panacea: The
Slogans
- Perl, definition of: A
Brief History of Perl
- Perl, history of: A
Brief History of Perl
- Perl, overview of: Background
of Perl
- pragma: A
First Perl Program
- precedence: Numerical
Operators
- quotes, double: Scalar
Interpolation, Double-quoted
Strings
- reading from a file: A
First Perl Program
- scalar: Output
of Scalar Data, Scalar
Variables, Working
with Scalars, A
First Perl Program
- standard input: A
First Perl Program
- statement: Expressions,
A
First Perl Program
- STDIN: A
First Perl Program
- strings: Double-quoted
Strings, Strings
- Usenet: A
Brief History of Perl
- variables, scalar: Output
of Scalar Data, Scalar
Variables
- Wall, Larry: Perl
as a Natural Language, A
Brief History of Perl
Table of Contents
Footnotes
-
Female pronouns are used throughout this book. It can be assumed that they
refer to both genders.
-
Actually, it cannot be longer than your computer has virtual memory, but
that is rarely a problem.
-
C programmers are already probably used to this idea.
-
There are also standard packages available to handle very large and very
small numbers, and packages to force use of integers only for all
calculations.
-
Language historians may notice that this is a feature from the Ada
language.
-
The ' character is a synonym for :: which is used
for packages, a topic not covered in this text.
-
Some operators are not associative at all (see Summary
of Scalar Operators).
-
It is possible to make an array of arrays using a concept called
"references", but that topic is beyond the scope of this book.
-
For another way to do this, see the exercises in this section.
-
Perl will eventually support unicode, or some other extended character
format, in which case it will no longer merely be ASCII
characters.
-
Actually, Perl regular expressions have a few additional features that go
beyond the traditional, simple set of regular expressions, but these are an
advanced topic.
-
Perl has also been given the name, Pathologically Eclectic Rubbish Lister.
Choose the one with which you feel more comfortable. Some even insist that
Perl is no longer an acronym for anything. This argument has merit, since Perl
is never written PERL.
|
|
