Go to the first, previous, next, last section, table of contents.

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.


Any sequence of @acronym{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 @acronym{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 section Scalar Variables).

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 @string{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.

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 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!

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.

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.

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 section Single-quoted Strings, into a full Perl program, like this:


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 @builtin{print} function.

The @builtin{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:


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.

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 @acronym{ASCII} characters between two delimiters (in this case, our delimiter is `"'). However, something called interpolation happens when you use a double-quoted string.

Interpolation in Double-quoted Strings

Interpolation is a special process whereby certain special strings written in @acronym{ASCII} are replaced by something different. In section 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

Examples of Interpolation

Let us consider an example that uses a few of these characters:


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
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.

Examples of Interpolation (ASCII Octal Values)

With the exception of `\n', you should note that the interpolated sequences are simply shortcuts for actually @acronym{ASCII} characters that can be expressed in other ways. Specifically, you are permitted to use the actual @acronym{ASCII} codes (in octal or hexadecimal) to represent characters. To exemplify this, consider the following program:


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 @acronym{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 @acronym{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 @acronym{ASCII} value.

Examples of Interpolation (ASCII Hex Values)

You need not use only the octal values when interpolating @acronym{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:


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 @acronym{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 @acronym{ASCII} character that does not have a shortcut, single character sequence.

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 section Scalar Interpolation and section Array Interpolation.


Perl has the ability to handle both floating point and integer numbers in reasonable ranges(4).

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;         # @cc{The number 42}
12.5;       # @cc{A floating point number, twelve and a half}
101873.000; # @cc{101,873}
.005        # @cc{five thousandths}
5E-3;       # @cc{same number as previous line}
23e-100;    # @cc{23 times 10 to the power of -100 (very small)}
2.3E-99;    # @cc{The same number as the line above!}
23e6;       # @cc{23,000,000}
23_000_000; # @cc{The same number as line above}
            # @cc{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 @ifnottex 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.

Printing Numeric Literals

As with string literals, you can also use the print function in Perl to print numerical literals. Consider this program:


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 @builtin{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 section Output of Scalar Data).

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 section 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.

Scalar Interpolation

Recall that when we discussed double-quotes strings (see section 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.


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 section 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

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:


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.

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:


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 section A Digression--Truth Values.


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.

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

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 @acronym{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 section 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 ""

    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

    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.

    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>

    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.

    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
    @operator{++}, @operator{--} nonassoc auto-increment and auto-decrement
    @operator{**} right exponentiation
    @operator{*}, @operator{/}, @operator{%} left multiplication, division, modulus
    @operator{+}, @operator{-}, @operator{.} left addition, subtraction, concatenation
    @operator{<}, @operator{>}, @operator{<=}, @operator{>=}, @operator{lt}, @operator{gt}, @operator{le}, @operator{ge} nonassoc comparison operators
    @operator{==}, @operator{!=}, @operator{<=>}, @operator{eq}, @operator{ne}, @operator{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'.

    Go to the first, previous, next, last section, table of contents.