5.4. Output to Standard Output
The print operator takes a list of values and sends each item (as a string, of course) to standard output in turn, one after another. It doesn't add any extra characters before, after, or in between the items.[*] If you want spaces between items and a newline at the end, you have to say so:
$name = "Larry Wall"; print "Hello there, $name, did you know that 3+4 is ", 3+4, "?\n";
Of course, that means printing an array and interpolating an array are different:
print @array; # print a list of items print "@array"; # print a string (containing an interpolated array)
The first print statement will print a list of items, one after another, with no spaces in between. The second one will print one item, which is the string you get by interpolating @array into the empty stringthat is, it prints the contents of @array, separated by spaces. If @array holds qw/ fred barney betty /, the first one will print fredbarneybetty, and the second will print fred barney betty separated by spaces.
But before you decide to use the second form all the time, imagine that @array is a list of unchomped lines of input. That is, imagine that each of its strings has a trailing newline character. Now, the first print statement prints fred, barney, and betty on three separate lines. But the second one prints this:
fred barney betty
Do you see where the spaces come from? Perl is interpolating an array, so it puts spaces between the elements. We get the first element of the array (fred and a newline character), a space, the next element of the array (barney and a newline character), a space, and the last element of the array (betty and a newline character). The result is that the lines seem to have become indented except for the first one. Every week or two, a message appears on the newsgroup comp.lang.perl.misc with a subject line like this:
Without reading the message, we know the program used double quotes around an array containing unchomped strings. When asked, "Did you perhaps put an array of unchomped strings inside double quotes?", the answer is always yes.
Generally, if your strings contain newlines, you'll simply want to print them:
But if they don't contain newlines, you'll generally want to add one at the end:
If you're using the quote marks, you'll generally be adding the \n at the end of the string anyway; this should help you to remember which is which.
It's normal for your program's output to be buffered. Instead of sending out every little bit of output immediately, it'll be saved until there's enough to bother with. If (for example) you're going to save the output to disk, it would be (relatively) slow and inefficient to spin the disk every time you add one or two characters to the file. Generally, then, the output will go into a buffer that is flushed (that is, actually written to disk or wherever) only when the buffer gets full or when the output is otherwise finished (such as at the end of runtime). Usually, that's what you want.
But if you (or a program) are waiting impatiently for the output, you may wish to take that performance hit and flush the output buffer each time you print. See the Perl manpages for more information on controlling buffering.
Since print is looking for a list of strings to print, its arguments are evaluated in list context. Since the diamond operator (as a special kind of line-input operator) will return a list of lines in a list context, these can work well together:
print <>; # source code for 'cat' print sort <>; # source code for 'sort'
To be fair, the standard Unix commands cat and sort do have some additional functionality that these replacements lack, but you can't beat them for the price! You can now reimplement all of your standard Unix utilities in Perl and painlessly port them to any machine that has Perl whether that machine is running Unix or not. And you can be certain that the programs on every different type of machine will have the same behavior.[*]
What might not be obvious is that print has optional parentheses, which can sometimes cause confusion. Remember the rule that parentheses in Perl may be omitted except when doing so would change the meaning of a statement. Here are two ways to print the same thing:
print("Hello, world!\n"); print "Hello, world!\n";
So far, so good. Another rule in Perl is that if the invocation of print looks like a function call, then it is a function call. It's a simple rule, but what does it mean for something to look like a function call?
In a function call, there's a function name immediately[*] followed by parentheses around the function's arguments, like this:
That looks like a function call, so it is a function call. It prints 5, but then it returns a value like any other function. The return value of print is a true or false value, indicating the success of the print. It nearly always succeeds unless you get some I/O error, so the $result in the following statement will normally be 1:
$result = print("hello world!\n");
But what if you used the result in some other way? Suppose you decide to multiply the return value times four:
print (2+3)*4; # Oops!
When Perl sees this line of code, it prints 5 as you asked. Then it takes the return value from print, which is 1, and multiplies that times 4. Then, it throws away the product, wondering why you didn't tell it to do something else with it. At this point, someone looking over your shoulder says, "Hey, Perl can't do math! That should have printed 20, rather than 5!"
This is the problem with the optional parentheses; sometimes, we humans forget where the parentheses belong. When there are no parentheses, print is a list operator, printing all of the items in the following list, which is what you'd expect. But when the first thing after print is a open parenthesis, print is a function call, and it will print only what's found inside the parentheses. Since that line had parentheses, it's the same to Perl as if you'd said this:
( print(2+3) ) * 4; # Oops!
Fortunately, Perl can almost always help you with this if you ask for warnings. So use -w, or use warnings, at least during program development and debugging.
This ruleIf it looks like a function call, it is a function callapplies to all list functions in Perl, not just to print, but you're most likely to notice it with print. If print (or another function name) is followed by an open parenthesis, ensure the corresponding closed parenthesis comes after all of the arguments to that function.