You should change:

            chomp $_;

            # Split the line by whitespace
            my @array = split (/\s+/, $_);

            # If the first column of a line is blank whitespace, shift
+ it out so the
            # first column corresponds to actual user viewable data, w
+hich is the way
            # a user will count the columns, ignoring leading whitespa
+ce.
            if ($array[0] eq "") {
                shift (@array)
            }
[download]

To:

            # Split the line by whitespace
            my @array = split;
[download]

Because split with no arguments ignores leading whitespace so there is nothing to remove and it also removes all trailing whitespace so there is nothing for chomp to remove.

            while (<@array>) {
[download]

That is short for:

            while (glob join $", @array) {
[download]

and it is usually written as:

            foreach (@array) {
[download]

Thanks for the tips. Incorporated and tested fine.

Question: What is better coding practice and quicker?

        if (defined($opt_ignore)) {
            if (defined($opt_reverse)) {
                $map{lc($array[1])} = $array[0]
            } else {
                $map{lc($array[0])} = $array[1]
            }
        } else {
            if (defined($opt_reverse)) {
                $map{$array[1]} = $array[0]
            } else {
                $map{$array[0]} = $array[1]
            }
        }
[download]

or

$map{ (defined($opt_ignore) ? lc( (defined($opt_reverse) ? $array[1] :
+ $array[0])) : (defined($opt_reverse) ? $array[1] : $array[0])) } = (
+defined($opt_reverse) ? $array[0] : $array[1])
[download]

I would avoid both of those approaches. The first involves too much repetition of code, and the second is too obfuscated. How about like this:

my ( $src, $dst ) = ( $opt_reverse ) ? ( 0, 1 ) : ( 1, 0 );

if ( $opt_ignore ) {
    $map{lc($array[$dst])} = $array[$src];
} else {
    $map{$array[$dst]} = $array[$src];
}
[download]

(I hope I got the polarity right on what "reverse" means, but in any case, I think you can see the point.)

(update: got rid of the "defined()" call -- the option values should just be true or false, and undefined is false)

Another update: better solution:

my ( $src, $dst ) = ( $opt_reverse ) ? (0,1) : (1,0);
my $key = ( $opt_ignore ) ? lc($array[$dst]) : $array[$dst];

$map{$key} = $array[$src];
[download]

The first one looks a lot more readable and maintainable.   As for speed, you would have to use something like Benchmark to determine which is fastest.

Since pod2usage by default exits, your explicit exit calls are redundant at best and confusing at worst. This

pod2usage(-verbose => 1) && exit if defined $opt_help;
[download]

pod2usage(-verbose => 1) if defined $opt_help;
[download]

You could also take advantage of the -message option. This

    print "$0: input_file required\n";
    pod2usage(-verbose => 0) && exit
[download]

    pod2usage(-verbose => 0, -message => "$0: input_file required\n")
[download]

A comment on Getopt::Long usage: instead of declaring several separate $opt_XXX scalar variables, it might be more natural Storing options values in a hash.

april
barrel
[download]

225    April
1168    barrel
3143    Il
9432    PR
....
[download]

a94323143
11777rr340
[download]

It happens because the map file is read into a hash and normally there is no "order" to a hash. Thus, you can't guarantee that the search and replace will happen in the order you give in you map file.

You're actually hitting this part of the code:

        # user didn't specify columns, so just SAR each line and leave
+ alone
        } else {

            # loop through mapping array for each line
            foreach my $replace (keys(%map)) {
                # ignore case?
                if (defined($opt_ignore)) {
                    $YESMapping += ($_ =~ s/$replace/$map{$replace}/gi
+)
                } else {
                    $YESMapping += ($_ =~ s/$replace/$map{$replace}/g)
                }
            }
            print $OUT $_
        }
[download]

Stick in a helpful print to "debug" what's going on:

        # user didn't specify columns, so just SAR each line and leave
+ alone
        } else {

            # loop through mapping array for each line
            foreach my $replace (keys(%map)) {
                # ignore case?
                if (defined($opt_ignore)) {

print "SAR on $_ with $replace\n";

                    $YESMapping += ($_ =~ s/$replace/$map{$replace}/gi
+)
                } else {
                    $YESMapping += ($_ =~ s/$replace/$map{$replace}/g)
                }
            }
            print $OUT $_
        }
[download]

This is what we see using your input and mapping files:

{C} > msar input.txt map.txt -r -i
Reading mappings from file:  map.txt
----------------------------
SAR on april
 with il
SAR on apr3143
 with barrel
SAR on apr3143
 with april
SAR on apr3143
 with pr
a94323143
SAR on barrel
 with il
SAR on barrel
 with barrel
SAR on 1168
 with april
SAR on 1168
 with pr
1168
----------------------------
Mapped 3 entries.
[download]

You could maybe fix it by adding in Tie::Hash (I think) which is supposed to be able to order your hash. You would need to manipulate the hash variable %map when it is loaded at the beginning of the program. Unfortunately, I don't have the time now to code this up, but hey, my Perl code is "open source" :-) so have at it!

UPDATE: If your infile is just the one column of words, call with:

{C} > msar input.txt map.txt -r -i -c 1

{C} > msar.pl in.txt map.txt -i -r -c 1
Reading mappings from file:  map.txt
----------------------------
225
1168
----------------------------
Mapped 2 entries.
[download]

UPDATE: MSAR.pl code now updated to use -w option which replaces on WHOLE WORDS only. Also, map.txt file will be read AND parsed AND used in search and replace in the order it is written (line 1, line 2 ... line n).