Expressions and Operators

Now that you've learned what scalar data is and know how to use scalar variables, you can start doing something useful with Perl. Perl programs are just collections of expressions and statements executed in order from the top of your Perl program to the bottom—unless you specify otherwise with flow-control statements, covered in Hour 3, "Controlling the Program's Flow." Listing 2.1 shows a valid Perl program.

Listing 2.1 A Simple Perl Program

1:   #!/usr/bin/perl -w
2:
3:   $radius=50;
4:
5:   $area=3.14159*($radius ** 2);
6:   print $area;

Line 1: This line is the path to the Perl interpreter, as explained in Hour 1. The -w switch tells Perl to inform you of any warnings encountered.

Line 3: This line is an assignment. The numeric scalar data 50 is stored in the scalar variable $radius.

Line 5: This line is another assignment. On the right side of the assignment operator is an expression. This expression contains the scalar variable $radius, operators (* and **, explained later) and a numeric scalar (2). The expression's value is computed and assigned to $area.

Line 6: This line prints the result of the calculation stored in $area.

Expressions are simply things that have a value. For example, 2 is a valid expression. So are 54*$r, "Java", sin($pi*8), and $t=6. The values of expressions are computed when your program is run. The program evaluates the functions, operators, and scalar constants in the expression and reduces it to a value. You can use these expressions with assignments, as part of other expressions, or as part of other Perl statements.

Basic Operators

As you saw in Listing 2.1, to assign scalar data to a scalar variable, you use the assignment operator, =. The assignment operator takes the value on the right side and puts it in the variable on the left:

$title="Gone With the Wind";
$pi=3.14159;

The operand on the left side of the assignment operator must be something that a value can be assigned to—namely, a variable. The operand on the right side can be any kind of expression. The entire assignment itself is an expression; its value is that of the right-hand expression. This means that, in the following snippet, $a, $b, and $c are all set to 42:

$a=$b=$c=42;

Here, $c is first set to 42. $b is set to the value of the expression $c=42 (which is 42). $a is then set to the value of the expression $b=42. The variable being assigned to can even appear on the right side of the assignment operator, as shown here:

$a=89*$a;
$count=$count+1;

The right side of the assignment operator is evaluated using the old value of $a or $count, and then the result is assigned to the left side as the new value. The second example has a special name in Perl; it's called an increment. You'll read more about incrementing values later.

Numeric Operators

Perl has many operators to manipulate numeric expressions. Some of these operators are familiar to you already; some you will be meeting for the first time. The first kind of operator you should already know—the arithmetic operators. Table 2.3 shows a list of these operators.

Arithmetic operators are evaluated as you would think: exponentiation first; multiplication, division, and modulus next; and then addition and subtraction. If you're unsure of which order elements will be evaluated in an expression, you can always use parentheses to guarantee the evaluation order. Nested parentheses are always evaluated from the inside out:

5*6+9;        # Evaluates to 39
5*(6+9);      # Evaluates to 75
5+(6*(4−3));  # Evaluates to 11

String Operators

Numeric values aren't the only values in Perl that can be affected by operators; strings can be manipulated as well. The first string operator is the concatenation operator, represented by a period (.). The concatenation operator takes the string on the left and the string on the right and returns a string that is both strings put together:

$a="Hello, World!";
$b=" Nice to meet you";
$c=$a . $b;

$a and $b are given simple string values in this example. On the last line, $a and $b are concatenated to become Hello, World! Nice to meet you and stored in $c. $a and $b are not modified by the concatenation operator.

Concatenation-like behavior can be performed another way. Earlier, you learned that inside a double-quoted string Perl looks for variables. If Perl finds a variable inside a double-quoted string, it is interpolated. This means that the variable name inside the double-quoted string is replaced by its actual value:

$name="John";
print "I went to the store with $name.";

In this example, Perl looks inside the double-quoted string, sees $name, and substitutes the string John. This process is called variable interpolation. To prevent a variable-looking string from being interpolated, you either can use single quotation marks—which do not perform interpolation of any kind—or put a backslash in front of the variable identifier:

$name="Ringo";
print 'I used the variable $name';     # Will not print "Ringo"
print "I used the variable $name";    # Neither will this.

Both of the print statements in the preceding example print I used the variable $name; the string $name is not interpolated. So, to perform concatenation without using the concatenation operator, you can simply use double-quoted strings, as follows:

$fruit1="apples";
$fruit2="and oranges";
$bowl="$fruit1 $fruit2";

In cases in which Perl can't clearly tell where the variable name ends and the rest of the string begins, you can use curly braces {} around the variable name. This syntax allows Perl to find the variable name where it might be ambiguous:

$date="Thurs";
print "I went to the fair on ${date}day";

Without the braces, it wouldn't be clear whether you intended Perl to interpolate $date or a variable named $dateday in the double-quoted string. The braces make it clear what you meant to be interpolated.

The other string operator presented here is the repetition operator, x. The x operator takes two arguments—a string to repeat and the number of times to repeat that string—as you can see here:

$line="-" x 70;

In the preceding example, the - character is repeated 70 times by the x operator. The result is stored in $line.