Wie eine Schleife über ein Array von Arrays als Referenz?

foreach my $row (@$array_ref) {
    foreach my $cell (@$row) {
        if ($cell eq $s) {
            $cell = $d;
            last;
        }
    }
}

Auch, zu berechnen, die Anzahl der Elemente im array-Referenz (die, wie Sie sehen können aus dem obigen code müssen Sie nicht für Ihre spezifischen code), der einfachste Ansatz ist:

my $count = scalar(@$array_ref);
my $row_count = scalar(@{ $array_ref->[$i] });
my $last_index = $#$array_ref; 

Auch, um auf die Daten innerhalb einer arrayref von arrayrefs, verwenden Sie einfach den dereference operator auf Sie:

$array_ref->[$i]->[$j]; # The second arrow is optional but I hate omitting it.

Darüber hinaus können Sie Ihre arrayref von arrayrefs die Weise hast du (nehmen Sie eine Referenz auf array von arrays) oder sofort als Referenz:

my $array_ref = [
         [1,2,3]
         ,[4,5,6]
        ];

Als seitliche Anmerkung, bitte verwenden Sie niemals $a und $b als identifyer Namen - Sie haben Besondere Zwecke (verwendet im Art-Blöcke für Beispiel)

Der einfachste Weg zu dereferenzieren, meiner Meinung nach, ist daran zu erinnern, dass arrays und hashes kann immer nur enthalten scalar Werte (siehe perldoc perldata). Was bedeutet, dass das array

my @AoA = ( ['aaa','hdr','500'],
            ['bbb','jid','424'],
            ['ccc','rde','402']);

...enthält nur drei scalar-Werte, die Referenzen auf andere arrays. Sie schreiben, könnte es wie folgt aus:

my $first = [ qw(aaa hdr 500) ];      # using qw() which will quote the args
my $sec   = [ qw(bbb jid 424) ];
my $third = [ qw(ccc rde 402) ];
my @all   = ($first, $sec, $third);   # this array is now identical to @AoA

Mit diesem im Verstand, es ist einfach vorstellbar (wie DVK schlug in seiner Antwort) eine Schleife wie:

for my $aref (@all) {
    # $aref will contain $first, $sec, and $third 
}

Wissen, dass $aref ist eine array-Referenz, die die Dereferenzierung ist einfach:

for my $aref (@all) {
    for my $value (@$aref) {
        # do your processing here
    }
}

Auch, da die Werte in einer for-Schleife mit alias, alle änderungen, Sie wirkt sich auf das original-array. Also, wenn die "Verarbeitung" in der Schleife oben enthält eine Zuordnung wie

$value = $foo;

Das bedeutet, dass die Werte in @all auch geändert, genau so, wie wenn du geschrieben hättest:

$all[0][1] = $foo;

Immer, wenn ich viel mit arrays von arrays oder hashes oder hashes oder arrays von hashes von arrays, beginne ich zu denken, in Begriffen der objektorientierten Programmierung. Perl-OOP ist nicht alles, was Komplex ist, und es versteckt sich eine Menge der logischen Komplexität.

Nun, in diesem sehr einfachen Beispiel, wäre es viel einfacher, nur um es zu schreiben ohne Objekt-Orientierung, und Sie haben bereits mehrere gute Antworten (vor allem vergaß zu dereferenzieren Referenzen).

Aber sobald Sie anfangen, merken Sie, dass Sie mehr komplexe Strukturen in Perl als einfach hashes, arrays und Skalare, Ihre Daten-Strukturen beginnen immer komplexer und schwieriger zu analysieren, ohne OOP.

#!/usr/bin/env perl

use strict;
use warnings;
use feature qw(say);

my $a_of_a = array_of_arrays->new;

$a_of_a->push(["aaa", "hdr", "500"]);
$a_of_a->push(["bbb", "jid", "424"]);
$a_of_a->push(["ccc", "rde", "402"]);

foreach my $member ($a_of_a->list) {
    my @array = @{$member};
    foreach my $element (@array) {
        printf "%-5.5s  ", $element;
    }
    print "\n";
}


package array_of_arrays;

sub new {
    my $class = shift;
    my $self = [];

    bless $self, $class;
    return $self;
}

sub push {
    my $self = shift;
    my $item = shift;

    push @{$self}, $item;
    return $self;
}

sub pop {
    my $self = shift;

    if (scalar @{$self}) {
        return pop @{$self};
    }
    else {
        return;
    }
}

sub list {
    my $self = shift;
    return @{$self};
}