#print $hash{key} "This is line 4.\n";

Note {} curly braces around $hash{key}:
    print {$hash{key}} "This is line 4.\n";

Update: From print:

If you're storing handles in an array or hash, or in general whenever you're using any expression more complex than a bareword handle or a plain, unsubscripted scalar variable to retrieve it, you will have to use a block returning the filehandle value instead, in which case the LIST may not be omitted:

    print { $files[$i] } "stuff\n";
    print { $OK ? *STDOUT : *STDERR } "stuff\n";

Did you consider redirecting your default output with select rather than passing it as an argument?

UPDATE: I believe that the OP is passing a file-handle to a subroutine using the method that his reference (Cookbook recipe 10.7) calls 'Named Parameters'. Using this method, the file-handle is stored as a value in a hash. He as asking for the syntax to use that value in a print statement. AnomalousMonk has provided the answer. My suggestion to use select to pass the file-handle to the subroutine would work, but I no longer recommend it.

use strict;
use warnings;

myfunction1( handle => \*STDERR);

sub myfunction1{
    my %hash = (
        handle => \*STDOUT,
        @_
    );
    print "something will happen\n";
    print {$hash{handle}}  "anything from myfunction1\n";
#         ^             ^   # braces added here

}
[download]

Did you consider redirecting your default output with select rather than passing it as an argument?

The handle is not passed as an argument, if it was, it would be followed by a comma. It is actually indirect object syntax (method $object @arguments in contrast to $object->method(@arguments)), see perlobj.

Using select is a global operation, it switches the default handle for all write, print, and (not yet documented in select) say <Update>without an explicit handle</Update> from STDOUT (or whatever was previously selected) to the handle passed to select. This has consequences that may lead to unwanted features a.k.a. bugs:

package Some::Third::Party::Module;
# ...
sub doSomething
{
   say "This will take some time";
   sleep 10;
   say "Done";
}
# ...
[download]

#!/usr/bin/perl
# ...
use Some::Third::Party::Module qw( doSomething );
# ...

open my $h,'>:raw','output.bin';
my $oldSelected=select $h;
print "\x00\x42\xAF\x99";
doSomething();
print "\x33\xFF\x81\x73";
select $oldSelected;
close $h;
[download]

Guess why output.bin is longer than expected and does not work as expected.

Using the usual indirect object notation fixes the problem:

open my $h,'>:raw','output.bin';
print $h "\x00\x42\xAF\x99";
doSomething();
print $h "\x33\xFF\x81\x73";
close $h;
[download]

Of course, if you like the mental pain and want to get hurt by the future maintainer, you could also select handles as needed. Welcome back to the 1960s, when this was the only way to handle files in MUMPS:

open my $h,'>:raw','output.bin';
my $oldSelected=select $h;
print "\x00\x42\xAF\x99";
select $oldSelect;
doSomething();
select $h;
print "\x33\xFF\x81\x73";
select $oldSelected;
close $h;
[download]

I would not use select to globally switch file handles, not even for a short piece of code. It just causes way too much trouble.

Alexander

--
Today I will gladly share my knowledge and experience, for there are no sweeter words than "I told you so". ;-)

Good point! The function select acts as if it controls an anonymous global variable. That 'variable' has all the advantages and disadvantages of any global variable except that we cannot examine it. In your example, we all expect say to output to stdout. It is easy to forget that it may not be true.

Until the documentation for say is corrected, the victim of this bug could certainly claim that the bug is in perl, not his code.

Bill

G'day Fireblood,

$ alias perle
alias perle='perl -Mstrict -Mwarnings -Mautodie=:all -MCarp::Always -E
+'
[download]

Probably the first thing to note is that filehandles are globrefs. Here's an example (along with a hashref for comparison).

$ perle 'open my $fh, ">", "not_a_file"; say "$fh"; unlink "not_a_file
+";'
GLOB(0x8000c42e0)

$ perle 'my $hashref = {}; say "$hashref";'
HASH(0x800003bc8)
[download]

Had you used the strict pragma, you would have seen:

Bareword "STDERR" not allowed while "strict subs" in use ...
[download]

Always start your code with the following:

use strict;
use warnings;
[download]

or code that gives you one or both of those (e.g. use v5.12 gives you strict; use v5.36 gives you strict and warnings; various modules have similar effects):

The next question might be, what should you use instead of STDERR? I'd argue that \*STDERR is strictly correct as it's a globref; however, *STDERR will also work.

$ perle 'my $x = \*STDERR; say "$x";'
GLOB(0x80008fcd0)

$ perle 'my $x = *STDERR; say "$x";'
*main::STDERR
[download]

That finally brings us to how to use the hash value without an intermediate scalar value. You have two main options (perhaps others will suggest additional ones).

• As already mentioned by ++AnomalousMonk, continue to use "Indirect Object Syntax" and wrap the hash value in braces:

  $ perle 'my %fh = (err => \*STDERR); print {$fh{err}} "errmsg\n";'
  errmsg
  
  $ perle 'my %fh = (err => *STDERR); print {$fh{err}} "errmsg\n";'
  errmsg
  [download]

• Use the hash value with the filehandle, and invoke print, say, and so on, as methods:

  $ perle 'my %fh = (err => \*STDERR); $fh{err}->print("errmsg\n");'
  errmsg
  
  $ perle 'my %fh = (err => *STDERR); $fh{err}->print("errmsg\n");'
  errmsg
  [download]

may I suggest you use the approach to call print as a direct method?

> perl -de0
...
  DB<108> open my $x, ">", \$out; $h{k}=$x

  DB<109> $h{k}->print("bla")

  DB<110> p $out
bla
  DB<111> open FH, ">", \$out2; $h{k2}=FH

  DB<112> $h{k2}->print("bla")

  DB<113> p $out2
bla
  DB<114>
[download]

NB: I directed the output to $out vars only for demo purpose, it will work with all destinations.

°) bareword FH, glob *FH, glob-ref \*FH, ...

Sorry, this

> $h{k2}=FH

will only work in no strict scenarios, here corrected versions

use v5.12;
use warnings;
use Data::Dump;


my %h;

open my $fh, ">>", \ my $out;
$h{k}=$fh;
$h{k}->print("bla");
dd $out;


open FH2, ">>", \ my $out2;
$h{k2}=*FH2;
$h{k2}->print("bla2");
dd $out2;


open FH3, ">>", \ my $out3;
$h{k3}=\*FH3;
$h{k3}->print("bla3");
dd $out3;


# open FH4, ">>", \ my $out4;
# $h{k4}=FH4;
# $h{k4}->print("bla4");
# dd $out4;

# Bareword "FH4" not allowed while "strict subs" in use at c:/tmp/pm/f
+h.pl line 27.
# Execution of c:/tmp/pm/fh.pl aborted due to compilation errors.
[download]

    
"bla"
"bla2"
"bla3"
[download]

FWIW: I prefer the 3rd $h{k3}=\*FH3 over the 2nd variant

Cheers Rolf
_{(addicted to the Perl Programming Language :)
Wikisyntax for the Monastery}