Presumably you know what you expect; if you have a first_name parameter, fetch the value in scalar context.

If you do need a truly generic solution, always call param() in list context; stuff the values into an array and check the number of elements of the array. If it's one, you have one value. If it's more than one, you have a list of values.

First, an issue of terminology. param() doesn't return an array, it returns a list. Secondly, using foreach with only one element is perfectly fine. It will simply loop once. You could use this as a generic (as chromatic mentioned) way to handle your CGI parameters, but I repeat his advice that you should probably only look for a list when you expect a list.

Both CGI and CGI::Simple store the param values internally as:

{
    key => [ val ],
    key2=> [ val1, val2, ... ]
}
[download]

So the values are really always 'arrays' (well array refs) but if there is one val it is a single element array.

The param method is sensitive to context via wantarray so if you call it in list context you get all the values, but in scalar context you get val->[0]. The || operator forces scalar context which is why your syntax does not work.

The easy way to do it is just assume you have a list, and loop through it. Looping through a list of one is quick ;-)

[me@here perl]$ cat foo.pl
#!/usr/bin/perl -l

use CGI qw(param);

print for param('foo');


[me@here perl]$ ./foo.pl 'foo=bar'
bar


[me@here perl]$ ./foo.pl 'foo=bar&foo=baz&foo=qux'
bar
baz
qux
[download]

One small point of terminology, "param" _never_ returns an array. It returns a list. The difference can be important.

Here's some code that does what (I think) you want.

my %params;

foreach (param) {
  $params{$_} = [ param($_) ];
  $params{$_} = $params{$_}[0] if @{$params{$_}} == 1;
}
[download]

You'll end up with a hash (%params) that contains a key/value pair for each parameter name. If the parameter is single-valued the value will contain that (single) value. If the parameter is multi-valued, then the value will be a reference to an anonymous array containing all of the values.

use strict;
use CGI::Simple qw(-debug2);

my $q = CGI::Simple->new();

for my $key ( $q->param() ) {

   # this:
   for my $value ( $q->param($key) ) {
      printf "'%s' has value '%s'\n", $key, $value;
   }

   # or this:
   print "'$key' has value(s):\n",
      map { "- $_\n" } $q->param($key);
}
[download]

my %condition=();
foreach my $key ( $q->param() ) {
    local @_;
    $condition{$key} = ( @_ = $q->param($key) ) - 1 ? \@_ : pop;
}
[download]

Update to an update: Actually what I really wanted to do was:

$condition{$key} = \@{$query->param($key)} || $condition{$key} = $quer
+y->param($key);
[download]

$condition{$key} = [$query->param($key)];
[download]

If you really need to, you can later do:

if (@{$condition{$key}} == 1) {
   # one value
}
else {
   # ... zero or more than one value
}
[download]