Sidenote: Using both $array and @array in your code decreases its readability and makes it error prone.

I wanted to go through your simple example line by line to try to shed light:

foreach my $line (@$array) {
[download]

Here $line is becoming an alias for each element in the array referenced by $array, one iteration and one element at a time. Any changes made to the contents of $line will propagate back to the corresponding element in @{$array}. So, you're on the right track.

    chomp $line;
[download]

Assuming $line contains a trailing "newline" character ( \n ), and also assuming that the special variable, $/ (the input record separator) hasn't been tampered with, and is set to the default of \n, chomp will remove the trailing newline character. Here is one area where you may have a problem. If $/ has been changed from its default, you may be expecting to chomp a newline, when in reality you're chomping some other value. More on this later.

print "$line**";
[download]

Now in your output you're not printing a newline character. Since you've already chomped the input record separator out of $line, (again assuming $/=="\n") there won't be a newline printed between iterations. This can cause the output buffer to not immediately flush. This isn't necessarily related to your problem, but it could be leading to difficult to read output, unless there's something later on in the loop we don't know about that is outputting a newline.

my @array = split(/\t/, $line);
[download]

This is just a style point. We have a loop based on @{$array}, and a lexical within the loop named @array. With this sort of naming strategy you're not doing yourself any favors with respect to clarity. In particular, the inner lexical may be given a more descriptive name that avoids visual confusion with @{$array}.

...}
[download]

The omitted code paraphrased by "..." may contain something relevant here. The question may be, "How do you know chomp isn't working?" Whatever comes next in the loop might help us, or may not. But the point is that nothing contained within your example would explain why chomp isn't doing what you expect it to be doing.

My theory is that you may have one of the following issues:

• $/ is set to something other than newline.
• Your test to see if newline is being chomped could be flawed, and if that's the case, we might see the flaw in the omitted code that comprises the remainder of your loop.
• You may have more than one trailing newline, with $/ set to "\n" instead of "".
• There may be some other whitespace or non-printing character between two newline characters. chomp, in paragraph mode, will remove all trailing newlines. But if you have a trailing "\n\t\n", only the last "\n is removed, since the first one isn't "trailing" (there's a tab after it.

I would start by wrapping that loop in the following code:

{
    local $/ = ""; # Set paragraph mode
    foreach my $line .............
    ....}
}
[download]

In other words, localize the special variable $/, and set it to paragraph mode to see if that resolves your issue. It's an easy test, and while it may not be the problem, it only takes a few seconds to check so that it can be eliminated as an issue. In Paragraph Mode chomp will remove all trailing newlines, even if there's more than one.

Perhaps the value doesn't end in a newline, or perhaps someone changed $/. You can check what the values of $line and $/ using

use Data:::Dumper;

{
   local $Data::Dumper::Useqq = 1;
   print(Dumper($var));
}
[download]

You might have better luck with the following:

$line =~ s/\s+\z//;
[download]

You could chomp @$array outside the loop which has the same effect as the chomp inside the loop but makes it obvious that that is happening. $line is aliased to each element of @$array so the contents of @$array is altered by the loop in any case.

#!/usr/bin/perl -w
use strict;

my @a = ( "asdfadsf  df\n", 
         "qrwtqtre ab\n");
my $ref = \@a;

print "simple print\n";
foreach my $line (@a)
{
   print $line;
}

print "\nnow with chomp\n";
foreach my $line (@$ref)
{
    chomp $line; ## this modifies @a
    print "$line**";
}

print "\nnow again simple print\n";
foreach my $line (@a)
{
   print $line;
}

__END__
simple print
asdfadsf  df
qrwtqtre ab

now with chomp
asdfadsf  df**qrwtqtre ab**
now again simple print
asdfadsf  dfqrwtqtre ab
[download]

Thanks again for all the help! The lines ended in \r\n, so a substitution did the trick. Cheers, Michael