my $thescalar=shift; 
my %thehash=shift;
[download]

my $thescalar = shift; # 1st parameter goes in $thescalar
my %thehash = @_;      # everything else goes in %thehash
[download]

my ($thescalar, %thehash) = @_;
[download]

Thanks for the quick reply... I used my %thehash=%{(shift)}; which does the trick as well... Should not have given up the search thanks again for replying

Some observations:

• The code doesn't compile. It's missing a semicolon.
• Modules must return a true value, or else perl will think something's wrong with it and refuse to continue.
• The name of your module shouldn't be all lowercase, or you risk clashing with some future Perl pragma.
• I don't think you need a BEGIN block
• It's better to use our instead of vars.

For passing the hash to the sub, you can use a reference. Try this module...

## file: Myperl.pm
package Myperl;

use strict;
require Exporter;

our $VERSION     = 0.1; 
our @ISA         = qw(Exporter);
our @EXPORT      = qw(getInfo);
our %EXPORT_TAGS = ();
our @EXPORT_OK   = qw();
 
sub getInfo {
  my $thescalar=shift;
  my $thehash=shift;    ## pick a reference

  print "scalar: $thescalar\nhash:\n";
  print "$_ => ", $thehash->{$_}, "\n" for keys %$thehash;
}
  
1;
[download]

...with this code:

use Myperl;
my $s=4;
my %h=(0..5);
my $myresult=getInfo($s, \%h);  ## pass a reference
[download]

TheDamian in his recent tome, Perl Best Pratices explains on pp194-196 just what can go wrong with code using prototypes and why. When I first started using Perl I used prototypes, for, oh, about the first week! I had come from 'C' and expected that this was how things should be done. My problem was the one pointed out on p195. If a prototype is given thus (stolen shamelessly from shmem's reply

#!/usr/bin/perl

sub getInfo ($\%) {
    my $scalar = shift;
    my $hash = shift;
    print "scalar = '$scalar'\n";
    print "hash = $hash\n";
    print "$_ => $hash->{$_}\n" for keys %$hash;
}   

my %hash = (foo => 'bar', baz => 'quux');
my $scalar = 'string';

getInfo($scalar,%hash);
__END__
[download]

getInfo($scalar,%hash);
[download]

my ( $thescalar, %thehash ) = @_;
[download]

If we want to pass a hash reference, why not do it explicitly:

sub getInfo {
  my ( $thescalar, $thehashref ) = @_;
  ....
}

getInfo( $scalar, \%hash );
[download]

sub getInfo {
  my ( $thescalar, %thehash ) = @_;
  ....
}

getInfo( $scalar, %hash );
[download]

jdtoronto

jdtoronto++, absolutely right. What gets passed are references. But it is just this fact which lets us do calls like

getInfo $scalar, @array, %hash;
[download]

and have the arguments not collapsed into a flat list:

#!/usr/bin/perl
package Foo;
use Exporter;
our @ISA    = qw(Exporter);
our @EXPORT = qw(getInfo);

sub getInfo ($\@\%) {
    my $scalar = shift;
    my $array = shift;
    my $hash = shift;
    print "scalar = '$scalar'\n";
    print "array = $array\n";
    print "hash = $hash\n";
    print '('.join(', ',map{"'$_'"} @$array).")\n";
    print "$_ => $hash->{$_}\n" for keys %$hash;
    push @$array, 'unexpected';
} 

1;
__END__

# calling programm foo.pl
#!/usr/bin/perl

use Foo;
my $scalar = 'string';
my @array  = qw(di da doh);
my %hash = (foo => 'bar', baz => 'quux');

getInfo $scalar, @array, %hash;
print "passed array: ".join(', ',map{"'$_'"} @array).")\n";
__END__

# output
scalar = 'string'
array = ARRAY(0x8190b74)
hash = HASH(0x81677bc)
('di', 'da', 'doh')
baz => quux
foo => bar
passed array: 'di', 'da', 'doh', 'unexpected')
[download]

True, the reference constructions are implicit and thus somewhat obscure, but I see them as a feature akin to autovivification. And the prototype check at compile time is something like a use strict for function arguments. The fact that the sub is able to modify the caller's arguments is something inherent to references and would be the same if we just passed references.

It's arguably not a good practice to do calls like getInfo $scalar, @array, %hash instead of using references in the first place on both sides of the call, because normally $scalar, @array and %hash are flattened into a single list, and it is not visible from the caller's perspective what will happen on the other end.

OTOH, if the arguments are flattened into a list and you do

sub getInfo {
    my $scalar = shift;
    my %hash   = @_;
}
[download]

you should check scalar @_ for evenness before assigning.

But then, them's flavours, and as everywhere, the behaviour and calling conventions of subs / methods must be documented, and you must just know what you're doing... TIMTOWTDI ;-)

greets,
--shmem

update: an excellent example using function prototypes is Embedding a mini-language for XML construction into Perl.

_($_=" "x(1<<5)."?\n".q·/)Oo.  G°\        /
                              /\_¯/(q    /
----------------------------  \__(m.====·.(_("always off the crowd"))."·
");sub _{s./.($e="'Itrs `mnsgdq Gdbj O`qkdq")=~y/"-y/#-z/;$e.e && print}

You could use prototypes (see perlsub, caveats here). Consider:

#!/usr/bin/perl

sub getInfo ($\%) {
    my $scalar = shift;
    my $hash = shift;
    print "scalar = '$scalar'\n";
    print "hash = $hash\n";
    print "$_ => $hash->{$_}\n" for keys %$hash;
}   

my %hash = (foo => 'bar', baz => 'quux');
my $scalar = 'string';

getInfo($scalar,%hash);
__END__
[download]

output:

scalar = 'string'
hash = HASH(0x81677a4)
baz => quux
foo => bar
[download]

This has the advantage of throwing an error at compile time if the wrong arguments are passed in:

my @array = qw(foo bar baz);
getInfo($scalar, @array);

Type of arg 2 to main::getInfo must be hash (not private array) at foo
+.pl line 16, near "@array)"
[download]

--shmem

you mean Passing, not Parsing :-)

update: inserted "You could" and caveat :-)

_($_=" "x(1<<5)."?\n".q·/)Oo.  G°\        /
                              /\_¯/(q    /
----------------------------  \__(m.====·.(_("always off the crowd"))."·
");sub _{s./.($e="'Itrs `mnsgdq Gdbj O`qkdq")=~y/"-y/#-z/;$e.e && print}

Thanks it works now!