no strict 'refs';
for($cgi->param) {
  ## &func is bad form, see. perlsub
  complain()
    unless exists  ${__PACKAGE__."::"}{$_}
       and defined *{ ${__PACKAGE__."::"}{$_} }{SCALAR}
       and defined ${ *{ ${__PACKAGE__."::"}{$_} }{SCALAR} };
}
[download]

_________
broquaint

Instead of fetching your form values individually, look at the CGI::Vars() method for retrieving a hash containing them.

If you then hold the values which you are comparing against in another hash, the comparison becomes a simple loop.

If you are looking for exact equality between the two lists, you can even use grep in the conditional.

my %checks = (var1=>'foo', var2='bar', var3=>'qux' );
my %params = q->Vars;
complain() 
    unless keys %checks 
    == grep{ $param{$_} eq $checks{$_} }keys %checks;
[download]

This relies on both grep and keys returning numeric values in a scalar context to determine if all the values in values in %checks had equivalent keys with the same value in %params.

I think your solution is just fine. Otherwise, you could use something like WWW::Form and set the 'optional' attribute on its validators as needed.

Update: Didn't notice that you were using symbolic refs. That makes your solution less fine (:

----
I wanted to explore how Perl's closures can be manipulated, and ended up creating an object system by accident.
-- Schemer

Note: All code is untested, unless otherwise stated

Try Params::Validate for all your parameter validation needs.

You can do something like this:

my $nonempty = sub { shift() ne '' };
my $check_params = {
    client1 => sub {
        validate( @_,
          { var1 =>
        { type => SCALAR,   # a scalar ...
              callbacks =>
              { # and is non-empty
                'not empty' => $nonempty,
              },
            },
            var2 =>
            { type => SCALAR,   # a scalar ...
              callbacks =>
              { # and is non-empty
                'not empty' => $nonempty,
              },
            },
        } );
    },
    client2 => sub {
         # more of the same
    },
  };

my %vars;
my @varnames = $q->param;
@vars{@varnames} = map { $q->param($_) } @varnames;
$check_params->{$client}->(%vars);
[download]

With this approach you can check for type, regex matching or require that an arbitrary subroutine(s) return true. You may want to consider generating the hash of functions, instead of having it hard coded.

Params::Validate is very nice.

TGI says moo

#!/usr/bin/perl -w
use strict;
use CGI;
#using params in a file 'cause I don't have a webserver handy
open(INPUTFILE,"c:\\temp\\inputs.dat");
 my $cgi = new CGI(\*INPUTFILE);
close(INPUTFILE);

my @keywords = qw~man dog horse barker~;

foreach(@keywords) {
    
    if (!defined($cgi->param($_)) || $cgi->param($_) eq ' ' || $cgi->p
+aram($_) eq '' ) {
    print "Nothing there for $_!\n";
    }
}
#contents of the .dat file are
#man=horse 
#dog=man 
#horse=
[download]

Celebrate Intellectual Diversity

my @varnames = qw{var1 var2 var3};
foreach my $var (@varnames)
  {
  if(${$var} eq "")
    {&complain};
  }
[download]

It's kind of ugly, but it might be the best solution..

It is ugly and it most definitely is not the best solution.

The correct solution involves using a hash and iterating through that hash. One way of doing this could be:

my @varnames = qw(
    Var1
    Var2
    Var3
);

my %params;
@params{@varnames} = map { $cgi->param($_) } @varnames;

if (grep { !defined $params{$_} || $params{$_} eq '' } @varnames)
{
    &complain;
}

# Now, at this point, you have read in all your parameters
# and verified that each is defined as well as not the
# empty string.

# Do other stuff here.
[download]

This also illustrates a very important concept in application development - separating the things that can change from the things that won't ... aka Encapsulation. We are separating out the logic from the things being logic'ed. This is especially important for you because you don't know which varnames you want to apply this logic to.

------
We are the carpenters and bricklayers of the Information Age.

Don't go borrowing trouble. For programmers, this means Worry only about what you need to implement.

Please remember that I'm crufty and crochety. All opinions are purely mine and all code is untested, unless otherwise specified.

I like this a bit more than a hash, but why not use real references?

foreach my $check ( \( $var1, $var2, $var3 ) )
{
    complain() if $$check eq '';
}
[download]

my @varlist = qw(var1 var2 var3);

foreach (@varlist) {
    if (!defined $cgi->param($_) || $cgi->param($_) eq "") {
        &complain($_);
        }
    }
[download]

Cheers all;
JP,
-- Alexander Widdlemouse undid his bellybutton and his bum dropped off --