use CGI ':cgi-lib';
my $cgi = new CGI;
my $hash_ref = $cgi->Vars;
print $hash_ref->{'name'};
[download]

Or:

use CGI qw(:standard);

my %data = map { $_ => param ($_) } param();
[download]

The second line gets you the same result as

my %data;
foreach my $param ( param() ) {
    $data{$param}= param($param);
}
[download]

A call to param() (a function in the CGI module) in a list context gets you the name of all the parameters passed to the script via POST and GET. param("name") gets you the value of the passed "name" parameter.

HTH.

perl -e 'print "How sweet does a rose smell? "; chomp ($n = <STDIN>); 
+$rose = "smells sweet to degree $n"; *other_name = *rose; print "$oth
+er_name\n"'
[download]

arturo wrote:

        my %data = map { $_ => param ($_) } param();
[download]

While that will work for many cases, it fails with a query strings that have multiple values for a single name:

color=blue&color=red
[download]

There are two ways of resolving this. The first is map all hash keys to list references:

my %data = map { $_ => [ param($_) ] } param();
[download]

Because param() uses wantarray, it will return a list if called in that context. Accessing param names with a single value become $data{'someval'}->[0]. Some people might think that's a bit weird, so one could also do the following:

my %data = map { $_ => scalar @{[ param( $_ ) ]} == 1 ? param( $_ ) : 
+[ param( $_ ) ] } param;
[download]

With the following query string...

name=fred&color=red&color=blue
[download]

... the value for name can be accessed with $data{'name'} and the first value for color can be accessed with $data{'color'}->[0]

I don't like the second method because there winds up being two methods for accessing similar data. This will likely cause problems in the long run. Further, with the multiple calls to param(), it's less efficient. However, I really don't like either method (though I've posted similar stuff before) because when I see people blindly pulling in all of that data, they tend not to untaint it.

Cheers,
Ovid

Join the Perlmonks Setiathome Group or just click on the the link and check out our stats.

what exactly does:



use CGI qw(:standard);
my %data = map { $_ => param ($_) } param();
[download]



that do? whatever it does it worked fine, thanks alot... I'd just like to understand what's going on
heh

#!/usr/bin/perl -w

use strict;  #Trust us

use CGI;
my $query = CGI::new;
my %data = $query->Vars();
[download]

(Note: Masem above uses the same function in a scalar context to get a reference ($data). Used in a list context, Vars() will return a hash, which is what you asked for. Masem's solution is better if you intend to pass the data to subroutines, they work equally well if you treat them as global variables.)

can i use



use CGI qw(:standard);
my %data = map { $_ => param ($_) } param();
[download]

with both $ENV{'QUERY_STRING'} as well as <STDIN> because when I mannually open a script w/ just query string.. it works fine, but when I have input comming from both query string and <STDIN> it gives me an internal server error.

I'm not sure I'm clear on how you are using the script. There are three ways to pass data to a CGI script:
1. On the URL: script.cgi?foo=bar
2. Via a web POST (i.e. sent w/the HTTP request).
3. via STDIN, which is normally only used as a CGI debugging method.
1 & 2 can be combined. 3 (as far as I know), stands alone. How are you trying to do it?

@IN = params();
foreach $field (@IN){
DATA{$field} = param($field);
}
[download]

I think this creates a hash, %DATA. So, if you have a name of "name", to get that value it's $DATA{name}. Red------

You missed a $ off the front of $DATA{$field} which would prevent this code from compiling.

Even with that fix, it's still a bad idea as it breaks on multi-valued CGI parameters. See (Ovid) Re(2): use CGI for more details.

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

"Perl makes the fun jobs fun
and the boring jobs bearable" - me

That should be param(), not params(). Red------

Check this out:

#!/usr/bin/perl -w
###############################################################
use strict;
use CGI;
use Data::Dumper;

my $cgi=new CGI;

my $v={};
map { my($k,$vl) = ($_,$cgi->param($_));
     $v->{$k}=$vl;
    } $cgi->param();

print Dumper($v);
[download]

Running this a couple of different ways you get:

[pberghol@webdev0]:[~]
-$  echo "
> a=foo
> b=junk
> c=rats
> d=golf
> " | perl doParse.pl
(offline mode: enter name=value pairs on standard input)
$VAR1 = {
          'a' => 'foo',
          'b' => 'junk',
          'c' => 'rats',
          'd' => 'golf'
        };


[pberghol@webdev0]:[~]
[download]

[pberghol@webdev0]:[~]
-$  perl doParse.pl first=peter last=berghold hobby=cooking
$VAR1 = {
          'first' => 'peter',
          'hobby' => 'cooking',
          'last' => 'berghold'
        };


[pberghol@webdev0]:[~]
-$
[download]

Is this what you were after? HTH

See (Ovid) Re(2): use CGI for an explanation of why that is a bad idea. It breaks on CGI queries with multi-valued keys.

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

"Perl makes the fun jobs fun
and the boring jobs bearable" - me