Ocenite etot tekst:


---------------------------------------------------------------
   © Copyright (C) Maslov Vladimir Viktorovich
    Vse zamechaniya i predlozheniya napravlyajte po adresu:
    maslov@klgtts.kaluga.su
    maslov@news.kaluga.rosmail.com
---------------------------------------------------------------

Vse  primery  v  knige  provereny  dlya Perl versii 5.003
operacionnoj sistemy Unix FreeBSD 2.1.0.
===============================================================








     V  knige  privodyatsya  nachal'nye  svedeniya  po novomu yazyku
programmirovaniya Perl.
       Dannyj  yazyk  poluchil  shirokoe rasprostranenie v svyazi s
razvitiem komp'yuternoj  seti  Internet.  Vse  primery  v  knige
provereny  dlya  Perl  versii  5.003  operacionnoj  sistemy  Unix
FreeBSD 2.1.0.

     Dlya    programmistov,    sistemnyh    administratorov    i
pol'zovatelej komp'yuterov.

(C) Maslov Vladimir Viktorovich.



     Prezhde  chem  pristupit' k posledovatel'nomu oznakomleniyu s
ne znakomym dlya vas yazykom, dolzhen ogovorit'sya i  skazat',  chto
vse primery da i sam yazyk opisaniyu kotorogo posvyashchena eta kniga
eto Perl versii 5.003 dlya operacionnoj sistemy  FreeBSD  versii
2.01.   Sushchestvuyut  realizacii  etogo  yazyka  dlya  operacionnyh
sistem OS/2 , MS-DOS i Windows NT no  oni  nemnogo  otstayut  po
vozmozhnostyam ot originala, rozhdennogo v nedrah YUniksa.



		#!/usr/local/bin/perl
		# Soderzhimoe fajla test1.pl
		print "Nashe Vam s kistochkoj!\n";

A teper' podrobno razberem kazhduyu stroku.

#!/usr/local/bin/perl
	Dannaya stroka dolzhna byt' pervoj v lyuboj Pel-programme.
Ona ukazyvanet sistemnomu interpretatoru chto dannyj fajl - eto  Pel-programma.

# Soderzhimoe fajla test1.pl
	|ta stroka nazyvaetsya kommentariem. Ona vsegda nachinaetsya
simvolom '#' i zakanchivaetsya takim  ob座asneniem chto kak govoril
velikij  Hodzha Nasreddin "eto tonkij filosovskij
vopros", a govorya prostym yazykom zdes' mozhno pisat' vse chto ugodno.
Dazhe pozhelanie  rukovodstvu. Uzh zdes' ono tochno do nego ne
dojdet.

print "Nashe Vam s kistochkoj!\n";
	Samaya poslednyaya nu i konechno glavnaya. Ona prosto vyvodit
na ekran nadpis' "Nashe Vam s kistochkoj!".

Zdes' slovo print - eto komanda "vyvesti". Vse chto v kavychkah - eto simvoly,
\n - perevod stroki i ';' - priznak konca komandy. On obyazatelen.
V odnoj stroke mozhet byt' neskol'ko komand i vse oni dolzhny zavershat'sya
simvolom ';'. Posle nego mozhet byt' simvol '#' - eto znachit ostatok
stroki schitaetsya kommentariem.

Nad etoj strokoj avtoru
prishlos' bol'she vsego polomat' golovu tak kak v nee postoyanno
lezli kakie to strannye "hello", "hello all", "Postroemsya i spasemsya",
"Stroj nashe spasenie" i t.d i t.p.

Esli vy nikogda ne rabotali s Pel, to b座us' na spor v 10$, chto dannaya
programma srazu u vas ne zarabotaet!
Ne potomu chto ona ne verna, a potomu chto "Nel'zya ob座at' neob座atnoe".
Srazu, potom mozhno, da i to chastyami.
Snachalo sdelajte vash fajl test1.pl ispolnyaemym. Dlya etogo vvedite
komandu:

	chmod +x test1.pl

Zatem prover'te gde u vas Pel. Dlya etogo vvedite:

	which perl

Sistema vam vydast chto to vrode: /usr/bin/perl

Esli: perl: Command not found.

To togda zakrojte knizhku i lozhites' spat'. U vas prosto net Pel ili
on ne ustanovlen. A mne ostaetsya poslat' vas k sistemnomu administratoru
ili k man (dlya perevodchikov- man sokrashchenie ot manual a ne to chto vy podumali).

Teper' prover'te chto by stroka 01 soderzhala to chto vydala komanda which.
Esli sovpalo to vvedite:

	test1.pl

i b峴' na 50$ chto i teper' programma ne zarabotaet, tak kak pravil'nej
vvesti:

	./test1.pl

Esli ya proigral, to ne radujtes'. Da zhe esli vam udalos' zapustit' programmu
kak test1.pl eto znachit, chto u vas budut nepriyatnosti v budushchem.



	#!/usr/local/bin/perl
	open(PASS, "</etc/passwd") || die "Fajl ne najden!";
	while(<PASS>)
	    {
	    print;
	    }
	close(PASS);

Poyasneniya:

open(PASS, "</etc/passwd") || die "Fajl ne najden!";
	"Otkryt'" fajl t.e. sozdat' ukazatel' fajla PASS i
v sluchae oshibki vydat' "Fajl ne najden!" i zakonchit' programmu.

while(<PASS>)
	CHitat' po odnoj stroke fajla v peremennuyu po umolchaniyu $_.

  {
	Otkryt' blok operatorov.

  print;
	Vyvesti na ekran peremennuyu po umolchaniyu $_

   }
	Konec bloka.

close(PASS);
	Zakryt' fajl. |togo mozhno i ne delat' tak-kak fajl avtomaticheski
zakroetsya posle okonchaniya programmy.

Rezul'tat raboty etoj programmy tot zhe chto i komandy cat /etc/passwd.
Po ekranu probezhali neponyatnye stroki no zato teper' pered vami
otkryty gorizonty Pel programmirovaniya!
Vse posleduyushchie primery budut razvitiem etoj programmy i ona
prevratitsya iz gadkogo utenka v prekrasnogo lebedya (ne generala).



      #!/usr/local/bin/perl
      open(PASS, "</etc/passwd") || die "Fajl ne najden!";
      while(<PASS>)
          {
	    ($login, $pass, $uid, $gid, $name, $home_dir, $shell) = split(':');
	    print "$login \t $name\n";
          }
      close(PASS);

Poyasnenie:

($login, $pass, $uid, $gid, $name, $home_dir, $shell) = split(':');
	Prisvoit' ukazannym peremennym polya vhodnoj stroki, schitaya razdelitelem simvol ':'.

print "$login \t $name\n";
	Vyvesti login - imya pol'zovatelya i ego opisanie. Polya razdeleny simvolom '\t' - tabulyacii.




	#!/usr/local/bin/perl
	open(PASS, "sort -n -t : +3 -4 +0 /etc/passwd|") || die "Fajl ne najden!";
	while(<PASS>)
	    {
	    ($login, $pass, $uid, $gid, $name, $home_dir, $shell) = split(':');
	    print "$login \t $gid \t $name\n";
	    }
	close(PASS);

Poesneniya:

open(PASS, "sort -n -t : +3 -4 +0 /etc/passwd|") || die "Fajl ne najden!";
	V dannoj stroke ves' fokus! Vhodnym fajlom dlya nashej programmy
stal vyhod komandy sort kotoraya i otsortiruet vhodnye dannye.


Formatirovannyj vyvod.

Nu a teper' napechataem na ekrane vse nashi dannye v udobnoj forme.


#!/usr/local/bin/perl

open(PASS, "sort -n -t : +3 -4 +0 /etc/passwd|") || die "Fajl ne najden!";
while(<PASS>)
    {
    ($login, $pass, $uid, $gid, $name, $home_dir, $shell) = split(':');
    write();	# Formatirovannyj yvod dannyh.
    }
close(PASS);
exit 0;		# Zavershenie programmy

############ Opisanie formy vyvoda ##################

format STDOUT =

Pol'zovatel': ^<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
				$name
              ^<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
                                $name
              ^<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
                                $name
----------------------------------------------------------------------
Login:@<<<<<<<<   Uid:@<<<  Gid:@<<<  Home dir:@<<<<<<<<<<<<<<<<<<<<<
      $login,         $uid,     $gid,          $home_dir
----------------------------------------------------------------------

.	# |to poslednyaya stroka programmy


Fragment rezul'tata:

Pol'zovatel': Kaluzhskij likero-vodochnyj zavod. Luchshie vodki i
              nastojki. Zvonit' tol'ko pered prazdnikom Kostrikovu
              Anatoliyu t. 2-23-06,,,
----------------------------------------------------------------------
Login:uucryst     Uid:1055  Gid:66    Home dir:/var/spool/uucppublic/
----------------------------------------------------------------------


Pol'zovatel': Torgovyj Dom Dilen,,,


----------------------------------------------------------------------
Login:uudilen     Uid:1075  Gid:66    Home dir:/var/spool/uucppublic
----------------------------------------------------------------------

Esli vam interesno uznat' kak rabotaet eta programma, to perevernite
stranicu i nachinite svoe puteshestvie v mire Pel.
ZHelayu udachi!





	perl [klyuchi] fajl argumenty

Pered startom Pel ishchet skript (programmu) v sleduyushchem poryadke:

	1. V komandnoj stroke esli ukazan klyuch '-e'

	2. Soderzhimoe fajla ukazannogo v komandnoj stroke. V pervoj
	stroke mozhno ukazyvat' #!/usr/bin/perl dlya "avtomaticheskogo"
	zapuska skripta.

	3. Standartnyj vvod/vyvod esli ne ukazan fajl ili argumenty
	soderzhashchie imya fajla. Dlya peredachi argumentov skriptu iz
	standartnogo potoka imya fajla v komandnoj stroke oboznachaetsya
	simvolom '-'.

V metodah 1 i 2 Pel skaniruet stroki nachinaya s pervoj esli ne
ukazan klyuch '-x', v protivnom sluchae nachalom programmy schitaetsya
stroka s simvolami '#!' v nachale i soderzhashchaya slovo 'perl'.
Koncom programmy schitaetsya stroka '__END__'.
V stroke s '#!' mozhno ukazyvat' i klyuchi. Naprimer '#!/bin/perl -d'
dlya otladki programm.

Posle "obnaruzheniya" skripta Pel kompiliruet ego celikom vo vnutrennee
predstavlenie. Esli obnaruzhivayutsya oshibki to vypolnenie prekrashchaetsya.
Esli oshibok net on vypolnyaetsya. Esli skript zakanchivaetsya bez
komand exit() ili die() to po umolchaniyu vypolnyaetsya komanda exit(0)
oboznachayushchaya normal'noe zavershenie programmy.




Kod simvola-razdelitelya zapisej. Po umolchaniyu \0.


Vklyuchaet rezhim avtomaticheskogo razdeleniya (split) peremennoj $_
v massiv $F. Primenyaetsya s klyuchami -n i -p.


Vypolnyaetsya sintaksicheskaya proverka skripta i vyhod bez zapuska.


Zapusk v rezhime interaktivnoj otladki.


Ustanovit' flagi otladki Pel. Naprimer -d14 prosledit'
kak Pel ispolnyaet vashu programmu.

	1	p	Sintaksicheskij razbor
	2	s	Sostoyanie steka
	4	l	Sostoyanie steka imen
	8	t	Trassirovka ispolneniya
	16	o	Sozdanie operatora uzla
	32	c	Strokovoe/chislovoe preobrazovanie
	64	p	Vyvod komandy preprocessora dlya -P
	128	m	Raspredelenie pamyati
	256	f	Obrabotka formata
	512	r	Sintaksicheskij razbor regulyarnyh vyrazhenij
	1024	x	Damp sintaksicheskogo dereva
	2048	u	Proverka zashchity
	4096	L	"Utechka" pamyati
	8192	H	Damp hesha
	16384	X	Raspredelenie scratchpad
	32768	D	Ochistka



Vypolnenie skripta iz odnoj stroki ukazannogo v komandnoj stroke.


Ukazyvaet shablon razdeleniya v rezhime raboty s klyuchom -a


Primenyaetsya dlya rezervnoj kopii fajla obrabatyvaemogo operatorom '<>'.
Original hranitsya v fajle s tem zhe imenem chto i ishodnyj, no s
ukazannym rasshireniem.

Primer:
	perl -p -i.old -e "s/ryadovoj/efrejtor/" file

	- Pomenyat' vse slova "ryadovoj" na "efrejtor" v fajle file
	a original zapisat' v fajle file.old


Direktoriya includ- fajlov dlya S preprocessora. Primenyaetsya s klyuchom -P
po umolchaniyu eto /usr/include i /usr/lib/perl.


Avtomaticheskaya obrabotka simvola konca stroki. Rabotaet v dvuh sluchayah.
1. Otbrasyvaet poslednij simvol chitaemyh strok dlya rezhimov -n i -p
2. Prisvaivaet ukazannoe znachenie peremennoj $\. Takim obrazom
k koncu kazhdoj stroki vyvodimoj operatorom print dobavlyaetsya etot simvol.


Zaciklivaet skript i posledovatel'no obrabatyvaet fajly ukazannye
v komandnoj stroke. Pozvolyaet sozdavat' komandy podobnye sed ili awk.
Operatory BEGIN i END dayut vozmozhnost' delat' nachal'nye i konechnye
ustanovki. Soderzhimoe fajlov ne vyvoditsya.


To zhe chto i -n no pechataet obrabatyvaemye stroki fajlov.


Predvaritel'naya obrabotko preprocessorom yazyka S. Bud'te vnimatel'ny
i ne primenyajte v kommentariyah slova 'if', 'else' ili 'define'
t.k. eto komandy S - preprocessora.


Vklyuchenie rezhima obrabotki klyuchej komandnoj stroki zapuska skripta.
Vse argumenty s simvolom '-' v nachale, schitayutsya klyuchom i peremennym
s takim zhe imenem prisvaivaetsya znachenie true.


Ispol'zovanie sistemnoj peremennoj PATH dlya poiska skripta.
Dannyj klyuch primenyaetsya v sistemah ne vosprinimayushchih posledovatel'nost'
"#!" v nachale skripta dlya ukazaniya interpretatora.


Rezhim proverki "dyr" v zashchite. Obychno eto nuzhno dlya programm
rabotayushchih v rezhime povyshennoj privelegii (setuid, setguid).
ZHelatel'no dlya CGI skriptov.


Prinuditel'nyj damp pamyati posle kompilyacii skripta. |tot damp
mozhno potom ispol'zovat' dlya sozdaniya ispolnyaemogo fajla s
pomoshch'yu programmy undump.


Razreshenie vypolnyat' opasnye operacii. Naprimer steret' direktoriyu
ili vypolnyat' yavno ne zakrytuyu programmu.


Vyvod nomera versii Pel.


Vyvod imen peremennyh ispol'zuemyh tol'ko odin raz, imen skalyarov
ispol'zuemyh do ih opredeleniya, imen pereopredelyaemyh podprogramm,
ssylok na neopredelennyj ukazateli fajlov, popytok zapisi v fajly
otkrytyh tol'ko na "chtenie", upotreblenie ne koretnyh zapisej chisel,
ispol'zovanie massivov kak skalyarov, rekursiya bolee 100 urovnej.


Rezhim zapuska skripta vstavlennogo v  fajl soderzhashchij
obychnyj tekst. Nachalom skripta schitaestsya stroka s simvolami '#!'
v nachale i soderzhashchiya slovo perl. Koncom - stroka s '__END__'
Ukazannaya direktoriya stanovitsya tekushchej v moment ispolneniya.
Esli neobhodimo chitat' posleduyushchie stroki to eto luchshe delat'
cherez ukazatel' fajla DATA.




Pel programma (skript) sostoit iz posledovatel'nosti deklaracij i predlozhenij.
Edinstvenno chto dolzhno byt' obyazatel'no deklarirovano eto formaty otchetov
i podprogrammy (funkcii). Vse ne ob座avlennye peremennye, massivy, imeyut
znachenie 0 ili null.



Pel imeet svobodnyj format. Kommentarii nachinayutsya s simvola '#' i
prodolzhayutsya do konca stroki.
Deklaracii mogut ispol'zovat'sya v lyubom meste programmy tak zhe kak i
predlozheniya (statements) no dejstvuyut oni tol'ko v faze kompilyacii
programmy. Obychno ih pomeshchayut ili v nachale ili v konce programmy.
Deklaraciya podprogramm pozvolyaet ispol'zovat' imya podprogrammy
kak spiskovyj operator nachinaya s momenta deklarirovaniya.

Primer:
	sub test;	# Deklaraciya podprogrammy test

	$var1 = test $0; # Ispol'zovanie kak operatora spiska.

Deklaracii podprogramm mogut byt' zagruzheny iz otdel'nogo fajla
predlozheniem require ili zagruzheno i importirovano v tekushchuyu
oblast' imen predlozheniem use. Podrobno sm. glavu Moduli.




Prostoe predlozhenie obyazatel'no
zakanchivaetsya simvolom ';' esli tol'ko eto ne poslednee predlozhenie
v bloke gde ';' mozhno opustit'. Zamet'te chto sushchestvuyut operatory
takie kak eval{} i do{} kotorye vyglyadyat kak slozhnye predlozheniya
no na samom dele eto termy i trebuyut obyazatel'nogo ukazaniya konca
predlozheniya.

Lyuboe prostoe predlozhenie mozhet soderzhat' single modifikator
pered ';'. Sushchestvuyut sleduyushchie single modifikatory:

	if EXPR
	unless EXPR
	while EXPR
	until EXPR

gde EXPR - vyrazhenie vozvrashchayushchee logicheskoe znachenie true ili false.
Modifikatory while i until vychislyayutsya v nachale predlozheniya krome bloka do kotoryj vypolnyaetsya pervym.

if EXPR		- Modifikator "esli". Predlozhenie vypolnyaetsya esli EXPR vozvrashchaet true.

Primer:
	$var = 1;
	$var2 = 3 if $var > 0; # Rezul'tat: $var2 = 3

while EXPR	- Modifikator "poka". Predlozhenie vypolnyaetsya stol'ko raz poka EXPR = true

Primer:
	$var = 1;
	print $var++ while $var < 5; # Pechat' $var s inkrementom

Rezul'tat: 1234


until EXPR	- Modifikator "do ". Predlozhenie vypolnyaetsya  do teh por poka EXPR = false

Primer:
	$var = 1;
	print $var++ until $var > 5; # Pechat' $var s inkrementom

Rezul'tat: 12345

unless EXPR	- Modifikator "esli ne" . Obratnyj k if. Vyrazhenie vypolnyaetsya esle EXPR = false.

Primer:
	$var = 1;
	print $var++ unless $var > 5; # Pechat' $var s inkrementom

Rezul'tat: 1




Posledovatel'nost' prostyh predlozhenij ogranichennaya funkcional'nymi
ogranichitelyami nazyvaetsya blokom. V Pel eto mozhet byt'
celyj fajl, posledovatel'nost' predlozhenij v operatore eval{} ili
chashche vsego eto mnozhestvo prostyh predlozhenij ogranichennyh kruglymi
skobkami '{}'.

Suzhestvuyut sleduyushchie vidy slozhnyh predlozhenij:

	if (EXPR) BLOCK
	if (EXPR) BLOCK else BLOCK
	if (EXPR) BLOCK elsif (EXPR) BLOCK ... else BLOCK

	LABEL while (EXPR) BLOCK
	LABEL while (EXPR) BLOCK continue BLOCK
	LABEL for (EXPR; EXPR; EXPR) BLOCK
	LABEL foreach VAR (LIST) BLOCK
	LABEL BLOCK continue BLOCK

Obratite vnimanie, chto slozhnye predlozheniya opisany v termah blokov
a ne predlozhenij kak v yazykah C ili Pascal. Poetomu neobhodimo
vsegda ispol'zovat' kruglye skobki dlya oboznacheniya bloka.

if (EXPR) BLOCK		- Vychislyaetsya logicheskoe vyrazhenie EXPR i esli true  blok vypolnyaetsya.

Primer:
	$var =1;
	if ($var == 1)
	   { print $var,"\n";
	   }
Rezul'tat: 1


if (EXPR) BLOCK else BLOCK2	-  Esli EXPR=true vypolnyaetsya BLOCK inache BLOCK2.

Primer:
	$var =2;
	if ($var == 1)
	   { print "\$var = 1\n";
	   }
	else
	   { print "\$var ne ravno 1\n";
	   }

Rezul'tat: $var ne ravno 1

if (EXPR1) BLOCK1 elsif (EXPR2) BLOCK2 ... else BLOCK	-
	Esli EXPR1=true vypolnyaetsya BLOCK1 inache esli EXPR2=true vypolnyaetsya
	BLOCK2 inache ... inache BLOCK.

Primer:
	$var = 1;
	if ($var == 0)
	   { print "\$var = 0\n";
	   }
	elsif ($var == 1)
	   { print "\$var = 1\n";
	   }
	else
	   { print "Ne izvestnoe \$var\n";
	   }

Rezul'tat: $var = 1

Cikl while vypolnyaet BLOCK do teh por poka EXPR = true. Metka LABEL ne
obyazatel'na i sostoit iz identifikatora zavershayushchegosya simvolom ':'.
Metka neobhodima pri ispol'zovanii vnutri bloka cikla upravlyayushchih
operatorov next, last i redo. Esli metka vse zhe otsutsvuet to
eti operatory ssylayutsya k nachalu blizhajshego cikla.
Blok posle continue vypolnyaetsya vsegda pered tem kak vychislyaetsya
logicheskoe vyrazhenie EXPR. |to podobno EXPR3 v predlzhenii for
poetomu v etom bloke udobno izmenyat' schetchiki i flagi cikla dazhe
esli primenyaestya operator next.



next	- podoben continue v S. Perehodit k nachalu tekushchego cikla
	t.e. povtoryaet iteraciyu.

Primer:
	M1:
	while ($i < 6)
	    {
	    ++$i;	# Uvelichivaem schetchik na 1
	    next M1 if $i < 3; # Perehodim v nachalo esli $i < 3
	    ++$i;	# inache uvelichivaem schetchik eshche raz na 1
	    }
	continue
	    {
	    print "$i "; # Pechataem $i
	    }

Rezul'tat: 1 2 4 6

last	- podoben operatoru break v yazyke S. Nemedlenno preryvaet cikl.
	Blok continue propuskaetsya.

Primer:
        M1:
        while ($i < 6)
            {
            ++$i;       # Uvelichivaem schetchik na 1
            last M1 if $i > 3; # Vyhod iz cikla esli $i > 3
            ++$i;       # inache uvelichivaem schetchik eshche raz na 1
            }
continue {
            print "$i "; # Pechataem $i
}

Rezul'tat: 2 4

redo	- nachat' novyj cikl ne vychislyaya EXPR i ne vypolnyaya continue blok.

Primer:
        M1:
        while ($i < 6)
            {
            ++$i;       # Uvelichivaem schetchik na 1
            redo M1 if $i == 3; # Dalee propustit' dlya $i = 3
            ++$i;       # inache uvelichivaem schetchik eshche raz na 1
            }
continue {
            print "$i "; # Pechataem $i
}

Rezul'tat: 2 5 7




	LABEL for (EXPR1; EXPR2; EXPR3) BLOCK
Operator for polnost'yu analogichen operatoru for v S. V pered nachalom
cikla vypolnyaetsya EXPR1, esli EXPR2 = true vypolnyaetsya blok, zatem
vypolnyaetsya EXPR3.

Primer:
	for ($i = 2; $i < 5; ++$i)
           {
           print $i, " ";
           }
        print "\nPosle cikla i = $i\n";

Rezul'tat:
	2 3 4
	Posle cikla i = 5



	LABEL foreach VAR (LIST) BLOCK

Peremennoj VAR prisvaivaetsya poocheredno kazhdyj element spiska LIST
i vypolnyaetsya blok. Esli VAR opushchenno to elementy prisvaivayutsya
vstroenoj peremennoj $_. Esli v tele bloka izmenyat' znachenie VAR
to eto vyzovet izmenenie i elementov spiska t.k. VAR fakticheski
ukazyvaet na tekushchij element spiska.
Vmesto slova foreach mozhno pisat' prosto for - eto slova sinonimy.

Primer:
        @mesyac = ("yanvar'","fevral'","mart");  # Sozdali massiv
        foreach $i (@mesyac)
            {
            print $i," ";       # Pechat' $i
            }

Rezul'tat: yanvar' fevral' mart

Primer:
        @mesyac = ("yanvar'","fevral'","mart");  # Sozdali massiv
        foreach $i (@mesyac)
            {
            $i = uc($i); # Pereveli v verhnij registr
            }
        print @mesyac;

Rezul'tat: YANVARXFEVRALXMART

Primer:

	for $i (3,5,7)
	    {
	    print "$i ";
	    }
Rezul'tat: 3 5 7




Blok ne zavisimo ot togo imeet on metku ili net semanticheski
predstavlyaet soboj cikl kotoryj vypolnyaetsya odin raz. Poetomu
dejstvie opratorov cikla next, last, redo - analogichno opisannomu
vyshe. Bloki udobny dlya postroeniya switch (pereklyuchatel') struktur.
V pel net special'nogo operatora switch podobnogo yazyku S poetomu
vy sami mozhete sozdavat' udobnye dlya vas konstrukcii. Opyt avtora
pokazyvaet chto dlya prostoty napisaniya luchshe vsego podhodit
konstrukciya vida if ... elsif ... else ... hotya mozhno sochinit'
i nechto podobnoe:

	SWITCH:
	{
	if ($i ==1 ) { .....; last SWITCH; }
	if ($i ==2 ) { .....; last SWITCH; }
	if ($i ==3 ) { .....; last SWITCH; }
	$default = 13;
	}

Vybirajte sami po svoemu vkusu.




V Pel sushchestvuet operator goto hotya gde , kak i kogda ego primenyat'
kak govoril Hodzha Nasredin "Tonkij filosovskij vopros".
Dlya nachinayushchih programmistov kotorym ot tak "nuzhen" ya by voobshche
posovetoval "zabyt'" o ego sushchestvovanii. Odnako pri sozdanii
bol'shih proizvodstvennyh zadach na poslednem etape osobenno
pri otrabotke "otval'nyh" oshibochnyh situacij konechno goto nuzhen.

V Pel realizovano tri formy goto. goto - metka, goto - vyrazhenie
i goto - podprogramma.

goto - metka vypolnyaet neposredstvennyj perehod na ukazannuyu metku.

goto - vyrazhenie - Vychislyaet imya metki i delaet sootvetsvuyushchij perehod.
	Naprimer esli my hotim sdelat' perehod na odnu iz treh metok
	"M1:", "M2:" ili "M3:" v zavisimosti ot znachenij peremennoj
	$i ravnoj 0, 1 ili 2 to eto luchshe sdelat' sleduyushchim obrazom:

	goto ("M1", "M2", "M3")[$i];

	zdes' $i ispol'zuetsya kak indeks massiva ukazannogo neposredstvenno
	v vyrazhenii.

goto podprogramma - dovol'no redkij sluchaj t.k. vsegda proshche i nadezhnej
vyzvat' podprogrammu "estestvennym" obrazom.



V Pel realizovan ochen' udobnyj mehanizm dlya napisaniya dokumentacii
v moment sozdaniya programmy. Dlya etogo primenyayutsya special'nye POD operatory.
Esli v tele programmy interpretator vstrechaet operator nachinayushchijsya
s simvola '=' naprimer:

	= head Nabor standartnyh procedur

to propuskaetsya vse do slova '=cut'. |to udobno dlya vklyucheniya
dlinnyh na neskol'ko strok ili stranic kommentariev. Zatem
s pomoshch'yu special'noj programmy pod mozhno otdelit' tekst
dokumentacii ot teksta programmy.



V Pel sushchestvuet tri tipa struktur dannyh: skalyary, massivy skalyarov i
heshi (hashes) - associativnye massivy skalyarov. Obychno elementy massivov
indeksiruyutsya celymi chislami, pervyj element - nulevoj. Otricatel'noe
znachenie indeksa oboznachaet nomer pozicii elementa s konca. Heshi indeksiruyutsya
strokami simvolov.

Imena skalyarnyh peremennyh vsegda nachinayutsya s simvola '$' dazhe kogda
oboznachayut element massiva.



	$var1		# Prostoj skalyar 'var1'

	@var1[0]	# Pervyj element massiva 'var1'

	$var1{'first'}	# |lement hesha s indeksom 'first'


V sluchae ispol'zovaniya imeni massiva "celikom" ili ego "sreza"
pered imenem massiva stavitsya simvol '@'.



	@var1		# Vse elementy massiva var1 ( $var1[0], $var1[1], ... $var1[n])

	@var1[1,3,10]	# |lementy $var1[1], $var1[3], $var1[10]

	@var1{'first','last'} # to zhe chto i ( $var1{'first'}, $var1{'last'} )

Hesh "celikom" nachinaetsya s simvola '%'.

Primer:

	%var, %key, %years

Imena podprogramm nachinayutsya simvolom '&' esli iz konteksta ne vidno
chto eto podprogramma.

Primer:

	&sub1, &test_prog, test(12)

Imena tablic simvolov vsegda nachinayutsya simvolom '*'.

Kazhdyj tip peremennyh imeet svoyu oblast' pamyati poetomu $var1 i $var1[0]
sovershenno raznye peremennye, hotya $var1[0] chast' massiva @var1. Tak zhe\
@var1 i %var1 - raznye massivy peremennyh.

Imena peremennyh mogut soderzhat' lyubye bukvenno-cifrovy simvoly za isklyucheniem
probela i tabulyacii. |ti smvoly ispol'zuyutsya v kachestve razdelitelej.
Bol'shie i malye bukvy razlichayutsya poetomu $var1 i $Var1 - raznye
peremennye. V Pel po umolchaniyu imena metok i ukazatelej fajlov pishut
bol'shimi bukvami.



Bol'shoe znachenie dlya pravil'nogo upotrebleniya vstroennyh funkcij
imeet kontekst ispol'zovaniya rezul'tata etih funkcij t.k. v protivnom
sluchae oni vozvrashchayut sovershenno "neponyatnyj" rezul'tat.
V Pel imeetsya dva glavnyh konteksta: skalyarnyj i spisok (list).
Proshche govorya esli v levoj chasti vyrazheniya imeetsya vvidu odno edinstvennoe znachenie - to
eto skalyarnyj kontekst. Esli mnozhestvo znachenij - spisok.

Primer:

	$var1 = <>;	# Prochitat' odnu stroku fajla

	@var1 = <>;	# Prochitat' vse stroki fajla v massiv @var1

	$var1 = (1,2,3); # $var = 3 - kolichestvo elementov

	@var1 = (1,2,3); # Sozdanie massiva @var1 s elementami 1,2,3



Vse dannye v Pel eto skalyary, massivy skalyarov i heshi skalyarov.
Skalyarnye peremennye mogut soderzhat' chisla, stroki i ssylki.
Preobrazovanie chisla - stroki proishodit avtomaticheski po umolchaniyu.
Skalyar mozhet imet' tol'ko odno edinstvennoe znachenie, hotya eto
mozhet byt' ssylka na massiv skalyarov. Tak -kak Pel sam preobrazovyvaet
chisla v stroki i naoborot to programmistu net neobhodimosti dumat'
o tom chto vozvrashchaet funkciya.

V Pel ne sushchestvuet tipov "stroka" ili "chislo" ili "fajl" ili chto to eshche.
|to kontekstno zavisimyj polimorfnyj yazyk dlya raboty s tekstami.

Skalyar imeet logicheskoe znachenie "TRUE" (istina) esli eto ne nulevaya
stroka ili chislo ne ravnoe 0.

V Pel sushchestvuet dva tipa nulevyh (null) skalyarov - opredelennye
(defined) i ne opredelennye (undefined). Ne opredelennoe znachenie
vozvrashchaetsya kogda chto-to ne sushchestvuet. Naprimer ne izvestnaya
peremennaya, konec fajla ili oshibka. S pomoshch'yu funkcii defined()
vy mozhete zaranee obnaruzhit' podobnoe sostoyanie.

Kolichestvo elementov massiva tak zhe yavlyaetsya skalyarom i nachinaetsya
simvolami $# podobno interpretatoru csh. Fakticheski $#var1 - eto
indeks poslednego elementa massiva. Nuzhno pomnit' chto pervyj
element imeet indkes 0 poetomu kolichestvo elementov opredelyaetsya
kak $#var1+1 . Prisvoenie znacheniya $#var1 - izmenit dlinu
massiva i razrushit "ostavlennye" znacheniya.
Prisvoenie znacheniya elementu massiva s indeksom bol'she chem $#var1
- uvelichit razmer massiva, a prisvoenie emu nulevogo spiska -
obnulit.

V skalyarnom kontekste imya massiva vozvrashchaet ego dlinu (dlya spiska
vozvrashchaetsya poslednij element).

Primer:

	@var1 = (4, 3, 2, 1);	# Prisvoenie znacheniya elementam massiva
	$i = @var1;		# Ispol'zovanie skalyarnogo konteksta
	print $i;		# Pechat' rezul'tata 4 - kol-vo elementov
	print @var1;		# Spiskovyj kontekst, pechat' vseh elementov.

Dlya prinuditel'nogo polucheniya skalyarnogo znacheniya udobno primenyat'
funkciyu scalar().

Primer:

	print scalar(@var1);	# Vyvod dliny massiva a ne ego znachenij

Hesh v skalyarnom kontekste vozvrashchaet "true" esli sushchestvuet
hotya by odna para "klyuch-znachenie". Fakticheski vozvrashchaetsya stroka
tipa 2/8 gde 8 - kolichestvo vydelennyh "yacheek" pamyati a
2 - kolichestvo ispol'zovannyh.

Konstruktory skalyarov.

CHisla pishutsya standartno:

	123
	123.123
	0.12
	.12E-10
	0xABCD		# SHestnadcetirichnaya zapis'
	0377		# Esli 0 v nachale - vos'merichnaya
	123_456_123	# Tak tozhe mozhno dlya udobstva chteniya.

Stroki ogranichivayutsya odinarnymi (') ili dvojnymi (") kavychkami:

	'Rovnyajs', smirno!'
	"Postroemsya i spasemsya."

Sposobov oboznacheniya strok ochen' mnogo. Plodrobno smotrite opisanie
operatora qq.
 V heshe mozhno opuskat' kavychki esli indeks ne soderzhit probelov.

Primer:

	$var1{first} to zhe chto i $var1{'first'}

Obratite vnimanie na to chto pered pervoj odinarnoj kavychkoj dolzhen stoyat'
probel inache stroka vosprimetsya kak imya peremennoj tak-kak v imenah
razresheno ispol'zovanie odinarnyh kavychek.
Zapreshchaetsya v kavychkah primenyat' zarezervirovannye literaly __LINE__
(nomer tekushchej stroki programmy), __FILE__ (tekushchij fajl).
Dlya oboznacheniya konca programmy mozhno primenyat' literal __END__
Ves' posleduyushchij tekst ignoriruetsya, no ego mozhno prochitat' ispol'zuyu
ukazatel' fajla DATA.

Slova v programme ne poddayushchiesya ni kakoj intepretacii vosprinimayutsya
kak stroki v kavychkah poetomu rekomenduetsya imena metok i ukazatelej fajlov
pisat' bol'shimi bukvami dlya izbezhaniya vozmozhnogo "konflikta" s zarezervirovannymi
slovami.

V Pel est' vozmozhnost' vstavlyat' tekst dokumenta pryamo v programmu.
Tak nazyvaemyj "here-doc" (zdes' tekst) metod. Oboznachaetsya simvolami
<< za kotorym idet slovo-ogranichitel'.

Primer:

	print <<EOF;	# Vse stroki do EOF - tekst dlya pechati.

	|j vy troe, idite dvoe syuda!

		Polkovnik Savon'kin.
	EOF



Spisok - mnozhestvo znachenij perechislennyh cherez zapyatuyu i zaklyuchennyh
v kruglye skobki. V spiskovom kontekste spisok vozvrashchaet poslednij
element spiska.

Primer:

	@var1 = (1, 2, 'privet', 1.2); # Prisvoit' znachenie elementam.

gde

		$var1[0] = 1,

		$var1[1] = 2,

		$var1[2] = 'privet'

		$var1[3] = 1.2


	$var1 = (1, 2, 'privet', 1.2);

a zdes' $var1 = 1.2 t.e. poslednee znachenie spiska.

Dopuskaetsya primenyat' v spiske drugie spiski, no v poluchennom spiske
uzhe nevozmozhno razlichit' nachalo i konec vklyuchennyh spiskov.

Primer:

	@s1 = (1, 2, 3); # 	Pervyj spisok

	@s2 = (6, 7, 8);	# Vtoroj

	@s = (0, @s1, 4, 5, @s2, 9, 10); # Vklyuchaem spiski @s1 i @s2

	print @s;	# Rezul'tat: 012345678910  - znacheniya bez probelov.


Spisok bez elementov oboznachaestya kak () i nazyvaetsya nul'-spiskom.
Spiskovoe vyrazhenie mozhno upotreblyat' kak imya massiva, no pri etom
ego nuzhno brat' v kruglye skobki.

Primer:

	print ('yanvar'','fevral'','mart')[1];

Rezul'tat: fevral'

Spisok mozhet byt' prisvoen spisku tol'ko esli kazhdyj element v spiske v
levoj chasti vyrazheniya dopustim po tipu spisku v pravoj chasti.

Primer:

	($a, $b, $c) = (1, 2, 3); # $a = 1, $b = 2, $c = 3

Prisvaivanie spiskov v skalyarnom kontekste vozvrashchaet kolichestvo prisvoennyh
elementov.

Primer:

	$x = (($a, $b, $c) = (1,2));  # Rezul'tat $x=2

V sluchae prisvaivaniya spiska heshu spisok razsmatrivaetsya kak pary: klyuch-znachenie.

Primer:

	%dni_mesyaca = ('yanvar'', 31, 'fevral'', 30);

Rezul'tat: $dni_mesyaca{yanvar'} = 31, $dni_mesyaca{fevral'} = 30

Dlya udobstva zapisi mozhno ispol'zovat' vyrazhenie s => .

Primer:

	%dni_mesyaca = (
			yanvar' => 31,
			fevral' => 30,
	);



V Pel ispol'zuetsya special'nyj vnutrennij tip typeglog dlya zapisi
massiva vseh peremennyh. Takie massivy nachinayutsya s simvola '*'.
Ih udobno primenyat' dlya peredachi ssylok na massivy i heshi, no
v dannoj versii Pel uzhe est' vozmozhnost' primenyat'
ssylki poetomu eto delaetsya ochen' redko.
Edinstvenno gde eto neobhodimo tak eto dlya raboty so
ssylkami na fajly. Naprimer esli vam nuzhno sozdat' lokal'nuyu
ssylku na fajl v procedure to eto luchshe sdelat' tak:

sub new_sub
{ local *IN; # Ssylka na fajl
open (IN, "test") || return undef;  # Otkryt' fajl. Vozvrat pri oshibke.
.........
return;
}

Bolee podrobno eto opisano v glave Ssylki.



Opisannye v dannoj glave peremennyye imeyut v Pel special'nye znacheniya.
Oni oboznachayutsya neskol'ko neprivychno dlya "glaza" programmistov
t.k. sostoyat obychno tol'ko iz dvu simvolov prichem pervyj eto '$'
simvolo s kotorogo nachinayutsya imena vseh peremennyh i proizvol'nyj chasto
ne bukvenno-cifrovoj simvol. Esli vy hotite pol'zovat'sya ih "normal'nymi"
bukvennymi sinonimami to vam nuzhno ukazat' v nachale programmy:

	use English;

Tochno tak  zhe  esli vy zahotite pol'zovat'sya peremennymi i metodami
tekushchego ukazatelya fajlov vy mozhete napisat':

	use FileHandle;

posle etogo mozhno mozhno prosto pisat':

	metod ukazatel' vyrazhenie

ili

	ukazatel' -> metod(vyrazhenie)


Nizhe privodyatsya imena kak v korotkoj tak i v dlinnoj (slovesnoj) forme.
Nekotorye iz vstroennyh peremennyh imeyut dostup to'ko na chtenie
poetomu izmenit' ih znachenie prosto ne vozmozhno.




	Peremennaya - po umolchaniyu dlya operatorov vvoda i poiska.
To est' esli v kachestve argumenta ne ukazana nikakaya peremennaya to
ispol'zuetsya imenno eta.


	Soderzhit najdennye podstroku v poslednem poiske kogda
shablon soderzhit metasimvoly v kruglyh skobkah. Cifra v dannom
sluchae eto nomer skobok. Pervaya podstroka imeet nomer 1.


$MATCH
	Najdennaya podstroka v poslednem poiske po shablonu.


	Podstroka predshevstvuyushchaya najdennoj podstroke.


$POSTMATCH
	Podstroka posleduyushchaya za najdennoj podstrokoj.


$LAST_PAREN_MATCH
	Podstroka najdennaya v poiske s vyborom po "ili".


$MULTILINE_MATCHING
	Esli znachenie etoj peremennoj ustanovit' ravnym 1 to
peremennaya v kotoroj osushchestvlyaetsya poisk budet schitat'sya mnogostorochnoj
t.e. soderzhashchej simvoly '\n' - perevod stroki. Esli znacheie ravno 0
to peremennaya schitaetsya odnostrochnoj. V Pel versii 5 i vyshe ne rekomenduestya
ispol'zovat' etu peremennuyu.


$INPUT_LINE_NUMBER
$NR
	Nomer prochitannoj stroki poslednego operatora vvoda.
Zakrytie fajla vyzyvaet ochistku znacheniya etoj peremennoj.


$RS
$INPUT_RECORD_SEPARATOR
	Simvol - priznak konca vhodnoj stroki. Po umolchaniyu eto '\n'


$OUTPUT_AUTOFLUSH
	Esli prisvoit' etoj peremennoj ne nulevoe znachenie to budet
sbros bufera vyvoda posle kazhdoj operacii vyvoda. Znachenie po umolchaniyu -0


$OFS
$OUTPUT_FIELD_SEPARATOR
	Simvol dobavlyaemyj  operatorom print posle kazhdogo elementa
iz spiska parametrov.


$ORS
$OUTPUT_RECORD_SEPARATOR
	Simvol dobavlyaemyj print posle vyvoda vseh parametrov.


$LIST_SEPARATOR
	Anologichen "$," no dobavlyaetsya posle kazhdogo elementa massiva
ukazanoogo v "....".


$SUBSEP
$SUBSCRIPT_SEPARATOR
	Simvol - razdelitel' dlya emulyacii mnogomernyh massivov v hesh
massivah. Po umolchaniyu '\034'.


$OFMT
	Format po umolchaniyu dlya vyvoda chisel.


$FORMAT_PAGE_NUMBER
	Format po umolchaniyu dlya vyvoda nomerov stranic.


$FORMAT_LINES_PER_PAGE
	Dlina odnoj stranicy. Po umolchaniyu 60 strok.


$FORMAT_LINES_LEFT
	Kolichestvo ostavshihsya strok na stranice.


$FORMAT_NAME
	Imya formata tekushchego vyvoda. Po umolchaniyu imya ukazatelya.


$FORMAT_TOP_NAME
	Imya tekushchego formata dlya zagolovka stranicy.


$FORMAT_LINE_BREAK_CHARACTERS
	Simvoly perenosa stroki dlya mnogostrochnyh polej. V stroke
formata takie polya nachinayutsya simvolom '^'. Po umolchaniyu '\n-'.


$FORMAT_FORMFEED
	Simvol perevoda formata ( smeny lista). Po umolchaniyu '\f'.


$ACCUMULATOR
	Tekushchee znachenie akkumulyatora funkcii write() dlya format().
Znachenie etoj peremennoj mozhno uvidet' tol'ko pri ispol'zovanii
funkcii formline() t.k. write() ochishchaet ee posle kazhdogo vyvoda.


$CHILD_ERROR
	Dannaya permennaya soderzhit status zaversheniya takih processov
kak: zakrytie pipe, zavershenie funkcij system(), wait() i `...`.


$ERRNO
$OS_ERROR
	V chislovom kontekste vozvrashchaet kod oshibki errno.
V strokovom - stroku soobshcheniya ob oshibke. Mozhno prinuditel'no
prisvoit' etoj permennoj kod oshibki chto by poluchit' sistemnoe
soobshchenie dlya dannogo koda ili ustanovit' kod zaversheniya dlya
funkcii die().


$EVAL_ERROR
	Soobshchenie ob oshibke poslednej komandy eval().


$PID
$PROCESS_ID
	Nomer tekushchego processa.


$UID
$REAL_USER_ID
	Real'nyj UID tekushchego processa.


$EUID
$EFFECTIVE_USER_ID
	|ffektivnyj UID tekushchego processa.


$GID
$REAL_GROUP_ID
	Real'nyj GID tekushchego processa.


$EGID
$EFFECTIVE_GROUP_ID
	|ffektivnyj GID tekushchego processa.


$PROGRAM_NAME
	Imya fajla programmy. Esli etoj peremennoj prisvoit' kakoe
nibud' znachenie to ego mozhno videt' v komande ps, chto udobno dlya
kontrolya za sostoyaniem programmy.


	Nomer pervogo elementa massiva ili simvola stroki.
Znachenie po umolchaniyu - 0.


$PERL_VERSION
	Stroka soobshchenie versii Pel. Pechataetsya po komande perl -v
Primenyaetsya v programme dlya opredeleniya rabochej versii Pel.
V chislovom kontekste eto nomer versii plyus nomer modifikacii / 1000.


$DEBUGGING
	Tekushchee znachenie klyucha otladki '-D'.


$SYSTEM_FD_MAX
	Nomer maksimal'nogo sistemnogo opisatelya fajlov (system file
descriptor). Obychno eto 2.


$INPLACE_EDIT
	Tekushchee znachenie inplace-edit vozmozhnosti.
Dlya otklyucheniya ispol'zujte undef.


$PERLDB
	Vnutrennij flag otladki. Primenyaetsya dlya togo chto by otladchik
ne otslezhival samogo sebya.


$BASETIME
	Vremya v sekundah s nachala 1970 goda starta tekushchej programmy.


$WARNING
	Znachenie flaga '-w'. true -esli vklyucheno i false - vyklyucheno.


$EXECUTABLE_NAME
	Komanda zapuska Pel. Analogichno argv[0] v S.


	Imya tekushchego fajla chitaemogo operatorom '&lt;>'.


	Massiv parametrov stroki zapuska programmy.
Vnimanie! @#ARGV - men'she kolichestva parametrov na 1 t.k.
$ARGV[0] eto pervyj parametr (ne imya programmy).


	Spisok direktorij diska kotorye prosmatrivaet Pel
dlya vypolneniya komand do, require ili use.


	|tot hesh soderzhit imena direktorij dlya imen ispol'zovannyh
fajlov komandami do ili require. Klyuch - imya fajla, a znachenie - direktoriya.


	Hesh %ENV soderzhit znacheniya peremennyh okruzheniya. Izmenenie
etih znachenij vyzyvaet izmenenie okruzheniya dlya processov potomkov.


	Hesh %SIG soderzhit imena podprogramm dlya sistemnyh
signalov takih kak INT, QUIT, PIPE, ...
Znachenie 'DEFAULT' - dlya sistemnoj obrabotki.
'IGNORE' - ignorirovat' dannyj signal.



V dannoj glave opisyvaetsya sintaksis regulyarnyh vyrazhenij. CHashche vsego
v Pel oni ispol'zuyustya v operatorah poiska i zameny takih kak s//
m/ operatorah svyazki =~ ili != i t.d.
Kak pravilo vse eti operatory imeyut shozhie opcii takie kak:

	i	- ne razlichat' strochnye i zaglavnye bukvy.
	m	- schitat' stroku mnogostrochnoj.
	s	- odnostrochnaya stroka.
	x	- rasshirennyj sintaksis ( ispol'zovanie probelov i kommentariev)

Obychno vse eti opcii oboznachayut kak '/x'. Ih mozhno ispol'zovat' dazhe
vnutri shablonov, ispol'zuya novuyu konstrukciyu (?...)

Regulyarnye vyrazheniya ili shablony (pattern) to zhe samoe chto i regexp
procedury v YUnikse. Vyrazheniya i sintaksis zaimstvovan iz svobodno
rasprostranyaemyh procedur V8 Genri Spensera (Henry Spencer) tam zhe
oni podrobno i opisany.

V shablonah ispol'zuyutsya sleduyushchie metasimvoly (simvoly oboznachayushchie
gruppy drugih simvolov) chasto nazyvaemyh egrep - standartom:

	\	- schitat' sleduyushchij metasimvol kak obychnyj simvol.
	^	- nachalo stroki
	.	- odin proizvol'nyj simvol. Krome '\n' - konec stroki.
	$	- konec stroki
	|	- al'ternativa (ili)
	()	- gruppirovka
	[]	- klass simvolov

Metasimvoly imeyut modifikatory (pishutsya posle metasimvola):

	*	- povtoryaetsya 0 ili bol'shee chislo raz
	+	- povtoryaetsya 1 ili bol'shee chislo raz
	?	- 1 ili 0 raz
	{n}	- tochno n raz
	{n,}	- po men'shej mere raz
	{n,m}	- ne menshe n, no i ne bol'she m

Vo vse drugih sluchayah figurnye skobki schitayutsya obychnymi (regulyarnymi)
simvolami. Takim obrazom '*' ekvivalentna {0,} , '+' - {1,}
i '?' - {0,1}. n i m ne mogut byt' bol'she 65536.

Po umolchaniyu dejstvie metasimvolov "zhadno" (greedy). Sovpadenie
rasprostranyaetsya stol'ko raz skol'ko vozmozhno ne uchityvaya rezul'tat
dejstviya sleduyuyushchih metasimvolov. Esli vy hotite "umen'shit' ih appetit"
to ispol'zujte simvol '?'. |to ne izmenyaet znachenie metasimvolov
prosto umen'shaet rasprostranenie. Takim obrazom:

	*?	- stanet 0 i bolee
	+?	- 1 i bolee
	??	- 0 ili 1 raz
	{n}?	- tochno n raz
	{n,}?	- ne men'she n raz
	{n,m}?	- bol'she ili ravno n i men'she m raz

SHablony rabotayut tak zhe kak i dvojnye kavychki poetomu v nih mozhno
ispol'zovat' `\` - simvoly (bakslesh-simvoly):

	\t	- simvol tabulyacii
	\n	- novaya stroka
	\r	- perevod karetki
	\A	- perevol formata
	\v	- vertikal'naya tabulyaciya
	\a	- zvonok
	\e	- escape
	\033	- vos'merichnaya zapis' simvola
	\x1A	- shestnadcaterichnaya
	\c[	- control simvol
	\l	- nizhnij registr sleduyushchego simvola
	\u	- verhnij registr -//-
	\L	- vse simvoly v nizhnem registre do \E
	\U	- v verhnem -//-
	\E	- ogranichitel' smeny registra
	\Q	- otmena dejstviya kak metasimvola

Dopolnitel'no v Pel dobavleny sleduyushchie metasimvoly:

	\w	- alfavitno-cifrovoj ili '_' simvol
	\W	- ne alfavitno-cifrovoj ili '_' simvol
	\s	- odin probel
	\S	- odin ne probel
	\d	- odna cifra
	\D	- odna ne cifra

Obratite vnimanie chto vse eto "odin" simvol. Dlya oboznacheniya posledovatel'nosti
primenyajte modifikatory. Tak:

	\w+	- slovo
	\d+	- celoe chislo
	[+-]?\d+	- celoe so znakom
	[+-]?\d+\.?\d*	- chislo s tochkoj

Krome togo sushchestvuyut mnimye metasimvoly. Oboznachayushchie ne sushchestvuyushchie
simvoly v meste smeny znacheniya. Takie kak:

	\b	- granica slova
	\B	- ne granica slova
	\A	- nachalo stroki
	\Z	- konec stroki
	\G	- konec dejstviya m//g

Granica slova (\b) - eto mnimaya tochka mezhdu simvolami \w i \W.
Vnutri klassa simvolov '\b' oboznachaet simvol backspace (stiraniya).
Metasimvoly \A i \Z - analogichny '^' i '$' no esli nachalostroki '^'
i konec stroki '$' dejstvuyut dlya kazhdoj stroki v mnogostorochnoj stroke
to \A i \Z oboznachayut nachalo i konec vsej mnogostorchnoj stroki.

Esli vnutri shablona primenyaetsya gruppirovka (kruglye skobki)
to nomer podstroki gruppy oboznachaetsya kak '\cifra'.
Zamet'te chto za shablonom v predelah vyrazheniya ili bloka eti gruppy oboznachayutsya
kak '$cifra'. Krome etogo sushchestvuyut dopolnitel'nye peremennye:

	$+	- oboznachaet poslednee sovpadenie
	$&	- vse sovpadenie
	$`	- vse do sovpadeniya
	$'	- vse posle sovpadeniya

Primer:

$s = "Odin 1 dva 2 i tri 3";
if ($s =~ /(\d+)\D+(\d+)/)
    {
        print "$1\n";	# Rezul'tat '1'
        print "$2\n";	# '2'
        print "$+\n";	# '2'
        print "$&\n";	# '1 dva 2'
        print "$`\n";	# 'Odin '
        print "$'\n";	# ' i tri 3'
   }




(?#kommentarij)	- kommentarij v tele shablona.

	(?:shablon)	- gruppirovka kak i '( )' no bez obratnoj ssylki

	(?=shablon)	- "zaglyadyvanie" vpered. Naprimer /\w+(?=\t)/
			sootvetstvuet slovu za kotorym idet tabulyaciya
no simvol '\t' ne vklyuchaetsya v rezul'tat.

Primer:
$s = "1+2-3*4";
if ($s =~ /(\d)(?=-)/)  # Naiti cifru za kotoroj stoit '-'
    {
        print "$1\n";   # Rezul'tat '2'
   }
else { print "oshibka poiska\n";}


	(?!shablon)	- "zaglyadyvanie" vpered po otricaniyu.

Primer:
$s = "1+2-3*4";
if ($s =~ /(\d)(?!\+)/) # Naiti cifru za kotoroj ne stoit '+'
    {
        print "$1\n";   # Rezul'tat '2'
   }
else { print "oshibka poiska\n";}


	(?ismx)	- "vnutrennie" modifikatory. Udobno primenyat' v shablonah
	gde naprimer nuzhno vnutri shablona ukazat' modifikator.




	1. Lyuboj simvol oboznachaet sebya samogo esli eto ne metasimvol.
	Esli vam nuzhno otmenit' dejstvie metasimvola to postav'te
	pered nim '\'.
	2. Stroka simvolov oboznachaet stroku etih simvolov.

	3. Mnozhestvo vozmozhnyh simvolov (klass) zaklyuchaetsya v kvadratnye
	skobki '[]' eto znachit chto v dannom meste mozhet stoyat' odin
	iz ukazannyh v skobkah simvol. Esli pervyj simvol v skobkah
	eto '^' - znachit ne odin iz ukazannyh simvolov ne mozhet
	stoyat' v dannom meste vyrazheniya. Vnutri klassa mozhno upotreblyat'
	simvol '-' oboznachayushchij diappazon simvolov. Naprimer a-z
	odin iz malyh bukv latinskogo alfavita, 0-9 - cifra i t.d.

	4. Vse simvoly, vklyuchaya special'nye mozhno oboznachat' s
	pomoshch'yu '\' kak v yazyke S.

	5. Al'ternativnye posledovatel'nosti razdelyayutsya simvolom '|'
	Zamet'te chto vnutri kvadratnyh skobok eto obychnyj simvol.

	6. Vnutri regulyarnogo vyrazheniya mozhno ukazyvat "podshablony"
	zaklyuchaya ih v kruglye skobki i ssylat'sya na nih kak '\nomer'
	Pervaya skobka oboznachaetsya kak '\1'.



     V   Pel   associativnost'   i   prioritetnost'  operatorov
analogichna  yazyku C. Nizhe perechisleny  vse  operatory v poryadke
umen'sheniya prioriteta, v nachale stroki ukazana associativnost'.

	assoc.	    operatory
	-----	---------------------------
	levaya	termy i levostoronnye spiskovye operatory
	levaya	->
	 -	++ --
	pravaya	**
	pravaya	! ~ \ unarnye + i -
	levaya	=~ !~
	levaya	* / % x
	levaya	+ - .
	levaya	<< >>
	  -	imenovannye unarnye operatory
	  -	< > <= >= lt gt le ge
	  -	== != <=> eq ne cmp
	levaya	&
	levaya	| ^
	levaya	&&
	levaya	||
	  -	..
	pravaya	?:
	pravaya	= += -= *= i t.d.
	levaya	, =>
	  -	pravostoronnie spiskovye operatory
	levaya	not
	levaya	and
	levaya	or xor




Lyuboj term imeet samyj vysokij prioritet. K termu otnosyatsya
peremennye, kavychki i ih operatory, arifmeticheskie i logicheskie vyrazheniya
v skobkah, lyubye funkcii s parametrami v skobkah. Fakticheski takih
funkcij net tak kak eto prosto unarnye i spiskovye operatory prosto
oni vedut sebya podobno funkciyam s parametrami v skobkah. Podrobno smotri
glavu "Funkcii".
Esli posle lyubogo spikovogo operatora ( print(), i t.d.) ili unarnogo
operatora (chdir(), i t.d.) sleduet levaya kruglaya skobka, to operatory
vnutri skobok imeyut naivysshij prioritet. Tak zhe kak i obychnye funkcii.

Esli skobki otsutsvuyut to prioritet spiskovyh operatorov ili naivysshij
ili naimen'shij v otnoshenii operatorov sprava ili sleva ot nego.

Naprimer:

        @i = ('a ','b ', print 'c ', 'd ');
        print "\n",@i,"\n";

Rezul'tat:
	c d
	a b 1

Zdes' my imeem spiskovyj operator print. Dlya zapyatyh sleva ot nego on
imeet naimen'shij prioritet, no povyshaet prioritet pravoj zapyatoj.
Poetomu pravaya zapyataya vosprinimaetsya kak parametr dlya print i pechataetsya
'c d' a levaya prosto zapisyvaet kod zaversheniya operacii v massiv @i
i poslednij print pokazyvaet eto.



Tak zhe kak v S ili S++ eto infiksnyj operator pereadressacii. Esli
sprava ot nego stoit [...] ili {...} vyrazhenie, to pravaya chast' mozhet
byt' neposredstvennoj ili simvolicheskoj ssylkoj na massiv ili hesh.
V protivnom sluchae pravaya storona eto metod ili prostoj skalyar soderzhashchij
imya metoda, a pravaya ili ob容kt ili imya klassa. Podrobno smotri
glavu "Klassy".



|ti operatory rabotayut tak zhe kak i v S. Esli operator stoit pered
peremennoj to znachenie peremennoj izmenyaetsya na 1 i poluchennoj znachenie
ispol'zuetsya. Esli posle peremennoj to ee velichina izmenyaetsya posle
primeneniya.

Upotreblenie inkrementa k strokovym peremennym v Pel imeet odnu osobennost'.
Kazhdyj simvol ostaetsya v svoem klasse (bol'shie, malye, cifry) i uchityvaetsya
perenos predydushchego simvola. Takim obrazom strokovye peremennye s ciframi
rabotayut kak chislovye peremennye.

Primer:
	print ++($i = "09");	# Rezul'tat "10"

	print ++($i = "a9");	# "b0"

	print ++($i = "az");	# "ba"

	print ++($i = "aZ");	# "bA"



Primer:
	print 4**2	# Rezul'tat 16

	print -4**2	# Rezul'tat -16 t.e. -(4**2)



	'!'	- logicheskoe otricanie

	'-'	- arifmeticheskij minus

	'~'	- pobitnaya inversiya (dopolnenie do 1)

	'+'	- arifmeticheskij plyus

	'\'	- poluchenie ssylki na peremennuyu (kak & v S)



     |ti  "neobychnye"  ya  by  dazhe skazal original'nye operatory imeyut ochen'
shirokoe primenenie v Pel. Mozhno dazhe  nazvat'  ih  "original'nym"  resheniem.
Operator  =~ logicheski svyazyvaet levuyu chast' vyrazheniya s paternom (pattern -
obrazec, shablon, model') v pravoj.  Po  umolchaniyu  poisk  ili  izmenenie  po
paternu  vypolnyaetsya v peremennoj $_ Operatory privyazki pozvolyayut delat' eto
s lyuboj peremennoj ukazannoj v levoj  chasti.  Logicheskim  rezul'tatom  budet
uspeh  operacii.   Esli v pravoj chasti vmesto paterna prisutsvuet vyrazhenie,
to rezul'tat etogo vyrazheniya vosprinimaetsya kak patern. Odnako eto ne  ochen'
effektivno  t.k.  patern budet kompilirovat'sya vo vremya ispolneniya programmy
chto  zametno  snizit  bystrodejstvie.   Operator  !~  analogichen  =~  tol'ko
rezul'tat  sovpadeniya inventiruetsya (logicheskoe "net"). Podrobnoe primenenie
etih operatorov privoditsya v glave "Paterny".



	'*'	- arifmeticheskoe umnozhenie

	'/'	- arifmeticheskoe delenie

	'%'	- arifmeticheskij modul'

	'x'	- operator povtoreniya
V skalyarnom kontekste vozvrashchaet stroku levoj chasti povtorennuyu velichinoj
ukazannoj v pravoj chasti. V spiskovom kontekste, esli v levoj chasti spisok
v kruglyh skobkah - povtorennyj spisok.

Primer:
	print '*' x 5;	# Rezul'tat '*****'

	print (1,2) x 3; # Rezul'tat 121212




	'+'	- arifmeticheskij plyus

	'-'	- arifmeticheskij minus

	'.'	- konkatenaciya (ob容dinenie) strok



	'<<'	- Sdvigaet pobitno vlevo znachenie vyrazheniya v levoj chasti
		na kolichestvo bit ukazannoe v pravoj.

	'>>'	- Sdvigaet pobitno vpravo znachenie vyrazheniya v levoj chasti
		na kolichestvo bit ukazannoe v pravoj.



Fakticheski eto funkcii s odnim argumentom. Kruglye skobki mozhno opuskat'.



	'<'	- arifmeticheskoe men'she

	'>'	- arifmeticheskoe bol'she

	'<='	- arifmeticheskoe men'she ili ravno

	'>='	- arifmeticheskoe bol'she ili ravno

	'lt'	- strokovoe men'she

	'gt'	- strokovoe bol'she

	'le'	- strokovoe men'she ili ravno

	'ge'	- strokovoe bol'she ili ravno



	'=='	rezul'tat true esli levaya chast' ravna pravoj (ravno)

	'!='	- ne ravno

	'<=>'	- -1 esli levaya chast' men'she pravoj, 0 esli ravna,
		1 esli bol'she.

	'eq'	- strokovoe ravno

	'ne'	- strokovoe ne ravno

	'cmp'	- kak i '<=>' primenitel'no k strokam



	'&'	- pobitnoe AND

	'|'	- pobitnoe OR

	'^'	- pobitnoe XOR



	'&&'	- esli levoe vyrazhenie vozvrashchaet false, pravoe ne vypolnyaetsya.

	'||'	- esli levoe vyrazhenie vozvrashchaet true, pravoe ne vypolnyaetsya.

Otlichie ot podobnyh operatorov v S zaklyuchaetsya v tom, chto v S vozrashchaemoe
znachenie libo 0 libo 1. Togda kak v Pel vozvrashchaetsya rezul'tat vyrazheniya.



     Rezul'tat raboty dannogo operatora zavisit ot konteksta. V
spiskovom kontekste rezul'tat est' spisok s elementami.  Pervyj
element  kotorogo  eto  levoe  vyrazhenie  i poslednee - pravoe.
Znachenie kazhdogo elementa vnutri  spiska  uvelichivaetsya  na  1.
Dannyj   operator  udoben  dlya  nebol'shih  ciklov  t.k.  pamyat'
otvoditsya dlya vsego spiska celikom. Poetomu bud'te  vnimatel'ny
i ne zadavajte slishkom bol'shoj diappazon.
 Primer:
	for $i (1..4)
	   { print "$i ";
	   }
Rezul'tat: 1 2 3 4

V skalyarnom kontekste rezul'tat - logicheskoe znachenie. Kazhdaya '..'
operaciya ustanavlivaet svoe sobstvennoe sostoyanie. |to false
do teh por poka levyj operand false. Kak tol'ko levyj operand
stal true rezul'tat - true do teh poka pravyj true, posle chego
rezul'tat opyat' - false. Esli vy ne hotite proveryat' pravyj operand
to ispol'zujte operator '...'.
Pravyj operand ne vychislyaetsya poka rezul'tat false i  levyj
operand ne vychislyaetsya poka poka rezul'tat true. Prioritetnost'
operatora '..' nemnogo nizhe chem '&&' i '||'. Vozvrashchaemoe
znachenie esli flase - nulevaya stroka, esli true - poryadkovyj nomer
nachinaya s 1. Poryadkovyj nomer obnulyaetsya dlya kazhdogo novogo diappazona.
Poslednij poryadkovyj nomer dobavlyaetsya strokoj "E0" kotoraya ne izmenyaet
ego znachenie no pozvolyaet fiksirovat' poslednee znachenie.

Primer:
	@alfavit = ('a'..'z'); # Massiv malyh bukv latinskogo alfavita

	@cifry = (0..9);	# Massiv cifr

Uslovnyj operator '?:'

|tot operator rabotaet tak zhe kak i v S. Esli vyrazhenie pered '?'
istinno to vypolnyaetsya argument pered ':' - inache posle ':'.

Primer:
	$i = 1;
	$i > 1 ? print "bol'she" : print "men'she";

Rezul'tat: men'she



	'='	- obychnyj operator "prisvoit'" pravoe znachenie peremennoj sleva
Vsya eta gruppa operatorov podobna operatoram S t.e.

	$i += 2;
ekvivalentno
	$i = $i + 2;
Ostal'nye operatory etoj gruppy rabotayut analogichno.
Dopustimy sleduyushchie operatory:

	**=
	+=	-=	.=
	*=	/=	%=	x=
	&=	|=	^=
	<<=	>>=
	&&=	||=

Prioritet vsej etoj gruppy operatorov raven prioritetu '='.




V skalyarnom kontekste vypolnyaetsya levyj argument, rezul'tat ignoriruetsya
zatem pravyj i ego rezul'tat est' rezul'tat dejstviya operatora.
V spiskovom kontekste eto razdelitel' elementov spiska kotoryj
vklyuchaet ukazannye elementy v spisok.



Unarnyj not vozvrashchaet protivopolozhnoe znachenie poluchennoe vyrazheniem
sprava. On ekvivalenten '!' no imeet ochen' nizkij prioritet.



Vypolnyaet logicheskuyu kon座unkciyu dvuh vyrazhenij. |kvivalenten '&&'
no imeet ochen' nizkij prioritet i "kratkost'" dejstviya. t.e
esli levoe vyrazhenie ravno false - levoe ne vypolnyaetsya.



Vypolnyaet logicheskuyu diz座unkciyu dvuh vyrazhenij. |kvivalenten '||'
no imeet ochen' nizkij prioritet i "kratkost'" dejstviya. t.e
esli levoe vyrazhenie ravno true - levoe ne vypolnyaetsya.

Logicheskoe xor (isklyuchayushchee ILI).
Vypolnyaet logicheskoe isklyuchayushchie ili. Vsegda vypolnyayutsya oba
pravoe i levoe vyrazhenie.


 V Pel otsutsvuyut operatory yazyka S takie kak:
	unarnoe &	- poluchit' adres. Dlya etogo primenyaetsya '\'.

	unarnyj *	- pereadresaciya.

	(TYPE)		- sovmeshchenie tipov.




Obychno ogranichiteli strok my schitaem literalami, no v Pel eto operatory
vypolnyayushchie raznogo roda interpolyaciyu i poisk po shablonu. Vy mozhete
sami zadavat' udobnye dlya vas ogranichiteli. V sleduyushchej tablice
priveden polnyj perechen' variantov. Figurnye skobki '{}' oboznachayut
lyuboj simvol ispol'zuemyj dlya ogranichitelya. V sluchae ispol'zovaniya
skobok (kruglyh '()', kvadratnyh '[]', figurnyh '{}', uglovyh '<>')
v nachale stavitsya otkryvayushchayasya skobka a v konce zakryvayushchaya.

  Po umolchaniyu	Polnoe	Funkciya     Interpolyaciya
   ----------	------	------------	----
	''	q{}	Literal		net
	""	qq{}	Literal		da
	``	qx{}	Komanda		da
		qw{}	Spisok slov	net
	//	m{}	SHablon		da
		s{}{}	Podstanovka	da
		tr{}{}	Translyaciya	net

V strokah dopuskayushchih interpolyaciyu imena peremennyh nachinayushchiesya s
simvolov '$' ili '@' - interpoliruyutsya t.e. v stroku vstavlyaetsya
znachenie stroki ili massiva.
Dannye posledovatel'nosti simvolov imeyut special'noe znachenie:

	\t	simvol tabulyacii
	\n	simvol novoj stroki
	\r	vozvrat
	\f	perevod formata
	\v	vertikal'naya tabulyaciya
	\b	backspace (zaboj)
	\a	zvonok
	\e	escape
	\034	vos'merichnyj simvol
	\x1a	shest'nadcaterichnyj simvol
	\c[	simvol upravleniya
	\l	nizhnij registr sleduyushchego simvola
	\u	verhnij registr sleduyushchego simvola
	\L	nizhnij registr dlya vseh simvolov do \E
	\U	verhnij registr dlya vseh simvolov do \E
	\E	ogranichitel' smeny registra
	\Q	otmena dejstviya metasimvolov do \E

SHablony interpoliruyutsya kak regulyarnye vyrazheniya. |to vypolnyaetsya
vtorym prohodom posle interpolyacii peremennyh poetomu
v shablony mozhno vstavlyat' peremennye. Dlya otmeny interpolyacii
ispol'zujte '\Q'. Esli vy primenyaete vlozhennye ogranichiteli to
vnutrennie ogranichiteli rabotat' ne budut.


Dejstvie etogo operatora analogichno /shablon/ no vypolnyaetsya
do pervogo sovpadeniya. |to udobno dlya poiska nalichiya kakoj
nibud' stroki v odnom ili mnozhestve fajlov. |to ne ochen'
udachnyj operator poetomu v sleduyushchih versiyah Pel ego
vozmozhno ne budet.


/PATERN/gimosx
Poisk v stroke po paternu (shablonu). V skalyarnom kontekste vozvrashchaet
logicheskoe znachenie true (1) ili false (''). Esli stroka ne ukazana
s pomoshch'yu operatorov '=~' ili '!~' poisk vedetsya v stroke $_

Opcii:
	g	- Global'nyj poisk. Poisk vseh vhozhdenij.
	i	- Sravnenie ne zavisit ot registra (verhnij ili nizhnij)
	m	- Stroka mnogostrochna.
	o	- odnoprohodnaya kompilyaciya
	s	- odnostrochnaya stroka
	x	- ispol'zueyutsya rasshirennye regulyarnye vyrazheniya.

Esli '/' - ogranichitel' to nachal'noe 'm' mozhno opustit'. S pomoshch'yu
nego v kachestve ogranichitelya mozhet byt' lyuboj simvol krome probela.

PATTERN mozhet soderzhat' peremennye kotorye budut interpolirovat'sya
(perekompilirovat'sya) kazhdyj raz v moment vychisleniya.
Peremennye $) i $| ne interpoliruyutsya. Esli vy hotite chto by
takoj shablon interpolirovalsya odin raz - dobav'te /o.
|to neobhodimo delat' v ciklah poiska dlya uvelicheniya bystrodejstviya
odnako esli vy izmenite znachenie peremennoj Pel etogo dazhe ne zametit.

Esli PATERN - nulevaya stroka to ispol'zuetsya poslednee regulyarnoe
vyrazhenie.

V skalyarnom kontekste vozvrashchaetsya spisok elementy kotorogo
rezul'taty vypolneniya vyrazhenij v skobkah paterna ($1, $2, $3...).
Obratite vnimanie chto pervyj element $1.

Primer:
	$a = "/usr/local/perl/perl.bin"; # Analiziruemaya stroka

Cel':	Sozdat' massiv @dirs s imenami direktorij.

Reshenie:
	Samyj prostoj sposob vospol'zovat'sya split('\/')
	no v kachestve primera ispol'zuem skobki.

	@dirs =~ m[/(\w*)/(\w*)/(\w*)/(\w*)]

Zdes' 'm[' - ispol'zovat' kvadratnye skobki kak ogranichiteli.
(\w*)	- shablon alfavitnocifrovoj posledovatel'nosti.

V rezul'tate @dirs raven ('usr', 'local', 'perl')


'stroka'
	Stroka literalov. Ne interpoliruetsya. Vnutri stroki razreshaetsya ispol'zovat'
\' ili \\ dlya oboznacheniya simvolov ' i \ .

Primer:
	print q#Privet.#;	# Rezul'tat Privet.

	print 'O\'K';		# O'K

qq/stroka/
"stroka"
	Interpoliruemaya stroka.

Primer:
	$var = 13;
	print "\$var = $var";

Rezul'tat:
	$var = 13


`stroka`
	Snachalo stroka interpoliruetsya a potom vypolnyaetsya kak
	sistemnaya komanda.

Primer:
	print `date`;

Rezul'tat:
	Thu Nov 14 13:36:49 MSK 1996


	Vozvrashchaet spisok elementy kotorogo - slova stroki razdelennye
	probelami.

Primer:
	print qw/Postroemsya i spasemsya!/; # ('Postroemsya','i','spasemsya!')

Rezul'tat:
	Postroemsyaispasemsya!

CHasto primenyaetsya kak:
	use POSIX qw( setlocale localeconv )
	@EXPORT = qw( proc1 var );


	Poisk po shablonu i v sluchae uspeha zamena podstrokoj.
	Vozvrashchaet kolichestvo proizvedennyh podstanovok inache false (0).
Esli stroka v kotoroj vedestya poisk ne ukazana (operatory =~ ili != )
to ispol'zuetsya peremennaya $_ .
Esli v kachestve radelitelya '/' isrol'zovat' odinarnuyu kavychku (')
to interpolyacii ne budet inache mozhno primenyat' peremennye v shablone
ili podstroke.

Opcii:

	e	- Rasmmatrivat' pravuyu chast' kak vyrazhenie.
	g	- Global'nyj poisk.
	i	- Bez razlichiya registra bukv
	m	- mnogostochnaya peremennaya
	o	- kompilirovat' shablon odin raz
	s	- odnostrochnaya peremennaya
	x	- rasshirennoe regulyarnoe vyrazhenie

Razdelitel' '/' mozhno zamenit' na lyuboj alfavitno-cifrovoj simvol
krome probela.

Primer:
	$var = "12345"; # ishodnaya stroka
	$var =~ s/1/0/; # Zamenit' '1' na '0'. Rezul'tat 02345
	$var =~ s(5)(.); # Zamenit' '5' na '.' Rezul'tat 0234.

Zdes' v kachestve razdelitelya primeneny skobki poetomu podstroka
vzyata v dve skobki.

	$var =~ s/\d*/kalambur/; Zamenit' vse cifry. Rezul'tat 'kalambur.'

	$var =~ s/a/o/g; # Zamenit' vse 'a' na 'o'. Rezul'tat 'kolombur.'

	$var = "12 34"; # Novoe znachenie

	$var =~ s/(\d\d) (\d\d)/$2 $1/; # Pomenyat' mestami chisla. Rezul'tat '34 12'.



y/tablica1/tablica2/cds

	Zamena vseh simvolov iz "tablica1" na sootvetsvuyushchij simvol
iz "tablica2". Rezul'tat - kolichestvo zamen ili stiranij. Bez operatora
=~ ili != operaciya vypolnyaetsya s strokoj $_. Dlya sovmestimosti s programmoj
sed vmesto tr mozhno pisat' 'y'.

Opcii:
	c	- dopolnenie "tablica1"
	d	- steret' najdennye no ne zamenennye simvoly.
	s	- "zzhat'" povtoryayushchiesya zamenennye simvoly.

Esli ukazana opciya /d tablica2 vsegda interpretiruetsya kak polozheno.
Drugimi slovami esli tablica2 koroche chem tablica1 to simvol iz tablicy1
interpretiruetsya vsegda. Esli tablica2 - null to vse simvoly stroki
ostayutsya ne izmennennye. |to udobno dlya podscheta kolichestva sivolov
v stroke opredelennogo klassa ili dlya szhatiya povtoryayushchihsya simvolov
naprimer probelov.

Primer:
	$s = "hello";	# Ishodnaya stroka

	$s =~ tr/a-z/A-Z/;	# Zamenit' malye bukvy na bol'shie. Rezul'tat
				# 'HELLO'

	$s = 'Hel....lo';
	$s =~ tr/a-zA-z/_/c;	# Zamenit' vse ne bukvy na '_'
				# Rezul'tat 'Hel____lo'
	$s =~ tr/_/ /s;		# Zamenit' '_' na ' ' i szhat'.
				# Rezul'tat 'Hel lo'
	$s =~ tr/a-zA-Z /a-zA-Z/d; # Udalit' vse ne bukvy. Rezul'tat 'Hello'

Esli odin i tot zhe simvol neskol'ko raz ukazan v tablice1 to primenyaetsya
tol'ko pervaya zamena.




V Pel sushchestvuet neskol'ko operatorov vvoda-vyvoda. Pervyj eto skobki
iz simvola '`' - akcenta. Stroka v etih skobkah vosprinimaetsya kak
sistemnaya komanda i rezul'tat ee dejstviya vozvrashchaetsya kak "psevdo"
literal. V skalyarnom kontekste eto stroka soderzhashchaya ves' rezul'tat,
a v spiskovom - spisok elementy kotorogo - stroki rezul'tata.
Status vypolnenoj komandy hranitsya v peremennoj $? .

Sleduyushchaya komanda vvoda vyvoda vygledit kak '<fajl>'.
Vychislenie <fajl> privodit k chteniyu stroki iz fajla. Obratite vnimanie
chto 'fajl' zdes' ne imya fajla a ukazatel' fajla kotoryj sozdaetsya
funkciej open(). V skalyarnom kontekste chitaetsya odna stroka vmeste
s simvolom '\n' - perevoda stroki, a v spiskovom ves' fajl chitaetsya
v spisok elementy kotorogo sut' stroki fajla.
V sluchae obnaruzheniya konca fajla rezul'tat operatora ne opredelen
i vosprinimaetsya kak false. Esli ne ukazana peremennaya rezul'tata
to po umolchaniyu eto $_. Ukazatel' fajla po umolchaniyu STDIN -
standartnyj vvod.

Primer:
	while(<>) { print; }; # Prochitat' i vyvesti ves' fajl STDIN

U operatora '<>' est' odna otlichitel'naya osobennost'. Esli v komandnoj
stroke net nikakih argumentov to chitaetsya standartnyj vvod, esli
est' argumenty to oni schitayutsya imenami fajlov kotorye posledovatel'no
chitayutsya.
Esli v uglovyh skobkah zapisana peremennaya to soderzhimoe etoj
peremennoj schitaetsya imenem ukazatelya fajla ili ssylkoj na
ukazatel' fajla. Esli takogo ukazatelya ne sushchestvuet to soderzhimoe
peremennoj vosprinimaetsya kak shablon imen fajlov i rezul'tat
- imena fajlov na diske podhodyashchih po shablonu.

Primer:
	while(<*.pl>) { print;}; # To zhe chto i ls *.pl

	@files = <*>;	# Massiv @files soderzhit imena fajlov v direktorii

no luchshe sdelat': @files = glob("*"); t.k. vnutri skobok mozhno ispol'zovat'
peremennye.




Kak i S Pel vypolnyaet vozmozhnye vychisleniya v period kompilyacii.
Tak podstanovka simvolov posle '\' , operaciya konkatenacii strok,
arifmeticheskie vyrazheniya soderzhashchie tol'ko odni konstanty, vse eto
delaetsya v moment kompilyacii chto sushchestvenno uvelichivaet skorost'
vypolneniya programmy.



Po umolchaniyu Pel vypolnyaet arifmetiku s plavayushchej zapyatoj, no
esli vy ukazhete:

	use integer;

to kompilyator budet ispol'zovat' celochislennuyu arifmetiku do
konca tekushchego bloka, hotya vlozhennyj blok mozhet eto i otmenit'
v svoih predelah s pomoshch'yu:

	no integer;



     Vstroennye  funkcii  ispol'zuyutsya  kak  termy  vyrazhenij i
podrazdelyayutsya na dve kategorii: spiskovye operatory i  unarnye
operatory.  |to vliyaet na ih prioritet po otnosheniyu k operatoru
',' - zapyataya.   Spiskovye  operatory  mogut  iment'  mnozhestvo
(spisok)  argumentov,  a  unarnye  tol'ko  odin.  Takim obrazom
zapyataya zavershaet  argumenty  unarnogo  operatora  i  razdelyaet
argumenty spiskovogo.
     Argument   unarnogo   operatora  vosprinimaetsya  obychno  v
skalyarnom  kontekste  a  spiskovogo  kak  v  skalyarnom  tak   i
spiskovom  prichem skalyarnye argumenty idut pervymi. V dal'neshem
spiskovye argumenty  my  budem  oboznachat'  slovom  'LIST'  eto
znachit chto funkciya imeet spisok argumentov razdelennyh zapyatoj.
Argumenty funkcij mozhno zaklyuchat'  v  kruglye  skobki  i  takim
obrazom  oboznachat'  chto  "eto  funkciya"  i  prioritet ne imeet
znacheniya  inache  eto   spiskovyj   ili   unarnyj   operator   s
opredelennym  fiksirovannym  prioritetom.  Probel  posle  imeni
funkcii  i  skobkoj  znacheniya   ne   imeet.    Poetomu   bud'te
vnimatel'ny!

Primer:
	print 1 + 2 + 3; # rezul'tat 6

	print(1+2)+3;	# rezul'tat 3

	print (1+2)+3;	# opyat' 3

	print (1+2+3);	# 6

Esli funkciya vozvrashchaet rezul'tat kak v skalyarnom tak i v spiskovom kontekste
to kod vyhoda po oshibke - skalyar c neopredelennym znacheniem ili pustoj
spisok.

Zapomnite pravilo:

	Ne sushchestvuet obshchego pravila preobrazovaniya spiska v skalyar!

Kazhdyj operator i funkciya imeyut svoj vid znacheniya v skalyarnom kotekste.
Dlya odnih eto kolichestvo elementov iz skalyarnogo konteksta. Dlya drugih
pervyj element spiska ili poslednij ili kolichestvo
uspeshnyh operacij. Kazhdyj svoe esli vy special'no ne ukazyvaete.



	-X ukazatel' fajla
	-X vyrazhenie
	-X

Proverka fajla, gde 'X' odno iz nizhe opisannyh znachenij.
|to unarnyj operator s odnim argumentom - libo imenem fajla libo
ukazatelem fajla. Proveryaet odno iz uslovij. Esli argument ne ukazan
to beretsya znachenie peremennoj $_. Dlya klyucha -t STDIN.
Rezul'tat 1 esli true i '' esli false ili neopredelennoe znachenie
esli fajl ne najden. Nesmotrya na strannyj vid eto unarnyj operator
s sootvetsvuyushchim prioritetom. Argument mozhno zaklyuchat' v kruglye skobki.
'X' imeet sleduyushchie znacheniya:

	-r	Fajl razreshen na chtenie effektivnym uid/gid
	-w	na zapis' -//-
	-x	ispolnenie -//-
	-o	prinadlezhit effektivnomu uid (identifikator pol'zovatelya)

	-R	Fajl razreshen na chtenie real'nym uid/gid
	-W	na zapis' -//-
	-X	ispolnenie -//-
	-O	prinadlezhit real'nomu uid

	-e	fajl sushchestvuet
	-z	pustoj
	-s	ne pustoj

	-f	obychnyj tekst
	-d	direktoriya
	-l	simvolicheskaya ssylka
	-p	pipes (konvejer)
	-S	socket (gnezdo)
	-b	special'noe blochnoe ustrojstvo
	-c	-//- simvol'noe -//-
	-t	ukazatel' na ust-vo tty

	-u	ustanovlen bit setuid
	-g	-//- setgid
	-k	-//- sticky

	-T	tekstovoj fajl
	-B	dvoichnyj

	-M	"vozrast" fajla v dnyah na moment starta skripta
	-A	dnej s poslednego chteniya
	-C	dnej s poslednej modifikacii inode




        Absolyutnoe znachenie vyrazheniya



	Okryt' novyj sokit po vneshnemu zaprosu. Analogichno
sistemnomu vyzovu accept(). Vozvrashchaet adres ili false v sluchae
neudachi.



	Poslat' signal SIGALARM tekushchimu processu
po istechenii ukazannogo promezhutka vremeni. Ne dopustimo delat'
neskol'ko vyzovov odnovremenno v odnom promezhutke vremeni.
Vozvrashchaet ostatok vremeni predydushchego schetchika.



	Arktanges otnosheniya Y k X v predelah ot -pi do +pi.



	Naznachit' setevoj adres sokitu. Podobno sistemnomu
vyzovu bind. Vozvrashchaet true v sluchae uspeha i false inache.
Imya - paketnyj adres sokita.


	Otkryt' fajl dlya dvoichnogo (binary) rezhima dostupa.
V obychnom rezhime pri vvode simvoly CR LF transliruyutsya v LF,
a pri vyvode LF transliruetsya v CR LF.


bless ssylka

	Dannaya funkciya opredelyaet chto ob容kt ukazannyj ssylkoj
prinadlezhit klassu. Esli klass ne ukazan to on otnositsya k tekushchemu
klassu. Obychno eto poslednij operator v konstruktore ob容kta.
Neobhodimo obyazatel'no ukazyvat' imya klassa esli opredelyaemyj
ob容kt mozhet nasledovat'sya klassom-potomkom.


caller
	Vozvrashchaet kontekst vyzova tekushchej podprogrammy.
V skalyarnom kontekste true esli eto podprogramma ili procedura
vyzvannaya operatorami eval() ili require() i false - inache.
V spiskovom eto spisok ($package, $filename, $line)
gde
	$package - imya paketa
	$filename - imya fajla paketa
	$line - nomer stroki otkuda byl sdelan vyzov.

Esli ukazano vyrazhenie to vozvrashchaetsya spisok:

	($package, $filename, $line, $subroutine, $hasargs, $wantargs)
Vyrazhenie opredelyaet "glubinu" vlozhennosti prosmotra steka vyzovov.

	$subroutine - imya podprogrammy
	$hasargs - imeyushchiesya argumenty
	$wantargs - neobhodimye argumenty
Primenenie dannoj funkcii v DB pakete vozvrashchaet bolee detal'nuyu
informaciyu. K spisku argumentov dobavlyaetsya spisok @DB::args.



	Perejti v direktoriyu ukazannuyu vyrazheniem. Esli
vyrazhenie otsutsvuet to perejti v "domashniyu" direktoriyu.
Vozvrashchaet true v sluchae uspeha i false - neudachi.



	Izmenit' prava dostupa k fajlam ukazannym v spiske.
Pervyj element v spiske - chislovoe ,obychno vos'merichnoe znachenie prav.
Vozvrashchaet kolichestvo fajlov kotorym byli izmeneny prava.

Primer:		chmod 0666 'f1', 'f2', 'f3';


chomp spisok
chomp
	Udalyaet v konce stroki simvol ukazannyj peremennoj $/.
Obychno eto 'LF'. Vozvrashchaet kolichestvo udalennyh simvolov.
Esli peremennaya ne ukazana to ispol'zuetsya peremennaya $_.
Esli ukazan spisok to obrabatyvaetsya kazhdaya stroka spiska i
vozvrashchaetsya obshchee kolichestvo udalennyh simvolov.


chop spisok
chop
	Polnost'yu analogichno funkcii chomp no vsegda udalyaet
poslednij simvol stroki.



	Izmenit' "vladel'ca" i "gruppu" fajlov spiska.
Pervyj element - nomer novogo vladel'ca, vtoroj nomer novoj gruppy
a dalee spisok fajlov.
V bol'shinstve YUniks-sistem vy ne smozhete smenit' vladel'ca esli vy
ne superpol'zovatel', no mozhete izmenit' gruppu esli eto odna iz
vashih "vtorichnyh" grupp.


	Vozvrashchaet simvol s ukazannym kodom kodirovki.



	Sdelat' "kornevoj" ukazannuyu direktoriyu.
"Kornevaya" - znachit vnutri programmy na nee mozhno ssylat'sya kak '/'.


	Zakryt' otkrytyj fajl ili potok. Mozhno ne ispol'zovat'
esli odin i tot zhe fajl otkryvaetsya povtortno t.k. on budet
avtomaticheski zakryvat'sya novym vyzovom open().



	Zakryt' direktoriyu otkrytuyu funkciej opendir().



	Svyazat'sya s udalennym sokitom. Dannaya funkciya podobna
sistemnomu vyzovu connect(). Vozvrashchaet true v sluchae uspeha
i false pri oshibke.


	Kosinus vyrazheniya v radianah.



	SHifraciya tekta. Analogichno sistemnomu crypt().



	Zakryvaet svyaz' mezhdu hesh i bazoj dannyh.



	Associirovat' ukazannyj hesh i bazu v opredelennom rezhime.
Delo v tom chto v Pel realizovan ochen' udobnyj mehanizm raboty
s bazami dannyh tipa dbm, ndbm, sbdm, gdbm i Berkeley DB. Dlya etogo nuzhno
svyazat' (otkryt') bazu pod imenem hesha. Vsya rabota s zapisyami
bazy vypolnyaetsya tak budto eto obychnyj hesh (associativnyj massiv).
Bolee podrobno smotrite opisanie funkcii AnyDBM().


	Vozvrashchaet true esli znachenie opredeleno (sushchestvuet)
i false esli net. Mnogie operacii zavershayutsya ne opredelennym
znacheniem, naprimer chtenie posle konca fajla, ispol'zovanie
ne opredelennyh peremennyh, sistemnye oshibki i t.d.
Dannaya funkciya pozvolyaet razlichat' nulevoe i ne opredelennye
znacheniya, opredelennost' ili ne opredelennost' funkcij ili
ssylok. Pri ispol'zovanii opredelennosti klyucha v heshe
ona vozvrashchaet opredelen dannyj klyuch ili net no ne sushchestvuet
on ili net.


	Udalit' znachenie iz hesha. Vozvrashchaet udalyaemoe znachenie
ili ne opredelennost' esli ni chego ne udalyaetsya.
Udalenie iz massiva okruzheniya $ENV{} - izmenyaet okruzhenie.
Udalenie iz hesha svyazannogo s bazoj dannyh - udalyaet zapis' v
baze dannyh.


	Esli programma ne byla zapushchena iz eval() dannaya
funkciya vyvodit spisok v potok STDERR i zavershaet rabotu
programmy s kodom iz peremennoj $!. Esli $! soderzhit 0
to s kodom ($? >> 8). Esli i eto 0 to s kodom 255.
Pri vyzove iz eval() soobshchenie ob oshibke zanositsya v peremennuyu $@
i eval() zavershaetsya s neopredelennym znacheniem. |to pozvolyaet
otrobatyvat' oshibochnye situacii ne zavershaya golovnoj modul'.
Esli stroka iz spiska ne zavershaetsya simvolom '\n' to dopolnitel'no
pechataetsya nomer stroki skripta otkuda vyzvana funkciya i nomer
vhodnoj stroki isli takovoj imeetsya.


	|to ne sovsem funkciya. Zdes' vozvrashchaetsya znachenie
poslednego operatora bloka. Kogda ispol'zuetsya ciklicheskij modifikator
BLOCK ispolnyaetsya pered proverkoj usloviya cikla v otlichii ot obychnyh
ciklov.



	Ustarevshij metod vyzova podprogramm.


	Znachenie vyrazheniya vosprinimaetsya kak imya fajla Pel skripta.
Iznachal'no eto primenyalos' dlya vklyucheniya podprogramm biblioteki.
Sejchas pravil'nej ispol'zovat' vyzovy use() i require() kotorye
obespechivayut kontrol'  oshibok i zaversheniya.


	Vypolnnie "dampa" tekushchej pamyati. Primenyalos' dlya
vozmozhnosti isrol'zovat' programmu undump chto by vklyuchit' tekushchij
ispolnyaemyj kod v programmu posle inicializacii vseh peremennyh.
Vypolnenie etoj novoj programmy budet nachinat'sya operatorom
goto metka. Esli metka opushchena to zapusk snachala.
Vnimanie! Fajly otkrytye do momenta dampa ne budut otkrytymi
v moment ispolneniya  novoj programmoj.


	Vozvrashchaet 2-elementnyj massiv. Pervyj element - klyuch
vtoroj - znachenie sleduyushchego elementa hesha. Pozvolyaet
"prosmatrivat'" vse znacheniya hesha v opredelennom poryadke.
Sbros peremennoj cikla proishodit tol'ko posle prohlzhdeniya vsego
massiva.


eof()
eof
	Vozvrashchaet 1 esli vypolnyaetsya chtenie posle konca ili
chtenie iz ne otkrytogo fajla. Argumentom dolzhno byt' vyrazhenie
vozvrashchayushchee sushchestvuyushchij ukazatel' fajla. Dannuyu funkciyu nel'zya
ispol'zovat' dlya chteniya fajlov otkrytyh kak terminaly.
Esli argument ne ukazan to ispol'zuetsya poslednij chitaemyj fajl.
Ispol'zovanie v forme eof() celesoobrazno primenyat' v ciklah
while(<>) dlya opredeleniya konca tol'ko poslednego fajla iz
spiska. Primenyajte eof(ARGV) ili eof dlya opredeleniya konca
kazhdogo fajla iz spiska.


eval blok
	Vyrazhenie skaniruetsya i vypolnyaetsya kak obychnaya Pel programma.
|to delaetsya v kontekste tekushchej programmy poetomu mozhno ispol'zovat'
uzhe opredelennye peremennye i podprogrammy.
Vorzvrashchaetsya rezul'tat poslednego operatora v bloke ili znachenie
operatora return. Esli obnaruzhitsya sintaksicheskaya oshibka ili vypolnitsya
operator die vozvrashchaetsya ne opredelennoe znachenie a peremennaya $@
soderzhit soobshchenie ob oshibke. Esli oshibki ne bylo to $@ soderzhit
nulevuyu stroku. Pri otsutsvii argumenta beretsya znachenie peremennoj $_.


	Vypolnyaetsya sistemnaya komanda iz spiska i vypolnenie
programmy zavershaetsya. Esli vam neobhodimo vernut'sya to luchshe
primenyajte funkciyu system(). Esli v spiske kolichestvo argumentov
bol'she 1 ili spisok eto massiv s kolichestvom elementov bol'she 1
to vypolnyaetsya sistemnyj vyzov execvp() s argumentami iz spiska.
Esli odin skalyarnyj argument to on skaniruetsya na obrabotku
metasimvolov i esli oni prisutsvuyut to poluchennye argumety
peredayutsya interpretatoru /bin/sh -c dlya dal'nejshej obrabotki.
Esli metasimvolov net to argument rasshcheplyaetsya na slova i peredaetsya
sistemnomu vyzovu execvp() chto bolee effektivno.
Vnimanie! exec() i system(0) ne sbrasyvayut bufer vvoda/vyvoda
poetomu neobhodimo ustanovit' peremennuyu $| dlya predotvrashcheniya
poteri vyhodnoj informacii.


	Vozvrashchaet true esli sushchestvuet ukazannyj klyuch hesha
dazhe esli ne opredeleno ego znachenie.


	Vypolnenie programmy zavershaetsya s kodom vyrazheniya.


	Vozvrashchaet e (osnovanie natural'nogo logarifma) v stepeni
vyrazheniya.


	Vypolnyaet sistemnyj vyzov fcntl(). Dlya ispol'zovaniya
obyazatel'no vypolnit' use Fcntl;


	Vozvrashchaet opisatel' fajla dlya dannogo ukazatelya fajla.


	Sistemnyj vyzov flock()


	Sistemnyj vyzov fork(). Vozvrashchaet pid potomka dlya roditelya
i 0 dlya potomka v sluchae uspeha inache - neopredelennoe znachenie.


	Deklarativnaya funkciya Pel. Opredelyaet format vyvoda dlya
operatora write. Podrobno smotrite glavu Formaty.


	Vnutrennyaya funkciya ispol'zuemaya v format. Formatiruet
vyvod parametrov iz spiska. Rezul'tat pomeshchaetsya v peremennuyu $^A
Funkciya write prosto vyvodit znachenie etoj peremennoj, no ee tak zhe
mozhno chitat' a zatem obnulyat'. Obychno format vypolnyae odin vyzov
formline dlya odnoj stroki formy, no formline ne razdelyaet stroki
formata. |to znachit chto simvoly '~' i '~~' rassmatrivayut ves'
format kak odnu stroku poetomu neobhodimo ispol'zovat' mnogostrochnye
formyd dlya opisaniya odnoj zapisi formata.


getc
	CHitaet i vozvrashchaet simvol iz ukazannogo fajla.
Esli fajl ne ukazan to chitaetsya STDIN. Posle konca fajla vozvrashchaet
pustuyu stroku.


	Vozvrashchaet tekushchij login iz fajla /etc/utmp
Ne primenyajte dlya identifikacii pol'zovatelya on ne tak sil'no
"zakryt" kak getpwuid().


	Vozvrashchaet upakovannyj adres udalennogo sokita.


	Vozvrashchaet gruppu processa s ukazannym PID. Esli
argument otsutsvuet vozvrashchaet gruppu tekushchego processa.



	Vozvrashchaet PID roditel'skogo processa.


	Vozvrashchaet tekushchij prioritet processa, gruppy processov
ili pol'zovatelya.



getpwnam NAME

getgrnam NAME

gethostbyname NAME

getnamebyname NAME

getprotobyname NAME

getpwuid UID

getgrid GID

getservbyname NAME, PROTO

gethostbyaddr ADDR, ADDRTYPE

getnetbyaddr ADDR, ADDRTYPE

getprotobynumber NUMBER

getservbyport PORT, PROTO

getpwent

gethostent

getnetent

getprotoent

getservent

setpwent

setgrent

sethostent STAYOPEN

setnetent STAYOPEN

setprotoent STAYOPEN

setservent STAYOPEN

endpwent

endgrent

endhostent

endnetent

endprotoent

endservent

	Vse eti funkcii anologichny odnoimennym sistemnym vyzovam.
V spiskovom kontekste vozvrashchayut sleduyushchie spiski:

($name, $passwd, $uid, $gid, $quota, $comment, $gcos, $dir, $shell) = getpw*

($name, $passwd, $gid, $members) = getgr*

($name, $aliases, $addrtype, $length, @addrs) = gethost*

($name, $aliases, $addrtype, $net) = getnet*

($name, $aliases, $proto) = getproto*

($name, $aliases, $port, $proto) = getserv*

V skalyarnom kontekste vozvrashchaetsya imya ili chto-to drugoe v zavisimosti
ot tipa funkcii.
|lement $members v vyzove getgr soderzhit razdelennye probelom imena
chlenov gruppy.
@addrs soderzhit IP adresa komp'yuterov v seti Internet v upakovannom vide.
Dlya raspakovki primenyajte: ($a, $b, $c, $d) = unpack('C4',$addr[0]);



	Vozvrashchaet upakovannyj adress sokita lokal'noj mashiny.


	Vozvrashchaet opciyu sokita.


	Vozvrashchaet spisok fajlov udovletvoryayushchih vyrazheniyu s '*'
kak v komande ls.


	Perevodit mestnoe vremya poluchennoe funkciej time() vo vremya
po Grinvichu.
Obychno ispol'zuetsya v vide:

($sec,$min,$hour,$mday,$mon,$year,$wday,$yday,$isdst)=gmtime(time);


goto vyrazhenie
goto &podprogramma
	Buzuslovnyj perehod na metku. Nel'zya delat' perehod na
metku v strukturu kotoraya dolzhna byt' iniciirovana naprimer podprogrammu
ili cikl foreach i t.d.
Vtoraya forma primenyaetsya dlya dinamicheskogo opredeleniya perehoda.

Naprimer:
	goto ('metka1', 'metka2', 'metka3')[$i];

Zdes' pri $i = 0 budet perehod na 'metka1', $i = 1 na 'metka2' i t.d.

Tret'ya forma (goto &podprogramma) dovol'no "hitryj" metod podmeny
imeni vyzyvaemoj podprogrammy imenem tekushchej. |to ispol'zuetsya
v metode avtozagruzki kogda nuzhno zapustit' druguyu proceduru
no pod imenem tekushchej kak-budto ta byla vyzvana ran'she.



grep vyrazhenie, spisok
	Vypolnyat blok ili vyrazhenie dlya kazhdogo elementa spiska.
Peremennaya $_ soderzhit tekushchij element.
Vozvrashchaet spisok elementov s kotorymi vyrazhenie dalo rezul'tat true.
V skalyarnom kontekste vozvrashchaet kolichestvo rezul'tatov true.


	Vosprinimaet vyrazhenie kak stroku shestnadcetirichnyh cifr
i vozvrashchaet desyatichnoe znachenie.


	V Pel net vstroennoj funkcii import, no est' metod
s pomoshch'yu kotorogo moduli mogut eksportirovat' oblast' imen
drugim modulyam. Podrobno smotrite funkciyu use().


index stroka, podstroka
	Vozvrashchaet poziciyu pervogo vhozhdeniya podstroki v stroke
nachinaya s ukazannoj pozicii. Esli poziciya otsutsvuet to sravnenie
nachinaetsya s nachala stroki. Otschet pozicii vedetsya s 0 esli tol'ko
ne izmeneno znachenie vstroenoj peremennoj $[. Esli podstroka ne
najdena to rezul'tat men'she pervoj pozicii na 1. Obychno eto -1.

int vyrazhenie
        Vozvrashchaet celuyu chast' vyrazheniya.


	Vypolnyaet sistemnyj vyzov ioctl(). V nachale programmy
neobhodimo ukazat': require "ioctl.ph";


	Soedinyaet stroki spiska ili massiva v odnu stroku
s kodom razdelitelya ravnomu vyrazheniyu.


	Vozvrashchaet massiv vseh klyuchej hesha. V skalyarnom
kontekste - kolichestvo klyuchej. Poryadok sledovaniya klyuchej
analogichen poryadku v each funucii.


	Poslat' signal (pervyj element) ukazannym v spiske
processam. Vozvrashchaet kolichestvo processov kotorye signal prinyali.


last
	Funkciya analogichnaya break v S. Preryvaet cikl i perehodit
na ukazannuyu metku. Esli metki net na blizhajshij vneshnij cikl.
Blok continue ne vypolnyaetsya.


	Preobrazovat' stroku v bukvy nizhnego registra.


	Zamenit' pervuyu bukvu stroki na maluyu.


	Vozvrashchaet dlinu stroki vyrazheniya.


	Sozdat' fajl NEWFILE svyazannyj s fajlom OLDFILE.


	Vypolnit' sistemnyj listen().


	Ob座avlyaet perechislennye peremennye kak lokal'nye v tekushchem
bloke ili podprogramme. Esli ukazano dva i bolee imeni ih
neobhodimo zaklyuchit' v kruglye skobki. Predpochtitel'nej ispol'zovat'
funkciyu my().


	Preobrazovat' 9-elementnyj massiv vozvrashchaemyj fugkciej
time otnositel'no mestnogo vremeni. Upotreblyaetsya kak:

($sec,$min,$hour,$mday,$mon,$year,$wday,$yday,$isdst)=localtime(time);


	Vozvrashchaet natural'nyj logarifm vyrazheniya.


lstat vyrazhenie
	To zhe chto i sistemnyj vyzov stat() no kasatel'no ssylki
na fajl a ne samogo fajla.


	Operator soavpadeniya. Smotri glavu "Operatory"


map vyrazhenie, spisok
	Vypolnyaet blok ili vyrazhenie dlya kazhdogo elementa spiska.
Vozvrashchaet spisok rezul'tatov.


	Sozdat' direktoriyu s ukazannymi pravami dostupa. Vozvrashchaet
1 pri uspehe i 0 pri neudache.


	Sistemnyj vyzov msgctl() System V


	Sistemnyj vyzov msgget() System V


	Sistemnyj vyzov msgsnd() System V


	Sistemnyj vyzov msgrcv() System V


	Ob座avlyaet lokal'nymi peremennye v spiske.
Esli dva ili bolee imeni ih neobhodimo zaklyuchit' v kruglye skobki.


next
	Analogichen continue v S. Perehod k sleduyushchej iteracii v cikle.
Esli v cikle prisutsvuet blok continue on tak zhe vypolnyaetsya.
Esli metka otsutsvuet - perehod na blizhajshij vnutrennij cikl.


	Isklyuchit' ispol'zovanie ukazannyh modulej.


	Vozvrashchaet desyatichnoe chislo predstavlennoe vos'merichnymi ciframi.


open fajl
	Otkryt' fajl s ukazannym imenem. Argument "fajl" - eto
fakticheski ukazatel' na blok opisaniya fajla. Esli imya (vyrazhenie)
fajla otsutsvuet to imya schitaetsya takim zhe kak i ukazatel' fajla.
Esli pered imenem stoit simvol '<' to fajl otkryvaetsya tol'ko
na chtenie (znachenie po umolchaniyu). Esli '>' - na zapis'.
Esli '>>' - na dobavlenie zapisej. '+>' ili '+<' - fajl otkryt
na chtenie i zapis' odnovremenno.
Esli imya fajla nachinaetsya s simvola '|' to imya schitaetsya sistemnoj
komandoj na vhod kotoroj vyvodyatsya dannye (potok).
Imya '-' - standartnyj vhod (STDIN), '>-' - standartnyj vyvod (STDOUT).
Funkciya vozvrashchaet true pri uspehe i false - neudache.

	Esli imya (vyrazhenie) nachinaetsya s simvolov ">&" to ostatok
imeni schitaetsya imenem ukazatelya fajla kotoryj okryvaetsya povtorno.
Simvol '&' mozhet stoyat' posle '<', '>>', '+>', '+>>' i '+<'.
Rezhim povtornogo otkrytiya dolzhen sootvetsvovat' pervomu.
Vyrazhenie vida "<&=N" gde N -chislo, ekvivalentno sistemnomu vyzovu
fdopen().
Esli imya "|-" ili "-|" to proishodit "rasshcheplenie" (fork) processa
na potomka i roditelya. Pri etom vozvrashchaetsya nomer processa potomka
(PID) vnutri roditel'skogo processa i 0 - vnutri potomka. Pri etom
zapis'/chtenie v fajl roditel'skim processom vosprinimaetsya kak
chtenie/zapis' potomkom. Dlya potomka eto standartnyj vvod/vyvod.
Roditel'skij process zhdet zaversheniya potomka posle zakrytiya potoka
i poluchaet kod zaversheniya v peremennoj $?.
Imya fajla ne dolzhno soderzhat' probelov kak v nachale tak i v konce.



	Otkryt' direktoriyu s imenem vyrazheniya dlya obrabotki
funkciyami readdir(), telldir(), seekdir(), rewinddir() i closedir().
Vozvrashchaet true pri uspehe.


	Vozvrashchaet ascii kod pervogo simvola vyrazheniya.


	Upakovyvaet spisok v dvoichnuyu strukturu po shablonu.
SHablon - eto stroka simvolov opisyvayushchaya poryadok i tip upakovannyh
znachenij.

	A	- tekstovaya stroka, dobavlyaetsya probelami.

	a	- tekstovaya stroka, dobavlyaetsya 0 simvolom.

	b	- bitovaya stroka (vozrastayushchaya numeraciya bit)

	B	- bitovaya stroka (ubyvayushchaya numeraciya bit)

	h	- shestnadcaterichnaya stroka ( mladshij bajt - pervyj)

	H	- shestnadcaterichnaya stroka (starshij bajt pervyj)

	c	- simvol so znakom

	C	- simvol bez znaka.

	s	- korotkoe celoe (odin bajt) so znakom.

	S	- korotkoe celoe bez znaka.

	i	- celoe (dva bajta) so znakom.

	I	- celoe bez znaka.

	l	- dlinnoe celoe (4 bajta) so znakom.

	L	- dlinnoe celoe bez znaka.

	n	- korotkoe v "setevom" formate.

	N	- dlinnoe v "setevom" formate.

	v	- korotkoe v "VAX" formate.

	V	- dlinnoe v "VAX" formate.

	f	- single float.

	F	- double float.

	p	- ukazatel' na stroku ogranichennuyu 0.

	P	- ukazatel' na strukturu s fiksirovannoj dlinoj.

	u	- upakovka uuencode.

	x	- nul'-bajt

	X	- rezervnyj bajt.

	@	- zapolnit' nulyami poziciyu.

Za kazhdoj bukvoj mozhet stoyat' chislo oznachayushchee kolichestvo povtorov.
Dlya vseh tipov za isklyucheniem 'a', 'A', 'b', 'B', 'h' i 'H',
upakovyvaetsya maksimal'no vozmozhnoe kolichestvo znachenij iz spiska.
Simvol '*' posle tipa oznachaet ispol'zovat' ostavshiesya parametry.
Tip 'a' i 'A' ispol'zuet tol'ko odno znachenie iz spiska i dobavlyaet
ostatok polya libo nul'-simvolami libo probelami (pri raspakovke
po tipu 'A' probely i nuli otbrasyvayutsya, a po 'a' - net).
Tipy 'b' i 'B' upakovyvayut stroku v ukazannoe chislo bit.
Tak zhe kak i 'h' i 'H' v chislo niblov (bajt).
'P' - upakovyvaet ukazatel' na strukturu s ukazannoj dlinoj.
CHisla s plavayushchej zapyatoj (floats i double) zapisyvayutsya v
standartnom dlya kazhdoj mashiny formate i mogut byt' raznymi
dlya raznyh tipov mashin. Zamet'te, chto Pel vsegda ispol'zuet
dvojnuyu tochnost' (double) poetomu upakovka i raspakovka po
tipu 'f' privedet k potere tochnosti.
SHablony dlya raspakovki i upakovki sovershenno odinakovy.

Primery:

	print(pack("ccc",65,66,67)); # Rezul'tat ABC

	print(pack("A4A3","ab","cdefg")); # "ab  cde"

	print(pack("a4a3","ab","cdefg")); # "ab\0\0cde"


	Analogichen sistemnomu pipe().


	Udalyaet i vozvrashchaet poslednij element massiva.
Dlina massiva umen'shaetsya na 1. Rezul'tat ne opredelen esli massiv
pustoj. Esli imya massiva otsutsvuet to izvlekaet iz @ARGV
dlya golovnoj programmy i @_ dlya polprogrammy.


	Vozvrashchaet smeshchenie ot poslednego m//g poiska.


print spisok
print
	Vyvodit stroku ili spisok strok v fajl. Vozvrashchaet true
pri uspehe. Argument fajl mozhet byt' skalyarnoj peremennoj soderzhashchej
imya ukazatelya fajla esli on otsutsvuet to osushchestvlyaetsya vyvod
v standartnyj vyhodnoj potok STDOUT (esli ne bylo vyzova select()).
Esli spisok otsutsvuet to vyvoditsya znachenie peremennoj $_.
Dlya vyvoda po umolchaniyu v drugoj fajl neobhodimo ispol'zovat'
funkciyu select().
Tak kak print rabotaet v spiskovom kontekste, to vse elementy spiska
tak zhe vychislyayutsya v spiskovom kontekste t.e. funkcii budut vozvrashchat'
spiskovye znacheniya. Argumenty mozhno zaklyuchat' v kruglye skobki.
Esli ukazatel' fajla - element massiva to element nuzhno zaklyuchit'
v figurnye skobki dlya vychisleniya bloka.


printf spisok
	Analogichen vyzovu "print fajl sprintf(spisok)".
Pervyj element spiska dolzhen byt' formatom printf() kak i v S.


	Dobavit' elementy massiva znacheniyami iz spiska.
Dlina massiva uvelichivaetsya na kolichestvo elementov spiska.


qq/stroka/
qx/stroka/
qw/stroka/
	Obychnye operatory strok. Smotri glavu Operatory.


	Vychislyaet vyrazhenie v kotorom metasimvoly rassmatrivayutsya
kak obychnye simvoly.


rand
	Vozvrashchaet sluchajnoe chislo v diappazone mezhdu 0 i vyrazheniem.
Esli vyrazhenie otsutsvuet - mezhdu 0 i 1. Dannaya psevdosluchajnaya
posledovatel'nost' sbrasyvaetsya funkciej srand().


read fajl, skalyar, dlina
	Prochitat' ukazannoe chislo bajt iz fajla v skalyarnuyu peremennuyu.
Vozvrashchaet kolichestvo prochitanyh bajt ili neopredelennost' pri
oshibke. Dlina skalyara stanet ravnoj kolichestvu schitannyh bajt. Smeshchenie
ukazyvayut esli dannye nuzhno pomestit' ne s samogo nachala stroki.


	Vozvrashchaet imya sleduyushchego fajla v direktorii otkrytoj komandoj
opendir(). V skalyarnom kontekste vozvrashchaet vse ostavshiesya imena
fajlov. Esli fajlov bol'she net to vozvrashchaet neopredelennost' v
skalyarnom kontekste i pustuyu stroku v spiskovom.


	Vozvrashchaet znachenie simvolicheskoj ssylki. Pri oshibke
vozvrashchaet neopredelennoe znachenie.


	Poluchit' soobshchenie iz sokita. Analogichen sistemnomu recvfrom().


redo
	Perejti k nachalu bloka minuya vychislenie usloviya i bloka
continue. Esli metka otsutsvuet to perehod k blizhajshemu vneshnemu
bloku.


	Vozvrashchaet true esli vyrazhenie eto ssylka inache - false.
Vozvrashchaemoe znachenie zavisit ot tipa ssylki. Sushchestvuyut
sleduyushchie tipy ssylok:

	REF, SCALAR, ARRAY, HASH, CODE, GLOB

Esli argument - ssylka na klass to vozvrashchaetsya imya klassa.
Funkciya ref() analogichna funkcii typeof().


	Pereimenovat' fajl. Vozvrashchaet 1 v sluchae uspeha inache 0.


require
	Esli vyrazhenie - chislo, trebuet chto by tekushchaya versiya
Pel byla ne nizhe ukazannoj. Esli stroka - schityvaet bibliotechnyj fajl
s ukazannym imenem esli on eshche ne prochitan.
Poslednij operator bibliotechnogo fajla dolzhen vozvrashchat' true.
Obychno eto stroka vida 1;
Esli rasshirenie imeni fajla otsutsvuet to po umolchaniyu prinimaetsya ".pm"
V dannoj funkcii mozhno ukazyvat' put' raspolozheniya fajla, a esli
biblioteka raspolozhena v standartnoj sistemnoj oblasti Pel to vmesto
require predpochtitel'nej ispol'zovat' use().


reset
	Obychno ispol'zuetsya v blokah continue ciklov dlya
ochistki peremennyh i poiska dlya povtornogo primeneniya.
Vyrazhenie vosprinimaetsya kak spisok simvolov. Dlya ukazaniya
diappazona mozhno primenyat' simvol minus '-'.
Vse peremennye i massiva nachinayushchiesya s etih simvolov
obnulyayutsya. Esli vyrazhenie otsutsvuet to obnulyaestya poisk
?shablon? dlya povtornogo poiska. Sbrasyvayutsya tol'ko
peremennye tekushchego modulya.

Primer:
	reset 'a';	# ochistit' vse peremennye nachinayushchiesya
			# bukvoj 'a'
	reset 'a-z'	# vse peremennye s malyh bukv.

Vyrazhenie vida: 'A-Z' upotreblyat' ne rekomenduestya t.k.
obnulyayutsya vazhnye massivy @ARGV i @ENV.


	Vyhod iz podprogrammy s ukazannym kodom. Esli dannaya
funkciya otsutsvuet to vyhod iz podprogrammy osushchestvlyaetsya s
kodom poslednego vypolnennogo operatora.


	V spiskovom kontekste vozvrashchaet spisok s elementami
v obratnom poryadke ukazannomu spisku. V skalyarnom kontekste
vozvrashchaet stroku sperestavlennymi simvolami pervogo elementa
spiska.


	Ustanavlivaet ukazatel' fajlov otkrytoj direktorii
v nachalo dlya posleduyushchego chteniya funkciej readdir().


rindex stroka, podstroka
	Podobna funkcii index , no vozvrashchaet poziciyu poslednego
vhozhdeniya podstroki v stroku. Esli ukazana poziciya, to prosmotr
vypolnyaetsya do nee.


	Udalit' ukazannuyu direktoriyu esli v nej net nikakih fajlov.
Vozvrashchaet 1 pri uspehe i 0 pri ne udache. Pri etom peremennaya $!
soderzhit kod (errno).




	Vychislyaet vyrazhenie v skalyarnom kontekste i vozvrashchaet
rezul'tat. V Pel net special'noj funkcii dlya prinuditel'nogo
vychisleniya v spiskovom kontekste t.k. dlya dostatochno zaklyuchit'
ego v kruglye skobki.


	Ustanovit' ukazatel' na proizvol'nuyu poziciyu v fajle.
Esli otschet raven 0 - pozicionirovat' ot nachala fajla, esli  1 - ot
tekushchego polozheniya, 2 - ot konca fajla. Vozvrashchaet 1 pri uspehe
i 0 - neudache.


	Ustanovit' ukazatel' fajla v otkrytoj direktorii dlya
posleduyushchego chteniya funkciej readdir(). Tekushchaya poziciya
mozhet byt' poluchena funkciej telldir().


select
	Vozvrashchaet tekushchij ukazatel' fajla- po umolchaniyu
ili delaet tekushchim ukazannyj. Takim obrazom esli v funkciyah
print ili write ne ukazan fajl vyvoda to eto osushchestvlyaetsya
v fajl ukazannyj select. Peremennye svyazannye s vyvodom tak zhe
dejstvuyut na vyvod v etot fajl.

select RBITS, WBITS, EBITS, TIMEOUT
	Vypolnyaet sistemnyj select()


	Sistemnyj vyzov semctl() dlya SYSTEM V.


	Sistemnyj vyzov semget() dlya SYSTEM V.


	Sistemnyj vyzov semop() dlya SYSTEM V.


send SOCKET, MSG, FLAGS
	Poslat' soobshchenie cherez sokit. Analogichno sistemnomu send().


	Ustanovit' nomer gruppy PGRP processu s nomerom PID
	0 = dlya tekushchego processa.


	Ustanovit' prioritet PRIORITY processu pol'zovatelya WHO
i gruppe WHICH.


	Ustanovit' parametry sokita. Vozzvrashchaet neopredelennost'
pri oshibke.


shift
	Udalyaet pervyj element massiva i vozvrashchaet ego znachenie.
Esli massiv pustoj to rezul'tat neopredelennost'. Esli argument
opushchen - obrabatyvaetsya massiv @ARGV v golovnoj programme
ili @_ v podprogramme.


	Sistemnyj vyzov shmctl() System V


	Sistemnyj vyzov shmget() System V

shmread ID, VAR, POS, SIZE
shmread ID, STRING, POS, SIZE
	Pishet ili chitaet segment obshchedostupnoj pamyati v System V.


	Prekrashchaet rabotu sokita metodom HOW.


	Vozvrashchaet v radianah sinus vyrazheniya.


sleep
	Priostanavlivaet rabotu processa na ukazannoe chislo sekund
ili zaciklivaetsya esli argument otsutsvuet. Rabota prodolzhaetsya esli
poluchen signal SIGALARM. Vozvrashchaet vremya fakticheskoj pauzy.


	Otkryvaet sokit i privyazyvaet ego k ukazatelyu SOCKET.


	Sozdaet "bezymyannuyu" paru sokitov v ukazanom DOMAIN.
Vozvrashchaet true pri uspehe i false - neudache.


sort blok spisok
sort spisok
          Sortiruet  elementy  spiska  i  vozvrashchaet poluchennyj
spisok.  Ne sushchestvuyushchie elementy spiska otbrasyvayutsya. Esli ne
ukazano  imya  podprogrammy  ili blok to sortiruet v standartnom
strokovom poryadke.
     Ukazannaya  podprogramma vozvrashchaet znacheniya bol'she, men'she
ili ravnoe  nulyu  v  zavisimosti  ot  dvuh  sosednih  elementov
spiska.  Imya podprogrammy mozhet byt' ukazano peremennoj. Ona ne
dolzhna byt' rekursivnoj  i  dva  sravnivaemyh  elementa  spiska
peredayutsya  kak  global'nye peremennye $main::a i $main::b. |to
ssylki  poetomu  ih  izmenenie  privodit  k   izmeneniyu   samih
elementov spiska.


splice massiv, smeshchenie, dlina
splice massiv, smeshchenie
	Udalyaet elementy massiva nachinaya so smeshcheniya i ukazannoj dliny.
Zamenyaet ih ukazannym spiskom. Vozvrashchaet udalennyj spisok.
Esli dlina ne ukazana udalyaet vse elementy spiska nachinaya so smeshcheniya.


split /shablon/, vyrazhenie
split /shablon/
split
	Razdelyaet stroku,ukazannuyu vyrazheniem, na massiv elementov i vozvrashchaet ego.
V skalyarnom kontekste vozvrashchaet kolichestvo poluchennyh elementov massiva,
a sam massiv pomeshchaet v @_ (v spiskovom kontekste pomestit' rezul'tat
v @_ mozhno esli primenit' ?shablon?)
Esli vyrazhenie otsutsvuet to obrabatyvaetsya soderzhimoe peremennoj $_.
Esli shablon otsutsvuet to razdelitelem yavlyaetsya probel.
Vse chto podhodit po shablonu schitaetsya razdelitelem. Esli ukazan predel
to eto maksimal'noe chislo razdelenij. Otricatel'noe znachenie predela
vosprinimaetsya kak neogranichenno bol'shoj predel.
Esli pustaya stroka pohodit pod shablon razdelitelya to ishodnoe znachenie
razdelyaetsya po simvol'no.
Predel udobno ispol'zovat' dlya chastichnogo razdeleniya stroki.

Primer:
	($a, $b, $ostatok) = split(/ /, "Odin Dva Tri CHetyre",3);

zdes' $a = 'Odin', $b = 'Dva' i $ostatok = 'Tri CHetyre'

Esli shablon soderzhit kruglye skobki to simvoly-razdeliteli ukazannye
v nih vstavlyayutsya v rezul'tiruyushchij spisok kak obychnye elementy,
prichem vstavlyaetsya simvol kotoryj sovpal s razdelitelem.

Primer:

        @a = split(/([,.])/, "Odin,Dva.Tri");

zdes' @a = ("Odin", "," ,"Dva", ".", "Tri")


	Formatiruet spisok po ukazannomu formatu analogichno
funkcii sprintf() yazyka S.


	Vozvrashchaet koren' kvadratnyj vyrazheniya.


	Zadaet nachal'noe znachenie dlya generatora sluchajnyh chisel
operatora rand. Esli argument otsutsvuet to ispol'zuetsya tekushchee
mashinnoe vremya.


stat vyrazhenie
	Vozvrashchaet 13 elementnyj massiv parametrov ukazannogo fajla
ili pustoj spisok pri oshibke. Primenyaetsya obychno sleduyushchim obrazom:

($dev,$ino,$mode,$nlink,$uid,$gid,$rdev,$size,$atime,$mtime,$ctime,
$blksize,$blocks) = stat($filename);

gde
	$dev	- imya ustrojstva
	$ino	- nomer i-uzla
	$mode	- prava dostupa
	$nlink	- kolichestvo svyazej
	$uid	- identifikator vladel'ca
	$gid	- identifikator gruppy
	$rdev	- tip ustrojstva
	$size	- razmer fajla v bajtah
	$atime	- data poslednego obrashcheniya
	$mtime	- data poslednej modifikacii
	$ctime	- data poslednego izmeneniya statusa
	$blksize - razmer bloka na diske
	$blocks	- kolichestvo blokov v fajle.

Esli ukazan argument '_' to vozvrashchaetsya rezul'tata predydushchego
vyzova stat().


study
	Vlyuchenie metoda chastotnogo sravneniya. Celesoobraznost'
primeneniya zavisit ot kolichestva poiskov i kolichestva konstant v
stroke v kotoroj vedetsya poisk.
Funkciya rabotaet sleduyushchim obrazom:
Dlya ukazannogo skalyara (esli argument otsutsvuet beretsya znachenie
peremennoj $_) stroitsya spisok ukazatelej na kazhdyj simvol stroki.
Zatem kogda nachinaetsya poisk pervymi prosmatrivayutsya simvoly kotorye
naibolee redko vstrechayutsya v anglijskom yazyke.
Vyigrysh po vremeni ocheviden kogda vypolnyaetsya mnogokratnyj poisk
v odnoj i toj zhe stroke i vremya zatrachennoj na indeksaciyu okupaetsya.


substr vyrazhenie, smeshchenie
	Vozvrashchaet podstroku vyrazheniya nachinaya so smeshcheniya i zadannoj
dliny. Esli smeshchenie otricatel'noe to otschet vedetsya ot konca stroki.
Esli dlina ne ukazana to beretsya vse do konca stroki.


	Sozdaet novyj fajl simvolicheski svyazannyj so starym t.e.
sozdaet ssylku na fajl. Vozvrashchaet 1 pri uspehe i 0 - neudache.


	Vypolnyaet sistemnuyu funkciyu. Pervyj element spiska - eto
imya funkcii a ostal'nye elementy - ee argumenty.
Esli funkciya ne vypolnima to vozvrashchaetsya fatal'naya oshibka.
Argumenty interpretiruyutsya sleduyushchim obrazom.
Esli argument chislo, to ono schitaestya celym. Esli ne chislo to argument
schitaetsya ukazatelem na stroku. Vam neobhodimo obespechit' dostatochnuyu
dlinu argumenta dlya podstanovki znacheniya ukazatelya. V Pel peredaetsya
maksimum 14 parametrov. Obychno etogo dostatochno.


sysread fajl, skalyar, dlina
	Prochitat' iz fajla ukazannoe chislo bajt v skalyar s pomoshch'yu
sistemnogo vyzova read(). Smeshchenie oboznachaet poziciyu v skalyare
posle kotoroj budut vstavleny prochitannye bajty.


	Delaet to zhe samoe chto i "exec spisok" s toj lish' raznicej
chto vyzov fork() delaetsya pervym i roditel'skij process zhdet
zaversheniya potomka. Vozvrashchaet znachenie analogichnoe funkcii wait().
Dlya polucheniya dejstvitel'nogo koda zaversheniya neobhodimo razdelit'
na 256.


syswrite fajl, skalyar, dlina
	Zapisat' v fajl ukzannoe chislo bajt skalyara s pomoshch'yu
sistemnogo vyzova write(). Smeshchenie ukazyvaet poziciyu v skalyare
otkuda nachinaetsya zapis'.


tell
	Vozvrashchaet tekushchuyu poziciyu ukazatelya v otkrytom fajle.
Esli fajl ne ukazan to poslednego chitaemogo fajla.


	Vozvrashchaet tekushchuyu poziciyu ukazatelya v otkrytoj direktorii.
Obychno eto parametr dlya pozicionirovaniya ukazatelya direktorii
funkciej seekdir().


	Prisvaivaet peremennuyu klassu. Spisok - eto argumenty
new metoda klassa (TIESCALAR, TIEARRAY ili TIEHASH).
Vozvrashchaet ukazatel' na sozdannyj novyj ob容kt klassa kotoryj
udoben dlya vyzova drugih metodov klassa.
Vnimanie! Takie funkcii kak keys() i values() mogut vernut'
v kacheste znacheniya ogromnoe kolichestvo dannyh.

Dlya sozdaniya ob容kta associativnogo tipa neobhodimo opredelenie
sleduyushchih metodov:

	TIEHASH classname, LIST
	DESTROY this
	FETCH this, key
	STORE this, key, value
	DELETE this, key
	EXISTS this, key
	FIRSTKEY this
	NEXTKEY this, lastkey

Obychnogo massiva:

	TIEHASH classname, LIST
	DESTROY this
	FETCH this, key
	STORE this, key, value
	[others TBD]

Skalyarnogo tipa:

	TIEHASH classname, LIST
	DESTROY this
	FETCH this, key
	STORE this, key, value


	Vozvrashchaet kolichistvo sekund nachinaya s 1 yanvarya 1970 g
00:00:00 UTC. Gody ne razdelyayutsya na visokosnye.


	Vozvrashchaet 4-h elementnyj massiv znachenij:

	($user, $system, $cuser, $csystem) = times;

gde:

	$user	-  pol'zovatel'skoe vremya processa v sekundah.

	$system	- sistemnoe vremya tekushchego processa.

	$cuser	- vremya processa-potomka tekushchego prcessa.

	$csystem - ego sistemnoe vremya.

tr///
	Oprerator translyator. Podrobno smotri glavu "Operatory".

truncate fajl, dlina
truncate vyrazhenie, dlina
	Usekaet dlinu ukazannogo fajla.


	Vozvrashchaet stroku vyrazheniya v kotoroj malye bukvy zameneny
na zaglavnye.


	Vozvrashchaet stroku vyrazheniya v kotoroj pervaya bukva zamenena
na zaglavnuyu.


umask
	Ustanavlivaet masku umask i vozvrashchaet staroe znachenie.
Bez argumenta vozvrashchaet tekushchee znachenie.


undef
	Delaet neopredelennym znachenie vyrazheniya. Primenyaetsya
tol'ko dlya skalyarnyh peremennyh, celyh massivov ili podprogramm.
Vsegda vozvrashchaet neopredelennoe znachenie.


	Udalyaet fajly ukazannye v spiske. Vozvrashchaet kolichestvo
udalennyh fajlov. Tol'ko supervizor mozhet udalyat' direktorii
s fajlami esli Pel zapushchen s klyuchom -U.


	Funkciya obratnaya pack(). Raspakovyvaet stroku vyrazheniya
po ukazannomu shablonu v massiv znachenij. V skalyarnom kontekste
vozvrashchaet znachenie tol'ko pervogo elementa. SHablony takie zhe
kak i v pack().
Simvol '%' v shablone oznachaet chto vy hotite poluchit' vmesto
znacheniya ego kontrol'nuyu summu. Po umolchaniyu 16 bitovuyu.


	Isklyuchaet peremennuyu iz klassa ukazannogo tie().


	Protivopolozhnoe shift. Pomeshchaet elementy spiska
v nachalo massiva.


use modul'
	Ukazyvaet bibliotechnyj modul' iz kotorogo mozhno
vyzyvat' podprogrammy. Spisok perechislyaet imena podprogramm kotorye
dobavlyayutsya k tekushchej oblast' imen. Esli ne ukazan to vse imena.
Dejstvie analogichno bloku:

	BEGIN { require modul'; import modul' spisok; }

Sam modul' dolzhen raspologat'sya v sistemnoj oblasti Pel fajlov.


	Izmenyaet datu obrashcheniya i modifikacii fajlov iz spiska.
Pervye dva elementa spiska dolzhny ukazyvat' novoe znachenie daty
obrashcheniya i modifikacii.
Vozvrashchaet kolichestvo izmenennyh fajlov.


	Vozvrashchaet obychnyj massiv so vsemi znacheniyami hesha.
V skalyarnom kontekste vozvrashchaet kolichestvo znachenij hesha.


	Vozvrashchaet znacheni stroki kak vektor bez znakovyh celyh.


	Ozhidat' okonchanie porozhdennogo processa. Vozvrashchaet
PID dlya roditel'skogo processa ili -1 esli net processa potomka.
Kod zaversheniya zapisyvaetsya v peremennuyu $?.


	Ozhidat' okonchaniya processa potomka s ukazannym PID.
Vozvrashchaet libo PID etogo processa libo -1 esli net takogo processa.
Kod zaversheniya zapisyvaetsya v permennuyu $?.


	Vozvrashchaet true esli podprogramma vyzyvaetsya v spiskovom
kontekste i false - v skalyarnom.


	Vyodit v standartnyj potok oshibok STDERR soobshchenie
analogichno die(), no ne prekrashchaet rabotu programmy.


write vyrazhenie
write
	Vyvodit v fajl formatirovannye dannye po operatoru
format. Po umolchaniyu imya formata sovpadaet s imenem ukazatelya fajla.
Imya fajla-po umolchaniyu mozhno izmenit' funkciej select(), a imya
formata pri etom nado prisvoit' peremennoj $~.
Zagolovok lista pishetsya avtomaticheski. Esli na liste ne hvataet
mesta dlya vyvoda to vyvoditsya "perevod formata" i special'naya
forma zagolovka lista zatem sami zapisi.
Po umolchaniyu imya formata zagolovka lista sostoit iz imeni ukazatelya
fajla i dobavlennoj stroki "_TOP". Dinamicheski eto mlzhno delat'
prisvaivaya format peremennoj $^. Kolichestvo ostavshihsya strok lista
soderzhitsya v peremennoj $- i esli prisvoit' ej 0 to proizojdet
smena lista. Podrobno opisanie formatov smotri v glave "Formaty".


	Operator translyator. Smotri glavu "Operatory".



Dlya primeneniya podprogrammy ee neobhodimo opredelit' libo v tekshchem module
(fajle) libo vo vneshnem module (fajle).
Podprogrammy opredelyayutsya i deklariruyutsya sleduyushchim obrazom:

	sub imya;	# Tol'ko deklaraciya. Opredelenie nizhe.

	sub imya (prototipy);  To zhe no s deklaraciej parametrov.

	sub imya blok;	# Deklaraciya i opredelenie.

	sub imya (prototipy) blok; # To zhe, no s parammetrami.

Dlya opredeleniya dinamichskoj anonimnoj podprogrammy mozhno ukazat':

	$peremennaya = sub blok;

Dlya importirovaniya podprogramm iz drugih modulej ispol'zujte:

	use modul' qw(podprogramma1 podprogramma2 );

Vyzov podprogrammy:

	imya(spisok parametrov);	# simvol '&' mozhno ne ukazyvat'.

	imya spisok;	# Esli podprogrmma uzhe deklarirovana.

	&imya;		# Parametry v @_

Vse parametry peredayutsya podprogramme kak massiv @_.
Sootvetsvenno $_[0] - pervyj parametr, $_[1] - vtoroj i t.d.
Massiv @_ - lokal'nyj, no on soderzhit adresa parametrov poetomu
mozhno izmenyat' znachenie parametrov.
Vozvrashchaemoe znachenie podprogrammy - rezul'tat poslednego operatora.
|to mozhet byt' kak skalyar tak i massiv. Mozhno prinuditel'no vozvrashchat'
rezul'tat ispol'zuya funkciyu return().

Podprogrammu mozhno vyzvat' ispol'zuya prefiks '&' pered imenem
podprogrammy. Esli podprogramma predvaritel'no prodeklarirovana to
prefiks i skobki mozhno opustit'.



Dlya primeneniya peremennyh dostupnyh tol'ko vnutri bloka ili podprogrammy
neobhodimo opredelit' ih s pomoshch'yu funkcii my(spisok).

Esli peremennaya odna to skobki mozhno opustit'.

my() deklariruet private peremennye v predelah tekushchej podprogrammy,
bloka, funkcii eval() ili do/require/use fajlov. Private peremennye
analogichny auto peremennym v S.

Primer:

	# Programma vychisleniya faktoriala.

	print fact(3);  # vychislit' faktorial 3*2*1

	sub fact	# Opredelyaem podprogrammu.
	{ my $m;                # private peremennaya no ne local !
	$m = $_[0];
	return 1 if $m <= 1;
	return($m * fact($m -1));
	}

Mozhno ukazyvat' nachal'nye znacheniya private peremennyh kak:

	my(spisok) = vyrazhenie;

Tak dlya vysheprivedennogo primera luchshe bylo napisat':

	my($m) = $_[0];


Peremennye tipa local.

V obshchem luchshe ispol'zovat' private peremennye tak-kak eto nadezhnej i
bystree. private peremennye obespechivayut leksicheskuyu oblast' primeneniya
(vidimosti) a local - dinamicheskuyu. Obychno eto peremennye formatov
znachenie kotoryh dolzhno byt' vidimo iz vyzyvaemyh podprogramm.
Primenenie funkcii local() ne celesoobrazno v ciklah tak kak
ona vyzyvaetsya kazhdyj raz i takim obrazom zametno zamedlyaet vremya
vypolneniya cikla.




Dlya kratkogo opisanya tipa parametrov peredavaemyh podprogramme
mozhno primenyat' prototipy. V Pel sushchestvuyut sleduyushchie prototipy:

	Deklaraciya		Primer vyzova

	sub mylink($$)		mylink $old, $new
	sub myvec($$$)		myvec $var, $offset, 1
	sub myindex($$;$)	myindex &getstring, "substr"
	sub myreverse(@)	myreverse $a, $b, $c
	sub myjoin($@)		myjoin ":",$a,$b,$c
	sub mypop(\@)		mypop @array
	sub mysplice(\@$$@)	mysplice @array, @array, 0, @pushme
	sub mykeys(\%)		mykeys %{$hashref}
	sub myopen(*;$)		myopen HANDLE, $name
	sub mypipe(**)		mypipe READHANDLE, WRITEHANDLE
	sub mygrep(&@)		mygrep { /foo/ } $a, $b, $c
	sub myrand($)		myrand 42
	sub mytime()		mytime

Zdes':
	\'simvol'	- parametr s tipom 'simvol'

	'@' ili '%'	- vse ostavshiesya parametry kak spisok

	'$'		- skalyar

	'&'		- bezimyannaya podprogramma

	'*'		- ssylka na tablicu imen

	';'		- razgranichitel' obyazatel'nyh i ne obyazatel'nyh paramettrov.




Inogda nuzhno v kachestve parametra peredat' podprogramme ne znachenie
elementa massiva a ssylku na nego, chto by podprogramma mogla izmenit'
znachenie elementa. Dlya etogo v Pel k imeni peremennoj dobavlyaetsya
simvol '*' Podbnoe vyrazhenie nazyvayut 'type glob' tak kak v YUnikse
simvolom '*' oboznachayut "vse vozmozhnye znacheniya". Poetomu '*' dlya
massiva oznachaet "vse elementy massiva".
Dlya skalyarov upotryablyat' '*' ne imeet smysla t.k. oni i tak peredayutsya
ssylkoj i vy mozhete izmenyat' znachenie parametra izmenyaya naprimer
peremennuyu $_[0].




Bol'shinstvo vstroennyh funkcij Pel mozhno pereopredelit' svoimi
sobstvennymi. Obychno eto delayut dlya udobstva sovmestimosti Pel dlya
raznyh platform sistem.

Dlya etogo nuzhno perechislit' imena etih funkcij v vide:

	use subs 'funkciya1', 'funkciya2' ....;

i dalee v module opredelit' sami funkcii.




Esli vy popytaetes' vyzvat' ne sushchestvuyushchuyu funkciyu to Pel vydast
nemedlenno soobshchenie ob oshibke. No esli vy opredelite podprogrammu
s imenem 'AUTOLOAD' to ona budet vyzvana s temi zhe parametrami
a peremennaya $AUTOLOAD budet soderzhat' imya ne sushchestvuyushchej
podprogrammy. Dannyj mehanizm ochen' udoben dlya sredstv otladki.



     V  Pel  realizovan  mehanizm  modulej.  Modul'  eto gruppa
podprogramm i peremennyh obychno vklyuchennyh v odin fajl.  Vnutri
odnogo  modulya  mozhno  opredelit'  drugoj modul'. Nachalo modulya
opredelyaetsya direktivoj:

	packages imya_modulya;

     Konec  modulya  eto  konec bloka ili fajla. Golovnoj modul'
imeet po  umolchaniyu  imya  main.  Na  imya  vnutri  modulya  mozhno
ssylat'sya dobavlyaya '::' posle imeni modulya.
 Naprimer:

	$main::var1	- peremennaya v golovnom module.

	::var1		- to zhe samoe. Imya main mozhno opuskat'.

	$modul'1::var1	- peremennaya v module 'modul'1'

	$modul'1::modul'2::var1 - Modul'2 soderzhitsya v module 1.

Tol'ko identifikatory nachinayushchiesya s bukvy ili simvola '_' hranyatsya
v prostrantsve imen tekushchego modulya. Ostal'nye hranyatsya v prostranstve
golovnogo modulya main.
Krome etogo imena STDIN, STDOUT, STDERR, ARGV, ARGVOUT, ENV, INC i SIG
tak zhe hranyatsya v golovnom module.



Vse imena modulya hranyatsya v associativnom massive (heshe) s imenem
modulya k kotoromu dobavleny simvoly "::". Takim obrazom imena
golovnogo modulya hranyatsya v %main:: , modulya 'mod1' v %mod1::
i t.d. Vyrazhenie vida *imya ukazyvaet znachenie elementa hesha 'imya'
eto udobno dlya opredeleniya konstant.

Naprimer:
	*pi = \3.14159;

Zdes' peremennaya $pi - eto konstanta pi kotoruyu uzhe nel'zya izmenit'.



Konstruktor - eto podprogramma kotoraya vypolnyaetsya v moment sozdaniya
ob容kta, a destruktor - udaleniya ob容kta. Dlya modulya eto podprogrammy
s imenami BEGIN i END. Pri opredelenii etih podprogramm slovo
sub mozhno opuskat'.

Konstruktor BEGIN vypolnyaetsya srazu kak tol'ko vozmozhno t.e. kak tol'ko
on opredelen dazhe ne zavershaya dal'nejshij razbor programmy. Mozhno ukazat'
neskol'ko blokov BEGIN. Oni budut vypolnyat'sya odin za drugim v poryadke
opredeleniya.

Destruktor END vypolnyaetsya poslednim kak tol'ko vozmozhno t.e. pri
zavershenii raboty interpreratora. Mozhno ukazat' nesol'ko blokov END
pri etom oni budut vypolnyat'sya v obratnom opredeleniyu poryadke.




V Pel net special'nogo sintaksisa dlya klassov. No funkcional'no
polnocennymi klassami mogut byt' moduli. Pri etom podprogrammy modulya
stanovyatsya metodami, a s pomoshch'yu massiva @ISA mozhno realizovat'
mehanizm nasledovaniya v klassah. Bolee podrobno klassy opisany otdel'no.



Esli vy hotoite sozdat' modul' otdel'nym fajlom i ispol'zovat'
kak biblioteku podprogramm, pri etom vyzyvat' podprogrammy biblioteki
ne ukazyvaya imeni modulya, vam neobhodimo oformit' modul' sleduyushchim
obrazom:

	package imya_modulya;	# Takoe zhe kak i imya etogo fajla bez rasshireniya '.pm'
	require Exporter;	# Obyazatel'naya stroka dlya eksporta imen
	@ISA = qw(Exporter);	# -//-
	@EXPORT = qw(func1 func2) # Perechislyaem imena funkcij. Vnimanie ! net zapyatoj!
	@EXPORT_OK = qw( $peremennaya @massiv ); # Ukazat' publichnye peremennye, massivy i t.d. esli neobhodimo
	{  # Nachalo bloka modulya
	.....
	sub func1
	........
	sub func2
	........
	1;
	}

Dannyj fajl s rasshireniem ".pm" dolzhen hranit'sya v odnoj iz bibliotechnyh
direktorij Pel. Oni perechisleny v massive @INC odno iz nih obychno
"/usr/local/lib/perl/".

V golovnoj programme vy ukazyvaete:

	use imya_modulya;

i vam stanovyatsya dostupny imena podprogramm dannogo modulya.




Standartnyj nabor bibliotek obychno postavlyaetsya s distributivom Pel
oni razdelyayutsya na pragma biblioteki (rabotayut kak direktivy kompilyatoru)
i standartnye biblioteki.

Pragma bibliototeki.

Dannye biblioteki ispol'zuyut kak:

	use imya;

kogda hotyat vklyuchit' dejstvie i

	no imya;

kogda vyklyuchit'.



diagnostics
	Vklyuchit' rezhim rasshirennoj diagnostiki.

integer
	Ispol'zovat' celochislennuyu arifmetiku.

less
	Rezhim minimal'noj zagruzki kompilyatora.


overload
	Rezhim pereopredeleniya operatorov.

sigtrap
	Rezhim slezheniya za preryvaniyami.

strict
	Rezhim ogranichennogo ispol'zovaniya "opasnyh" operatorov.

subs
	Rezhim obyazatel'nogo deklarirovaniya podprogramm.


Standartnye biblioteki.

AnyDBM_File
	Vozmozhnost' raboty s raznymi tipami baz dannyh.

AutoLoader
	Zagruzka v pamyat' funkcij tol'ko vo vremya vyzova.

AutoSplit
	Razdelit' modul' dlya avtozagruzki.

Benchmark
	Analiz skorosti ispolneniya programmy.

Carp
	Preduprezhdeniya ob oshibkah.

Config
	Dostup k konfiguracii Pel.

Cwd
	Poluchit' imya tekushchej rabochej direktorii.

DB_File
	Rabota s bazoj dannyh formata Berkley DB.

Devel::SelfStubber
	Rezhim otladki avtozagruzki.

DynaLoader
	Dinamicheskaya zagruzka bibliotek C.

English
	Ispol'zovat' dlinnye imena vstroennyh peremennyh.

Env
	Importirovat' imena peremennyh okruzheniya

Exporter
	Obespechivaet eksport/import dlya modulej.

ExtUtils::LibList
	Opredelyaet ispol'zuemye biblioteki.

ExtUtils::MakeMaker
	Sozdaet fajl proekta Makefile

ExtUtils::Manifest
	Programmy dlya sozdaniya i proverki fajla MANIFEST

ExtUtils::Mkbootstrap
	Primeneie fajla nachal'noj zagruzki dlya DynaLoader.

Fcntl
	Opredeleniya kak i v S Fcntl.h

File::Basename
	Sintaksicheskij razbor specifikacii fajla.

File::CheckTree
	Bystryj prohod po direktoriyam diska.

File::Find
	Bystryj poisk fajlov po direktoriyam.

FileHandle
	Obespechivaet ob容ktnyj metod dostupa k ukazatelyam fajlov.

File::Path
	Sozdanie/udalenie direktorij.

Getopt::Long
	Rasshirennaya obrabotka opcij.

Getopt::Std
	Standartnaya obrabotka opcij.

I18N::Collate
	Sravnenie simvolov lokalbnoj kodirovki.

IPC::Open2
	Mezhprocessornyj obmen po chteniyu i zapisi.

IPC::Open3
	Mezhprocessornyj obmen po chteniyu, zapisi, i obraboki oshibok.

Net::Ping
	Test dostupa k hostu.

POSIX
	Standartnyj interfejs po IEEE Std 1003.1

SelfLoader
	Zagruzka funkcij tol'ko po vyzovu.

Socket
	Opredelenie struktur i konstant kak i v S socket.h

Test::Harness
	Standartnyj test s statistikoj.

Text::Abbrev
	Sozdanie tablicy sokrashchenij po spisku.

Podrobnoe opisanie kazhdoj biblioteki zapisano v samom fajle.




     Programisty   vsego   mira   rabotayushchie   s   Pel  sozdali
obshchedostupnuyu  biblioteku  modulej  CPAN.  Ona  dostupna  cherez
Internet i soderzhit ogromnoe kolichestvo razlichnyh po naznacheniyu
modulej.
     K   nim   otnosyatsya  dokumentatory,  sistemnye  interfesy,
interfejsy raboty s bazami dannyh, rabota v  seti,  s  fajlami,
Internet-brouzery,  sistemy  poiska,  ogromnoe  kolichestvo  CGI
skriptov dlya  Web  serverov  i  mnogoe  mnogoe  drugoe.  Spisok
nekotoryh CPAN serverov vy mozhete najti v prilozhenii.



     V  Pel  realizovan  udobnyj metod sozdaniya formatirovannyh
otchetov.  S pomoshch'yu operatora format vy  opisyvaete  zagolovki,
razmery  polej,  ukazyvaete polozhenie dannyh na liste v udobnoj
tekstovoj forme. Zatem vypolnyaete komandu  write(fajl)  kotoraya
vyvodit otformatirovannye dannye v ukazannyj fajl.

Operator format imeet sleduyushchij sintaksis:

	format imya =
	FORMLIST
	.

Obratite vnimanie na to chto opisanie formata idet posle stroki format i zakanchivaetsya
simvolom '.' v nachale stroki.

Zdes' 'imya' - eto imya formata, takoe zhe kak i imya ukazatelya vyhodnogo fajla.
Esli 'imya' otsutsvuet to znachenie po umolchaniyu - STDOUT.

FORMLIST - eto stroki formata. Oni byvayut treh tipov:

	1. Kommentarij. Stroka nachinaetsya simvolom '#'.

	2. Opisatel' polej dannyh (picture).

	3. Stroka argumentov ispol'zuemyh opisatelem.

Opisatel' - eto stroka kotoraya vyvoditsya v vide "kak est'" za isklyucheniem
special'no oboznachennyh formatov polej dannyh. Kazhdoe pole nachinaetsya
libo simvolom '@' libo '^'.
V opisatel'noj stroke ukazyvaetsya tol'ko polozhenie i vid
vyvodimyh dannyh, no ne imena polej i peremennyh.
Dlya etogo prednaznachena sleduyushchaya stroka argumentov kotoraya sleduet vsegda
posle opisatelya i soderzhit imena peremennyh ili celye vyrazheniya
v poryadke ukazannom opisatelem.

Razmer i vid polya v opisatele oboznachaetsya sleduyushchimi simvolami:

	">>>>"	- vyrovnit' znachenie po pravomu krayu.

	"<<<<"	- -//- po levomu.

	"||||"	- -//- po centru.

	"####.###"	- format chisla s tochkoj.

	"@*"	- mnogostrochnaya stroka. Dannye vyvodyatsya v kolonku.

Razmer polya raven kolichestvu ukazannyh simvolov.

Simvol '^' v nachale polya imeet special'noe znachenie.

Tak:
	"^####"	- pusto esli peremennaya ne opredelena.

dlya strochnogo skalyara:

	"^<<<<<" - Vyvoditsya skol'ko vozmozhno simvolov, a znachenie
peremennoj menyaetsya na ostatok vyvod kotorogo mozhno prodolzhit' na
sleduyushchih strokah kotorye mogut imet' svoi polya.

Primer:

#!/usr/local/bin/perl
#
#	Programma pechati priglasitel'nogo bileta
#
$komu = "CHapaevu Vasiliyu Ivanovichu";

$ot_kogo = "Kompaniya MMM";

$adres = "Moskva, ul. Petrovka, d 38";

$tekst = "Uvazhaemyj Vasilij Ivanovich! Kompaniya MMM imeet chest' priglasit'
Vas i Vashih blizkih na prezentaciyu nashih novyh hromovyh sapog, sdelannyh
na urovne mirovyh standartov kachestva i dizajna.";

format STDOUT =

	P R I G L A S I T E L X N Y J      B I L E T
----------------------------------------------------------------------
Komu: @<<<<<<<<<<<<<<<<<<<<<<<<<<  | ^|||||||||||||||||||||||||||||||
      $komu,				$tekst
                                   | ^|||||||||||||||||||||||||||||||
      					$tekst
Ot kogo: @<<<<<<<<<<<<<<<<<<<<<<<  | ^|||||||||||||||||||||||||||||||
      $ot_kogo,				$tekst
                                   | ^|||||||||||||||||||||||||||||||
      					$tekst
Adres:@<<<<<<<<<<<<<<<<<<<<<<<<<<  | ^|||||||||||||||||||||||||||||||
      $adres,				$tekst
                                   | ^|||||||||||||||||||||||||||||||
      					$tekst
                                   | ^|||||||||||||||||||||||||||||||
      					$tekst
                                   | ^|||||||||||||||||||||||||||||||
      					$tekst
----------------------------------------------------------------------
Otpechatano v tipografii ITU 38
.

write();	# Vyvod dannyh.
exit 0;		# Konec programmy


Rezul'tat:


	P R I G L A S I T E L X N Y J      B I L E T
----------------------------------------------------------------------
Komu: CHapaevu Vasiliyu Ivanovichu    |   Uvazhaemyj Vasilij Ivanovich!
                                   |     Kompaniya MMM imeet chest'
Ot kogo: Kompaniya MMM              |  priglasit' Vas i Vashih blizkih
                                   |    na prezentaciyu nashih novyh
Adres:Moskva, ul. Petrovka, d 38   |   hromovyh sapog, sdelannyh na
                                   |    urovne mirovyh standartov
                                   |       kachestva i dizajna.
                                   |
----------------------------------------------------------------------
Otpechatano v tipografii ITU 38

Special'nye peremennye:

	$~	- postrochnyj format soderzhimogo.

	$^	- format zagolovka lista.

	$%	- nomer lista.

	$=	- strok v liste.

Esli vy hotite ispol'zovat' odni i te zhe formaty dlya raznyh fajlov
to samyj prostoj put':

	use FileHandle;	# Ukazat' v nachale programmy

	format_name fajl imya_formata; # Format soderzhimogo lista.

	format_top_name fajl imya_formata; # Format zagolovka lista.

	write(fajl);	# vyvod dannyh.


Zdes' 'fajl' imeetsya vvidu ukazatel' fajla poluchennyj komandoj open();

Esli vam nuzhno v tele lista vyvodit' raznogo roda formaty (naprimer
zagolovki grupp ili otbivku lista) to primenyajte format_name.



V Pel realizovan prevoshodnyj mehanizm otladki programm.
Vam dostatochno zapustit' programmu s klyuchom '-d' i vy nachnete rabotat'
s interaktivnym otladchikom. Vam stanovyatsya dostupny vse peremennye i
massivy, vy mozhete vvodit' vyrazheniya i operatory, trassirovat',
issledovat' rabotu programmy v po-shagovom rezhime i mnogoe drugoe.
Nizhe perechislenny komandy otladchika kotorye vy mozhete vvodit'
na ego podskazku.

Komandy otladchika.

	h	- Poluchit' spravku po komandam.

	T	- Prosmotret' stek programmy

	s	- Vypolnit' odnu komandu i ostanovit'sya.

	n	- Vypolnit' podprogrammu i ostanovit'sya.

	r	- Vypolnit' tekushchuyu podprogrammu i ostanovit'sya.

	c	- Prodolzhit' vypolnenie do sdeduyushchej tochki ostanovki.

	c nomer	- Prodolzhit' vypolnenie do stroki s dannym nomerom.

	<CR>	- Povtorit' posledniyu komandu n ili s.

	l min+incr	- Vyvesti incr+1 strok programmy nachinaya so stroki min.

	l min-max	- Vyvesti stroki nachinaya s min do max.

	l nomer	- Vyvesti stroku s ukazannym nomerom.

	l	- Vyvesti sleduyushchij ekran strok.

	-	- Vyvesti predydushchij ekran strok.

	w strok	- Vyvesti ekran strok. Tekushchaya v seredine.

	l podprogramma	- Vyvesti stroki ukazannoj podprogrammy.

	/shablon/	- Najti stroku v tekste programmy.

	?shablon?	- Obratnyj poisk stroki v tekste programmy.

	L	- Vyvesti stroki s tochkami ostanova i aktivami.

	S	- Vyvesti imena vseh podprogramm.

	t	- Vklyuchit' ili vyklyuchit' trassirovku.

	b stroka [ uslovie] - Ustanovit' tochku ostanovki.

	b podprogramma [ uslovie ] - Ustanovit' tochku ostanovki v nachale
ukazannoj podprogrammy i esli ukazano pri dannom uslovii.

	d	- Ubrat' tochku ostanovki.

	D	- Ubrat' vse tochki ostanovki.

	a stroka komanda - Ustanovit' aktiv (komandu kotoraya vypolnitsya vmeste
s ukazannoj strokoj. "komanda" - obychnyaya komanda Pel.

	A	- Steret' vse aktivy.

	< komanda	- Vypolnyat' komandu pered kazhdoj ostanovkoj.

	> komanda	- Vypolnit' komandu posle ostanovki otladchika.

	V modul' [imena] - Vyvesti znachenie vseh ili ukazannyh imen
v module. Vnimanie! Simvol '$' ne vvoditsya.

	X [imena]	- To zhe chto i V , no tol'ko dlya tekushchego modulya.

	! nomer	- Vypolnit' odnu stroku programmy.

	! -nomer	- Vypolnit' odnu komandu s nomerom predshestvuyushchim
			tekushchej stroke.

	H - n	- Vyvesti n poslednih vypolnennyh komand.

	q ili ^D	- Vyhod iz programmy.

	komanda		- Vypolnit' komandu Pel.

	p vyrazhenie	- Vyvesti znachenie vyrazheniya.

Konstruktor BEGIN ne otslezhivaetsya otladchikom, no mozhno v tele konstruktora
ukazat':
	$DB::single =1;

i otladchik ostanovitsya. Dannaya komanda ne vyzovet oshibku pri rabote
bez otladchika.



     Pri napisanii knigi avtor v osnovnom pol'zovalsya opisaniem
Pel "Perl Programmers Reference Guide".

Naibolee izvestnaya zarubezhnaya literatura:

	Programming Perl (the Camel Book)

	Learning Perl (Llama Book)





	comp.lang.perl.announce - Razlichnye ob座avleniya i soobshcheniya.

	comp.lang.perl.misc - Mesto dlya voprosov i obsuzhdenij.

	comp.lang.perl.modules - Moduli Pel.

	comp.lang.perl.tk - Pel i Tcl/tk.




	http://www.perl.org
                                - Special'nyj Pel-server

	http://www.ora.com
                                - Knigi po YUniks izdatel'stva O`Reily

	ftp://ftp.perl.com
                                - Specializirovannyj FTP server

	http://franz.ww.tu-berlin.de/modulelist


Last-modified: Sun, 02 Jul 2000 22:34:02 GMT
Ocenite etot tekst: