Home > Articles > Programming > Perl

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

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

An expression in Perl is simply something that has 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.

Table 2.3 Arithmetic Operators

Example

Operator Name

Expression Value

5 + $t

Addition

Sum of 5 and $t

$y - $x

Subtraction

Difference between $y and $x

$e * $pi

Multiplication

Product of $e and $pi

$f / 6

Division

Quotient of $f divided by 6

24 % 5

Modulus

Remainder of 24 divided by 5 (4)

4 ** 2

Exponentiation

4 raised to the 2nd power


Arithmetic operators are evaluated in the order 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.

There is another way to put strings together. 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 type identifier and variable name inside the double-quoted string are replaced by the variable's 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 something that looks like a variable in a 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", prints $name
print "I used the variable \$name"; # Neither will this.

The last two print statements in the preceding example print I used the variable $name; the value of the variable $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";

If a variable name is followed immediately by letters or numbers, Perl will not be able to tell clearly where the variable name ends and the rest of the string begins. In that case, 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, Perl would think you wanted to interpolate a variable named $dateday in the double-quoted string, not to interpolate $date and follow it with the string day. The braces make it clear what you meant to be interpolated. For historical reasons, apostrophies following variable names have the same issue:

$name="Bob";
Print "This is $name's house"; # does not print Bob.

This can also be fixed with a judicious use of curly braces:

$name = "Bob";
print "This is ${name}'s house"; # Does print Bob

The other string operator presented here is the repetition operator, x. The x operator takes two values—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.

  • + Share This
  • 🔖 Save To Your Account