use warnings; use strict;
sub print_to {
    print {$_[0]} $_[1];
}
print_to (*STDOUT, "test stdout");
print_to (*STDERR, "test stderr");
[download]

goeb -

Why do I get the error 'scalar found where operator expected' if I omit the braces around the $_[0]? What are the braces doing and why aren't they required around the second element?

Regards,
Scott

From the docs for print:

Note that if you're storing FILEHANDLEs in an array, or if you're using any other expression more complex than a scalar variable to retrieve it, you will have to use a block returning the filehandle value instead:

I believe the braces define a block of code, and I believe $_[0] qualifies as an 'expression more complex than a scalar variable'. If you refactor the sub like this, then the braces around the FILEHANDLE are not needed:

use warnings; use strict;
sub print_to {
    my ($fh, $str) = @_;
    print $fh $str;
}
print_to (*STDOUT, "test stdout");
print_to (*STDERR, "test stderr");
[download]

I recommend one of the following. (All the code below are UNTESTED and may contain errors.)

• If the output data is short, just collect it to a string, eg.

  sub foo {
      my $o = "";
      $o .= "blah\n";
      $o;
  }
  if ($to_file == 0) {
      print foo();
  } else {
      print MYFILE foo();
  }
  [download]

• Use the default filehandle you select, eg.

  sub foo {
      print "blah\n";
  }
  my $OLDH;
  if ($to_file) {
      $OLDH = select MYFILE;
  }
  foo();
  $OLDH and select $OLDH;
  [download]

• Pass a filehandle as an argument to the function and print to that, eg.

  sub foo {
      my($O) = @_;
      print $O "blah\n";
  }
  foo($to_file ? *MYFILE : *STDOUT);
  [download]

• Pass a callback sub as an argument to the function that's called for each line.

  sub foo {
      my($P) = @_;
      &$P("blah\n");
  }
  foo($to_file ? sub { print MYFILE @_ } : sub { print @_ });
  # or foo(sub { if ($to_file) { print MYFILE @_ } else { print @_ } });
  [download]

• Same as above but with a global variable or global sub instead of argument, eg one of.

  our $O;
  sub foo {
      print $O "blah\n";
  }
  $O = $to_file ? *MYFILE : *STDOUT;
  foo();
  # OR
  sub foo {
      print O "blah\n";
  }
  *O = $to_file ? *MYFILE{IO} : *STDOUT{IO};
  # (the {IO} is not strictly needed but this way we avoid overwriting $
  +O etc)
  foo();
  # or same as above but like
  open O, ">&=", ($to_file ? *MYFILE : *STDOUT);
  # or you could even use *MYFILE instead of *O
  # OR
  sub foo {
      my($P) = @_;
      pri("blah\n");
  }
  sub pri {
      if ($to_file) { print MYFILE @_ } else { print @_ }
  }
  [download]

my $out_fh;
if ($to_file) {
    open($out_fh, '>', ...)
        or die(...);
} else {
    $out_fh = \*STDOUT;
}

...

print $out_fh "blah\n";
[download]

You can also change the default handle:

if ($to_file) {
    open(my $out_fh, '>', ...)
        or die(...);
    select($out_fh);
}

...

print "blah\n";
[download]

This is why I LOVE this website...so many options! Thanks to everyone that responded. The quickest and most direct route for me is to store to a concatenated string and then print that string to either STDOUT or MYFILE depending on how I call a print function.

print that string to either STDOUT or MYFILE depending on how I call a print function.

print { $to_file ? *MYFILE : *STDOUT } $str;
[download]