Hi, if I have understood your question correctly then try this,

use strict;
use warnings;

#####Function 1#############
open (FF, "sample.xml")||die $!;
my @con = <FF>;
close(FF);

#Passing Array to a function
&function1(\@con);

#####Function 2#############
open (FF, "sample.xml")||die $!;

#Passing File handle to a function
&function2(\*FF);

close(FF);


sub function1{
    my ($con) = @_;
    
    #Dereference the array
    my @con = @{$con};
    
    $,="\n";
    print @con;
}

sub function2{
    my ($con) = @_;
    
    print <$con>;
}
[download]

View these How (Not) To Ask A Question and How do I post a question effectively?

You probably just need to pass a reference to the array into the function:

your_function(\@lis_array);
[download]

But if you really want to pass a file handle around then create a lexical filehandle and use that:

open my $kerlis, '<', $lis_file or die $!;
your_function($kerlis);

sub your_function {
  my $fh = shift;

  while (<$fh>) {
    # do something
  }
}
[download]

People will recommend passing the typeglob into the function, but in my opinion that's a confusing hack that is no longer necessary with modern versions of Perl.

GOOD:

fast(@data);
sub fast {
    my $x = $_[0];
}
[download]

slow(@data);
sub slow {
    my @arr = @_;
    my $x = $arr[0];
}
[download]

fast(\@data);
sub fast {
    my $arr = $_[0];
    my $x = $arr->[0];
}
[download]

no strict 'vars';
use Fatal qw(open);

open local(*KERLIS) , $file;
@KERLIS = <I>;
close KERLIS;
passboth( *KERLIS );

sub passboth {
        local *FH = shift;
        # print @FH;
        # open *FH, $file;
}
[download]

Example from the perlfunc docs

# process argument list of files along with any includes

 foreach $file (@ARGV) {
    process($file, 'fh00');
}

sub process {
    my($filename, $input) = @_;
    $input++;               # this is a string increment
    unless (open($input, $filename)) {
      print STDERR "Can't open $filename: $!\n";
      return;
    }

    local $_;
    while (<$input>) {              # note use of indirection
       if (/^#include "(.*)"/) {
           process($1, $input);
           next;
       }
       #...                # whatever
    }
}

See perliol for detailed info on PerlIO.
[download]

Hope it help

UnderMine

foreach $file (@ARGV) {
    process($file, 'fh00');
}

sub process {
    my($filename, $input) = @_;
    $input++;               # this is a string increment
    unless (open($input, $filename)) {
      print STDERR "Can't open $filename: $!\n";
      return;
    }

    local $_;
    while (<$input>) {              # note use of indirection
       if (/^#include "(.*)"/) {
           process($1, $input);
           next;
       }
       #...                # whatever
    }
}
[download]

Did you try that under "use strict"?

Can't use string ("fh01") as a symbol ref while "strict refs" in use

From perldoc open:

If FILEHANDLE is an undefined scalar variable (or array or hash element) the variable is assigned a reference to a new anonymous filehandle, otherwise if FILEHANDLE is an expression, its value is used as the name of the real filehandle wanted. (This is considered a symbolic reference, so use strict 'refs' should not be in effect.)

So what you're trying only works with "use strict" if the variable that you use for the filehandle contains an undefined value.

--
<http://dave.org.uk>

"The first rule of Perl club is you do not talk about Perl club."
-- Chip Salzenberg

True. I was quoting directly from perldoc perlfunc examples for open. Which seams different from the perldoc open.

UnderMine