Like anything that seems magical, there’s always a trick to it – and programming is no different. All you need are some analytical thinking skills, the desire to learn, and some time to learn Perl. The best way to learn how to program a computer – or any task really – is to have a goal. Your goal could be to spice up your Web pages, to convert a program you already have to Perl, or to satisfy idle curiosity – it doesn’t really matter.

Now given that you’ve established a goal and have some thinking skills, what do these 4 chapters from the "Sams Teach Yourself Perl in 24 Hours" have for you? The goal of these four chapters, Chapters 2 – 5, is to introduce you to the fundamentals of the Perl programming language. In chapter 2, you will learn Perl’s most basic type of data and what it consists of. You will learn about statements, operators, and expressions. Chapter 3 covers the many flow control constructs. Chapter 4 focuses on arrays and lists, Perl’s collective variables. Opening and closing filehandles is the topic in Chapter 5. Go ahead…take a look.

By the end of the book, you’ll have learned just enough Perl to do something useful. You will not be overwhelmed with details that although interesting, will only get in your way and that you’ll probably never use again. Each new concept in this book is demonstrated with lots of working code examples.

This chapter is from the book

This chapter is from the book

Every programming languageand every human languagehas a similar
beginning: You have to have something to talk about. In Perl, numbers and strings
are the basic unit of conversation, and these are called scalars.

Every hour in this book deals in some way with scalarsincreasing, decreasing,
querying, testing, collecting, clearing, separating, folding, sorting, saving,
loading, printing, and deleting them. Scalars are Perl's singular nouns;
they can represent a word, a record, a document, a line of text, or a character.

Some scalars in Perl can represent information that does not change over the
life of the program. Some programming languages call these values constants
or literals. Literal data is used for things that simply do not change,
such as the value of þ, the rate of acceleration of a body falling to Earth,
and the name of the 15th President of the United States. If these values are
needed by a Perl program, they would, at some point in the program, be represented
by a scalar literal.

The other kinds of scalars in Perl are those that change, called scalar
variables. Variables hold data while you manipulate it. You can change the
contents of variables, because they merely act as handles for the data they
represent. Variables are given namesconvenient and easy-to-remember names,
ideallythat enable you to refer to the data you are manipulating.

This hour also introduces Perl's operators. They are one kind of verb
in the Perl language. Operators take Perl's nouns and do the actual manipulations
you need to write programs that perform useful tasks.

In this hour, you'll learn about

Literal numbers and strings

Scalar variables

Operators

Literals

Perl has two different types of scalar constants called literals:
numeric literals and string literals.

Numbers

Numeric literals are numbers, and Perl accepts several different ways of
writing numbers. All the examples shown in Table 2.1 are valid numeric literals
in Perl.

Table 2.1 Samples of Numeric Literals

Number

Type of Literal

6

An integer

12.5

A floating-point number

15.

Another floating-point number

.7320508

Yet another floating-point number

1e10

Scientific notation

6.67E-33

Scientific notation (e or E is acceptable)

4_294_296

A large number with underscores instead of commas

Numbers are expressed as you think they would be. Integers are
just groups of consecutive digits. Floating-point decimal numbers contain a
decimal point in the correct position, even if there are no digits to the right
of it. A floating-point number can be expressed in scientific notation as an
exponent preceded by the letter e (or E) and a decimal number called the
mantissa. The value of the scientific-notation literal is 10 raised to the power
indicated by the exponent, multiplied by the mantissa; for example, 6.5536E4 =
65,536.0. (Strictly speaking, a mantissa is the decimal part of a logarithm,
where it serves the same purpose as it does here.)

You cannot put commas into a numeric literal to improve readability, but you
can use underscores where commas would normally appear. Perl removes the
underscores when using the value.

NOTE

Do not use a leading zero in front of a number, such as 010. To Perl, a
leading zero means that the literal represents an octal numberbase 8. Perl
also allows you to use literal hexadecimal numbersbase 16 and binary
numbersbase 2. More information on these is in the online documentation in
the perldata section.

Strings

String literals in Perl are sequences of characters, such as Hello,
World. They can contain as much data as you want; strings have no real
limit on their size except the amount of virtual memory in your computer.
Strings can also contain any kind of datasimple ASCII text, ASCII with the
high bits on, even binary data. Strings can even be empty.

In Perl you must enclose string literals, with very few exceptions, in
quotation marks. This process is called quoting the string. The two
primary ways of quoting strings are to use single quotation marks ('
') or double quotation marks (" "). The following
are some sample string literals:

What if you need to put another quotation mark inside your string literal?
For example, the following string literal would make no sense to Perl:

"Then I said to him, "Go ahead, make my day""

Here, the quotation mark in front of the word Go marks the end of
the string literal started by the first quotation mark, leaving the phrase
Go ahead, make my day outside the string literalin which case it
would have to be valid Perl code, which it isn't. To prevent this
situation, you must use a backslash (\) in front of the quotation marks
that are inside the string. A backslash inside of a string literal tells Perl
that the character that follows should not be treated as Perl would normally
treat itin this case, it should be handled as a character in the string
literal rather than as the marker for the end of the string literal. Put a
backslash character in front of each quotation mark that you want Perl to treat
simply as a character, as shown here:

"Then I said to him, \"Go ahead, make my day.\""

The backslashes let Perl know that the quotation mark that follows is not the
match for the first quotation mark that started the string literal. This rule
applies to single quotation marks as well as double quotation marks, as you can
see here:

'The doctors\'s stethoscope was cold.'

The primary difference between double-quoting and single-quoting a string is
that single-quoted strings are quite literal; every character in a single-quoted
string (except the sequence \') means exactly what is there. In a
double-quoted string, on the other hand, Perl checks to see whether variable
names or escape sequences are present and translates them if they are.
Escape sequences are special strings that allow you to embed characters in
strings when just typing the characters would cause problems. Table 2.2 shows a
short list of Perl's escape sequences.

Table 2.2 Sample String Escape Sequences

Sequence

Represents

\n

Newline

\r

Carriage return

\t

Tab

\b

Backspace

\u

Change next character to uppercase

\l

Change next character to lowercase

\\

A literal backslash character

\'

A literal ' inside of a string surrounded by single quotation
marks ('').

\"

A literal " inside of a string surrounded by double quotation
marks.

You can find the full list of escape sequences in the online
manual. As I indicated in Hour 1, "Introduction to the Perl Language,"
you can find the entire Perl language documentation by using the
perldoc utility included with the Perl distribution. The escape
sequences are listed in the "perlop" manual page under the heading
"Quote and Quote-like Operators."

Having many quotation marks embedded in a string can make typing the string
error-prone and difficult, because each embedded quote mark has to be escaped,
as shown here:

"I said, \"Go then,\", and he said \"I'm gone.\"."

Perl provides another quoting mechanism: the qq and q
operators. To use qq, you can surround the string literal with qq(
) instead of quotation marks:

qq(I said, "Go then," and he said "I'm gone")

qq replaces the double quotation marks; this mechanism behaves
exactly like double quotes in almost all respects.

You can use the q operator to surround text instead of using single
quotation marks:

q(Tom's kite wedged in Sue's tree)

The qq and q operators can use any nonalphabetic,
nonnumeric character to mark the beginning and ending of a string. Those markers
are called delimiters. In the preceding examples, I used parentheses, but
any other nonalphabetic or nonnumeric character could have been used:

q/Tom's kite wedged in Sue's tree/q,Tom's kite wedged in Sue's tree,

The character you want to use as a delimiter must appear immediately after
the qq or q operator.

If you use any of the character pairs (), <>, {}, or
[] as delimiters, they will nest properly. That is, if you use them in
matched pairs inside the qq or q operators, you do not need to
use a backslash escape sequence:

q(Joe (Tom's dad) fell out of a (rather large) tree.);

However, doing this doesn't make your Perl programs very readable.
Usually it's easier just to pick delimiters that don't appear in your
string: