perllol - Online in de cloud

PROGRAMMA:

NAAM

perllol - Arrays van arrays manipuleren in Perl

PRODUCTBESCHRIJVING

Verklaring en Toegang tot of arrays of arrays
De eenvoudigste gegevensstructuur op twee niveaus die in Perl kan worden gebouwd, is soms een reeks arrays
terloops een lijst met lijsten genoemd. Het is redelijk gemakkelijk te begrijpen, en bijna
alles wat hier van toepassing is, zal later ook van toepassing zijn met de liefhebbergegevens
structuren.

Een array van een array is gewoon een gewone oude array @AoA die je met twee kunt bereiken
subscripts, zoals $AoA[3][2]. Hier is een declaratie van de array:

gebruik 5.010; # zodat we Say() kunnen gebruiken

# wijs aan onze array een array van arrayreferenties toe
@AoA = (
[ "fred", "barney", "kiezels", "bambam", "dino", ],
[ "george", "jane", "elroy", "judy", ],
[ "homer", "bart", "marge", "maggie", ],
);
zeg $AoA[2][1];
bart

Nu moet u heel voorzichtig zijn dat het type buitenste beugel een ronde is, dat wil zeggen een
haakje. Dat komt omdat je een @array toewijst, dus je hebt haakjes nodig. Als
daar wilde je niet om een ​​@AoA te zijn, maar liever gewoon een verwijzing ernaar, zou je kunnen doen
zoiets meer als dit:

# wijs een verwijzing toe aan een array met arrayreferenties
$ref_to_AoA = [
[ "fred", "barney", "kiezels", "bambam", "dino", ],
[ "george", "jane", "elroy", "judy", ],
[ "homer", "bart", "marge", "maggie", ],
];
zeg $ref_to_AoA->[2][1];
bart

Merk op dat het type buitenste haakjes is veranderd, en dus is onze toegangssyntaxis ook veranderd.
Dat komt omdat je, in tegenstelling tot C, in perl niet vrijelijk arrays en referenties kunt uitwisselen
daaraan. $ref_to_AoA is een verwijzing naar een array, terwijl @AoA een eigenlijke array is.
Op dezelfde manier is $AoA[2] geen array, maar een arrayreferentie. Dus hoe komt het dat je deze kunt schrijven:

$AoA[2][2]
$ref_to_AoA->[2][2]

in plaats van deze te moeten schrijven:

$AoA[2]->[2]
$ref_to_AoA->[2]->[2]

Dat komt omdat de regel is dat alleen op aangrenzende haakjes (vierkant of gekruld)
u bent vrij om de verwijzingspijl voor de aanwijzer weg te laten. Maar u kunt dit niet doen voor de zeer
de eerste als het een scalair is die een verwijzing bevat, wat betekent dat $ref_to_AoA altijd
heeft het nodig.

Groeiend Your Eigen
Dat is allemaal leuk en aardig voor het declareren van een vaste datastructuur, maar wat als je dat zou willen
om direct nieuwe elementen toe te voegen of helemaal opnieuw op te bouwen?

Laten we eerst eens kijken naar het inlezen vanuit een bestand. Dit is zoiets als het toevoegen van een rij bij a
tijd. We gaan ervan uit dat er een plat bestand is waarin elke regel een rij is en elk woord een
element. Als u een @AoA-array probeert te ontwikkelen die al deze bevat, vindt u hier de juiste keuze
manier om dat te doen:

terwijl (<>) {
@tmp = splitsen;
druk op @AoA, [ @tmp ];
}

Mogelijk heb je dat ook vanuit een functie geladen:

voor $i ( 1 .. 10 ) {
$AoA[$i] = [ een func($i) ];
}

Of misschien had u een tijdelijke variabele met de array erin.

voor $i ( 1 .. 10 ) {
@tmp = een func($i);
$AoA[$i] = [ @tmp ];
}

Het is belangrijk dat u ervoor zorgt dat u de array-referentieconstructor "[ ]" gebruikt. Dat is omdat
dit zou niet werken:

$AoA[$i] = @tmp; # FOUT!

De reden dat dat niet doet wat je wilt, is omdat je zo'n benoemde array toewijst aan a
scalair neemt een array in scalaire context, wat betekent dat alleen het aantal wordt geteld
elementen in @tmp.

Als u onder "gebruik strikt" valt (en als dat niet het geval is, waarom doet u dat dan niet?),
je zult een aantal verklaringen moeten toevoegen om het gelukkig te maken:

gebruik strikt;
mijn(@AoA, @tmp);
terwijl (<>) {
@tmp = splitsen;
druk op @AoA, [ @tmp ];
}

Natuurlijk heb je de tijdelijke array helemaal niet nodig om een ​​naam te hebben:

terwijl (<>) {
druk op @AoA, [splitsen];
}

Je hoeft het ook niet te gebruiken Duwen(). Je zou gewoon een directe opdracht kunnen geven als je het wist
waar je het wilde plaatsen:

mijn (@AoA, $i, $lijn);
voor $i ( 0 .. 10 ) {
$regel = <>;
$AoA[$i] = [ splitsen " ", $line ];
}

of zelfs gewoon

mijn (@AoA, $i);
voor $i ( 0 .. 10 ) {
$AoA[$i] = [ splitsen " ", <> ];
}

Over het algemeen moet u op uw hoede zijn bij het gebruik van functies die mogelijk lijsten kunnen retourneren
scalaire context zonder dit expliciet te vermelden. Dit zou voor de gewone man duidelijker zijn
lezer:

mijn (@AoA, $i);
voor $i ( 0 .. 10 ) {
$AoA[$i] = [ gesplitst " ", scalair(<>) ];
}

Als u een variabele $ref_to_AoA als referentie naar een array wilt hebben, moet u
iets zoals dit:

terwijl (<>) {
push @$ref_to_AoA, [splitsen];
}

Nu kunt u nieuwe rijen toevoegen. Hoe zit het met het toevoegen van nieuwe kolommen? Als je gewoon te maken hebt met
matrices, is het vaak het gemakkelijkst om eenvoudige toewijzing te gebruiken:

voor $x (1 .. 10) {
voor $ y (1 .. 10) {
$AoA[$x][$y] = func($x, $y);
}
}

voor $x ( 3, 7, 9 ) {
$AoA[$x][20] += func2($x);
}

Het maakt niet uit of die elementen er al zijn of niet: het creëert graag
ze voor u, waarbij u de tussenliggende elementen indien nodig op "undef" zet.

Als je alleen iets aan een rij wilt toevoegen, moet je iets grappigers doen:

# voeg nieuwe kolommen toe aan een bestaande rij
push @{ $AoA[0] }, "wilma", "betty"; # expliciete deref

Vóór Perl 5.14 kon dit niet eens worden gecompileerd:

push $AoA[0], "wilma", "betty"; # impliciete deref

Hoe kan dat? Want ooit was het argument om Duwen() moest een echte array zijn, niet
slechts een verwijzing naar één. Dat is niet langer waar. In feite is de regel gemarkeerd met "impliciete deref"
bovenstaande werkt prima - in dit geval - om te doen wat degene die zegt expliciete deref deed.

De reden dat ik "in dit geval" zei, is omdat dat Slechts werkt omdat $AoA[0] al
hield een array-referentie vast. Als je dat op een ongedefinieerde variabele probeert, neem je een
uitzondering. Dat komt omdat de impliciete dereferentie nooit een ongedefinieerde automatisch tot leven zal wekken
variabele zoals "@{ }" altijd zal doen:

mijn $aref = undef;
push $aref, qw(nog wat waarden); # FOUT!
druk op @$aref, qw(nog een paar); # OK

Als je wilt profiteren van dit nieuwe impliciete dereferentiegedrag, ga je gang:
het maakt coderen gemakkelijker voor het oog en de pols. Begrijp gewoon dat oudere releases zullen stikken
erop tijdens het compileren. Wanneer je iets gebruikt dat alleen bij sommigen werkt
gegeven release van Perl en later, maar niet eerder, moet u een prominente

gebruik v5.14; # nodig voor impliciete deref van array-referenties door array-ops

richtlijn bovenaan het bestand dat deze nodig heeft. Op die manier, wanneer iemand probeert de
nieuwe code onder een oude perl, in plaats van een foutmelding te krijgen zoals

Het type arg 1 dat moet worden gepusht, moet array zijn (geen array-element) op /tmp/a regel 8, in de buurt van ""betty";"
Uitvoering van /tmp/a afgebroken vanwege compilatiefouten.

ze zullen dat beleefd laten weten

Perl v5.14.0 vereist - dit is alleen v5.12.3, gestopt bij /tmp/a regel 1.
BEGIN mislukt - compilatie afgebroken op /tmp/a regel 1.

Toegang tot en Print
Nu is het tijd om uw datastructuur af te drukken. Hoe ga je dat doen? Nou als
je wilt slechts één van de elementen, het is triviaal:

druk $AoA[0][0] af;

Als u echter alles wilt afdrukken, kunt u dat niet zeggen

print @AoA; # FOUT

omdat je alleen referenties op de lijst krijgt, en perl zal de referentie nooit automatisch verwijderen
dingen voor jou. In plaats daarvan moet je jezelf een lus of twee rollen. Hiermee drukt u het geheel af
structuur, met behulp van de shell-stijl voor() constructie om over de buitenste set te lussen
abonnementen.

voor $aref ( @AoA ) {
zeg "\t [ @$aref ],";
}

Als u abonnementen wilt bijhouden, kunt u dit doen:

voor $i ( 0 .. $#AoA ) {
say "\t elt $i is [ @{$AoA[$i]} ],";
}

of misschien zelfs dit. Let op de binnenlus.

voor $i ( 0 .. $#AoA ) {
voor $j ( 0 .. $#{$AoA[$i]} ) {
zeg "elt $i $j is $AoA[$i][$j]";
}
}

Zoals je kunt zien, wordt het een beetje ingewikkeld. Daarom is het soms makkelijker om een
tijdelijk onderweg door:

voor $i ( 0 .. $#AoA ) {
$aref = $AoA[$i];
voor $j ( 0 .. $#{$aref} ) {
zeg "elt $i $j is $AoA[$i][$j]";
}
}

Hmm... dat is nog steeds een beetje lelijk. Wat denk je hiervan:

voor $i ( 0 .. $#AoA ) {
$aref = $AoA[$i];
$n = @$aref - 1;
voor $j ( 0 .. $n ) {
zeg "elt $i $j is $AoA[$i][$j]";
}
}

Als u het beu bent om een ​​aangepaste afdruk voor uw datastructuren te schrijven, kunt u eens kijken naar
de standaard Dumpvalue of Data::Dumper modules. De eerste is wat de Perl debugger
gebruikt, terwijl de laatste ontleedbare Perl-code genereert. Bijvoorbeeld:

gebruik v5.14; # met behulp van het + prototype, nieuw in v5.14

subshow(+) {
Dumpwaarde vereisen;
state $prettily = nieuwe dumpwaarde::
vink => q("),
compactDump => 1, # commentaar op deze twee regels
veryCompact => 1, # als je een grotere stortplaats wilt
;
dumpValue $mooi @_;
}

# Wijs een lijst met arrayreferenties toe aan een array.
mijn @AoA = (
["fred", "barney"],
[ "george", "jane", "elroy" ],
[ "homer", "marge", "bart" ],
);
push $AoA[0], "wilma", "betty";
toon @AoA;

zal afdrukken:

0 0..3 "fred" "barney" "wilma" "betty"
1 0..2 "george" "jane" "elroy"
2 0..2 "homer" "marge" "bart"

Terwijl als je commentaar geeft op de twee regels waarvan ik zei dat je dat misschien zou willen, het je dat wordt getoond
op deze manier in plaats daarvan:

0 ARRAY(0x8031d0)
0 "fred"
1 "barney"
2 "wilma"
3 "betty"
1 ARRAY(0x803d40)
0 "George"
1 "jan"
2 "eleroy"
2 ARRAY(0x803e10)
0 "homer"
1 "marge"
2 "bart"

Slices
Als je een segment (een deel van een rij) in een multidimensionale array wilt bereiken, ga je dat doen
moet een aantal mooie abonnementen doen. Dat komt omdat we daar een mooi synoniem voor hebben
afzonderlijke elementen via de aanwijspijl voor het verwijderen van verwijzingen, een dergelijk gemak bestaat niet
plakjes.

Hier leest u hoe u één bewerking uitvoert met behulp van een lus. We gaan uit van een @AoA-variabele zoals voorheen.

@deel = ();
$ x = 4;
voor ($y = 7; $y < 13; $y++) {
push @part, $AoA[$x][$y];
}

Diezelfde lus zou kunnen worden vervangen door een slice-operatie:

@deel = @{$AoA[4]}[7..12];

of een beetje uit elkaar:

@deel = @{ $AoA[4] } [ 7..12 ];

Maar zoals je je misschien kunt voorstellen, kan dit behoorlijk ruw zijn voor de lezer.

Ah, maar wat als je een tweedimensionaal plak, zoals $x laten lopen van 4..8 en $y
lopen van 7 tot 12? Hmm... hier is de eenvoudige manier:

@nieuweAoA = ();
voor ($startx = $x = 4; $x <= 8; $x++) {
voor ($starty = $y = 7; $y <= 12; $y++) {
$newAoA[$x - $startx][$y - $starty] = $AoA[$x][$y];
}
}

We kunnen een deel van het doorlussen van plakjes verminderen

voor ($x = 4; $x <= 8; $x++) {
druk op @newAoA, [ @{ $AoA[$x] } [ 7..12 ] ];
}

Als je van Schwartzian Transforms hield, zou je daar waarschijnlijk een kaart voor hebben gekozen

@newAoA = kaart { [ @{ $AoA[$_] } [ 7..12 ] ] } 4 .. 8;

Hoewel als uw manager u ervan beschuldigde werkzekerheid (of snelle onzekerheid) te zoeken
ondoorgrondelijke code, zou het moeilijk zijn om te argumenteren. :-) Als ik jou was, zou ik dat in een
functie:

@newAoA = splice_2D( \@AoA, 4 => 8, 7 => 12 );
subsplitsing_2D {
mijn $lrr = dienst; # ref naar array van array-referenties!
mijn ($x_lo, $x_hi,
$y_lo, $y_hi) = @_;

retourkaart {
[ @{ $lrr->[$_] } [ $y_lo .. $y_hi ] ]
} $x_lo .. $x_hi;
}

Gebruik perllol online met behulp van onworks.net-services