Home > Articles > Web Development > Perl

Perl's Building Blocks: Numbers and Strings

  • Print
  • + Share This
Learn to express yourself in Perl through scalar variables, operators, and expressions and test your knowledge by following an Interest Calculator example.

See all Sams Teach Yourself on InformIT Programming Tutorials.

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.

—Clinton Pierce

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


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


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


Type of Literal


An integer


A floating-point number


Another floating-point number


Yet another floating-point number


Scientific notation


Scientific notation (e or E is acceptable)


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.


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.


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:

'Fourscore and seven years ago'
"One fish,\nTwo fish,\nRed fish,\nBlue fish\n"
"Frankly, my dear, I don't give a hoot.\n"

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






Carriage return






Change next character to uppercase


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:

q[Joe (Tom's dad) fell out of a (rather large) tree.];
  • + Share This
  • 🔖 Save To Your Account