Just use an ordinary for loop to step through 3 elements at a time:

for (my $i=0; $i<$#dynval3; $i+=3) {
    my ( $a, $b, $c ) = @dynval3[$i..$i+2];  # shorthand slice idiom i
+nstead of $ary[$i], $ary[$i+1],...
    print "$a|$b|$c\n";
}
[download]

But if you are creating this data structure an easier structure would be an array of arrays which is perls version of a list of lists.

my @dynval3 = ( 
    [ 'Version', 'obVersion', '0x0204' ],
    [ 'Stat', 'obStat', '0x04b4' ],
    [ 'Mode', 'obMode', '0x0020' ],
    [ 'Regulation', 'obRegulation', '0x0014' ],
    [ 'Scheduler', 'obScheduler', '0x0001' ],
);

for my $ref(@dynval3) {
    # access examples
    print "@$ref\n";
    my ( $a, $b, $c ) = @$ref;
    print "$a $b $c\n";
    print "Field 1 is: ", $ref->[1], "\n\n";
}
[download]

See perlman:perlref

my @dynval3 = (
               [qw/Version          obVersion         0x0204/],
               [qw/Stat             obStat            0x04b4/],
               [qw/Mode             obMode            0x0020/],
               [qw/Regulation       obRegulation      0x0014/],
               [qw/Scheduler        obScheduler       0x0001/],
);

for my $aref (@dynval3) {
  my ( $newname, $name, $val ) = @$aref;
  change_value( $newname, $name, $val );
}
[download]

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

my @array = 0 .. 30;
my $next = by_groups_of( 3, @array );

while ( my @group = $next->() ) {
    print "@group\n";
}

sub by_groups_of {
    my $by = shift;
    return sub { () } if ! $by || $by =~ /\D/ || ! @_;
    my @list = @_;  # Make a copy in case it changes

    my $end = $#list;
    my $pos = 0;
    my $done;

    return sub {
        return () if $done;
        my $stop = $pos + $by - 1 > $end ? $end : $pos + $by - 1;
        my @sub = @list[ $pos .. $stop ];
        $pos += $by - 1;
        $done = 1 if $stop == $end;
        return @sub;
    }
}
[download]

Since you're making a separate copy of the list that gets passed in anyway, you could also use the splice trick that merlyn showed above, and get rid of all the arithmetic.

sub by_groups_of {
    my $by = shift;
    return sub { () } if ! $by || $by =~ /\D/ || ! @_;
    my @list = @_; # here's the copy. we're safe to splice

    return sub { splice @list, 0, $by };
}
[download]

while (@dynval3) { # warning, eats it up
  my ($newname, $name, $val) = splice @dynval3, 0, 3;
  ...
}
[download]

The OP should be made aware that this example will destroy the contents of the @dynval3 array which may not be what is wanted. That is once you fix the typo in the splice as it is currently an infinite loop {chuckle}.

cheers

tachyon

I do this like:

my @tmp = @dynval3;
while (my ($newname, $name, $val) = splice @tmp, 0, 3) {
   ...
}
[download]

In my own version of List::Util I have this subroutine:

    sub group {
        my $n = shift;
        map [ @_[$_*$n .. $_*$n + $n - 1] ] => 0 .. $#_ / $n;
    }
[download]

    for (group(3, @dynval3)) {
        my ($newname, $name, $val) = @$_;
        ...
    }
[download]

ihb

Read argumentation in its context!

for (my $i=0; $i<@dynval3; $i+=3) {
    change_value(@dynval3[$i..$i+2])
}
[download]

my %hash = (
    'Version' => ['obVersion', '0x0204'],
    'Stat' => ['obStat', '0x04b4'],
    'Mode' => ['obMode', '0x0020'],
    'Regulation' => ['obRegulation', '0x0014'],
    'Schedule' => ['obScheduler', '0x0001']
);

$hash{'Regulation'} = ['newReg', '0x0015'];
my $p = $hash{'Schedule'};
@$p[0] = 'obUpdater';
$hash{'NewKey'} = ['This', 'Is', 'Four', 'Items'];
delete($hash{'Mode'});

foreach (keys %hash) {
    $p = $hash{$_};
    print "$_ => [" . join(' ', @$p) . "]\n";
}
[download]