The reason your map gives you the empty string in spite of your if is that it always gives you the last expression evaluated, much like do or a sub. Consider this timeless classic (from Evil Interview Questions):

sub baz { return 11 unless shift }

print 'baz(5): ', baz(5), "\n";
print 'baz(0): ', baz(0), "\n";
__END__
baz(5): 5
baz(0): 11
[download]

If you want to take something out of a list processed with map, have the block explicitly return an empty list.

my @a = ( qw (onexxx txwxo txhrexe xfourx xxx five) );
my @b = map {
        $_ =~ s/x//g;
        $_ ? $_ : ();
        } @a;
print Dumper(\@b);
__END__
$VAR1 = [
          'one',
          'two',
          'three',
          'four',
          'five'
        ];
[download]

As a side note, you should know that modification of $_ inside map modifies the original list element. Your code (and mine) leaves @a looking like this:

$VAR1 = [
          'one',
          'two',
          'three',
          'four',
          '',
          'five'
        ];
[download]

You can use Benchmark to try to find the most efficient way to do something, but for something like this I think you'd have to have a pretty long list before it would make a significant difference. It's generally best to use the most easily understood code until profiling tells you that something is worth optimizing.

my @b = grep { s/x//g;  $_ ne ''; } @a;
[download]

Personally I would use a grep before or after the map, but when you want to return a varying number of elements from map you can use the ternary operator:

my @b = map {
    s/x//; # this could be written more efficient as tr[x][]d;
    $_ ? $_ : ()
} @a;
[download]

    s/x//; # this could be written more efficient as tr[x][]d;
[download]

The difference being that  s/x// removes one 'x' character while  tr[x][]d removes all 'x' characters.    To be fair, the OP's code used s/x//g instead   :-)

And you don't need two statements to accomplish that:

my @b = map s/x//g ? $_ : (), @a;

# Or:

my @b = map tr/x//d ? $_ : (), @a;
[download]

Not exactly:

perl -le "print for map s/x//g ? $_ : (), @ARGV" 1 2 3x 4xx xxx 6x
3
4

6
[download]

perl -le "print for map tr/x//d ? $_ : (), @ARGV" 1 2 3x 4xx xxx 6x
3
4

6
[download]

The return value of s/// and tr[] is the number of substitutions made, not the modified string (unfortunatley).

Oops: kyle points out that he had mentioned it. I scanned for it and thought I didn't see it. Oops. But it still bears repeating.

$ cat 669837.pl
# 669837
use strict;
use warnings;
use Data::Dumper;

my @a = qw (onexxx txwxo txhrexe xfourx xxx five);
my @b = ();
for (@a) {
  s/x//g;
  push @b, $_ if $_;
}

print Dumper(\@b);
__END__
$ perl 669837.pl
$VAR1 = [
          'one',
          'two',
          'three',
          'four',
          'five'
        ];
[download]

Is using map here the most efficient way to do this (for much larger lists)?

What kind of problem are you having? Speed? memory? something else?

If you want to reduce your memory footprint, you could use a counting loop and push.

for my $i (0..$#a) {
   my $s = $a[$i];
   $s =~ s/x//g;
   push @b, $s if $s;
}
[download]

As for the speed difference between this and your solution, only a benchmark will tell. Should be very similar.

"for" over an array is optimized; this works just as well from a memory perspective:

for my $a_val (@a) {
    (my $s = $a_val) =~ s/x//g;
    push @b, $s if $s;
}
[download]

--
Online Fortune Cookie Search

Thanks. I suspected as much — I already realized naught-but-an-array was special — but I didn't have time to check it when I posted the grandparent.