You use strict and warnings, that is good.
You use @_ so strict doesn't complain when you don't declare a variable, that is bad.

@_ is a special variable that Perl uses to provide you with the arguments that were passed to a subroutine. (which is why strict ignores it). What is happening is that you set @_ to two values, you then call handle_fix. Perl then silently replaces the values in @_ with that arguments passed to the subroutine (empty array), and runs the sub. On return Perl restores the old values of @_ and merrily continues along, making you angry :)

I would change the code to something more like...

se strict;
use warnings;

#why negate, reverse the operations. Also, specifying STDIN is more se
+lf documenting.
my $infile  = @ARGV ? shift(@ARGV) : <STDIN>;
my $outfile = @ARGV ? shift(@ARGV) : <STDIN>;

handlefix($infile,$outfile);

open(INFILE, '<', $infile) or die "\nCan't open $infile: $!\n";
open(OUTFILE, '>', $outfile) or die "\nCan't open $outfile: $!\n";

print OUTFILE 
               map { my $s=$_; $s=~s/\s*#.*$//; $s } 
              (grep { !/^\s*#/ } <INFILE>), "\n"   ; 

#close INFILE && close OUTFILE; close returns a value... if the first 
+close fails Perl will ignore second close

close INFILE;
close OUTFILE; 

sub handlefix {
    for(@_){
        chomp($_);
        $_=~s/"//g;
        $_=~s/\//\\/g;
    }
}
[download]

sub handlefix {
    my @return;
    for(@_){
        my $val = $_; #decouple the value from the argument variable
        chomp($val);
        $val =~ s/"//g;
        $val =~ s/\//\\/g;
    }
    return @return;
}
($infile,$outfile) = handlefix($infile,$outfile); #more obvious what i
+s happening
[download]

Wow, I ask for advice and get an entire mini-tutorial.
THAT'S why I love it here.

Thanks for the schooling, I never knew that you could specify variables to be used in a subroutine!

my and local work in any scope...

my $test = 1;
print "$test\n";
{
  my $test = 2;
  print "$test\n";
  test(3);
}
print "$test\n";

sub test {
  my($test) = @_; # parens make list assignment, otherwise you get the
+ count of items in @_
  print "$test\n";
}

#prints...
1
2
3
1
[download]

You can also do something like

while(my $var = shift @ARGV) {
  print "$var\n"; # var is scoped only in the while loop
}
[download]

                - Ant
                - Some of my best work - (1 2 3)

my $infile = !@ARGV?<>:shift @ARGV;
my $outfile = !@ARGV?<>:shift @ARGV;
handlefix($infile, $outfile);
[download]

Might I also suggest to rewrite conditionals to avoid having a negative condition? For example, $infile = @ARGV ? shift @ARGV : <>

Whoops, I didn't re-think the logic of it.
I have the negative condition in there because I originally started with two commands, and spent maybe half an hour frustrated because I could not figure out why, even with cmd arguments, it asked me for input.

I eventually figured out that because I was shifting @ARGV, there was nothing left afterwards. ;)

Note what happens when you do:

print "Debug:  Arguments are $_[0] and $_[1]\n";
[download]

Read about chop and chomp for more information on how to remove newlines.

Here's a better implementation of what you're trying to do (note that chomp only removes the last character if it's a newline):

chomp(my $arg1 = shift || <>);
chomp(my $arg2 = shift || <>);
[download]

Liverpole -- I know I have a newline in my arguments, but I also have them being chomped in the subroutine. :-\
That's why i'm so confused.

Whoops -- didn't read that far :-/

It's because you're not passing @_.

You could fix this with:

handlefix(@_);
[download]

but it's really better practice to chomp the variables on input, and assign them to actual variable names, leaving @_ to its better purpose of the default argument list.

---

s''(q.S:$/9=(T1';s;(..)(..);$..=substr+crypt($1,$2),2,3;eg;print$..$/

Because handlefix(); sends nothing to @_ in your sub.

Take a look at perlsub, @_ is local

grep

XP matters not. Look at me. Judge me by my XP, do you?