You can accumulate the current string in a scalar and then print and reset it as soon as you know you'll want to. The code will look a lot like what you have.

#!/usr/bin/perl -w
use strict;

my ($string, $count);

while(<DATA>){
    s/\s//g;
    next if !$count and /^>/;
    if (/^>/ and $count) {
        print $count, ' : ', $string, $/;
        $string = '';
        $count++;
        next;
    }    
    $count || $count++;
    $string .= $_;
}
print $count, ' : ', $string, $/;

__DATA__
> Seq 1 (two lines)
AAAAAAAAAAAAA
CCAAAAAAAAAAA
> Seq 2 (two lines)
AAAAAAAAAAAAA
AAAAAAAAAAAAA
> Seq 3 (one line)
TTTTTTTTTTTTAACTGAAGATTCGC
[download]

Having a leading marker instead of a trailing one makes this a little awkward.

use Bio::FASTASequence::File;
my $file = '/path/to/seq.fa';

my $obj = Bio::FASTASequence::File->new($file);
my $result_ref = $obj->get_result();
my $counter = 1;

foreach(keys(%{$result_ref})){
  print $counter,": ",$result_ref->{$_}->getSequence(),"\n";
  $counter++;
}
[download]

>Seq1 (two lines)
AAAAAAAAAAAAA
CCAAAAAAAAAAA
>Seq2 (two lines)
AAAAAAAAAAAAA
AAAAAAAAAAAAA
>Seq3 (one line)
TTTTTTTTTTTTAACTGAAGATTCGC
[download]

#!/usr/bin/perl -w
use strict;

my $i = 0;
while(<DATA>){
    s/\s//g;
    if (/^>/) {
        print "\n" if $i;
        print ++$i, " : ";
        next;
    }
    chomp;
    print;
}
print "\n";
[download]

use Bio::SeqIO;
my $in = Bio::SeqIO->new(-format => 'fasta', -fh => \*DATA);
my $i =1;
while( my $s = $in->next_seq  ) {
 print $i++, " : ", $seq->seq(), "\n";
}
__DATA__
> Seq 1 (two lines)
AAAAAAAAAAAAA
CCAAAAAAAAAAA
> Seq 2 (two lines)
AAAAAAAAAAAAA
AAAAAAAAAAAAA
> Seq 3 (one line)
TTTTTTTTTTTTAACTGAAGATTCGC
[download]

Thanks so much for your reply stajich.

Indeed the module is very very useful.
However I find a problem while extending the usage. Perhaps you can give some advice.

Suppose I am taking a file as input (the content of the file is similar to my OP), and wish to process that file in *multiple trials*. So I have the following code.

#!/usr/bin/perl -w
use strict;
use Bio::SeqIO;

my $file = $ARGV[0];
open INFILE, "<$file" or die "$0:  Can't open file $file: $!";

for (my $trial = 1; $trial <=2; $trial++)
{
   seek(INFILE,0,0); #This is line 10
   print "Trial $trial\n";

   my $i =1;
   my $in = Bio::SeqIO->new(-format => 'fasta', -fh => \*INFILE);

   while( my $seq = $in->next_seq  ) {
      print $i++, " : ", $seq->seq(), "\n";
   }

}
[download]

The my code above (especially in Bio::SeqIO method) encounter this warning while arriving at second trial.

Trial 1
1 : TGCAATCACTAGCAAGCTCTCGCTGCCGTCACTAGCCTGTGG
2 : GGGGCTAGGGTTAGTTCTGGANNNNNNNNNNNNNNNNNNNNN
seek() on closed filehandle INFILE at test.pl line 10.
Trial 2
readline() on closed filehandle INFILE at /usr/lib/perl5/site_perl/5.8
+.0/Bio/Root/IO.pm line 440.
[download]

I know that I can avoid this warnings by replacing SEEK function with "open INFILE.."
But I am curious how can I solve this problem if I intend to keep the SEEK function.
Since I found the solution is neater that way. Hope to hear from you again.
Regards,
Edward

Then open the file within the for-loop:



#!/usr/bin/perl -w
use strict;
use Bio::SeqIO;

my $file = $ARGV[0];

for (my $trial = 1; $trial <=2; $trial++)
{
   open INFILE, "<$file" or die "$0:  Can't open file $file: $!";
   seek(INFILE,0,0); #This is line 10
   print "Trial $trial\n";

   my $i =1;
   my $in = Bio::SeqIO->new(-format => 'fasta', -fh => \*INFILE);

   while( my $seq = $in->next_seq  ) {
      print $i++, " : ", $seq->seq(), "\n";
   }

}
[download]

Running the while loop

while( my $seq = $in->next_seq  ) {
      print $i++, " : ", $seq->seq(), "\n";
   }
[download]

will read until the end of the filehandle. (That is why the loop ended in the first place). So subsequently calling next_seq on the $in object will give you the error mesg you are seeing. You can
1. open SeqIO object outside of trial loop, and put seek(INFILE,0) inside the loop. Note that if the SeqIO object gets destroyed (or goes out of scope), you will need to add the flag -noclose => 1 option when initing the SeqIO object or else the filehandle is closed. But if you are going to do this, just move the initialization of the SeqIO object outside the loop.
2. re-open the file each time in the list (move the Bio::SeqIO initialization into the trial loop)
3. Or read all the sequences in at once and keep them in memory. (put them into an array).

   my @seqs; 
   while(my $s = $in->next_seq ) { push @seqs, $s; }
   # now do your loop of trials
   [download]

#3 might not work depending on how many sequences and how big they are.

$/ = "\n>";
[download]

1. You have to delete the trailing ">", at the end of every string (but the last)
2. You have to delete the leading ">", at the start of every line
3. You still have to delete every newline, and chomp won't work, because of the changed setting for $/.

Oh well. Such is life.

s/^>//;
s/>$//;
tr/<n//d;
[download]

my $counter = 1;
my $tmp = '';


foreach(<DATA>) {
  chomp;
  if (!/^>/) {
    $tmp .= $_;
  } else {
    print $counter++, " : $tmp\n" if length $tmp;
    $tmp = "";
  }
}
print $counter, " : $tmp\n" if length $tmp;
[download]

Caveat: Different quotes for different folks!

perl -ple"BEGIN{$/=qq'\n>'}s[>? Seq (\d+).*$][$1 : ]m; tr[\n.][]d" in 
+>out
[download]

use strict;

open(DATA,"< c:\\temp.txt") || die "Sorry";
print grep (!/^>/,<DATA>);
[download]

use strict;

open(DATA,"< c:\\temp.txt") || die "Sorry";

while(<DATA>){
if ($_=~s/(^>\s+)//){
print "\n";
}
else
{
    chomp;
    print;
    
}
}
[download]

use strict;

my $count=1;
while(<DATA>){
    s/\s//g;
    chomp;
    /^>/ ? print "\n " . $count++ . ": " : print;
}
__DATA__
> Seq 1 (two lines)
AAAAAAAAAAAAA
CCAAAAAAAAAAA
> Seq 2 (two lines)
AAAAAAAAAAAAA
AAAAAAAAAAAAA
> Seq 3 (one line)
TTTTTTTTTTTTAACTGAAGATTCGC
[download]

$ grep '^[ACGT]' foo | cat -n
     1  AAAAAAAAAAAAA
     2  CCAAAAAAAAAAA
     3  AAAAAAAAAAAAA
     4  AAAAAAAAAAAAA
     5  TTTTTTTTTTTTAACTGAAGATTCGC
[download]

TMTOWTDI, some of them not involving perl at all . . .

Update: D'oh! Never mind me. That'll teach me to try and make a cogent point on 5 hours sleep . . .

Nice idea, but it doesn't do what the OP wants. He wants to concatenate each sequence into one line, then print it and its sequence number. TMTOWTDI is only useful if the other ways are equivalent.