Home > Articles > Web Development > Perl

  • Print
  • + Share This
This chapter is from the book

More Operators

Perl has so many operators that there isn't enough space in this book to document them all fully. (You can read about them all in the "perlop" manual page.) But for the remainder of this hour, you'll read about the most commonly used operators and functions in Perl.

One-Operand (Unary) Operators

Until now, all the operators you've read about take two operands—that is, two expressions, from whose values the operators make a new value in some way. For example, division (6/3) requires a dividend (6) and a divisor (3), multiplication (5*2) requires a multiplicand (5) and a multiplier (2), and so on. Another kind of operator, called a unary operator, takes only one operand. You're probably familiar with one example of these already—the unary minus (-). The unary minus returns the value of its operand with the sign reversed: negative if the operand is positive, positive if the operand is a negative number:

6;   # Six
-6;   # Negative six.
-(-5); # Positive five, not negative five.

Many of Perl's unary operators are actually named operators; that is, instead of a symbol—like the - for unary minus—they use a word. The parentheses around the operand with named unary operators are optional but are shown in Table 2.4 for clarity. Named unary operators in Perl look and act like functions (discussed in Hour 8), and their operands are called arguments—the term used for the expressions that Perl functions act on.

Some named unary operators are listed briefly in Table 2.4.

Table 2.4 Some Named Unary Operators


Sample Usage




-Returns the integer portion of its argument (5).



-Returns the length of its string argument (4).


lc("ME TOO")

-Returns its argument shifted to lowercase letters ("me too").


uc("hal 9000")

Returns the reverse of lc ("HAL 9000").



-Returns the cosine of 50 in radians (.964966).



-Returns a random number from 0 to less than its argument. If the argument is omitted, a number between 0 and 1 is returned.

You can find the full list of named operators in the online manual. As discussed in Hour 1, you can find the entire Perl language documentation by using the perldoc utility included with the Perl distribution. All of the operators are listed in the "perlop" manual and in the "perlfunc" manual. (Operators that are symbols, such as *, are listed in perlop, whereas named unary operators are listed in perlfunc.) More operators will be presented in later lessons as they are needed.

Increment and Decrement

In the "Numeric Operators" section, you read about a special type of assignment called an increment, which looks like the following:


An increment is typically used to count things, such as the number of records read, or to generate sequence numbers, such as numbering the items in a list. It's such a common idiom in Perl that you can use a special operator called an autoincrement operator (++). The autoincrement operator adds 1 to its operand:


When this code is executed, $counter is increased by 1.

Perl also offers a shortcut for decreasing a variable's value called, not surprisingly, the autodecrement operator (--). You use the autodecrement exactly the same way you use the autoincrement:

$countdown--;   # decrease to 9

Let me add a final note on the autoincrement operator: When the operator is applied to a text string, and the text string starts with an alphabetic character and is followed by alphabetic characters or numbers, this operator becomes magical. The last (rightmost) character of the string is increased. If it's an alphabetic character, it becomes the next letter in sequence; if it's numeric, the number increases by 1. You can carry across alphabetic and numeric columns as follows:

print $a;      # prints 1000, as you'd expect
print $a;      # prints d0. 9+1=10, carry 1 to the c.
print $a;     # prints "aaaa".

The autodecrement operator does not decrement strings like this.

Angle Operator (<>)

The angle operator (<>), sometimes called a diamond operator, is primarily used for reading and writing files; it will be covered fully in Hour 5, "File I/O." However, a brief introduction now will make the exercises more interesting, and when you begin Hour 5, the operator will look somewhat familiar to you.

Until then, you can use the angle operator in its simplest form: <STDIN>. This form indicates to Perl that a line of input should be read from the standard input device— usually the keyboard. The <STDIN> expression returns the line read from the keyboard:

print "What size is your shoe? ";
print "Your shoe size is $size. Thank you!\n";

The preceding code, when executed (assuming you type 9.5 as your shoe size), would print this on the screen:

What size is your shoe? 9.5
Your shoe size is 9.5
. Thank you!

The <STDIN> expression reads from the keyboard until the user presses the Enter key. The entire line of input is returned and is placed in $size. The line of text returned by <STDIN> also includes the newline character that the user typed by pressing Enter. That's why the period and "Thank you!" appear on a new line in the preceding display—the newline was part of the value of $size. Often, as here, you don't want the newline character at the end of the string—just the text. To remove it, you can use the chomp function as follows:

print "What size is your shoe?";
chomp $size;
print "Your shoe size is $size. Thank you!\n";

chomp removes any trailing newline character at the end of its argument. It returns the number of characters removed, which is usually 1 but is 0 if nothing needs to be removed.

More Assignment Operators

Earlier, you learned that to assign a value to a scalar variable you use the assignment operator (=). Perl actually has an entire set of operators for doing assignments. Every Perl arithmetic operator and quite a few others can be combined to do an assignment and an operation all at the same time. The general rule for building an assignment with an operator is as follows:

variable operator=expression

This form of the assignment produces the same result as the following:

variable=variable operator expression

Using combined assignments generally doesn't make your programs any more readable but can make them more concise. Following this rule, the statement


can be reduced to


The following are some more examples of assignments:

$line.=", at the end";     # ", at the end" is appended to $line
$y*=$x             # same as $y=$y*$x
$r%=67;             # Divide by 67, put remainder in $r

A Few Words on Strings and Numbers

For the most part, Perl allows you to use numbers and strings interchangeably; the representation it uses depends on what Perl is looking for in that situation.

  • If something looks like a number, Perl can use it as a number when it needs a number:

  • $a=42;     # A number
    print $a+18;  # displays 60.
    print $b-10;  # Displays 40.
  • If something looks like a number, when Perl needs a string, it uses the string representation of the number:

  • $a=42/3;
    $a=$a . "Hello"; # Using a number like a string.
    print $a     # displays "14Hello"
  • If something doesn't look like a number, but you've used it where a number was expected, Perl simply uses the value 0 in its place:

  • $a="Hello, World!";
    print $a+6;   # displays the number 6

    If you have warnings enabled, Perl emits a warning if you do this, however.

All these uses are in keeping with Perl's philosophy of Least Surprise. Even when given nonsense—as in the last example here—Perl tries to do something sensible with it. If you have warnings enabled in your Perl program—by putting a -w on the #! line or invoking the Perl interpreter with the -w option—Perl warns you that you're doing something nonsensical by giving you the following message: Argument X isn't numeric.

  • + Share This
  • 🔖 Save To Your Account