NAZWA¶
perlsyn - Składnia perla
OPIS¶
Uwaga! To tłumaczenie może być nieaktualne!
Skrypt perla składa się z sekwencji deklaracji i instrukcji.
Jedynymi rzeczami, które muszą być zadeklarowane w perlu,
to formatki raportowe i procedury. Więcej informacji o tych deklaracji
znajdziesz w sekcjach poniżej. Wszystkie niezainicjalizowane, stworzone
przez użytkownika obiekty, uznawane są za posiadające
początkową wartość null lub 0, dopóki nie
zostaną zdefiniowane w jakiejś jawnej operacji, jak np.
przypisanie. (Choć jeśli chcesz, możesz dostawać
ostrzeżenia o używaniu wartości niezdefiniowanych.)
Sekwencja instrukcji jest wykonywana tylko jednokrotnie, w
przeciwieństwie do skryptów
sed(1) czy
awk(1),
gdzie sekwencja taka jest wykonywana dla każdej linii
wejściowej. Oznacza to, że musisz jawnie przetwarzać w
pętli linie swojego pliku wejściowego (lub plików),
oznacza to też, że masz dużo większą
kontrolę nad tym, którymi plikami i liniami się
zajmujesz. (Właściwie to kłamię--można
zrobić niejawną pętlę za pomocą
przełącznika
-n lub
-p. Nie jest to po prostu
domyślne i zarazem obowiązkowe jak w
sed(1) czy
awk(1).)
Deklaracje
Perl jest w ogólności językiem wolnej postaci (free-form).
(Jedynym wyjątkiem są deklarację formatek--z oczywistych
przyczyn.) Komentarze są rozpoczynane znakiem "#" i
ciągną się do końca linii. Jeśli
spróbujesz użyć komentarzy /* */ w stylu C, to
zostaną one zinterpretowane albo jako dzielenie, albo jako
porównywanie wzorca. Z kolei komentarz // z C++ wygląda
dokładnie jak puste wyrażenie regularne. Nie kombinuj
więc z tymi konstrukcjami.
Deklaracja może być wstawiona gdziekolwiek, gdzie można
wstawić instrukcję, lecz nie ma wpływu na wykonywanie
podstawowej sekwencji instrukcji--deklaracje mają znaczenie tylko
podczas kompilacji. Zazwyczaj wszystkie deklaracje wstawiane są na
początku lub na końcu skryptu. Jeśli jednak
używasz zmiennych prywatnych zawężonych leksykalnie,
utworzonych przez
my(), będziesz musiał się
upewnić, czy twoja definicja formatki lub procedury,
używającej tych deklaracji leży wewnątrz tego
samego zakresu.
Deklarowanie procedury zezwala na używanie jej nazwy tak, jakby
była operatorem listowym, licząc od tego miejsca, aż do
końca programu. Możesz zadeklarować procedurę bez
jej definiowania, pisząc sub name, więc:
sub myname;
$me = myname $0 or die "can't get myname";
Zauważ, że działa to jak operator listowy, a nie jak
jednoargumentowy; uważaj więc i używaj or zamiast
⎪⎪. Jednak jeśli zadeklarowałbyś
procedurę jako sub myname ($), to myname funkcjonowałoby jak
operator jednoargumentowy, więc działałyby zarówno
or jak i ⎪⎪.
Deklaracje procedur mogą być również ładowane
instrukcją require, lub jednocześnie ładowane jak i
importowane do przestrzeni nazw dzięki instrukcji use. Dla
szczegółów polecam podręcznik
perlmod(1).
Sekwencja instrukcji może zawierać deklaracje zmiennych
zawężonych leksykalnie, lecz poza deklarowaniem nazwy zmiennej,
deklaracja działa jak zwykła instrukcja i jest wykonywana w
sekwencji instrukcji jak zwyczajna instrukcja. Znaczy to, że ma ona
zarówno skutki podczas kompilacji, jak w czasie działania.
Instrukcje proste
Jedynym rodzajem instrukcji prostej jest wyrażenie, analizowane dla
swoich efektów ubocznych. Każda instrukcja prosta musi
się kończyć średnikiem, chyba że jest
ostatnią instrukcją bloku, wtedy średnik nie jest
obowiązujący. (Jednak wciąż jest zalecany
jeśli blok zajmuje więcej niż jedną linię,
gdyż możliwe że dodasz jeszcze kolejne linie.)
Zauważ, że istnieją operatory takie, jak eval {} i do {},
które wyglądają jak instrukcje złożone,
lecz nimi nie są i wymagają jawnego zakończenia
jeśli są użyte jako ostatni element instrukcji.
Za każdą prostą instrukcją, tuż przed
średnikiem (lub końcem bloku) może znajdować
się
POJEDYNCZY modyfikator. Dopuszczalne modyfikatory to:
if WYRAŻ
unless WYRAŻ
while WYRAŻ
until WYRAŻ
foreach WYRAŻ
Modyfikatory if i unless mają semantykę zgodną z
oczekiwaniami (jeżeli i chyba że). Modyfikator foreach jest
iteratorem: dla każdej wartości w WYRAŻ przypisuje jej
nazwę zastępczą $_ i wykonuje instrukcję.
Modyfikatory while i until również mają typową
semantykę pętli while (warunek jest analizowany najpierw).
Wyjątkiem jest poprzedzenie tych modyfikatorów
konstrukcją do-BLOK - wówczas blok jest wykonywany raz przed
sprawdzeniem warunku. Dzięki temu możesz tworzyć
pętle w rodzaju:
do {
$line = <STDIN>;
...
} until $line eq ".\n";
Zobacz opis do w podręczniku
perlfunc. Zauważ też,
że opisane poniżej instrukcje kontroli pętli
NIE
będą działały w tej konstrukcji, gdyż
modyfikatory nie pobierają etykiet pętli. Przykro mi.
Możesz zawsze umieścić wewnątrz inny blok (dla
WnextfR) lub też umieścić swoją instrukcję
wewnątrz bloku (dla last), aby zrobić coś takiego. W
przypadku next po prostu podwój nawiasy:
do {{
next if $x == $y;
# coś tu robi
}} until $x++ > $z;
Dla next musisz się bardziej rozpisać:
LOOP: {
do {
last if $x = $y**2;
# coś tu robi
} while $x++ <= $z;
}
Instrukcje złożone
W perlu, sekwencja instrukcji definiująca zakres nazywana jest blokiem.
Czasami ograniczeniem bloku stanowi zawierający go plik (w wypadku
wymaganego (required) pliku lub programu jako całości), a
czasami zasięg łańcucha znakowego (w wypadku eval).
Lecz ogólnie, blok jest ograniczony nawiasami klamrowymi. Taką
konstrukcję syntaktyczną nazwiemy BLOKIEM.
Do kontroli przepływu można używać
następujących instrukcji złożonych:
if (WYRAŻ) BLOK
if (WYRAŻ) BLOK else BLOK
if (WYRAŻ) BLOK elsif (WYRAŻ) BLOK ... else BLOK
ETYKIETA while (WYRAż) BLOK
ETYKIETA while (WYRAŻ) BLOK continue BLOK
ETYKIETA for (WYRAŻ; WYRAŻ; WYRAŻ) BLOK
ETYKIETA foreach VAR (LISTA) BLOK
ETYKIETA BLOK continue BLOK
Zauważ, że w przeciwieństwie do C i Pacala, są one
zdefiniowane w kategoriach BLOKÓW, a nie instrukcji. Znaczy to,
że nawiasy klamrowe są niezbędne--wiszące
instrukcje nie są dozwolone. Jeśli chcesz pisać warunki
bez nawiasów, to są na to inne sposoby.
Następujące przykłady robią wszystkie to samo:
if (!open(FOO)) { die "Can't open $FOO: $!"; }
die "Can't open $FOO: $!" unless open(FOO);
open(FOO) or die "Can't open $FOO: $!"; # FOO lub giń!
open(FOO) ? 'hi mom' : die "Can't open $FOO: $!";
# to ostatnie trochę egzotyczne
Instrukcja if jest nieskomplikowana. Ponieważ BLOKI są zawsze
ograniczone nawiasami klamrowymi, nigdy nie ma niejednoznaczności co do
tego, do którego if przynależy dany else. Jeśli zamiast
if używasz unless, sens testu jest odwrócony.
Instrukcja while wykonuje swój blok tak długo, jak
wyrażenie jest prawdziwe (jego wartością nie jest
łańcuch pusty, 0 czy "0"). ETYKIETA jest opcjonalna, a
jeśli jest obecna, składa się z identyfikatora, za
którym następuje dwukropek. ETYKIETA identyfikuje
pętlę dla instrukcji kontroli pętli, czyli next, last i
redo. Jeśli pominięto ETYKIETĘ, instrukcje kontroli
pętli odnoszą się do najbardziej wewnętrznej
otaczającej pętli. Może to wymagać dynamicznego
przeglądania wstecz stosu wywołań w czasie wykonania, aby
znaleźć odpowiednią ETYKIETĘ. Takie desperackie
zachowania dają zwykle ostrzeżenia przy włączonej
fladze
-w.
Jeśli istnieje BLOK continue, to jest on zawsze wykonywany tuż
przed kolejną analizą warunku, podobnie jak trzeci element
pętli for w C. Można tego używać do
zwiększania zmiennej sterującej pętli, nawet gdy
pętla jest właśnie kontynuowana instrukcją next
(która jest z kolei podobna do instrukcji continue z C).
Kontrola pętli
Polecenie next jest podobne do instrukcji continue z C; rozpoczyna nową
iterację pętli:
LINE: while (<STDIN>) {
next LINE if /^#/; # wykasuj komentarze
...
}
Polecenie last jest podobne do instrukcji break z C (używanej w
pętlach); natychmiastowo opuszcza pętlę. Blok continue
nie jest wykonywany:
LINE: while (<STDIN>) {
last LINE if /^$/; # zakończ po obsłużeniu nagłówka
...
}
Polecenie redo restartuje pętlę bez ponownego analizowania
warunku. Blok continue nie jest wykonywany. Polecenie to jest zazwyczaj
używane w programach, które chcą się
okłamywać co do tego, co właśnie pobrały z
wejścia.
Na przykład, podczas przetwarzania pliku takiego, jak
/etc/termcap. Jeśli twoje wiersze wejściowe mogą
się kończyć lewymi ukośnikami, wskazującymi
kontynuację, możesz chcieć z wyprzedzeniem pobrać
następny rekord.
while (<>) {
chomp;
if (s/\\$//) {
$_ .= <>;
redo unless eof();
}
# teraz przetwórz $_
}
co w perlu jest skrótem dla wersji napisanej bardziej dosłownie:
LINE: while (defined($line = <ARGV>)) {
chomp($line);
if ($line =~ s/\\$//) {
$line .= <ARGV>;
redo LINE unless eof(); # nie eof(ARGV)!
}
# teraz przetwórz $line
}
A tu mamy prosty striptizer komentarzy Pascalowych (uwaga: zakłada brak {
lub } w łańcuchach).
LINE: while (<STDIN>) {
while (s⎪({.*}.*){.*}⎪$1 ⎪) {}
s⎪{.*}⎪ ⎪;
if (s⎪{.*⎪ ⎪) {
$front = $_;
while (<STDIN>) {
if (/}/) { # koniec komentarza?
s⎪^⎪$front{⎪;
redo LINE;
}
}
}
print;
}
Zauważ, że jeśli w powyższym kodzie istniałby
blok continue, został by on wywołany nawet dla usuniętych
wierszy. Blok ten jest często używany do resetowania
liczników wierszy czy jednokrotnych dopasowań ?wzorców?.
# zainspirowane przez :1,$g/fred/s//WILMA/
while (<>) {
?(fred)? && s//WILMA $1 WILMA/;
?(barney)? && s//BETTY $1 BETTY/;
?(homer)? && s//MARGE $1 MARGE/;
} continue {
print "$ARGV $.: $_";
close ARGV if eof(); # reset $. (nr wiersza)
reset if eof(); # reset ?wzorca?
}
Jeśli słowo while jest zamieniane słowem until, to sens
testu jest odwrócony, lecz warunek jest wciąż testowany w
pierwszej iteracji.
Instrukcje sterujące pętli nie współpracują z
if ani unless, gdyż nie są one pętlami. Możesz
jednak podwoić nawiasy by je nimi uczynić.
if (/wzorzec/) {{
next if /fred/;
next if /barney/;
# coś tu robi
}}
Postać while/if BLOCK BLOCK, która była dostępna w
Perl 4 nie jest już prawidłowa. Zmień wszystkie
wystąpienia if BLOCK na if (do BLOCK).
Pętle for
Perlowa pętla for w stylu C, działa dokładnie jak
odpowiadająca jej pętla while, co znaczy, że to:
for ($i = 1; $i < 10; $i++) {
...
}
jest tym samym, co to:
$i = 1;
while ($i < 10) {
...
} continue {
$i++;
}
(Jest jedna drobna różnica: pierwsza postać wymusza
zawężenie leksykalne dla zmiennych zadeklarowanych przez my w
wyrażeniu inicjalizacji.)
Poza zwykłymi pętlami po indeksach tablic, for daje wiele innych
zastosowań. Oto przykład, zapobiegający problemowi,
który napotyka się testując jawnie EOF na interaktywnym
deskryptorze pliku, co powoduje, że program wygląda jakby
się zawiesił.
$on_a_tty = -t STDIN && -t STDOUT;
sub prompt { print "yes? " if $on_a_tty }
for ( prompt(); <STDIN>; prompt() ) {
# zrób coś
}
Pętle foreach
Pętla foreach iteruje poprzez normalną wartość
listową i przypisuje zmiennej VAR wartość każdego
kolejnego elementu listy. Jeśli zmienna jest poprzedzona słowem
kluczowym my, to jest ona leksykalnie zawężona i widzialna tylko
wewnątrz pętli. W przeciwnym wypadku, zmienna jest niejawnie
lokalna w pętli i, po wyjściu z niej, odzyskuje pierwotną
wartość. Jeśli zmienna była poprzednio
zadeklarowana przez my, to pętla używa tej zmiennej, zamiast
zmiennej globalnej, lecz wciąż jest ona lokalna w obrębie
pętli. (Zauważ, że zmienne o zasięgu leksykalnym
mogą być przyczyną kłopotów, jeśli
wewnątrz pętli masz odwołujące się do nich
procedury lub deklaracje formatów.)
Słowo kluczowe foreach jest w rzeczywistości synonimem
słowa for, więc foreach możesz używać dla
czytelności, a for dla skrócenia. (Albo też
powłoka Bourne'a jest Ci milsza niż
csh, więc
pisanie for jest naturalniejsze.) Jeśli VAR jest pominięte, na
kolejne wartości ustawiane będzie $_. Jeśli dowolny
element LISTY jest lwartością, to możesz łatwo
modyfikować jego wartość, modyfikując VAR
wewnątrz pętli. Jest tak dlatego, że zmienna indeksu
pętli foreach jest niejawnym synonimem każdego iterowanego
elementu. W szczególności możliwa jest zmiana tym
sposobem wartości elementów tablicy LISTA (ale nie
wyrażenia zwracającego LISTĘ).
Jeśli dowolna część LISTY jest tablicą, to
foreach bardzo się zmiesza, jeśli wewnątrz pętli
dodasz lub usuniesz elementy, na przykład przy pomocy splice. Nie
rób więc tego.
foreach prawdopodobnie nie zrobi tego, czego oczekujesz, jeśli VAR jest
zmienną specjalną. Tego też nie rób.
Przykłady:
for (@ary) { s/foo/bar/ }
foreach my $elem (@elements) {
$elem *= 2;
}
for $count (10,9,8,7,6,5,4,3,2,1,'BOOM') {
print $count, "\n"; sleep(1);
}
for (1..15) { print "Merry Christmas\n"; }
foreach $item (split(/:[\\\n:]*/, $ENV{TERMCAP})) {
print "Item: $item\n";
}
Oto, jak programista C mógłby zakodować szczególny
algorytm w perlu:
for (my $i = 0; $i < @ary1; $i++) {
for (my $j = 0; $j < @ary2; $j++) {
if ($ary1[$i] > $ary2[$j]) {
last; # nie mogę wyjść do zewnętrznej :-(
}
$ary1[$i] += $ary2[$j];
}
# tu zabiera mnie last
}
Podczas gdy programista perla mógłby zrobić to wygodniej:
OUTER: foreach my $wid (@ary1) {
INNER: foreach my $jet (@ary2) {
next OUTER if $wid > $jet;
$wid += $jet;
}
}
Widzisz jakie to proste? Czystsze, bezpieczniejsze i szybsze. Jest czystsze, bo
mniej tu zamieszania. Jest bezpieczniejsze, bo jeśli między
wewnętrzną, a zewnętrzną pętlę
zostanie później dodany kod, to nie będzie on przypadkiem
wykonywany. next jawnie iteruje inną pętlę zamiast
przerywania wewnętrznej. Jest to szybsze, gdyż perl
wywołuje instrukcje foreach szybciej niż
równoważnik z pętlą for.
Podstawowe instrukcje BLOKOWE i switch
BLOK (z etykietą lub bez) jest równoważny pętli,
która jest wykonywana jeden raz. Tak więc możesz
wewnątrz używać instrukcji kontroli pętli by
wyjść z bloku lub ponowić jego wykonanie. (Zauważ,
że nie jest to prawdą wewnątrz eval{}, sub{} czy,
przeciwnie do rozpowszchnionych przekonań, bloków do{},
które nie zaliczają się do pętli.) Blok continue
jest opcjonalny.
Konstrukcja BLOKU jest szczególnie wygodna do tworzenia struktur wyboru
(case).
SWITCH: {
if (/^abc/) { $abc = 1; last SWITCH; }
if (/^def/) { $def = 1; last SWITCH; }
if (/^xyz/) { $xyz = 1; last SWITCH; }
$nothing = 1;
}
W perlu nie ma oficjalnej instrukcji switch, gdyż istnieje już
kilka sposobów na wykonanie jej równoważnika.
Oprócz, mógłbyś napisać
SWITCH: {
$abc = 1, last SWITCH if /^abc/;
$def = 1, last SWITCH if /^def/;
$xyz = 1, last SWITCH if /^xyz/;
$nothing = 1;
}
(W rzeczywistości nie jest to tak dziwne jak wygląda. Musisz sobie
uświadomić, że możesz korzystać z
"operatorów" kontroli pętli wewnątrz
wyrażeń. Jest to zwyczajny operator przecinka z C.)
lub
SWITCH: {
/^abc/ && do { $abc = 1; last SWITCH; };
/^def/ && do { $def = 1; last SWITCH; };
/^xyz/ && do { $xyz = 1; last SWITCH; };
$nothing = 1;
}
lub sformatowane w taki sposób, że wygląda bardziej na
"poprawną" instrukcję switch:
SWITCH: {
/^abc/ && do {
$abc = 1;
last SWITCH;
};
/^def/ && do {
$def = 1;
last SWITCH;
};
/^xyz/ && do {
$xyz = 1;
last SWITCH;
};
$nothing = 1;
}
lub
SWITCH: {
/^abc/ and $abc = 1, last SWITCH;
/^def/ and $def = 1, last SWITCH;
/^xyz/ and $xyz = 1, last SWITCH;
$nothing = 1;
}
lub nawet straszliwe
if (/^abc/)
{ $abc = 1 }
elsif (/^def/)
{ $def = 1 }
elsif (/^xyz/)
{ $xyz = 1 }
else
{ $nothing = 1 }
Popularnym idiomem instrukcji switch jest wykorzystanie tworzonego przez foreach
synonimu. Uzyskane tymczasowe przypisanie do zmiennej $_ umożliwia
wygodne dopasowywanie:
SWITCH: for ($where) {
/In Card Names/ && do { push @flags, '-e'; last; };
/Anywhere/ && do { push @flags, '-h'; last; };
/In Rulings/ && do { last; };
die "unknown value for form variable where: `$where'";
}
Innym interesującym podejściem do instrukcji switch jest
rozplanowanie bloku do tak, by zwracał właściwą
wartość:
$amode = do {
if ($flag & O_RDONLY) { "r" }
elsif ($flag & O_WRONLY) { ($flag & O_APPEND) ? "a" : "w" }
elsif ($flag & O_RDWR) {
if ($flag & O_CREAT) { "w+" }
else { ($flag & O_APPEND) ? "a+" : "r+" }
}
};
lub też
print do {
($flags & O_WRONLY) ? "write-only" :
($flags & O_RDWR) ? "read-write" :
"read-only";
};
albo, jeśli jesteś pewien, że wszystkie klauzule &&
są prawdziwe, możesz posłużyć się
czymś podobnym, co "przełącza" w
zależności od wartości zmiennej środowiska
HTTP_USER_AGENT.
#!/usr/bin/perl
# dobierz plik ze stroną żargonu według przeglądarki
$dir = 'http://www.wins.uva.nl/~mes/jargon';
for ($ENV{HTTP_USER_AGENT}) {
$page = /Mac/ && 'm/Macintrash.html'
⎪⎪ /Win(dows )?NT/ && 'e/evilandrude.html'
⎪⎪ /Win⎪MSIE⎪WebTV/ && 'm/MicroslothWindows.html'
⎪⎪ /Linux/ && 'l/Linux.html'
⎪⎪ /HP-UX/ && 'h/HP-SUX.html'
⎪⎪ /SunOS/ && 's/ScumOS.html'
⎪⎪ 'a/AppendixB.html';
}
print "Location: $dir/$page\015\012\015\012";
Ten rodzaj instrukcji switch działa tylko, gdy wiesz, że klauzule
&& będą prawdziwe. Jeśli nie, to powinien
być użyty poprzedni przykład z ?:.
Możesz także rozważyć napisanie hasza (tablicy
asocjacyjnej) zamiast syntezowania instrukcji switch.
Goto
Perl obsługuje instrukcję goto. ETYKIETA pętli nie jest w
rzeczywistości prawidłowym celem goto; jest tylko nazwą
pętli. Istnieją trzy postacie: goto-ETYKIETA, goto-WYRAŻ
i goto-&NAZWA.
Postać goto-ETYKIETA szuka instrukcji oznaczonej ETYKIETĄ i
kontynuuje wykonywanie w tym miejscu. Nie może być
używana do wchodzenia do wnętrza konstrukcji, które
wymagają inicjalizacji, takich jak procedury lub pętle foreach.
Nie może też być używana do wchodzenia do
konstrukcji, które są w jakiś sposób
optymalizowane. Może być używane do wchodzenia prawie we
wszystkie inne miejsca w zakresie dynamicznym, łącznie z
wychodzeniem z procedur, lecz zwykle lepiej jest użyć
konstrukcji takiej jak last lub die. Autor Perla nigdy nie czuł
potrzeby używania tej postaci goto (w Perlu--C to inna sprawa).
Postać goto-WYRAŻ oczekuje nazwy etykiety, której zakres
zostanie rozwiązany dynamicznie. Umożliwia to stosowanie
wyliczanych goto jak w FORTRANie, lecz nie jest zbyt zalecane jeśli
optymalizujesz z uwagi na konserwację programu:
goto ("FOO", "BAR", "GLARCH")[$i];
Postać goto-&NAZWA jest bardzo magiczna i podstawia wywołanie
do nazwanej procedury za bieżącą procedurę. Jest
to używane przez procedury
AUTOLOAD(), które chcą
ładować inne procedury, a potem udawać, że inna
procedura została wywołana jako pierwsza (poza tym, że
wszelkie modyfikacje @_ w bieżącej procedurrze są
przenoszone do tej innej procedury.) Po takim goto, nawet
caller() nie
będzie w stanie powiedzieć, że ta procedura
została wywołana pierwsza.
W większości tego typu przypadków, zazwyczaj dużo,
dużo lepszym pomysłem jest używanie strukturalnych
mechanizmów kontroli przepływu next, last lub redo, zamiast
zwracać się ku goto. Dla niektórych zastosowań,
para eval{} i
die(), służąca do przetwarzania
wyjątków może być też rozsądnym
wyjściem.
POD: Osadzona dokumentacja
Perl posiada mechanizm łączenia dokumentacji z kodem
źródłowym. Podczas oczekiwania początku nowej
instrukcji, jeśli kompilator natrafi na linię,
rozpoczynającą się od znaku równości i
słowa, jak
=head1 Here There Be Pods!
To ten tekst, oraz reszta napisów, aż do linii,
rozpoczynającej się od =cut włącznie
zostaną zignorowane. Format tekstu wtrąconego jest opisany w
podręczniku
perlpod(1).
Umożliwia ci to łączenie kodu
źródłowego i dokumentacji, jak w
=item snazzle($)
Funkcja snazzle() będzie zachowywać się w najbardziej spektakularny
sposób, jaki możesz sobie wyobrazić, prześcigając nawet cyber
pirotechnikę.
=cut powrót do kompilatora, fora z tego pod-fora!
sub snazzle($) {
my $thingie = shift;
.........
}
Zauważ, że translatory pod powinny patrzeć tylko na
akapity, rozpoczynające się od dyrektywy pod (ułatwia to
przetwarzanie), podczas gdy kompilator wie, że ma szukać
sekwencji specjalnych pod nawet w środku akapitu. Znaczy to, że
następujący tajny tekst będzie ignorowany zarówno
przez kompilator, jak i przez translatory.
$a=3;
=tajne rzeczy
warn "Ani POD ani KOD!?"
=cut powrot
print "got $a\n";
Prawdopodobnie nie powinieneś opierać się na
warn(),
"wypodowanym" na zawsze. Nie wszystkie translatory zachowują
się w tym momencie dobrze i być może kompilator stanie
się wybredniejszy.
Dyrektyw pod można też używać do szybkiego
wykomentowania sekcji kodu.
Plain Old Comments (Nie!)
Podobnie jak preprocesor C, perl może przetwarzać dyrektywy
liniowe. Przy ich użyciu, można kontrolować perlowe
pojęcie nazw plików i numerów linii w komunikatach o
błędach/ostrzeżeniach (szczególnie dla
łańcuchów, które są przetwarzane z
eval()). Składnia tego mechanizmu jest taka sama dla jak dla
większości preprocesorów C: dopasowuje wyrażenie
regularne /^#\s*line\s+(\d+)\s*(?:\s"([^"]*)")?/ do $1,
będącego numerem linii i $2, będącego
opcjonalną nazwą pliku (podaną w cudzysłowach).
Oto niektóre przykłady, które możesz
sprawdzić w swojej powłoce:
% perl
# line 200 "bzzzt"
# znak `#' w poprzedniej linii musi być pierwszym znakiem linii
die 'foo';
__END__
foo at bzzzt line 201.
% perl
# line 200 "bzzzt"
eval qq[\n#line 2001 ""\ndie 'foo']; print $@;
__END__
foo at - line 2001.
% perl
eval qq[\n#line 200 "foo bar"\ndie 'foo']; print $@;
__END__
foo at foo bar line 200.
% perl
# line 345 "goop"
eval "\n#line " . __LINE__ . ' "' . __FILE__ ."\"\ndie 'foo'";
print $@;
__END__
foo at goop line 345.
Powyższe tłumaczenie pochodzi z nieistniejącego już
Projektu Tłumaczenia Manuali i
może nie być
aktualne. W razie zauważenia różnic między
powyższym opisem a rzeczywistym zachowaniem opisywanego programu lub
funkcji, prosimy o zapoznanie się z oryginalną
(angielską) wersją strony podręcznika za pomocą
polecenia:
- man --locale=C 1 perlsyn
Prosimy o pomoc w aktualizacji stron man - więcej informacji można
znaleźć pod adresem
http://sourceforge.net/projects/manpages-pl/.
