...
while (<$FH>){
   {
      local $/="\r\n";
      chomp;
   }
...
}
...
[download]

That was it, thanks.

Your string probably ends in "\r\n". You're chomping "\n", then complaining about the "\r" you didn't remove.

To verify, you can use:

use Data::Dumper;
$Data::Dumper::Useqq = 1;
print(Dumper($_));
[download]

Do a Super Search for solutions. This comes up all the time, once quite recently.

1. Starting each script and module with use strict;use warnings; can save you a bunch of headaches. The virtues of these pragmas have been extolled extensively on this site. For example, Use strict warnings and diagnostics or die.
2. You should consider using 3-argument open instead of 2. It allows for some more security against malicious people and messing stuff up. If your case, line 5 would be changed to

   open(plate_file,'<',$filename.".csv") or die "Can't open: $!";

   See open,perlopentut for some more details.

3. Rather than building your own paths, you might consider using File::Spec to do it for you, in a platform independent way.
4. In fact, rather than rolling your own CSV parser, consider using Text::CSV.
5. Regarding your second question, in list context a regular expression returns the captured expressions. So you could write something like:

   #!/usr/bin/perl 
   
   use strict;
   use warnings;
   my @data;
   while(<DATA>) {
       my @row = split /,/,(/(.*)\n?/)[0]; # <-- nice and clear, right?
       shift(@row);
       push(@data,@row);
   }
   print join "\n", @data;
   __DATA__
   1,2,3,4
   2,3,4,5
   3,4,5,6
   [download]

I could go on, but that should give you plenty to chew on.

Thanks, these suggestions are helpful. Regarding #5, that makes sense now - I had thought that would simply store true or false in the array. I do have a couple questions about the expression you used in #5. I get that /(.*)\n?/ matches all characters before the newline character, but I don't understand the outer outer parenthesis or the [0]. Also, is the ? necessary? Each line should end /n so is the ? there because of good practice or for some other reason?

The purpose of the ? on the newline is to make it not essential that the line ends with a new line. This handles the edge case where the file is not ended with a newline character - otherwise, that wouldn't match the expression and it would be silently dropped. For some reference on regex construction, see perlre and perlretut.

The purpose of the parentheses is to put the regular expression in list context, and then the [0] index takes the first and only element, which is the expression in the parentheses. Without that, the regular expression would be in scalar context because of the split function, and would return only the true/false. Perl's ability to modify functional behavior's based upon context is one of its great strengths, though it can also cause significant confusion to new acolytes.

(Update): After ack clarification, and I always have been having a trouble with scalar and list contexts, I would say I retract my observation since I thought the $firstline is the same as the @firstline, thanks ack and excuse my ignorance for I am still learning too.

From the op's code, $firstline appears to be scalar context, not list context (which would use the sigil '@' rather than the op's sigil '$'). In scalar context, the input operator '< >' only returns the next line; in list context (e.g., @firstline), the input operator '< >' will read all the lines in the file...one line per list element in @firstline). Hence, that part of the op's code looks to me to be OK.

I believe that the other responders' notations and observations (i.e., that the op has failed to account for the what is actually at the end of each input line in terms of the line separators) are the likely source of the op's difficulties.

ack Albuquerque, NM