perldsc — Online w chmurze

PROGRAM:

IMIĘ

perldsc — książka kucharska dotycząca struktur danych Perla

OPIS

Perl pozwala nam mieć złożone struktury danych. Możesz napisać coś takiego i w ogóle
nagle miałbyś tablicę z trzema wymiarami!

za moje $x (1 .. 10) {
za moje y $ (1 .. 10) {
dla mojego $z (1 .. 10) {
$AoA[$x][$y][$z] =
$x ** $y + $z;
}
}
}

Niestety, jakkolwiek proste może się to wydawać, pod spodem kryje się o wiele bardziej skomplikowana konstrukcja niż
rzuca się w oczy!

Jak to wydrukować? Dlaczego nie możesz powiedzieć po prostu „drukuj @AoA”? Jak to sortujesz? Jak
czy możesz przekazać go do funkcji lub odzyskać jeden z nich z funkcji? Czy to przedmiot?
Czy możesz zapisać go na dysku, aby przeczytać go później? Jak uzyskać dostęp do całych wierszy lub kolumn
ta matryca? Czy wszystkie wartości muszą być numeryczne?

Jak widać, bardzo łatwo jest się pomylić. Chociaż niewielka część winy za
można to przypisać implementacji opartej na referencjach, tak naprawdę jest to bardziej spowodowane a
brak istniejącej dokumentacji z przykładami przeznaczonymi dla początkujących.

Dokument ten ma na celu szczegółowe, ale zrozumiałe omówienie wielu różnych kwestii
rodzaje struktur danych, które możesz chcieć opracować. Powinna służyć także jako książka kucharska
przykłady. Dzięki temu, gdy zajdzie potrzeba utworzenia jednej z tych złożonych struktur danych, będzie to możliwe
po prostu uszczypnij, ukradnij lub ukradnij przykład z tego miejsca.

Przyjrzyjmy się szczegółowo każdej z tych możliwych konstrukcji. Istnieją osobne sekcje nt
każdy z poniższych:

· tablice tablic

· skróty tablic

· Tablice skrótów

· hasze haszy

· bardziej wyszukane konstrukcje

Ale na razie przyjrzyjmy się ogólnym problemom wspólnym dla wszystkich tego typu struktur danych.

LITERATURA

Najważniejszą rzeczą do zrozumienia na temat wszystkich struktur danych w Perlu – w tym
tablice wielowymiarowe — polega na tym, że nawet jeśli mogą wyglądać inaczej, Perl @ARRAYs i
Wszystkie %HASH są wewnętrznie jednowymiarowe. Mogą przechowywać tylko wartości skalarne (co oznacza a
ciąg, liczba lub odwołanie). Nie mogą bezpośrednio zawierać innych tablic ani skrótów, ale
zamiast tego zawierać referencje do innych tablic lub skrótów.

Nie możesz użyć odniesienia do tablicy lub skrótu w taki sam sposób, jak w przypadku wartości rzeczywistej
tablica lub skrót. Dla programistów C lub C++ nieprzyzwyczajonych do rozróżniania tablic i
wskazują na to samo, może to być mylące. Jeśli tak, pomyśl o tym jako o różnicy
pomiędzy strukturą a wskaźnikiem do struktury.

Możesz (i powinieneś) przeczytać więcej o referencjach w perlref. Krótko mówiąc, referencje są
raczej jak wskazówki, które wiedzą, na co wskazują. (Przedmioty są także swego rodzaju odniesieniem,
ale nie będziemy ich potrzebować od razu – jeśli w ogóle). Oznacza to, że kiedy już to zrobisz
coś, co dla ciebie wygląda na dostęp do dwu- lub więcej-wymiarowej tablicy i/lub
hash, tak naprawdę chodzi o to, że typ podstawowy jest jedynie jednowymiarową jednostką, która
zawiera odniesienia do następnego poziomu. Po prostu możesz posługiwać się to tak, jakby to był A
dwuwymiarowy. W rzeczywistości tak działają prawie wszystkie tablice wielowymiarowe w języku C
, jak również.

$array[7][12] # tablica tablic
$array[7]{string} # tablica skrótów
$hash{string}[7] # skrót tablic
$hash{string}{'another string'} # skrót skrótów

Teraz, ponieważ najwyższy poziom zawiera tylko odniesienia, jeśli spróbujesz wydrukować swoją tablicę
z prostym wydrukować() funkcji, otrzymasz coś, co nie wygląda zbyt ładnie, np
to:

mój @AoA = ( [2, 3], [4, 5, 7], [0] );
drukuj $AoA[1][2];
7
drukuj @AoA;
SZYK(0x83c38)SZYK(0x8b194)SZYK(0x8b1d0)

Dzieje się tak dlatego, że Perl (nigdy) pośrednio nie usuwa referencji do zmiennych. Jeśli chcesz
dostać się do rzeczy, do której odnosi się odniesienie, to musisz to zrobić samodzielnie, używając
albo wskaźniki wpisywania prefiksu, takie jak „${$blah}”, „@{$blah}”, „@{$blah[$i]}”, albo
strzałki wskaźnika postfiksowego, takie jak „$a->[3]”, „$h->{fred}” lub nawet „$ob->method()->[3]”.

WSPÓLNY BŁĘDY

Dwa najczęstsze błędy popełniane przy konstruowaniu czegoś w rodzaju tablicy tablic to:
albo przypadkowo policzyliśmy liczbę elementów, albo odnieśliśmy się do nich
lokalizację pamięci wielokrotnie. Oto przypadek, w którym po prostu otrzymujesz liczbę zamiast a
zagnieżdżona tablica:

za moje $i (1..10) {
moja @tablica = jakaś funkcja($i);
$AoA[$i] = @tablica; # ZŁO!
}

To po prostu prosty przypadek przypisania tablicy do skalara i pobrania jej elementu
liczyć. Jeśli tego naprawdę i szczerze chcesz, to może dobrze będzie, jeśli rozważysz bycie
trochę wyraźniej, na przykład tak:

za moje $i (1..10) {
moja @tablica = jakaś funkcja($i);
$liczba[$i] = skalarna @tablica;
}

Oto przypadek ciągłego odwoływania się do tej samej lokalizacji w pamięci:

# Albo bez ścisłego zakresu, albo z zewnętrznym zakresem moja @array;
#deklaracja.

za moje $i (1..10) {
@tablica = jakaś funkcja($i);
$AoA[$i] = \@tablica; # ZŁO!
}

Więc jaki jest w tym duży problem? Wygląda dobrze, prawda? W końcu właśnie powiedziałem
wiesz, że potrzebujesz szeregu referencji, więc, cholera, zrobiłeś mi jedno!

Niestety, chociaż jest to prawdą, nadal jest zepsute. Wszystkie odniesienia w @AoA odnoszą się do
dotychczasowy początku. taki sam miejscei dlatego wszystkie będą przechowywać to, co było ostatnie w @array! Jego
podobny do problemu zaprezentowanego w następującym programie C:

#włączać
główny() {
struktura passwd *getpwnam(), *rp, *dp;
rp = getpwnam("root");
dp = getpwnam("demon");

printf("Nazwa demona to %s\nnazwa roota to %s\n",
dp->nazwa_pw, rp->nazwa_pw);
}

Który wydrukuje

nazwa demona to demon
nazwa root to demon

Problem polega na tym, że zarówno „rp”, jak i „dp” są wskaźnikami do tej samej lokalizacji w pamięci! w C,
musiałbyś o tym pamiętać malloc () sobie nowe wspomnienie. W Perlu będziesz chciał użyć
zamiast tego konstruktor tablicowy „[]” lub konstruktor mieszający „{}”. Oto właściwy sposób
wykonaj poprzednie uszkodzone fragmenty kodu:

# Albo bez ścisłego zakresu, albo z zewnętrznym zakresem moja @array;
#deklaracja.

za moje $i (1..10) {
@tablica = jakaś funkcja($i);
$AoA[$i] = [ @tablica ];
}

Nawiasy kwadratowe odwołują się do nowej tablicy za pomocą a kopia tego, co jest w @array w
czas realizacji zadania. To jest to, czego chcesz.

Zauważ, że spowoduje to coś podobnego, ale jest znacznie trudniejsze do odczytania:

# Albo bez ścisłego zakresu, albo z zewnętrznym zakresem moja @array;
#deklaracja.
za moje $i (1..10) {
@tablica = 0 .. $i;
@{$AoA[$i]} = @tablica;
}

Czy to to samo? No cóż, może tak – a może nie. Subtelna różnica polega na tym, że kiedy ty
przypisz coś w nawiasach kwadratowych, wiesz na pewno, że jest to zawsze zupełnie nowe odniesienie
z nowym kopia danych. W tej nowej sprawie może dziać się coś innego
Odniesienie „@{$AoA[$i]}” po lewej stronie przypisania. Wszystko zależy od
czy $AoA[$i] było na początku niezdefiniowane, czy też zawierało już a
odniesienie. Jeśli już wypełniłeś @AoA referencjami, jak w

$AoA[3] = \@inna_tablica;

Wtedy przypisanie z kierunkiem po lewej stronie wykorzystałoby istniejący
odnośnik, który już tam był:

@{$AoA[3]} = @tablica;

Oczywiście to by mają „interesujący” efekt uderzania w @another_array. (Mieć
zauważyłeś, że gdy programista mówi, że coś jest „interesujące”, to raczej nie
co oznacza „intrygujące”, niepokojąco częściej oznacza, że ​​jest „irytujące”,
„trudne”, czy jedno i drugie? :-)

Pamiętaj więc, aby zawsze używać konstruktorów tablicowych lub skrótów z „[]” lub „{}” i
wszystko będzie dobrze, chociaż nie zawsze jest to optymalnie skuteczne.

Co zaskakujące, następujący niebezpiecznie wyglądający konstrukt faktycznie zadziała dobrze:

za moje $i (1..10) {
moja @tablica = jakaś funkcja($i);
$AoA[$i] = \@tablica;
}

To jest ponieważ mój() jest bardziej instrukcją wykonywaną niż deklaracją czasu kompilacji
dla se. Oznacza to, że mój() zmienna jest tworzona od nowa przy każdym przejściu pętli.
Więc chociaż wygląd tak jakbyś za każdym razem zapisywał to samo odwołanie do zmiennej, you
właściwie nie! Jest to subtelne rozróżnienie, które może wygenerować bardziej wydajny kod
ryzyko wprowadzenia w błąd wszystkich oprócz najbardziej doświadczonych programistów. Dlatego zazwyczaj doradzam
przeciwko nauczaniu tego początkujących. W rzeczywistości, z wyjątkiem przekazywania argumentów do funkcji, I
rzadko kiedy lubię widzieć operator „daj referencję” (ukośnik odwrotny) często używany w kodzie.
Zamiast tego radzę początkującym, aby oni (i większość z nas) próbowali używać metody
znacznie łatwiej zrozumiałe konstruktory „[]” i „{}” zamiast polegać na leksykalnych (lub
dynamiczne) ustalanie zakresu i ukryte liczenie referencji, aby postępować właściwie za kulisami.

W skrócie:

$AoA[$i] = [ @tablica ]; # zwykle najlepiej
$AoA[$i] = \@tablica; # niebezpieczne; jak moja() była tą tablicą?
@{ $AoA[$i] } = @tablica; # zbyt trudne dla większości programistów

OSTRZEŻENIE ON PRECEDENS

Mówiąc o rzeczach takich jak „@{$AoA[$i]}”, poniższe są w rzeczywistości tym samym:

$aref->[2][2] # wyczyść
$$aref[2][2] # mylące

Dzieje się tak, ponieważ zasady pierwszeństwa Perla dotyczące jego pięciu dereferencji przedrostków (które wyglądają jak
ktoś przeklinający: „$ @ * % &”) powoduje, że wiążą się one mocniej niż indeks dolny postfiksowy
wsporniki lub szelki! Bez wątpienia będzie to wielkim szokiem dla programisty C lub C++,
który jest przyzwyczajony do używania *a[i] w znaczeniu tego, na co wskazuje ja element
"A". Oznacza to, że najpierw biorą indeks dolny, a dopiero potem usuwają odniesienie do tej rzeczy
indeks. W C jest w porządku, ale to nie jest C.

Pozornie równoważna konstrukcja w Perlu, $$aref[$i], najpierw wykonuje deref $aref,
sprawiając, że przyjmuje on $aref jako odniesienie do tablicy, a następnie wyłuowuje to i na koniec
powiedz ci ja wartość tablicy wskazywanej przez $AoA. Gdybyś chciał pojęcia C, zrobiłbyś to
trzeba napisać „${$AoA[$i]}”, aby wymusić ocenę $AoA[$i] jako pierwszą przed
wiodący element dereferencji „$”.

CZEMU TY POWINIEN ZAWSZE "posługiwać się ścisły"

Jeśli zaczyna to brzmieć straszniej, niż jest to warte, zrelaksuj się. Perl ma pewne funkcje
pomogą Ci uniknąć najczęstszych pułapek. Najlepszym sposobem na uniknięcie pomyłki jest
uruchamiaj każdy program w ten sposób:

#!/usr/bin/perl -w
używaj ścisłego;

W ten sposób będziesz zmuszony zadeklarować wszystkie swoje zmienne za pomocą mój() a także zabronić
przypadkowe „symboliczne wyłuskanie referencji”. Dlatego jeśli byś to zrobił:

mój $aref = [
[ „fred”, „barney”, „kamyki”, „bambam”, „dino”, ],
["homer", "bart", "marge", "maggie", ],
[ „george”, „jane”, „elroy”, „judy”, ],
];

wydrukuj $aref[2][2];

Kompilator natychmiast oznaczy to jako błąd at skompilować czas, bo byłeś
przypadkowy dostęp do @aref, niezadeklarowanej zmiennej, co mogłoby ci o tym przypomnieć
napisz zamiast tego:

wydrukuj $aref->[2][2]

DEBUGOWANIE

Możesz użyć polecenia „x” debugera, aby zrzucić złożone struktury danych. Na przykład,
biorąc pod uwagę przypisanie do $AoA powyżej, oto wynik debugera:

DB<1> x $AoA
$AoA = SZYK(0x13b5a0)
0 SZYK(0x1f0a24)
0 „Fred”
1 „barney”
2 „kamyczki”
3 „bambam”
4 „dinozaur”
1 SZYK(0x13b558)
0 „dom”
1 „bart”
2 „marża”
3 „magiczna”
2 SZYK(0x13b540)
0 „George”
1 „Jana”
2 „elroy”
3 „Judia”

KOD PRZYKŁADY

Poniżej przedstawiono krótkie komentarze (kiedyś dostaną one własne strony podręcznika).
przykłady kodu ilustrujące dostęp do różnych typów struktur danych.

TABLICE OF TABLICE

Deklaracja of an SZYK OF TABLICE
@AoA = (
[ „fred”, „barney” ],
["george", "jane", "elroy"],
[ „homer”, „marge”, „bart” ],
);

Pożądania of an SZYK OF TABLICE
# czytanie z pliku
podczas gdy ( <> ) {
wciśnij @AoA, [podziel];
}

# wywołanie funkcji
dla $i ( 1 .. 10 ) {
$AoA[$i] = [jakaśfunkcja($i) ];
}

# używając zmiennych temp
dla $i ( 1 .. 10 ) {
@tmp = jakaś funkcja($i);
$AoA[$i] = [ @tmp];
}

# dodaj do istniejącego wiersza
push @{ $AoA[0] }, "wilma", "betty";

Wejdź i Drukowanie of an SZYK OF TABLICE
#jeden element
$AoA[0][0] = "Fred";

# kolejny element
$AoA[1][1] =~ s/(\w)/\u$1/;

# wydrukuj całość z referencjami
dla $aref ( @AoA ) {
print "\t [ @$aref ],\n";
}

# wydrukuj całość wraz z indeksami
dla $i ( 0 .. $#AoA ) {
print "\t [ @{$AoA[$i]} ],\n";
}

# wydrukuj całość pojedynczo
dla $i ( 0 .. $#AoA ) {
dla $j ( 0 .. $#{ $AoA[$i] } ) {
print "elt $i $j to $AoA[$i][$j]\n";
}
}

HASZE OF TABLICE

Deklaracja of a HASZYSZ OF TABLICE
%HoA = (
flintstones => [ "fred", "barney" ],
jetsons => [ "george", "jane", "elroy" ],
simpsons => [ "homer", "marge", "bart" ],
);

Pożądania of a HASZYSZ OF TABLICE
# czytanie z pliku
# flintstones: fred barney wilma dino
podczas gdy ( <> ) {
następny, chyba że s/^(.*?):\s*//;
$HoA{$1} = [ podział ];
}

# czytanie z pliku; więcej temp
# flintstones: fred barney wilma dino
podczas gdy ( $linia = <> ) {
($kto, $rest) = split /:\s*/, $line, 2;
@fields = podziel ' ', $reszta;
$HoA{$kto} = [ @pola ];
}

# wywołanie funkcji zwracającej listę
for $group ( "simpsonowie", "jetsonowie", "flintstonowie" ) {
$HoA{$grupa} = [ get_family($grupa) ];
}

# podobnie, ale używając temps
for $group ( "simpsonowie", "jetsonowie", "flintstonowie" ) {
@członkowie = get_family($grupa);
$HoA{$grupa} = [ @członkowie ];
}

# dodawaj nowych członków do istniejącej rodziny
push @{ $HoA{"flintstones"} }, "wilma", "betty";

Wejdź i Drukowanie of a HASZYSZ OF TABLICE
#jeden element
$HoA{flintstones}[0] = "Fred";

# kolejny element
$HoA{simpsonowie}[1] =~ s/(\w)/\u$1/;

# wydrukuj całość
foreach $rodzina ( klucze %HoA ) {
print "$rodzina: @{$HoA{$rodzina} }\n"
}

# wydrukuj całość wraz z indeksami
foreach $rodzina ( klucze %HoA ) {
wydrukuj "rodzina: ";
foreach $i ( 0 .. $#{ $HoA{$rodzina} } ) {
wydrukuj " $i = $HoA{$rodzina}[$i]";
}
drukuj "\n";
}

# wypisz całość posortowaną według liczby członków
foreach $family ( sortuj { @{$HoA{$b}} <=> @{$HoA{$a}} } klucze %HoA ) {
print "$rodzina: @{$HoA{$rodzina} }\n"
}

# wypisz całość posortowaną według liczby członków i nazwy
foreach $rodzina ( sortuj {
@{$HoA{$b}} <=> @{$HoA{$a}}
||
$a cmp $b
} klucze %HoA )
{
print "$rodzina: ", dołącz(", ", sortuj @{ $HoA{$rodzina} }), "\n";
}

TABLICE OF HASZE

Deklaracja of an SZYK OF HASZE
@AoH = (
{
Ołów => „fred”,
Przyjaciel => "Barney",
},
{
Ołów => „George”,
Żona => „Jane”,
Syn => "elroy",
},
{
Ołów => „homer”,
Żona => "marge",
Syn => "bart",
}
);

Pożądania of an SZYK OF HASZE
# czytanie z pliku
# format: LEAD=fred PRZYJACIEL=barney
podczas gdy ( <> ) {
$zapis = {};
dla pola $ (podział) {
($klucz, $wartość) = podział /=/, $pole;
$rec->{$key} = $wartość;
}
wciśnij @AoH, $rec;
}

# czytanie z pliku
# format: LEAD=fred PRZYJACIEL=barney
# brak temp
podczas gdy ( <> ) {
push @AoH, { podziel /[\s+=]/ };
}

# wywołanie funkcji zwracającej listę par klucz/wartość, np
# „ołów”, „fred”, „córka”, „kamyki”
podczas gdy ( %fields = getnextpairset() ) {
push @AoH, { %pola};
}

# podobnie, ale bez zmiennych tymczasowych
podczas (<>) {
push @AoH, {parsepary($_) };
}

# dodaj klucz/wartość do elementu
$AoH[0]{pet} = "dino";
$AoH[2]{pet} = "mały pomocnik Świętego Mikołaja";

Wejdź i Drukowanie of an SZYK OF HASZE
#jeden element
$AoH[0]{lead} = "fred";

# kolejny element
$AoH[1]{ołów} =~ s/(\w)/\u$1/;

# wydrukuj całość z referencjami
dla $href ( @AoH ) {
wydrukuj „{”;
dla $roli (klucze %$href) {
wydrukuj "$rola=$href->{$rola} ";
}
wydrukuj „}\n”;
}

# wydrukuj całość wraz z indeksami
dla $i ( 0 .. $#AoH ) {
wydrukuj "$i to { ";
dla $role ( klucze %{ $AoH[$i] } ) {
print "$rola=$AoH[$i]{$rola} ";
}
wydrukuj „}\n”;
}

# wydrukuj całość pojedynczo
dla $i ( 0 .. $#AoH ) {
dla $role ( klucze %{ $AoH[$i] } ) {
print "elt $i $rola to $AoH[$i]{$rola}\n";
}
}

HASZE OF HASZE

Deklaracja of a HASZYSZ OF HASZE
%HoH = (
Flinstonowie => {
ołów => "fred",
kumpel => "barney",
},
Jetsonowie => {
ołów => „George”,
żona => „jane”,
„jego chłopiec” => „elroy”,
},
simpsonowie => {
ołów => „homer”,
żona => „marge”,
dzieciak => "bart",
},
);

Pożądania of a HASZYSZ OF HASZE
# czytanie z pliku
# flintstones: lead=fred pal=barney żona=wilma pet=dino
podczas gdy ( <> ) {
następny, chyba że s/^(.*?):\s*//;
$kto = 1 $;
dla pola $ (podział) {
($klucz, $wartość) = podział /=/, $pole;
$HoH{$kto}{$klucz} = $wartość;
}

# czytanie z pliku; więcej temp
podczas gdy ( <> ) {
następny, chyba że s/^(.*?):\s*//;
$kto = 1 $;
$zapis = {};
$HoH{$kto} = $rec;
dla pola $ (podział) {
($klucz, $wartość) = podział /=/, $pole;
$rec->{$key} = $wartość;
}
}

# wywołanie funkcji zwracającej klucz, skrót wartości
for $group ( "simpsonowie", "jetsonowie", "flintstonowie" ) {
$HoH{$grupa} = { get_family($grupa) };
}

# podobnie, ale używając temps
for $group ( "simpsonowie", "jetsonowie", "flintstonowie" ) {
%członków = get_family($grupa);
$HoH{$grupa} = {%członków };
}

# dodawaj nowych członków do istniejącej rodziny
%new_folks = (
żona => "wilma",
zwierzak => "dino",
);

za $co (klucze %new_folks) {
$HoH{flintstones}{$co} = $new_folks{$co};
}

Wejdź i Drukowanie of a HASZYSZ OF HASZE
#jeden element
$HoH{flintstones}{żona} = "wilma";

# kolejny element
$HoH{simpsonowie}{ołów} =~ s/(\w)/\u$1/;

# wydrukuj całość
foreach $rodzina ( klucze %HoH ) {
wydrukuj "$rodzina: { ";
dla $roli ( klucze %{ $HoH{$rodzina} } ) {
print "$rola=$HoH{$rodzina}{$rola} ";
}
wydrukuj „}\n”;
}

# wydrukuj całość nieco posortowaną
foreach $rodzina (klucze sortowania %HoH) {
wydrukuj "$rodzina: { ";
dla $role (klucze sortowania %{ $HoH{$rodzina} } ) {
print "$rola=$HoH{$rodzina}{$rola} ";
}
wydrukuj „}\n”;
}

# wypisz całość posortowaną według liczby członków
foreach $family ( sortuj { klucze %{$HoH{$b}} <=> klucze %{$HoH{$a}} }
klawisze %HoH)
{
wydrukuj "$rodzina: { ";
dla $role (klucze sortowania %{ $HoH{$rodzina} } ) {
print "$rola=$HoH{$rodzina}{$rola} ";
}
wydrukuj „}\n”;
}

# ustal porządek sortowania (rangę) dla każdej roli
$i = 0;
for ( qw(główna żona syn córka kumpel zwierzę) ) { $rank{$_} = ++$i }

# teraz wydrukuj całość posortowaną według liczby członków
foreach $family ( sortuj { klucze %{ $HoH{$b} } <=> klucze %{ $HoH{$a} } }
klawisze %HoH)
{
wydrukuj "$rodzina: { ";
# i wydrukuj je zgodnie z kolejnością rang
dla $rola ( sort { $rank{$a} <=> $rank{$b} }
klucze %{ $HoH{$rodzina} } )
{
print "$rola=$HoH{$rodzina}{$rola} ";
}
wydrukuj „}\n”;
}

WIĘCEJ WYSZUKANY DOKUMENTACJA

Deklaracja of WIĘCEJ WYSZUKANY DOKUMENTACJA
Oto przykład pokazujący, jak utworzyć i używać rekordu, którego pola mają wiele różnych
rodzaje:

$rek = {
TEKST => $ciąg,
SEKWENCJA => [ @stare_wartości ],
WYSZUKAJ => {%jakaś_tabela },
THATCODE => \&jakaś_funkcja,
TEN KOD => sub { $_[0] ** $_[1] },
UCHWYT => \*STDOUT,
};

wydrukuj $rec->{TEKST};

drukuj $rec->{SEKWENCJA}[0];
$last = pop @ { $rec->{SEKWENCJA} };

wydrukuj $rec->{WYSZUKAJ="klucz"};
($first_k, $first_v) = każdy %{ $rec->{WYSZUKAJ} };

$odpowiedź = $rec->{THATCODE}->($arg);
$odpowiedź = $rec->{TEN KOD}->($arg1, $arg2);

# uważaj na dodatkowe nawiasy blokowe na fh ref
print { $rec->{HANDLE} } "ciąg\n";

użyj FileHandle;
$rec->{UCHWYT}->automatyczne spłukiwanie(1);
$rec->{UCHWYT}->print(" ciąg znaków\n");

Deklaracja of a HASZYSZ OF KOMPLEKS DOKUMENTACJA
%TV = (
Flinstonowie => {
seria => "krzemieńce",
noce => [ qw(poniedziałek czwartek piątek) ],
członkowie => [
{ imię => „fred”, rola => „prowadzący”, wiek => 36, },
{ imię => "wilma", rola => "żona", wiek => 31, },
{ imię => "kamyki", rola => "dziecko", wiek => 4, },
],
},

Jetsonowie => {
seria => „jetsonowie”,
noce => [ qw(środa sobota) ],
członkowie => [
{ imię => „George”, rola => „prowadzący”, wiek => 41, },
{ imię => „jane”, rola => „żona”, wiek => 39, },
{ imię => "elroy", rola => "dziecko", wiek => 9, },
],
},

simpsonowie => {
seria => „simpsonowie”,
noce => [ qw(Poniedziałek) ],
członkowie => [
{ imię => "homer", rola => "prowadzący", wiek => 34, },
{ imię => „marge”, rola => „żona”, wiek => 37, },
{ imię => "bart", rola => "dziecko", wiek => 11, },
],
},
);

Pożądania of a HASZYSZ OF KOMPLEKS DOKUMENTACJA
# czytanie z pliku
# najłatwiej to zrobić, ustawiając sam plik
# w formacie surowych danych, jak pokazano powyżej. Perl jest szczęśliwy
# do analizowania złożonych struktur danych, jeśli są zadeklarowane jako dane, tzw
# czasami najłatwiej to zrobić

# Oto kompilacja kawałek po kawałku
$zapis = {};
$rec->{series} = "krzemień";
$rec->{nights} = [find_days() ];

@członkowie = ();
# załóż ten plik w składni pole=wartość
podczas (<>) {
%fields = podział /[\s=]+/;
push @członkowie, {% pól };
}
$rec->{członkowie} = [ @członkowie ];

# teraz zapamiętaj całość
$TV{ $rec->{seria} } = $rec;

################################################## #########
# teraz możesz chcieć utworzyć interesujące dodatkowe pola
# dołącz wskaźniki z powrotem do tej samej struktury danych, więc if
# zmień jeden element, zmienia się wszędzie, jak na przykład
# jeśli chcesz, aby pole {kids} było odniesieniem
# do tablicy rekordów dzieci bez duplikatów
# rekordów i tym samym problemy z aktualizacją.
################################################## #########
foreach $rodzina (klucze %TV) {
$rec = $TV{$rodzina}; #wskaźnik temperatury
@dzieci = ();
dla $osoby ( @{ $rec->{members} } ) {
if ($osoba->{rola} =~ /dziecko|syn|córka/) {
push @dzieci, $osoba;
}
}
# PAMIĘTAJ: $rec i $TV{$family} wskazują na te same dane!!
$rec->{dzieci} = [ @dzieci ];
}

# skopiowałeś tablicę, ale sama tablica zawiera wskaźniki
# do nieskopiowanych obiektów. oznacza to, że jeśli sprawisz, że Bart dostanie
# starsze przez

$TV{simpsonowie}{dzieci}[0]{wiek}++;

# wtedy to również by się zmieniło
drukuj $TV{simpsonowie}{członkowie}[2]{wiek};

# ponieważ $TV{simpsons}{kids}[0] i $TV{simpsons}{członkowie}[2]
# oba wskazują na tę samą anonimową tabelę mieszającą

# wydrukuj całość
foreach $rodzina ( klucze %TV ) {
wydrukuj „rodzinę $”;
print " jest włączone podczas @{ $TV{$family}{nights} }\n";
print "jego członkami są:\n";
dla $who ( @{ $TV{$rodzina}{członkowie} } ) {
print " $kto->{imię} ($kto->{role}), wiek $who->{wiek}\n";
}
print "okazuje się, że $TV{$family}{lead} ma ";
wydrukuj skalar ( @{ $TV{$family}{kids} } ), "dzieci o imionach";
print dołącz (", ", mapa { $_->{name} } @{ $TV{$family}{kids} } );
drukuj "\n";
}

Baza danych Krawaty

Nie można łatwo powiązać wielopoziomowej struktury danych (takiej jak skrót skrótów) z bazą danych
plik. Pierwszy problem polega na tym, że wszystkie oprócz GDBM i Berkeley DB mają ograniczenia rozmiaru, ale
poza tym występują również problemy z reprezentacją odniesień na dysku.
Jednym z modułów eksperymentalnych, który częściowo próbuje zaspokoić tę potrzebę, jest MLDBM
moduł. Sprawdź najbliższą witrynę CPAN, jak opisano w perlmodlib, w celu uzyskania kodu źródłowego do MLDBM.

Korzystaj z perldsc online, korzystając z usług onworks.net