Section 5.4.  Output to Standard Output

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:

^[*] Well, it doesn't add anything extra by default, but this default (like so many others in Perl) may be changed. Changing these defaults will likely confuse your maintenance programmer, so avoid doing so except in small, quick-and-dirty programs or (rarely) in a small section of a normal program. See the perlvar manpage to learn about changing the defaults.

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

^[] Yes, the spaces are another default. See the perlvar manpage again.

^[] You know that we mean a three-element list here, right? This is just Perl notation.

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:

    print @array;

But if they don't contain newlines, you'll generally want to add one at the end:

    print "@array\n";

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.^[*]

^[*] In fact, the Perl Power Tools (PPT) project, whose goal is to implement all of the classic Unix utilities in Perl, completed nearly all the utilities (and most of the games) but got bogged down when they got to reimplementing the shell. The PPT project has been useful because it has made these standard utilities available on many non-Unix machines.

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:

^[*] We say "immediately" here because Perl won't permit a newline character between the function name and the open parenthesis in this kind of function call. If there is a newline there, Perl will see your code as making a list operator, rather than a function call. This is the kind of technical detail that we mention for completeness. If you're terminally curious, see the full story in the manpages.

    print (2+3);

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.

^[] Functions that take zero or one arguments don't suffer from this problem.