How about something like this:

$cgi->param($_) =~ tr/*//d foreach $cgi->param;
[download]

Note that I've switched to using tr for removing characters.

The code becomes even easier if you use the functional interface to CGI.pm:

param($_) =~ tr/*//d foreach param;
[download]

Update: Of course, merlyn's point below is right. This code was never going to work. CGI::param doesn't return an lvalue, so you cant' assign to it. Use the code that he proposes instead.

I wonder if all the people who voted this node up had actually tried the code :)

"The first rule of Perl club is you don't talk about Perl club."

Try this instead:

for my $p (qw(field1 field2)) {
  local $_ = $cgi->param($p);
  s/\*//g; # or tr/*//d;
  $cgi->param($p, $_); # set it back
}
[download]

-- Randal L. Schwartz, Perl hacker

Now that we have somewhat functional code, it is still broken for two reasons.

The first has to do with CGI's attempts to overload the param function with every possible behaviour. What happens if your form has an input variable named "-name"?

The second has to do with Perl's list versus scalar context. What happens if your form sent back multiple values with the same name?

Here is more robust code, using the functional interface (easily translated into the OO interface):

foreach my $name (param()) {
  my @values = param($p);
  s/\*//g foreach @values;
  param( -name=>$name, -values=>\@values );
}
[download]

And people wonder why I prefer to avoid creating highly magical polymorphic interfaces? Note between merlyn and myself in 8 lines of code, with 5 different invocations of the param function, no two of them used the same part of the possible interface! (This is even true if you don't count the OO vs functional invocation issue.) People handle context pretty well, true, but there is a limit beyond which people start having problems. And when you mess up for this reason, it isn't very obvious that you did mess up, or what you did wrong!

for (qw!field1 field2!) {
    $cgi->param($_) =~ s/\*//g;
}
[download]

Assuming your input is well-behaved, you might pop all of it into a hash with something as simple as

# updated -- davorg noticed that $-> ... should be $_=>
my %input = map { $_=>$cgi->param($_) } $cgi->param();
[download]

Warning: this won't work if you have multiple fields with the same name (that returns a list, not a scalar, as this code assumes -- if this is an issue, it can be dealt with, but I'll assume the simple case). Alternately, you can use the backwards-compatbility ReadParse function:

CGI::ReadParse();
# input values now in hash named "%in"
[download]

Anyhow, once it's all into the hash, you can do a

foreach my $key (keys %input) {
 $input{$key} =~ tr/*//d;
 # or whatever makes sense
}
[download]

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]

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

can be written as:

my %input = map { $_ => scalar $cgi->param($_) } $cgi->param();
[download]

to fix the possible "multiple value" problem, for some version of "fix". (Your arrow was wrong, by the way.)

foreach my $key (keys %input) { 
 $input{$key} =~ tr/*//d; 
 # or whatever makes sense 
}
[download]

can be written as:

tr/*//d for values %input;
[download]

for recent versions of Perl.

-- Randal L. Schwartz, Perl hacker

Second, read the docs, eg CGI.

Than, your code can be shuffled into:

for my $field ($cgi->param){
  $cgi->param($field) =~ s/search/replace/g;
}
[download]

Try subsequently to rethink your regexes...

Jeroen
"We are not alone"(FZ)

Update /me humbly crawls in the dust, ashamed of the mere suggestion, let alone the naked fact, of the use of $cgi->param as an l-value. I just was not thinking, that's the only thing I can come up with. That's not even an excuse. As a self-proclaimed punishment:

    open LETEVERYBODYKNOW, ">/var/www/index.html";
    print LETEVERYBODYKNOW "Thou shall not use CGI's param as an l-val
+ue\n" for 1..117682;
[download]