2.6. Output with printIt's generally a good idea to have your program produce some output; otherwise, someone may think it didn't do anything. The print( ) operator makes this possible. It takes a scalar argument and puts it out without any embellishment onto standard output. Unless you've done something odd, this will be your terminal display. For example: print "hello world\n"; # say hello world, followed by a newline print "The answer is "; print 6 * 7; print ".\n"; You can actually give print a series of values, separated by commas. print "The answer is ", 6 * 7, ".\n"; This is actually a list, but we haven't talked about lists yet, so we'll put that off for later. 2.6.1. Interpolation of Scalar Variables into StringsWhen a string literal is double-quoted, it is subject to variable interpolation[55] (besides being checked for backslash escapes). This means that any scalar variable[56] name in the string is replaced with its current value. For example:
$meal = "brontosaurus steak"; $barney = "fred ate a $meal"; # $barney is now "fred ate a brontosaurus steak" $barney = 'fred ate a ' . $meal; # another way to write that As you see on the last line above, you can get the same results without the double quotes. But the double-quoted string is often the more convenient way to write it. If the scalar variable has never been given a value,[57] the empty string is used instead:
$barney = "fred ate a $meat"; # $barney is now "fred ate a " Don't bother with interpolating if you have just the one lone variable: print "$fred"; # unneeded quote marks print $fred; # better style There's nothing really wrong with putting quote marks around a lone variable, but the other programmers will laugh at you behind your back.[58]
Variable interpolation is also known as double-quote interpolation, because it happens when double-quote marks (but not single quotes) are used. It happens for some other strings in Perl, which we'll mention as we get to them. To put a real dollar sign into a double-quoted string, precede the dollar sign with a backslash, which turns off the dollar sign's special significance: $fred = 'hello'; print "The name is \$fred.\n"; # prints a dollar sign print 'The name is $fred' . "\n"; # so does this The variable name will be the longest possible variable name that makes sense at that part of the string. This can be a problem if you want to follow the replaced value immediately with some constant text that begins with a letter, digit, or underscore.[59] As Perl scans for variable names, it would consider those characters to be additional name characters, which is not what you want. Perl provides a delimiter for the variable name in a manner similar to the shell. Simply enclose the name of the variable in a pair of curly braces. Or, you can end that part of the string and start another part of the string with a concatenation operator:
$what = "brontosaurus steak"; $n = 3; print "fred ate $n $whats.\n"; # not the steaks, but the value of $whats print "fred ate $n ${what}s.\n"; # now uses $what print "fred ate $n $what" . "s.\n"; # another way to do it print 'fred ate ' . $n . ' ' . $what . "s.\n"; # an especially difficult way 2.6.2. Operator Precedence and AssociativityOperator precedence determines which operations in a complex group of operations happen first. For example, in the expression 2+3*4, do we perform the addition first or the multiplication first? If we did the addition first, we'd get 5*4, or 20. But if we did the multiplication first (as we were taught in math class), we'd get 2+12, or 14. Fortunately, Perl chooses the common mathematical definition, performing the multiplication first. Because of this, we say multiplication has a higher precedence than addition. You can override the default precedence order by using parentheses. Anything in parentheses is completely computed before the operator outside of the parentheses is applied (just like you learned in math class). So if I really want the addition before the multiplication, I can say (2+3)*4, yielding 20. Also, if I wanted to demonstrate that multiplication is performed before addition, I could add a decorative but unnecessary set of parentheses, as in 2+(3*4). While precedence is simple for addition and multiplication, we start running into problems when faced with, say, string concatenation compared with exponentiation. The proper way to resolve this is to consult the official, accept-no-substitutes Perl operator precedence chart, shown in Table 2-1.[60] (Note that some of the operators have not yet been described, and in fact, may not even appear anywhere in this book, but don't let that scare you from reading about them in the perlop manpage.)
Table 2-2. Associativity and precedence of operators (highest to lowest)
In the chart, any given operator has higher precedence than all of the operators listed below it, and lower precedence than all of the operators listed above it. Operators at the same precedence level resolve according to rules of associativity instead. Just like precedence, associativity resolves the order of operations when two operators of the same precedence compete for three operands: 4 ** 3 ** 2 # 4 ** (3 ** 2), or 4 ** 9 (right associative) 72 / 12 / 3 # (72 / 12) / 3, or 6/3, or 2 (left associative) 36 / 6 * 3 # (36/6)*3, or 18 In the first case, the ** operator has right associativity, so the parentheses are implied on the right. Comparatively, the * and / operators have left associativity, yielding a set of implied parentheses on the left. So should you just memorize the precedence chart? No! Nobody actually does that. Instead, just use parentheses when you don't remember the order of operations, or when you're too busy to look in the chart. After all, if you can't remember it without the parentheses, your maintenance programmer is going to have the same trouble. So be nice to your maintenance programmer. 2.6.3. Comparison OperatorsFor comparing numbers, Perl has the logical comparison operators that remind you of algebra: < <= == >= > !=. Each of these returns a true or false value. We'll find out more about those return values in the next section. Some of these may be different than you'd use in other languages. For example, == is used for equality, not a single = sign, because that's used for another purpose in Perl. And != is used for inequality testing, because <> is used for another purpose in Perl. And you'll need >= and not => for "greater than or equal to", because the latter is used for another purpose in Perl. In fact, nearly every sequence of punctuation is used for something in Perl. For comparing strings, Perl has an equivalent set of string comparison operators which look like funny little words: lt le eq ge gt ne. These compare two strings character by character to see whether they're the same, or whether one comes first in standard string sorting order. (In ASCII, the capital letters come before the lowercase letters, so beware.) The comparison operators (for both numbers and strings) are given in Table 2-3. Table 2-3. Numeric and string comparison operators
Here are some example expressions using these comparison operators: 35 != 30 + 5 # false 35 == 35.0 # true '35' eq '35.0' # false (comparing as strings) 'fred' lt 'barney' # false 'fred' lt 'free' # true 'fred' eq "fred" # true 'fred' eq 'Fred' # false ' ' gt '' # true Copyright © 2002 O'Reilly & Associates. All rights reserved. |
|