And now, for a totally different solution!

while (<DATA>) {
   my ($key) = /^>?(\S+)/;

   local $/ = '>';
   chomp(my $val = <DATA>);
   $val =~ s/\n//g;

   $hash{$key} = $val;
}
[download]

Redefining $/ is fun!

I have to wake up earlier =). I've come with a similar solution redefining $/, but this time using split. Here is:

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

my %hash;
local $/ = ">";
<DATA>; #Skip first ">"
while(<DATA>){
        my ($key,$value) = split /\n/, $_ , 2;
        $key =~ s/(\S+).*?$/$1/;
        $value =~ s/\n\>?//g;
        $hash{$key} = $value;
}

print Dumper \%hash;
__DATA__
>EP11110 (-)
TGCAATCACTAGCAAGCTCTC
GCTGCCGTCACTAGCCTGTGG
>EP40005 (+)
GGGGCTAGGGTTAGTTCTGGA
NNNNNNNNNNNNNNNNNNNNN
__OUTPUT__
$VAR1 = {
          'EP40005' => 'GGGGCTAGGGTTAGTTCTGGANNNNNNNNNNNNNNNNNNNNN',
          'EP11110' => 'TGCAATCACTAGCAAGCTCTCGCTGCCGTCACTAGCCTGTGG'
        };
[download]

Regards,
deibyz

use strict;
use Data::Dumper;

my %hash=();
my ($key, $val);
while (<DATA>) {
    chomp;
    if (/^>(\w+)/) {
        if ($key) {$hash{$key} = $val}; 
        $key = $1; $val = "";
    } else {
        $val .= $_;
    }
}
$hash{$key} = $val; 
print Dumper \%hash;

__DATA__
>EP11110 (-) 
TGCAATCACTAGCAAGCTCTC
GCTGCCGTCACTAGCCTGTGG
>EP40005 (+) 
GGGGCTAGGGTTAGTTCTGGA
NNNNNNNNNNNNNNNNNNNNN
[download]

We came up with nearly the exact same solution. I believe you can eliminate $val, however, by operating directly on the hash value.

use strict;
use warnings;

my %hash;
my $id;

while( my $line = <DATA> )
{
    chomp $line;

    # if( $line =~ m/^>(.+?) / )  # changed to \S
    if( $line =~ m/^>(\S+)/ )
    {
        $id = $1;
    }
    else
    {
        $hash{$id} .= $line;
    }
}
[download]

ewijaya, if you are trying to read sequence files in fasta format, you might want to look at bioperl's Bio::SeqIO class.

Update: ihb made a good point about the regex. I made the assumption (based on the example data) that a space will always follow the sequence ID, but that may not always be true. Therefore, ihb's regex is a bit safer for that reason (although you should keep in mind that \w will not match '.' or '-', so \S is probably better).

Your regex change may be a bit too clever. We don't know for sure that the space always will be there. Looking at the OP, it's fair to assume that there always will be something though. Perhaps the next line is just ">EP40007". A better way to express what you want to express while not being as restrictive is /^>(\S)+/ which does what you want: gets the first non-space characters. Personally I'd probably do the check in two steps; one to see if there's a '>' there (assuming that /^>/ means a header line), and the next to see if the rest of the line holds a valid format. I habitually verify foreign input.

ihb

Read argumentation in its context!

A slightly different take than pg's, using references:

    my %hash;
    my $buf;
    local $_;
    while (<$fh>) {
        chomp;
        if (my ($key) = /^>(\w+)/) {
            $hash{$key} = '';
            $buf = \$hash{$key};
        }
        else {
            $$buf .= $_;
        }
    }
[download]

ihb

Basically, the code needs to be rewritten somewhat. Here's my version for what you're trying to do:

use strict;
use warnings;

my %hash;
while (<DATA>) {
    if (/>([\w]+) /) { }
    else { chomp; $hash{$1} .= $_; }
}
for (sort keys %hash) {
    print "$_ => $hash{$_}\n";
}

__DATA__
>EP11110 (-) 
TGCAATCACTAGCAAGCTCTC
GCTGCCGTCACTAGCCTGTGG
>EP40005 (+) 
GGGGCTAGGGTTAGTTCTGGA
NNNNNNNNNNNNNNNNNNNNN
[download]

your first problem is that you don't test to see if the regex matches, because you want to treat lines differently (> lines become hash keys, lines after then become their data). the next two lines make no sense, you append every $_ to $str but never clear it. at the end of the loop it will contain a concatenated copy of every line of data post-chomp.

i'm not going to post working code because this is very basic logic; i'm guessing you were given an assignment to do this and got frustrated. throw an if (/regex/) { this is a key } else { this is a data line } and you'll start going somewhere

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

local $/ = '>';

while (<DATA>) {
    next if $_ eq '>';

    my ($t, $v) = $_ =~ /^(\w+).*?\n([^>]*)/gs;
    $v =~ s/\n//g;

    print "$t, $v\n";
}


__DATA__
>EP11110 (-) 
TGCAATCACTAGCAAGCTCTC
GCTGCCGTCACTAGCCTGTGG
>EP40005 (+) 
GGGGCTAGGGTTAGTTCTGGA
NNNNNNNNNNNNNNNNNNNNN
[download]

You neither need nor support /g on the first regexp. You don't need the /s either, but /s is forgivable.