perldoc -f split
       split /PATTERN/,EXPR,LIMIT
       split /PATTERN/,EXPR
       split /PATTERN/
[download]

my $Phrase = "Hello World";
my @Parts = split(/ /, $Phrase); # split $Phrase on spaces
[download]

What you probably want is

my @Parts = split ' ', $Phrase;
[download]

Update: Also, note the subtle difference between split / / and split ' '. The latter is "magical" in that it drops leading whitespace, splits on runs of spaces instead of a single space. The following may demonstrate:

my $s = '   a     b   c   ';

my @p = split ' ', $s;
print map { ">$_< " } @p;

my @q = split " ", $s;
print map { ">$_< " } @q;

my @r = split / /, $s;
print map { ">$_< " } @r;

my @s = split /\s+/, $s;
print map { ">$_< " } @s;

__END__
>a< >b< >c< 
>a< >b< >c< 
>< >< >< >a< >< >< >< >< >b< >< >< >c< 
>< >a< >b< >c<
[download]

You're missing the first argument, what to split on,

my @Parts = split(" ", $Phrase );
[download]

I don't see where the uninitialized value warning is coming from. Perhaps before posting you trimmed away the part that really initializes $Phrase. [rhesa++]

$_ is undefined.

In addition to the good answers you already got, which I recommend you to read carefully to understand what's going on, you can get what you want with a syntax similar to yours with a slight abuse of map:

my @Parts = map split, $Phrase;
[download]

I recommend that you do not cargo-cult this usage though, and postpone adopting it to when you will understand exactly what's going on in it too. Also because this doesn't really buy you anything that split basic usage as in rhesa's example won't.

While we're there, one more warning: you must have noticed that people here suggested using a string contining a single space as a first argument. Notice that this is a special case, which is supposed to what you want - because it's in fact what often people want, which in turn is the reason why it's the default. But in general split expects a proper pattern as a first argument. If you give it a string, then it will be automatically converted. It is generally recommended that you use a real pattern instead.

What's the reasoning behind that general recommendation? From your description, it appears that splitting on 'foo' and /foo/ (or even on $bar, if $bar eq 'foo') would be equivalent, so why prefer the pattern version?

(My current practice is to use 'foo' on the principle of never using regexes where a simple comparison is sufficient. On the surface, at least, it seems that splitting on /foo/ is the same manner of overkill as using if $bar =~ /^foo$/ instead of if $bar eq 'foo'.)

What's the reasoning behind that general recommendation? From your description, it appears that splitting on 'foo' and /foo/ (or even on $bar, if $bar eq 'foo') would be equivalent, so why prefer the pattern version?

Because the documentation says

       split /PATTERN/,EXPR,LIMIT
       split /PATTERN/,EXPR
       split /PATTERN/
       split
[download]

In fact splitting on 'foo' and /foo/ are (currently) equivalent because perl converts the string to a regex:

perl -MO=Deparse -ne 'split "foo"'
LINE: while (defined($_ = <ARGV>)) {
    split(/foo/, $_, 0);
}
-e syntax OK
[download]

Who knows? I doubt it, but the docs do not specify what should happen with generic strings other than ' ' and maybe one day special behaviour may be implemented for them along the lines of what is currently available for ' '.

(My current practice is to use 'foo' on the principle of never using regexes where a simple comparison is sufficient. On the surface, at least, it seems that splitting on /foo/ is the same manner of overkill as using if $bar =~ /^foo$/ instead of if $bar eq 'foo'.)

Your principle is based on an assumption that is simply not true for as we've seen before, your string is converted to a regex anyway. And OTOH matches like /foo/ are internally optimized to basically do an index. So no overkill. If you don't trust me, just trust B::Concise:

$ perl -MO=Concise -pe '$_=split "foo"' >1.txt
-e syntax OK
$ perl -MO=Concise -pe '$_=split /foo/' >2.txt
-e syntax OK
$ diff [12].txt
20c20
< 6                          </> pushre(/"foo"/) s*/64 ->7
---
> 6                          </> pushre(/"foo"/) s/64 ->7
[download]

Notice that the only difference is an asterisk, which means "Do something weird for this op".

I'm not saying that I don't agree with you on the $bar =~ /^foo$/ vs. $bar eq 'foo' issue. Because I do agree. (Also because they're not strictly equivalent:

$ perl -le 'print "bar\n" =~ /^bar$/ ? "ok" : "not ok"'
ok
[download]

and people happen to use the former whereas they really want the latter.) Simply, that's not the same for split's first argument.

#!usr/bin/perl
use warnings;
use strict;
my $Phrase = "Hello World";
my @Parts = split(/\s/,  $Phrase) ;
[download]

If EXPR is omitted, splits the $_ string.  If PATTERN is also omitted,
+ splits on whitespace (after skipping any leading whitespace).  Anyth
+ing matching PATTERN is taken to be a delimiter separating the fields
+.  (Note that the delimiter may be longer than one character.)
[download]

#!/usr/bin/perl
use warnings;
use strict;

print "$_\n" for split ( "Hello World" );
 
print "$_\n" for split /\s+/, "Hello World";
[download]

Here are the places where Perl will assume $_ even if you don't use it
+:
__snip__
- The default iterator variable in a foreach loop if no other variable
+ is supplied.
[download]

#!/usr/bin/perl
use warnings;
use strict;
use Data::Dumper;

print "\n\n";
print "\$_ = $_\n";

print "\n\n";
for ( 1 .. 10 ) { print "\$_ = $_\n" }

print "\n\n";
print $_ for {};

print "\n\n";
print Dumper $_ for {};

print "\n\n";
my $count = 0;
for ( sort keys %{ $_ } ) { print $count++, ":$_{$_} $_\n" };
[download]

The key here is what happens when you perform the incorrect usage of split:

my @parts = split( "Hello World" ); # generates warning
print "Parts: " . scalar(@parts) . "\n"; # prints "Parts: 0"

for( @parts ){ # never enters this loop since the array is empty
    print "$_\n";
}
[download]

The warning you saw on your first loop was generated by the split statement, not the print statement. As demonstrated above, the print statement never gets executed because the loop is never entered.

Hope that helps make some sense of what's happening,
-- Brian

Myself I don't think I have ever used split without the two slashes, though it strikes me that if you use a scalar as a split pattern without putting it into slashes like
split($pat, $stringtosplit); then I'm not sure what you'll get out of it. My guess would be it will be like using slashes, since perl tries to Do What You Mean sometimes.

Anyway the perldoc says,

As a special case, specifying a PATTERN of space (' ') will split on white space just as split with no arguments does. Thus, split(' ') can be used to emulate awk's default behavior, whereas split(/ /) will give you as many null initial fields as there are leading spaces. A split on /\s+/ is like a split(' ') except that any leading whitespace produces a null first field. A split with no arguments really does a split(' ', $_) internally.

$phrase = "Hello World";
for ($phrase) { @parts = split }
[download]

while (<STDIN>) {
    push @parts, split;
}
[download]