splice can be used to extract elements from an array.

my @myArray = (1..100);

my @myMainArray;
while (@myArray) {
   push @myMainArray, [ splice(@myArray, 0, 5) ];
}

foreach my $record (@myMainArray) {
   print(join(', ', @$record), "\n");
}
[download]

Update: Fixed typo bug in code. Thanks ww.

my @a=(0..12); # Admittedly, not the best choice for variable names...
my @b;

for (my $i=0; $i <= $#a; $i+=5) { 
   push @b,join(',', @a[$i..$i+4]);
   print qq[ $i:$a[$i]=@b  \n];
}
# @b ends up with  comma-separated, 5-element (or less for last chunk)
+ chunks of @a
[download]

use List::MoreUtils qw(natatime);

my @myArray = (1..100);
my @myMainArray = ();
my $chunkSize = 5;

my $iterator = natatime $chunkSize, @myArray;
while(my @values = $iterator->()){
  push @myMainArray, [@values];
}
foreach  (@myMainArray){
  my @smallArray = @{$_};
  print "@smallArray\n";
}
[download]

use List::MoreUtils qw(part);
@array = (1..100);
$i = -0.1;
@parts = part { $i += 0.2   }  @array;
[download]

It's dangerous to repeatedly add decimal numbers since many of them are periodic in binary and therefore cannot be stored precisely. This includes 0.2.

>perl -le"printf '%.17f', .2
0.20000000000000001
[download]

The following is a safer, simpler and easier to read (since "5" actually appears) version of your second snippet:

use List::MoreUtils qw(part);
my @array = (1..100);
my $i; my @parts = part { ($i++)/5 } @array;
[download]

Thanks, I never knew the reason behind it. Very useful tip.
--Artist

my @myMainArray = 
    map { [ $myArray[$_] .. $myArray[$_+4] ] } 
    grep { !($_ % 5) } 0 .. $#myArray;
[download]

my @myMainArray = 
    map  { 
        exists $myArray[ $_+4 ] 
        ? [ $myArray[$_] .. $myArray[$_+4] ] 
        : [ $myArray[$_] .. $myArray[-1] ] 
    } 
    grep { !($_ % 5) } 0 .. $#myArray;
[download]

That refactors nicely:

my @myMainArray =
    map [ @myArray[$_ .. ($_+4 < $#myArray ? $_+4 : $#myArray)] ], 
    map $_ * 5, 0 .. $#myArray/5;
[download]

---

Caution: Contents may have been coded under pressure.

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


my @data = ( 1,2,3,4,5,6,7,8,9,10,11,12 );
my @collection = ();

my $break_5 = &break_by(5);

$break_5->( \@data, \@collection );

for my $c (@collection) {
    print $_, " " for @{$c};
    print "\n";
}

sub break_by {
    my $count = shift;
    return sub {
        my ( $data_ref, $collection_ref ) = @_;
        my @temp = ();
        foreach (@{$data_ref}) {
            push @temp, $_;
            if ( @temp >= $count ) {
                push @{$collection_ref}, [@temp];
                @temp = ();
            }
        }
        push @{$collection_ref}, [@temp] if (@temp);
    }
}
[download]

C:\Code>perl close_and_break.pl
1 2 3 4 5
6 7 8 9 10
11 12
[download]

Or you could go a step further and make an iterator.

sub break_by {
    my ($by, $data) = @_;
    my $i = 0;
    return sub {
        my $n = @$data - $i;
        $n = $n < 0 ? 0 : $n > $by ? $by : $n;
        $i += $n;
        return @$data[$i-$n..$i-1];
    }
}    

my @data = ( 1,2,3,4,5,6,7,8,9,10,11,12 );

my $iter = break_by(5, \@data);
while (my @group = $iter->()) {
   print("@group\n");
}
[download]

Here's another nondestructive method using array slices.

use strict;
use warnings;

my @myArray = (1..100);
my @myMainArray = ();

my $i = 0;
while ($i < scalar @myArray){
    push (@myMainArray, [@myArray[$i .. $i+4]]);
    $i += 5;
}
[download]

perl -e '@a=1..100;while(@a){push@b,[@a[0..4]];@a=@a[5..$#a];}'
[download]