In the case of your s/^-// the return value will always be 0 or 1.
But in the case of:   s/something/something else/g   it could easily be a higher number.

my $string = 'abacadaeaf';
my $result = $string =~ s/a/x/g;
print $result;            # prints 5
[download]

my @array = map { s/^-// } @ARGV;
[download]

two things are happening. First, the subtitution is changing $_ which is actually a reference to an element in @ARGV. Like in foreach when you change $_ in a map or grep it affects the item in the array being based to map or grep. As for the values in @array, they are always 1 in your example because the result of s/^-// is 1 (true) when the substitution succeeds, and false otherwise.

my @array = map {s/^-//;$_.="\n"}@ARGV;
[download]

First,

map { s/^-// } @ARGV;
  print join ("\n", @ARGV) . "\n";
[download]

to this

print join "\n", map { s/^-// } @ARGV;
[download]

now for an answer

however, the second time, you received a number indicating the number of succesful matches. Check out the /gmodifier you want - to match more than once in the string.

Here is a simpler example that shows what was happening each time you applied your regexp to $_

$_ = 'aaaaaaaaaaa';

my $x = s/a//;

print "$x\n";
[download]

my @array = map { (split(/^-/,$_))[0] . (split(/^-/,$_))[1] } @ARGV;
[download]

I think that'll work, assuming you want your command line arguments in @array whether they have leading hyphens or not, but, even if it does work, it's lousy code. Surely there's a better way, but I'm too tired to see it.

adamsj

They laughed at Joan of Arc, but she went right ahead and built it. --Gracie Allen

In the interest of making life easier, CPAN modules for processing of command line options include: Getopt::Std and Getopt::Long. These modules are very handy for processing command line options of the most commonly used forms.

With that out of the way, in order to make map work the way you'd like it to, you can use a pattern expression with capturing parentheses:

#!/usr/bin/perl

print "\@ARGV: [@ARGV]\n";
my @my_args = map { /^-(.*)/ } @ARGV;
print "\@my_args:\n";
print "$_\n" for @my_args;
[download]

map evaluates the block in list context. The pattern with capturing parantheses, when evaluated in list context, returns either the captured text, or an empty list. What this means is that new elements are added to @my_args only when the pattern matches. Notice that the argument "baz," which doesn't begin with minus, is not added to @my_args.

Example:

$ ./code.pl -foo=bar -bar baz
@ARGV: [-foo=bar -bar baz]
@my_args:
foo=bar
bar