Provided by:
manpages-pl_20060617-2_all 
NAZWA
perlsyn - Składnia perla
OPIS
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.