Ang mga built-in na function ay ginagamit bilang mga tuntunin ng mga expression at nahahati sa dalawang kategorya: list operator at unary operator. Nakakaapekto ito sa kanilang precedence kaysa sa "," - comma operator. Ang mga operator ng listahan ay maaaring kumuha ng maraming (listahan) ng mga argumento, habang ang unary operator ay maaaring tumagal lamang ng isa. Kaya, tinatapos ng kuwit ang mga argumento ng unary operator at pinaghihiwalay ang mga argumento ng isang list operator.

Ang argumento ng unary operator ay karaniwang nauunawaan bilang kontekstong scalar at listahan sa parehong scalar at

listwise na may mga scalar argument na mauna. Sa sumusunod, tutukuyin namin ang mga list argument na may salitang "LIST", na nangangahulugang ang function ay may listahan ng mga argumento na pinaghihiwalay ng mga kuwit.

Ang mga argumento ng function ay maaaring ilakip sa mga panaklong at sa gayon ay nagpapahiwatig na "ito ay isang function" at ang priyoridad ay hindi mahalaga, kung hindi, ito ay isang listahan o unary operator na may isang tiyak na nakapirming nangunguna. Ang puwang pagkatapos ng pangalan ng function at ang panaklong ay walang kahulugan. Samakatuwid, mag-ingat!

Halimbawa:

i-print ang 1 + 2 + 3; # resulta 6

print(1+2)+3; # resulta 3

print (1+2)+3; #muli 3

print(1+2+3); #6

Kung ang isang function ay nagbabalik ng resulta sa parehong konteksto ng scalar at listahan, ang error na exit code ay scalar c hindi natukoy o isang walang laman na listahan.

Tandaan ang panuntunan:

Walang pangkalahatang tuntunin para sa pag-convert ng isang listahan sa isang scalar!

Ang bawat operator at function ay may sariling uri ng halaga sa isang scalar na konteksto.

Para sa ilan, ito ang bilang ng mga elemento mula sa kontekstong scalar. Para sa iba, ang unang elemento ng listahan o ang huli o ang bilang ng mga matagumpay na operasyon. Bawat isa sa kanilang sarili maliban kung partikular mong ipahiwatig.

Operator "-X".

-X file pointer

-X expression

Sinusuri ang isang file kung saan ang "X" ay isa sa mga halagang inilalarawan sa ibaba.

Ito ay unary operator na may isang argumento, alinman sa pangalan ng file o isang file pointer. Sinusuri ang isa sa mga kundisyon. Kung hindi tinukoy ang argumento, kukunin ang halaga ng variable na $_. Para sa -t STDIN switch.

Resulta 1 kung totoo at "" kung mali o hindi natukoy kung hindi natagpuan ang file. Sa kabila ng kakaibang hitsura nito, isa itong unary operator na may kaukulang precedence. Ang argumento ay maaaring nakapaloob sa panaklong.

"X" ay may mga sumusunod na kahulugan:

-r Ang file ay nababasa ng epektibong uid/gid

-w para sa pagre-record -//-

-x pagpapatupad -//-

-o nabibilang sa epektibong uid (user id)

-R Ang file ay nababasa ng totoong uid/gid

-W para sa pagre-record -//-

-X pagpapatupad -//-

-O nabibilang sa totoong uid

-e umiiral ang file

-z walang laman

-s hindi walang laman

-f payak na teksto

-d direktoryo

-p mga tubo (conveyor)

-S saksakan

-b espesyal na block device

-c-//– simboliko -//-

-t pointer sa tty device

-u nakatakda ang setuid bit

-g-//– setgid

-k-//– malagkit

-T text file

-B binary

-M"edad" ng file sa mga araw sa oras na nagsimula ang script

-A araw mula noong huling pagbasa

-C araw mula noong huling pagbabago ng inode

ekspresyon ng abs

Ganap na halaga ng pagpapahayag

tanggapin ang NEWSOCKET, GENERICSOCKET

Magbukas ng bagong socket batay sa isang panlabas na kahilingan. Pareho sa system call tanggapin(). Ibinabalik ang address o false kapag nabigo.

mga segundo ng alarma

Magpadala ng signal ng SIGALARM sa kasalukuyang proseso pagkatapos lumipas ang isang tinukoy na tagal ng panahon. Hindi pinapayagan na gumawa ng ilang mga tawag nang sabay-sabay sa isang yugto ng panahon.

Ibinabalik ang natitirang oras ng nakaraang counter.

atan2 Y, X

Arctange ng ratio na Y hanggang X mula -pi hanggang +pi.

bind socket, pangalan

Magtalaga address ng network Sokitu. Katulad ng isang system call magbigkis. Nagbabalik totoo kung matagumpay at mali kung hindi.

Pangalan - address ng package Sokita.

binmode file

Buksan ang file para sa binary access mode.

Sa normal na mode, ang CR LF ay isinalin sa LF sa input, at ang LF ay isinalin sa CR LF sa output.

pagpapala function

Tinutukoy ng function na ito na ang object na tinukoy ng link ay kabilang sa klase. Kung ang klase ay hindi tinukoy, kung gayon ito ay tumutukoy sa kasalukuyang klase. Ito ay karaniwang ang huling pahayag sa isang object's constructor.

Kinakailangang tukuyin ang pangalan ng klase kung ang tinukoy na bagay ay maaaring mamana ng isang descendant na klase.

function ng tumatawag

expression ng tumatawag

Ibinabalik ang konteksto ng pagtawag ng kasalukuyang subroutine.

Sa kontekstong scalar, true kung ito ay isang subroutine o procedure na tinatawag ng eval() o require() na mga operator at false kung hindi.

Sa isang listbox ito ay isang listahan ($package, $filename, $line)

$package– pangalan ng package

$filename– pangalan ng file ng package

$linya– numero ng linya kung saan ginawa ang tawag.

Kung tinukoy ang isang expression, ibabalik ang isang listahan:

($package, $filename, $line, $subroutine, $hasargs, $wantargs)

Tinutukoy ng expression ang lalim ng nesting ng view ng stack ng tawag.

$subroutine– pangalan ng subroutine

$hasargs– magagamit na mga argumento

$wantargs- mga kinakailangang argumento

Ang paggamit ng function na ito sa isang DB package ay nagbabalik ng mas detalyadong impormasyon. Ang listahan ng @DB::args ay idinagdag sa listahan ng argumento.

chdir expression

Pumunta sa direktoryo na tinukoy ng expression. Kung nawawala ang expression, pumunta sa direktoryo ng "home".

Nagbabalik ng totoo sa tagumpay at mali sa kabiguan.

listahan ng chmod

Baguhin ang mga karapatan sa pag-access sa mga file na tinukoy sa listahan.

Ang unang elemento sa listahan ay isang numero, karaniwang octal, halaga ng pahintulot.

Ibinabalik ang bilang ng mga file na binago ang mga pahintulot.

chmod 0666 "f1", "f2", "f3";

chomp variable

listahan ng chomp

Tinatanggal ang character na tinukoy ng $/ variable mula sa dulo ng linya.

Ito ay karaniwang "LF". Ibinabalik ang bilang ng mga character na inalis. Kung hindi tinukoy ang variable, gagamitin ang $_ variable.

Kung tinukoy ang isang listahan, ipoproseso ang bawat linya ng listahan at ibabalik ang kabuuang bilang ng mga character na inalis.

chop variable

listahan ng chop

Ganap na katulad ng chomp function ngunit palaging inaalis ang huling character ng string.

listahan ng chown

Baguhin ang "may-ari" at "grupo" ng mga file ng listahan.

Ang unang elemento ay ang numero ng bagong may-ari, ang pangalawang numero bagong grupo at pagkatapos ay isang listahan ng mga file.

Sa karamihan ng mga system ng Unix, hindi mo mababago ang may-ari maliban kung ikaw ay isang superuser, ngunit maaari mong baguhin ang grupo kung ito ay isa sa iyong "pangalawang" pangkat.

numero ng chr

Nagbabalik ng character na may tinukoy na encoding code.

direktoryo ng chroot

Gawin ang tinukoy na direktoryo na "ugat".

Nangangahulugan ang “Root” na sa loob ng programa ay maaari itong tukuyin bilang " / ".

isara ang file

Isara ang isang bukas na file o stream. Maaaring hindi gamitin

kung ang parehong file ay binuksan muli dahil awtomatiko itong magsasara sa isang bagong open() na tawag.

closedir na direktoryo

Isara ang direktoryo bukas na function opendir().

ikonekta ang socket, pangalan

Makipag-ugnayan sa remote socket. Ang function na ito ay katulad ng isang system call kumonekta(). Nagbabalik ng totoo kung matagumpay

at mali sa pagkakamali.

cos expression

Ang cosine ng expression ay nasa radians.

crypt text, asin

Pag-encrypt ng teksto. Katulad ng system crypt().

dbmclose hash

Isinasara ang koneksyon sa pagitan ng hash at ng database.

dbmopen hash, base, mode

Iugnay ang tinukoy na hash at base sa isang partikular na mode.

Ang katotohanan ay ang Pearl ay nagpapatupad ng isang napaka-maginhawang mekanismo para sa pagtatrabaho sa mga database tulad ng dbm, ndbm, sbdm, gdbm at Berkeley DB. Upang gawin ito, kailangan mong i-link (buksan) ang database sa ilalim ng pangalan ng hash. Ang lahat ng trabaho sa mga rekord ng database ay ginagawa na parang ito ay isang regular na hash (associative array).

Tingnan ang paglalarawan ng function para sa higit pang mga detalye. AnyDBM().

tukuyin ang pagpapahayag

Nagbabalik ng true kung ang value ay tinukoy (umiiral) at false kung hindi. Maraming mga operasyon ang nagtatapos sa isang hindi natukoy na halaga, tulad ng pagbabasa sa dulo ng file, gamit ang mga hindi natukoy na variable, mga error sa system, atbp.

Binibigyang-daan ka ng function na ito na makilala ang pagitan ng null at hindi natukoy na mga halaga, at kung ang mga function o reference ay tinukoy o hindi natukoy. Kapag gumagamit ng pangunahing katiyakan sa isang hash, nagbabalik ito ng tiyak binigay na susi o hindi ngunit kung siya ay umiiral o hindi.

tanggalin ang expression

Mag-alis ng value sa isang hash. Ibinabalik ang halagang aalisin, o hindi matutukoy kung walang aalisin.

Pag-alis ng kapaligiran mula sa array $ENV() – binabago ang kapaligiran.

Pag-alis mula sa isang hash na nauugnay sa isang database – tinatanggal ang isang entry sa database.

listahan ng mamatay

Kung ang programa ay hindi inilunsad mula sa eval() Ang function na ito ay naglalabas ng listahan sa stream ng STDERR at tinatapos ang programa gamit ang code mula sa $! Kung $! naglalaman ng 0 pagkatapos ay may code ($? >> 8). Kung ito ay 0 din pagkatapos ay may code 255.

Kapag tinawag mula sa eval(), ang isang mensahe ng error ay iniimbak sa $@ variable at nabigo ang eval() na may hindi natukoy na halaga. Nagbibigay-daan ito sa iyo na gumawa ng mga sitwasyon ng error nang hindi isinasara ang head module.

Kung ang isang linya mula sa listahan ay hindi nagtatapos sa "\n" na character, ang numero ng script line kung saan tinawag ang function at ang numero ng input line, kung mayroon man, ay ipi-print din.

gawin BLOCK

Ito ay hindi talagang isang function. Ibinabalik nito ang halaga ng huling pahayag sa block. Kailan gagamitin ang cyclic modifier

Isinasagawa ang BLOCK bago suriin ang kondisyon ng loop, hindi tulad ng mga regular na loop.

gawin ang subroutine

Hindi na ginagamit na paraan ng pagtawag sa mga subroutine.

gumawa ng pagpapahayag

Ang halaga ng expression ay binibigyang kahulugan bilang pangalan ng Perl script file.

Ito ay orihinal na ginamit upang isama ang mga gawain sa library.

Ngayon ay mas tama na gumamit ng use() at require() na mga tawag, na nagbibigay ng error at kontrol sa pagwawakas.

itapon ang label

Nagsasagawa ng dump ng kasalukuyang memorya. Ginamit ito upang magamit ang undump program para isama ang kasalukuyang executable code sa program pagkatapos masimulan ang lahat ng variable.

Ang pagsasagawa ng bagong programang ito ay magsisimula sa isang goto statement. Kung ang label ay tinanggal, pagkatapos ay magsimula sa simula.

Pansin! Hindi mabubuksan ang mga file bago ang dump

sa oras ng pagpapatupad ng bagong programa.

bawat hash

Nagbabalik ng 2-element array. Ang unang elemento ay ang susi, ang pangalawa ay ang halaga ng susunod na elemento ng hash. Binibigyang-daan kang "i-browse" ang lahat ng mga halaga ng hash sa isang partikular na pagkakasunud-sunod. Ang loop variable ay nire-reset lamang pagkatapos na madaanan ang buong array.

eof()

Nagbabalik ng 1 kung nagbabasa pagkatapos ng pagtatapos o nagbabasa mula sa hindi bukas na file. Ang argument ay dapat na isang expression na nagbabalik ng isang kasalukuyang file pointer. Ang function na ito hindi maaaring gamitin upang basahin ang mga file na binuksan bilang mga terminal.

Kung ang argumento ay hindi tinukoy, ang huling file na nabasa ay ginagamit.

Ang paggamit ng eof() sa form ay kapaki-pakinabang sa habang umiikot(<>) upang matukoy ang wakas lamang huling file mula sa

listahan. Gamitin ang eof(ARGV) o eof upang matukoy ang dulo ng bawat file sa listahan.

eval expression

eval expression

Ang expression ay na-scan at naisakatuparan bilang isang normal na programa ng Pearl.

Ginagawa ito sa konteksto ng kasalukuyang programa upang magamit mo ang mga tinukoy nang variable at subroutine.

Ibinabalik ang resulta ng huling pahayag sa bloke o ang halaga ng pahayag bumalik . Kung natagpuan error sa syntax o ang pahayag ay isasagawa mamatay Ang return value ay hindi tinukoy at ang $@ variable ay naglalaman ng mensahe ng error. Kung walang error, ang $@ ay naglalaman ng null string. Kung walang argumento, kukunin ang halaga ng variable na $_.

listahan ng exec

Isinasagawa utos ng system mula sa listahan at magtatapos ang pagpapatupad ng programa. Kung kailangan mong bumalik, pagkatapos ay mas mahusay na gamitin ang function sistema(). Kung ang listahan ay may higit sa 1 argumento o ang listahan ay isang array na may higit sa 1 elemento, pagkatapos ay i-execute tawag sa sistema execvp() na may mga argumento mula sa isang listahan.

Kung mayroong isang scalar argument, pagkatapos ito ay ini-scan para sa pagproseso ng mga metacharacter at kung naroroon ang mga ito, ang mga resultang argumento ay ipapasa sa interpreter /bin/sh-c para sa karagdagang pagproseso.

Kung walang metacharacter, hahatiin ang argumento sa mga salita at ipapasa sa system call execvp() na mas mahusay.

Pansin! exec() At sistema(0) huwag i-reset ang I/O buffer kaya kailangan mong itakda ang variable $| upang maiwasan ang pagkawala ng impormasyon sa output.

umiiral na pagpapahayag

Nagbabalik ng totoo kung mayroon tinukoy na susi hash kahit na hindi tinukoy ang halaga nito.

exit expression

Ang pagpapatupad ng programa ay nagtatapos sa expression code.

exp expression

Ibinabalik ang e (ang base ng natural na logarithm) sa kapangyarihan ng expression.

fcntl file, function, scalar

Isinasagawa ang fcntl() system call. Upang gamitin ito, siguraduhing patakbuhin ang paggamit ng Fcntl;

fileno file

Ibinabalik ang file handle para sa ibinigay na file pointer.

flock file, operasyon

flock() system call

tinidor

fork() system call. Ibinabalik ang pid ng bata para sa magulang at 0 para sa bata kung matagumpay, kung hindi ay isang hindi natukoy na halaga.

pormat

Perl declarative function. Tinutukoy ang format ng output para sa pahayag magsulat. Tingnan ang Mga Format ng kabanata para sa mga detalye.

pormat ng formline, listahan

Panloob na function na ginagamit sa format. I-format ang output ng mga parameter mula sa isang listahan. Ang resulta ay inilalagay sa $^A variable Ang write function ay nagpi-print lamang ng halaga ng variable na ito, ngunit maaari rin itong basahin at pagkatapos ay i-reset. Karaniwan ang format ay gumagawa ng isang tawag sa formline bawat linya ng form, ngunit hindi pinaghihiwalay ng formline ang mga linya ng format. Nangangahulugan ito na tinatrato ng mga character na "~" at "~~" ang buong format bilang isang linya, kaya kinakailangang gumamit ng multiline formids upang ilarawan ang isang entry sa format.

getc file

getc file

Nagbabasa at nagbabalik ng character mula sa tinukoy na file.

Kung ang file ay hindi tinukoy pagkatapos STDIN ay basahin. Nagbabalik ng walang laman na string pagkatapos ng dulo ng file.

getlogin

Ibinabalik ang kasalukuyang login mula sa /etc/utmp file

Huwag gamitin ito upang kilalanin ang gumagamit; hindi ito "sarado" bilang getpwuid().

getpeername socket

Ibinabalik ang naka-pack na address ng remote socket.

getpgrp PID

Ibinabalik ang pangkat ng proseso na may tinukoy na PID. Kung ang argument ay nawawala, ibinabalik ang pangkat ng kasalukuyang proseso.

getppid

Ibinabalik ang PID ng proseso ng magulang.

getpriority NA, SINO

Ibinabalik ang kasalukuyang priyoridad ng isang proseso, pangkat ng proseso, o user.

Ipagpatuloy natin ang pag-aaral ng Perl. Sa kabanatang ito ibinaling natin ang ating pansin sa mga function. Ang mga function ay mga bloke ng code na binibigyan ng mga pangalan upang magamit natin ang mga ito kapag kinakailangan. Tinutulungan ka ng mga pag-andar na ayusin ang iyong code sa madaling maunawaang mga tipak. Pinapayagan ka nilang lumikha ng isang programa nang sunud-sunod, sinusubukan ito sa daan.

Kapag mayroon kang ideya para sa isang programa, dapat kang bumuo ng isang diagram ng pagbuo nito - sa iyong ulo o sa papel. Ang bawat hakbang sa diagram ay maaaring kumatawan sa isang function sa iyong programa. Ito ay tinatawag na modular programming. Napakahusay ng modular programming sa pagpapahintulot sa iyo na itago ang mga detalye ng programa, at sa gayon ay mapapabuti ang pagiging madaling mabasa ng source code ng iyong programa.

Halimbawa, kung ang iyong programa ay naglalaman ng isang function na kinakalkula ang lugar ng isang bilog, maaari mo itong tawagan gamit ang sumusunod na linya:

$areaOfFirstCircle = areaOfCircle($firstRadius);

Ang pagtingin sa mga tawag sa function ay ganito, ang taong nagbabasa source code iyong programa, nauunawaan kung ano ang ginagawa ng iyong programa. Kasabay nito, hindi niya kailangang malaman kung paano eksaktong ipinatupad ito o ang function na iyon. Samakatuwid, mahalagang bigyan ang mga function ng "pagsasabi" ng mga pangalan - upang sa pamamagitan ng pangalan ay maunawaan mo kung ano ang eksaktong ginagawa ng function.

Ang isang function call ay nangangahulugan na ang Perl interpreter sa punto kung saan ang function ay tinatawag ay hihinto sa pagpapatupad ng kasalukuyang serye ng mga linya ng code at nagpapatuloy sa pagpapatupad ng function code. Kapag nakumpleto na ang function code, babalik ang interpreter sa call point at ipagpapatuloy ang pagpapatupad ng programa mula sa susunod na linya.

Tingnan natin ang function na tawag - una nating makita ang scalar variable, pagkatapos ay ang assignment operator. Alam mo na kung ano ang ibig sabihin nito - Itatalaga ni Perl ang variable na $areaOfFirstCircle ang halaga sa kanan ng tanda ng pagtatalaga. Ngunit ano ba talaga ang nasa kanan?

Ang unang bagay na makikita mo ay ang function name areaOfCircle(). Ang mga tamang panaklong at ang kawalan ng $, @ at % na mga simbolo bago ang pangalan ay nagpapahiwatig na ito ay isang function na tawag. Sa loob ng mga panaklong ay isang listahan ng mga parameter o mga halaga na ipinasa sa function.

Pagkalkula ng lugar ng isang bilog:

$areaOfFirstCircle = areaOfCircle(5);
print("$areaOfFirstCircle\n");
sub areaOfCircle(
$radius = $_;
return(3.1415 * ($radius ** 2));
}

Ang programa ay magpi-print:

Deklarasyon ng function:

pangalan ng sub function (
function na katawan
}

Iyon lang. Handa na ang iyong function.

Ang sitwasyon ay mas kumplikado sa mga parameter. Ang mga parameter ay ang mga halaga na ipinapasa namin sa function. Ang mga parameter ay nakapaloob sa loob ng mga panaklong kaagad kasunod ng pangalan ng function. Sa halimbawa sa itaas, ang function na tawag ay areaOfCircle(5). Dito ay gumamit lamang kami ng isang parameter. Ngunit kahit na ang isang function ay may isang parameter lamang, ang Perl, kapag tinawag ang function, ay lumilikha ng isang hanay ng mga parameter para sa function na gamitin.

Sa loob ng function, ang parameter array ay pinangalanan @_. Ang lahat ng mga parameter na ipinasa sa function ay nakapaloob sa @_ array, kung saan maaaring makuha ang mga ito kung kinakailangan.

Ang aming maliit na function mula sa halimbawa sa itaas ay maaaring gawin ito sa sumusunod na linya:

$radius = $_;

Ang linyang ito ay nagtatalaga ng unang elemento ng @_ array sa scalar variable na $radius.

Kung gusto mo, hindi mo kailangang gumamit ng return statement sa function para magbalik ng value; Ngunit mas makakabuti kung gagamitin mo pa rin ang return statement - sa ganitong paraan maiiwasan mo ang maraming aksidenteng pagkakamali.

Maaaring nakita mo na ang pagkakaiba sa pagitan ng mga subroutine at function sa ilang programming language. Sa ganitong mga wika, ang isang function ay kinakailangang nagbabalik ng isang halaga, habang sa parehong oras, ang isang subroutine ay hindi nagbabalik ng isang halaga. Sa Perl walang ganoong bagay - mayroon ka lamang isang function - hindi alintana kung ito ay nagbabalik ng anumang halaga o hindi.

Paggamit ng array ng parameter (@_)

Tulad ng nabanggit kanina, mahahanap ng function ang lahat ng mga parameter sa array ng parameter @_. Ito ay napaka-maginhawa - upang malaman kung gaano karaming mga parameter ang naipasa sa isang function, kailangan mo lang i-access ang parameter array @_ sa kontekstong scalar.

firstSub(1, 2, 3, 4, 5, 6);
firstSub(1..3);
firstSub("A".."Z");
sub firstSub(
$numParameters = @_ ;
print("Ang bilang ng mga parameter ay $numParameters\n");
}

Ang programa ay magpi-print:

Ang bilang ng mga parameter ay 6

Ang bilang ng mga parameter ay 3

Ang bilang ng mga parameter ay 26

Binibigyang-daan ka ng Perl na ipasa ang anumang bilang ng mga parameter sa isang function. Ang function mismo ay maaaring matukoy kung aling mga parameter ang gagamitin at sa anong pagkakasunud-sunod. Ang array ng parameter na @_ ay maaaring gamitin tulad ng iba pang array.

Siyempre, hindi masyadong maginhawang i-access ang mga parameter na ipinasa sa isang function ng kanilang mga numero - @_ o @_. Maaari kang gumamit ng mas maginhawang teknolohiya:

areaOfRectangle(2, 3);
areaOfRectangle(5, 6);
sub areaOfRectangle(
($taas, $lapad) = @_ ;
$lugar = $taas * $lapad;
print("Ang taas ay $height. Ang lapad ay $width. Ang lugar ay $area.\n\n");
}

Ang programa ay magpi-print:

Ang taas ay 2. Ang lapad ay 3. Ang lugar ay 6.

Ang taas ay 5. Ang lapad ay 6. Ang lugar ay 30.

Kung magpapasa ka ng variable sa halip na isang numero sa isang function, kung magbago ang halaga nito sa loob ng function, magbabago rin ito para sa natitirang bahagi ng programa. Ito ay tinatawag na pagpasa ng mga parameter sa pamamagitan ng sanggunian.

@array = (0..5);

firstSub(@array);

sub firstSub(
$_ = "A";
$_ = "B";
}

Ang programa ay magpi-print:

Pagkatapos ng function call, array = A B 2 3 4 5

Tulad ng nakikita mo, binago ng function ang halaga ng mga parameter na ipinasa dito, at naapektuhan din nito ang natitirang bahagi ng programa - ang mga halaga ng array ng @array ay nagbago hindi lamang para sa function, ngunit para sa natitirang bahagi ng programa . Ito ay masamang kasanayan sa programming - kung wala kang isang tiyak na layunin, pagkatapos ay huwag gumamit ng mga naturang bonus - sila ay puno ng mga hindi halatang error. Sa kabilang banda, kung sa simula ng pag-andar ay itinalaga mo ang mga halaga ng naipasa na mga parameter sa mga bagong variable (tulad ng ipinakita kanina), at pagkatapos ay gagana lamang sa kanila, hindi ka magkakaroon ng ganoong problema - dahil sa kasong ito hindi mo talaga binabago ang mga halaga na ipinasa sa mga parameter ng function.

Narito ang isang halimbawa ng parehong programa, ngunit nakasulat nang mas tama:

@array = (0..5);
print("Bago ang function na tawag, array = @array\n");
firstSub(@array);
print("Pagkatapos ng function na tawag, array = @array\n");
sub firstSub(

$firstVar = "A";
$secondVar = "B";
}

Ang programa ay magpi-print:

Bago ang function na tawag, array = 0 1 2 3 4 5

Pagkatapos ng function call, array = 0 1 2 3 4 5

Tulad ng nakikita mo, ang function ay nagtatalaga ng mga halaga ng mga parameter na ipinasa dito sa mga bagong variable, at pagkatapos ay nagpapatakbo lamang sa kanila - nang hindi direktang binabago ang hanay ng mga parameter.

Ngunit pagkatapos ay maaari kang makatagpo ng isa pang problema:

$firstVar = 10;
@array = (0..5);
print("Bago ang function na tawag\n");

print("\tarray = @array\n");
firstSub(@array);
print("Pagkatapos ng function na tawag\n");
print("\tfirstVar = $firstVar\n");
print("\tarray = @array\n");
sub firstSub(
($firstVar, $secondVar) = @_ ;
$firstVar = "A";
$secondVar = "B";
}

Ang programa ay magpi-print:

Bago ang function na tawag
firstVar = 10
array = 0 1 2 3 4 5

Pagkatapos ng function na tawag
firstVar = A
array = 0 1 2 3 4 5

Iyon ay, bilang default, ang lahat ng mga variable sa isang Perl program ay naa-access mula sa anumang piraso ng code. Ito ay napaka-maginhawa sa maraming mga kaso, ngunit madalas na nagiging sanhi ng abala at humahantong sa hindi kasiya-siyang mga error. Susunod, matututunan mo kung paano lumikha ng mga variable na makikita lamang sa loob ng kani-kanilang mga function.

Saklaw ng mga variable.

Ang mga variable na saklaw ay ang mga piraso ng code kung saan maaari mong gamitin ang isang naibigay na variable. Bilang default, ang anumang variable sa isang Perl program ay "nakikita" mula saanman sa programa.

Minsan ito ay lubhang kapaki-pakinabang upang limitahan ang saklaw ng isang partikular na variable sa loob ng isang function. Sa kasong ito, ang pagbabago ng halaga ng isang variable sa loob ng function ay hindi makakaapekto sa natitirang bahagi ng programa sa anumang paraan. Ang Perl ay may dalawang function - my() at local(). Ang una ay lumilikha ng isang variable na makikita lamang sa loob ng ibinigay na function. Ang pangalawa ay lumilikha ng isang variable na maaari ding "makita" ng mga function na tinatawag mula sa function na ito.

firstSub("AAAA", "BBBBB");
sub firstSub(
local($firstVar) = $_;
my($secondVar) = $_;


secondSub();
print("firstSub: firstVar = $firstVar\n");
print("firstSub: secondVar = $secondVar\n\n");
}

Sub secondSub(


$firstVar = "ccccC";
$secondVar = "DDDDD";
print("secondSub: firstVar = $firstVar\n");
print("secondSub: secondVar = $secondVar\n\n");
}

Ang programa ay magpi-print:

firstSub: firstVar = AAAA
firstSub: secondVar = BBBBB
secondSub: firstVar = AAAA
Paggamit ng hindi inisyal na halaga sa test.pl line 19.
secondSub: secondVar =
secondSub: firstVar = ccccC
secondSub: secondVar = DDDDD
firstSub: firstVar = ccccC
firstSub: secondVar = BBBBB

Tulad ng nakikita mo, ang secondSub() function ay walang access sa $secondVar variable, na nilikha ng my() function sa loob ng firstSub() function. Nagpapakita pa si Perl ng mensaheng nagbabala sa iyo tungkol dito. Kasabay nito, ang $firstVar variable ay magagamit at maaaring baguhin ng secondSub() function.

Kung maaari, subukang gamitin lamang ang my() function at huwag gamitin ang local() function - ito ay magbibigay sa iyo ng higit na kontrol sa saklaw ng iyong mga variable.

Sa katunayan, ang my() function ay mas kumplikado at functional. Ngunit ito ay tatalakayin sa Kabanata 15 - "Perl Modules".

Naaalala mo ba ang pagkakaiba sa pagitan ng pagpasa ng mga parameter ng function sa pamamagitan ng sanggunian at sa pamamagitan ng halaga? Kung ipinasa mo ang mga parameter sa pamamagitan ng halaga, hindi mababago ng function ang mga halaga ng mga parameter (mga variable) na ipinasa dito, na nangangahulugang hindi ito makakaapekto sa buong programa sa anumang paraan. Kung ipinasa mo ang mga parameter sa pamamagitan ng sanggunian, maaaring baguhin ng function ang mga halaga ng mga parameter (mga variable), at ito ay makikita sa pangunahing programa. Kaya, kapag ginagamit ang local() function, ang paraan ng pagpasa ng mga parameter sa pamamagitan ng reference ay gumagana nang kaunti - maaaring baguhin ng mga function ang mga halaga ng mga parameter (mga variable) na ipinasa sa kanila, ngunit ito ay makakaapekto lamang sa "top" function - ang isa kung saan ginamit ang local( function ), - hindi ito makakaapekto sa pangunahing programa sa anumang paraan.

Paggamit ng isang listahan bilang isang parameter ng function.

Ngayon na naunawaan na natin ang saklaw ng mga variable, tingnan natin ang mga parameter ng function mula sa ibang pananaw. Tulad ng nasabi na natin, ang lahat ng mga parameter ng function ay ipinasa sa isang array, ngunit paano kung kailangan mong ipasa ang isang parameter sa function - isang scalar, at ang pangalawang parameter - isang array? Ang sumusunod na halimbawa ay nagpapakita kung ano ang mangyayari:

firstSub((0..10), "AAAA");
sub firstSub(
local(@array, $firstVar) = @_ ;

print("firstSub: firstVar = $firstVar\n");
}

Ang programa ay magpi-print:

firstSub: array = 0 1 2 3 4 5 6 7 8 9 10 AAAA
Paggamit ng hindi inisyal na halaga sa test.pl line 8.
firstSub: firstVar =

Makikita mo na kapag sinisimulan ang mga variable, ang @array ay sumisipsip ng lahat ng elemento ng @_ parameter array, na walang iiwan sa scalar variable na $firstVar. Kinumpirma ito ng mensahe ng babala mula sa Perl interpreter. Maaari mong lutasin ang problemang ito sa pamamagitan ng pagpapalit ng mga parameter - kung maglalagay ka muna ng scalar variable at pagkatapos ay isang array, kung gayon ang lahat ay magiging ayon sa nararapat:

firstSub("AAAA", (0..10));
sub firstSub(
local($firstVar, @array) = @_ ;
print("firstSub: array = @array\n");
print("firstSub: firstVar = $firstVar\n");
}

Ang programa ay magpi-print:

firstSub: array = 0 1 2 3 4 5 6 7 8 9 10
firstSub: firstVar = AAAA

Maaari kang magpasa ng maraming halaga ng scalar hangga't gusto mo sa function, ngunit isang array lamang. Kung susubukan mong magpasa ng maraming arrays sa isang function, magsasama-sama lang ang kanilang mga elemento sa isang array, at hindi malalaman ng function kung saan magtatapos ang isang array at magsisimula ang isa pa.

Nested (recursive) function.

Maaaring tawagan ng mga function ang kanilang sarili, na lumalalim sa ilang antas. Magkano ang depende sa partikular na pagpapatupad ng Perl, partikular na hardware, at configuration. Karaniwan, sapat na ang mga mapagkukunan ng iyong makina at hindi mo kailangang mag-alala tungkol dito. Ngunit kung interesado ka, maaari mong subukang patakbuhin ang program na ito:

FirstSub();
sub firstSub(
print("$bilang\n");
$count++;
firstSub();
}

Ang programa ay magpi-print:

Error: Runtime exception

Bago i-print ang mensahe ng error na ito, dagdagan ng program ang halaga ng variable na $count hangga't kaya nito recursive na tawag mga function. Kaya, sa pamamagitan ng halaga ng variable na $count, masasabi mo kung gaano karaming antas ng mga recursive na tawag ang pinapayagan ng iyong system.

Ngunit huwag madala sa recursion - ito ay nagkakahalaga ng pag-aaral nang mabuti sa mga espesyal na kaso, halimbawa, sa ilang mga kalkulasyon sa matematika.

Mga pribadong function.

Maaaring kailanganin mong gumamit ng scoped function. Naisip na namin kung paano ito gagawin sa mga variable. Narito kung paano ito gumagana sa mga function:

$temp = performCalc(10, 10);
print("temp = $temp\n");
sub performCalc(
my ($firstVar, $secondVar) = @_;
aking $square = sub (
return($_**2);
};
return(&$square($firstVar) + &$square($secondVar));
};

Ang programa ay magpi-print:

Gaya ng nakikita mo, mayroon kaming $square function. Mas tiyak, ang $square ay isang regular na scalar variable na tumutukoy sa isang function. Upang sumangguni sa isang function, ginagamit namin ang & sign sa harap ng $square variable na pangalan. Magagamit lang natin ang function na ito sa loob ng performCalc() function - hindi ito available sa natitirang bahagi ng program.

: atan2 numero1, numero2 Mga argumento: numero1, numero2 mga numeric na expression Resulta: numerong halaga

Function atan2 ibinabalik ang arctangent ng quotient ng dibisyon mga numero1 sa numero2. numero2, numero1 Ang resulta ay nasa hanay mula -π hanggang +π at tumutugma sa anggulo sa mga radian sa pagitan ng x-axis at ng vector hanggang sa puntong may mga coordinate (

). Mga halimbawa:

$x = atan2 -0, -1; # x ay -3.14159265358979 $x = atan2 -1, 0; # x ay katumbas ng -1.5707963267949 $x = atan2 0, 1; # x ay katumbas ng 0 $x = atan2 1, 1; # x ay katumbas ng 0.785398163397448 $x = atan2 1, 0; # x ay katumbas ng 1.5707963267949 $x = atan2 0, -1; # x ay katumbas ng 3.14159265358979

cos function Syntax :cos Mga argumento: :cos numero Resulta pagpapahayag ng numero

Function : numerong halaga cos nagbabalik ng cosine mga numero :cos

. Kung ang argumento ay tinanggal, kung gayon

$pi = atan2 0, -1; $x = cos 0; # x ay katumbas ng 1 $x = cos $pi/2; # x ay 6e-17 (halos 0) $x = cos $pi; # x ay katumbas ng -1

cos function exp function :cos Mga argumento: :cos numero Resulta pagpapahayag ng numero

Function : exp exp nagbabalik ng cosine mga numero :cos nagbabalik ng exponent :cos ay kinuha katumbas ng halaga ng $_ variable. Kung

ay mas malaki sa 709.78, pagkatapos ay 1. #INF ay ibinalik. Halimbawa:

int function

cos function : int :cos Mga argumento: :cos numero Resulta pagpapahayag ng numero

Function int ibinabalik ang buong bahagi nagbabalik ng cosine mga numero :cos

Print int 1.5; #1 print int -1.5; # -1

function ng log

cos function :log :cos Mga argumento: :cos numero Resulta pagpapahayag ng numero

Function log ibinabalik ang natural na logarithm nagbabalik ng cosine mga numero :cos

Print log 2.71828182845905; #1

rand function

cos function : rand :cos Mga argumento: :cos numero Resulta pagpapahayag ng numero

Function rand nagbabalik ng random na numero na mas malaki kaysa sa o katumbas ng zero at mas kaunti nagbabalik ng cosine, na dapat ay positibo. Kung ang argumento ay tinanggal, kung gayon :cos ay ipinapalagay na katumbas ng 1. Kung ang function ay hindi pa natatawag, awtomatiko itong tatawag dito.

pag-andar ng kasalanan

cos function : kasalanan :cos Mga argumento: :cos numero Resulta pagpapahayag ng numero

Function kasalanan nagbabalik ng sine nagbabalik ng cosine mga numero :cos ay kinuha katumbas ng halaga ng $_ variable. Mga halimbawa:

$pi = atan2 0, -1; $x = kasalanan 0; # x ay katumbas ng 0 $x = sin $pi/2; # x ay katumbas ng 1 $x = sin -$pi/2; # x ay katumbas ng -1

sqrt function

cos function :sqrt :cos Mga argumento: :cos numero Resulta pagpapahayag ng numero

Function sqrt ibinabalik ang square root ng nagbabalik ng cosine mga numero :cos ay kinuha katumbas ng halaga ng $_ variable. Kung ang argument ay mas mababa sa o katumbas ng zero, ang isang nakamamatay na runtime error ay nangyayari. Halimbawa:

I-print ang sqrt 2; #1.4142135623731

srand function

cos function : srand :cos Mga argumento: :cos pagpapahayag ng numero

Function srand sinisimulan ang generator random na mga numero. :cos Kung ang argumento nito ay tinanggal, kung gayon

nabuo ng runtime system. Mula sa PERL 5.004, ang isang tahasang tawag sa function na ito ay hindi na kailangan dahil awtomatiko na itong tinatawag ng rand() sa unang pagkakataong ito ay tinawag.

6.9.2. Mga function ng string

cos function chomp function :chomp linya chomp Mga argumento: :chomp listahan chomp Resulta pagpapahayag ng numero

Function pagpapahayag ng string chomp tinatanggal mula sa mga linya chomp ang trailing substring na tumutugma sa kasalukuyang record separator, ibig sabihin, ang mga nilalaman ng $/ variable. Kung ang argumento ay :chomp, pagkatapos ang function na ito ay inilapat sa bawat elemento ng listahan. Kung ang argumento ay tinanggal, kung gayon

ay kinuha katumbas ng halaga ng $_ variable. Ang resulta ng function ay ang kabuuang bilang ng mga character na inalis. Ang pangunahing gamit nito ay upang alisin ang mga sumusunod na bagong linya kapag nagbabasa ng bawat linya. text file

, Halimbawa:<>habang(

) (chomp; # remove \n sa dulo ng read line $_ . . . ) Kung katumbas ng $\ undef

o naglalaman ng isang reference sa isang numero (para sa mga fixed-length na talaan), kung gayon ang function na ito ay hindi nagtatanggal ng anuman.

cos function pag-chop function :chomp: tumaga chomp Mga argumento: :chomp listahan chomp tumaga Resulta listahan ng mga string expression

Function : halaga ng string chomp tinatanggal mula sa tumaga chomp ang huling karakter nito at ibinabalik ito. Kung ang argumento ay :chomp

, pagkatapos ang function na ito ay inilalapat sa bawat elemento ng listahan at ibinabalik ang huling character na inalis.

Kung ang argumento ay tinanggal, kung gayon

cos function $_ = "abcde"; tumaga; print; # prints "abcd" :chomp, function ng crypt Mga argumento: :chomp, function ng crypt:crypt Resulta listahan ng mga string expression

Function code mga ekspresyong string crypt ine-encode ang orihinal function ng crypt linya gamit ang string at ibinabalik ang resulta.

Code

cos function dapat binubuo ng dalawang character sa hanay [./0-9A-Za-z] . :chomp, substring, posisyon? Mga argumento: :chomp, substring mga ekspresyong string posisyon numero Resulta pagpapahayag ng numero

Function index nakatingin sa loob linya binigay substring, simula sa isang ibinigay mga posisyon o mula sa simula ng linya kung posisyon

$str = "Queen Mary"; print index($str, "Maria"); # 6 print index ($str, "mary"); # -1

lc function

cos function : lc :chomp Mga argumento: :chomp pagpapahayag ng string Resulta listahan ng mga string expression

Function lc kino-convert ang lahat ng mga character tinatanggal mula sa sa maliliit na titik. Kung ang argumento ay tinanggal, kung gayon :chomp

I-print ang lc "ABCDE"; #abcde

lcfirst function

cos function : lc muna :chomp Mga argumento: :chomp pagpapahayag ng string Resulta listahan ng mga string expression

Function lc una binago ang unang karakter tinatanggal mula sa V maliit na titik. Kung ang argumento ay tinanggal, kung gayon :chomp ay kinuha katumbas ng halaga ng $_ variable. Kung gagamitin ang direktiba ng lokal na paggamit, isasagawa ang conversion na isinasaalang-alang ang kasalukuyang setting ng lokal. Halimbawa:

I-print ang lcfirst "ABCDE"; # aBCDE

haba function

cos function :haba :chomp Mga argumento: :chomp pagpapahayag ng string Resulta pagpapahayag ng numero

Function haba ibinabalik ang bilang ng mga character sa linya. Kung ang argumento ay tinanggal, kung gayon :chomp ay kinuha katumbas ng halaga ng $_ variable. Halimbawa:

Haba ng pag-print "ABCDE"; #5

function ng rindex

cos function : rindex :chomp, substring, posisyon? Mga argumento: :chomp, substring mga ekspresyong string posisyon numero Resulta pagpapahayag ng numero

Function rindex nakatingin sa loob linya binigay substring mula kanan pakaliwa, simula sa isang ibinigay mga posisyon o mula sa dulo ng linya kung posisyon inalis. Ibinabalik nito ang posisyon ng nahanap na substring sa source string, o -1 kung hindi natagpuan ang substring. Halimbawa:

I-print ang rindex("abcabc", "abc"); #3

function substr

cos function :substr :chomp, pagkiling, haba?, kapalit? Mga argumento: :chomp, kapalit mga ekspresyong string pagkiling, haba mga numeric na expression Resulta listahan ng mga string expression

Function substr nagbabalik ng substring tinatanggal mula sa binigay haba, simula sa isang ibinigay mga offset. Kung pagkiling ay negatibo, pagkatapos ay binibilang ito mula sa dulo ng linya. haba Kung

ay tinanggal, pagkatapos ay ang mga character hanggang sa dulo ng linya ay kinukuha; kung ito ay negatibo, pagkatapos ay nagdaragdag ito sa haba ng string. Halimbawa:

I-print ang substr("abcdef", 1, -2); #bcd :chomp Kung

binigyan ng variable, kung gayon ang function na ito ay maaaring magkaroon ng pang-apat na argumento, na tumutukoy sa string kung saan pinapalitan ang ibinigay na substring, halimbawa:

$str = "abcdef"; substr($str, 1, -2,"xxx"); i-print ang $str; # axxxef

Ang halimbawang ito ay maaaring isulat tulad nito:

$str = "abcdef"; substr($str, 1, -2) = "xxx"; i-print ang $str; # axxxef

cos function uc function :chomp Mga argumento: :chomp pagpapahayag ng string Resulta listahan ng mga string expression

Function :uc kino-convert ang lahat ng mga character tinatanggal mula sa uc :chomp ay kinuha katumbas ng halaga ng $_ variable. Kung gagamitin ang direktiba ng lokal na paggamit, isasagawa ang conversion na isinasaalang-alang ang kasalukuyang setting ng lokal. Halimbawa:

sa malalaking titik. Kung ang argumento ay tinanggal, kung gayon

I-print ang uc "abcde"; #ABCDE

cos function ucfirst function :chomp Mga argumento: :chomp pagpapahayag ng string Resulta listahan ng mga string expression

Function : ucfirst binago ang unang karakter tinatanggal mula sa ucfirst :chomp ay kinuha katumbas ng halaga ng $_ variable. Kung gagamitin ang direktiba ng lokal na paggamit, isasagawa ang conversion na isinasaalang-alang ang kasalukuyang setting ng lokal. Halimbawa:

sa malaking titik. Kung ang argumento ay tinanggal, kung gayon

I-print ang ucfirst "abcde"; # Abcde

6.9.3. Iba pang mga scalar function

cos function chr function function ng crypt Mga argumento: function ng crypt numero Resulta listahan ng mga string expression

Function :chr chr function ng crypt mga numero function ng crypt nagbabalik ng isang character na may ibinigay na numero

ay kinuha katumbas ng halaga ng $_ variable. Halimbawa:

I-print ang chr 65; // A

cos function hex function :chomp Mga argumento: :chomp pagpapahayag ng string Resulta pagpapahayag ng numero

Function : hex hex crypt V nagbabago mga numero :chomp hexadecimal na numero

ay kinuha katumbas ng halaga ng $_ variable. Halimbawa, ang lahat ng sumusunod na pahayag ay magpapakita ng numero 165:

I-print ang hex na "0xaf"; print hex "xaf"; print hex "0af"; print hex "af";

cos function function ng okt :chomp Mga argumento: :chomp pagpapahayag ng string Resulta pagpapahayag ng numero

Function :oct hex crypt oct :chomp nagsisimula sa "0x", pagkatapos ito ay binibigyang kahulugan bilang isang hexadecimal na numero; kung ito ay nagsisimula sa "0b", ito ay binibigyang kahulugan bilang isang binary na numero; sa ibang mga kaso ito ay binibigyang kahulugan bilang octal na numero :chomp. Kung ang argumento ay tinanggal, kung gayon

ay kinuha katumbas ng halaga ng $_ variable. Mga halimbawa:

I-print ang okt "0xaf"; #165 print oct "0b101"; #5 print oct "0100"; #64 print oct "100"; #64

cos function function ord :chomp Mga argumento: :chomp pagpapahayag ng string Resulta pagpapahayag ng numero

Function :ord ord tinatanggal mula sa mga numero :chomp ay kinuha katumbas ng halaga ng $_ variable. Halimbawa:

ibinabalik ang numeric code ng unang character

I-print ang ord "ABC"; #65

cos function pack function : pack, chomp Mga argumento: : pack listahan chomp sample Resulta listahan ng mga string expression

Function listahan ng mga scalar expression pack chomp i-pack ang ibinigay : pack mga halaga sa isang string at ibinabalik ito bilang isang resulta. Ang mga panuntunan sa pag-iimpake ay tinukoy ng linya, na binubuo ng mga character na nagsasaad ng mga panuntunan sa pagbabago para sa mga elemento ng listahan.

Sample	Resulta
maaaring maglaman ng mga sumusunod na character:	Simbolo
a	Isang arbitrary string, magdagdag ng zero byte sa dulo. A
ASCII string	, magdagdag ng puwang sa dulo.
Z	ASCII string, magdagdag ng null byte sa dulo.
b	Bit string, ang mga bit sa isang byte ay naka-pack na nagsisimula sa hindi bababa sa makabuluhang bit.
B	Bit string, ang mga bit sa isang byte ay naka-pack na nagsisimula sa pinaka makabuluhang bit.
h	Hexadecimal string, nauuna ang mababang tetrad.
H	Hexadecimal string, nauuna ang mataas na tetrad.
c	Isang nilagdaang one-byte integer.
C	Isang unsigned one-byte integer.
s	Isang two-byte signed integer.
S	Isang two-byte na unsigned integer.
i	Naka-sign integer (ang bilang ng mga byte ay depende sa arkitektura).
ako	Unsigned integer (ang bilang ng mga byte ay depende sa arkitektura).
l	Isang four-byte signed integer.
L	Isang four-byte na unsigned integer.
n	Isang two-byte na unsigned integer, ang pinakamahalagang byte ang mauna.
N	Isang apat na byte na unsigned integer, pinaka makabuluhang byte muna.
v	Isang two-byte unsigned integer, low byte muna.
V	Isang four-byte unsigned integer, low byte muna.
q	Isang eight-byte signed integer.
Q	Isang eight-byte unsigned integer.
f	Normal na katumpakan na lumulutang na numero, nakadepende ang format sa arkitektura.
d	Dobleng katumpakan na lumulutang na numero, nakadepende ang format sa arkitektura.
p	Pointer sa isang null-terminated string.
P	Isang pointer sa isang fixed-length na istraktura.
u	String sa uuencode encoding.
U	String sa UTF-8 encoding.
w	Compressed integer sa BER na format.
x	Null byte.
@	X

Dobleng byte. Pad na may mga zero hanggang sa tinukoy na posisyon.:

• Sumusunod ang mga template pagsunod sa mga tuntunin. Kung ang counter ay tinukoy ng simbolo *, nangangahulugan ito ng pag-iimpake ng lahat ng natitirang elemento ng listahan (maliban sa @, x, X, kung saan ang simbolo na ito ay katumbas ng 0, at u, kung saan ito ay katumbas ng 1).
• Ang ibig sabihin ng Z* ay pagdaragdag ng dagdag na null byte sa dulo ng string. Ang bilang ng pag-uulit para sa u ay binibigyang kahulugan bilang ang maximum na bilang ng mga byte na dapat i-encode sa isang linya ng output; sa kasong ito, ang 0 at 1 ay pinapalitan ng 45.
• Ang mga uri ng a, A, Z ay palaging kumukuha ng isang halaga mula sa listahan. Ang bilang ng pag-uulit para sa kanila ay nangangahulugang ang haba ng naka-pack na string. Kung ang linya ay mas mahaba kaysa sa counter, ito ay pinutol; sa madaling salita, ito ay nilagyan ng mga zero (a, Z) o mga puwang (A). Kapag naka-pack, ang a at Z ay katumbas; Kapag nag-unpack, inaalis ni A ang mga trailing space at null byte mula sa string, inaalis ng Z ang lahat pagkatapos ng unang null byte, at wala itong inaalis.
• Ang mga uri ng b at B ay nagko-convert sa bawat isa sa mga input byte sa isang bit ng resulta. Ang resultang bit ay 0 o 1 depende sa halaga ng hindi bababa sa makabuluhang bit ng source byte. Tinutukoy ng repetition counter ang bilang ng mga byte na ii-pack. Sa kasong ito, ini-pack ng b ang mga natanggap na bit sa byte ng resulta, simula sa hindi bababa sa makabuluhang bit nito, at B mula sa pinaka makabuluhang bit nito. Kung ang haba ng source string ay hindi mahahati ng 8, ang resulta ay may palaman na zero bits.
• Sa panahon ng decompression, ang mga karagdagang bit na ito ay binabalewala. Kung ang input string ay mas mahaba kaysa sa counter, ito ay pinutol. * bilang isang umuulit na bilang ay nangangahulugan ng paggamit ng lahat ng byte ng input field. Kapag na-decompress, ang mga bit ay na-convert sa "0" at "1" na mga byte. Kung katumbas ng $\ Para sa mga uri ng h at H, ang bilang ng pag-uulit ay nangangahulugan ng bilang ng mga hexadecimal na digit (tetrads) na iimpake.
• Ang / sa halip na isang counter ng pag-uulit ay nagbibigay-daan sa iyo upang i-pack ang haba nito sa harap ng isang string. Halimbawa, ang pattern na "n/a*" ay nangangahulugan na ang resulta ay bubuo ng dalawang-byte na numero na naglalaman ng haba ng orihinal na string at ang string mismo.
• Kapag nag-iimpake, walang ginagawang equalization ng mga resultang halaga.
• Ang pattern ay maaaring maglaman ng komento na nagsisimula sa # na character at nagpapatuloy hanggang sa dulo ng linya.
• Kung ang isang template ay nangangailangan ng higit pang mga argumento kaysa sa nilalaman nito listahan, Iyon chomp ay nilagyan ng mga walang laman na linyang "" . listahan Kung ang isang template ay nangangailangan ng mas kaunting mga argumento kaysa sa nilalaman nito

, pagkatapos ay hindi papansinin ang mga karagdagang argumento.

$foo = pack("CCCC",65,66,67,68); # $foo = "ABCD" $foo = pack("C4",65,66,67,68); # $foo = "ABCD" $foo = pack("aaaa","abc","x","y","z"); # $foo = "axyz" $foo = pack("a14","abcdefg"); # "abcdefg\0\0\0\0\0\0\0" $foo = pack("s2",1,2); # $foo = "\1\0\2\0" sa IBM PC, "\0\1\0\2" sa Mac

cos function i-unpack ang function : pack, :chomp Mga argumento: : pack, :chomp:crypt Resulta: i-unpack

Function listahan ng mga scalar expression: hanay ng mga halaga crypt nag-unpack : pack, puno ng isang function. Nagbabalik ito ng hanay ng mga nagresultang halaga (sa kontekstong scalar, ibinabalik ang unang halaga na ibinalik). Ang mga panuntunan sa pag-unpack ay tinukoy ng linya Nagbabalik ito ng hanay ng mga nagresultang halaga (sa kontekstong scalar, ibinabalik ang unang halaga na ibinalik)., ang istraktura nito ay kapareho ng para sa . Bilang karagdagan, ang template ay maaaring maglaman ng prefix % bago ang titik na tumutukoy sa uri ng pag-unpack n

, na nagpapahiwatig na hindi namin nais na makuha ang resulta ng pag-unpack, ngunit ito

-bit checksum. Para sa iba pang mga detalye, tingnan ang paglalarawan ng function. Ang sumusunod na halimbawa ay nagpapakita

cos function mabisang paraan pagbibilang ng bilang ng isang bit sa $mask variable:, pagkiling, $setbits = unpack("%32b*", $mask); Mga argumento: pagbibilang ng bilang ng isang bit sa $mask variable: listahan pagkiling, $setbits = unpack("%32b*", $mask); mga numeric na expression Resulta pagpapahayag ng numero

Function vec function:vec pagbibilang ng bilang ng isang bit sa $mask variable: pagpapahayag lapad vec tumitingin sa string bilang isang array na binubuo ng mga elemento ng isang ibinigay pagkiling lapad

sa bits. Kinukuha nito ang elementong may ibinigay

Function vec function displacement

Function at ibinabalik ito. Ang lapad ay dapat na isang kapangyarihan ng 2 sa hanay 1 hanggang 32 (o 64 sa 64-bit na mga platform), ay itinuturing bilang isang unsigned integer. Halimbawa:$x = "\x10\x32\x54"; # $x = (0, 1, 2, 3, 4, 5) bilang vector ng mga 4-bit na numero na naka-print na vec($x, 2, 4); # kaya ang numero 2 ay ipi-print ay maaaring gamitin sa kaliwang bahagi ng isang assignment operator upang bumuo ng isang hanay ng mga bitgroup sa isang string. Halimbawa, maaari naming bumuo ng string $x sa itaas tulad nito: quotemeta

nagdaragdag ng "\" character sa argument string bago ang bawat character na hindi

split function

cos function : hati sample, :chomp, limitasyon Mga argumento: sample regular na pagpapahayag :chomp listahan limitasyon numero Resulta: listahan ng mga string

Function hati hinahati ang orihinal crypt sa mga substring at nagbabalik ng listahan ng mga substring na ito. Sa kontekstong scalar, nag-iimbak ito ng listahan ng mga substring sa @_ array at ibinabalik ang haba nito. :chomp Kung ay tinanggal, pagkatapos ay ipinapalagay na katumbas ng halaga ng variable na $_ . Ang paghahati sa mga substring ay nangyayari sa pagtutugma ng mga posisyon na may ibinigay sample ; kung ito ay tinanggal, pagkatapos ay ang split ay ginanap sa space character, habang nangungunang mga puwang

I-print ang substr("abcdef", 1, -2); #bcd limitasyon sa bawat substring ay aalisin. Kung ang pattern ay naglalaman ng mga panaklong, ang mga substring na tumutugma sa expression sa mga panaklong ay isasama bilang mga hiwalay na elemento sa resultang listahan.

ay ibinibigay at positibo, pagkatapos ay tinutukoy nito ang maximum na pinapayagang bilang ng mga substring na i-extract.

Kung aalisin ito o katumbas ng zero, hindi kasama sa resultang listahan ang mga sumusunod na walang laman na substring. Kung negatibo ito, ibabalik ang lahat ng na-extract na substring. Mga halimbawa:

cos function @_ = split(/,/, "a,b,c,d,"); # @_ = ("a", "b", "c", "d") @_ = split(/,/, "a,b,c,d,", 3); # @_ = ("a", "b", "c,d,") @_ = split(/,/, "a,b,c,d,", -3); # @_ = ("a", "b", "c", "d", "") @_ = split(/(,)/, "a,b,c,d,"); # @_ = ("a", ",", "b", ",", "c", ",", "d", ",") :chomp Mga argumento: :chomp pagpapahayag ng string Resulta function ng pag-aaral

Function : pag-aaral: Hindi crypt pag-aaral crypt nag-compile : pag-aaral(o ang halaga ng variable na $_ kung aalisin) sa panloob na representasyon. Kung

, Halimbawa:<>ay nilayon na itugma sa isang pattern nang maraming beses, ang pag-compile nito ay makakatipid ng oras sa mga susunod na pagpapatakbo ng pagtutugma. Isang linya lamang ang maaaring i-compile sa isang pagkakataon; aplikasyon ng function

sa isa pang linya ay kinakansela ang compilation ng kasalukuyang linya. Halimbawa:

) ( pag-aralan; i-print ang "Akin\n" kung /\bme\b/; i-print ang "Iyo\n" kung /\byou\b/; ... )

Problema

Kailangan mong gumawa ng link para tawagan ang subroutine. Lumilitaw ang problemang ito kapag lumilikha ng mga tagapangasiwa ng signal, na hindi direktang tinatawag na mga function ng Tk, at mga pointer upang gumana ang mga hash.

Solusyon

Upang makakuha ng reference sa isang function, i-prefix lang ang pangalan nito sa \&. Bilang karagdagan, ang sub() formulation ay nagbibigay-daan sa iyo na lumikha ng mga hindi kilalang function. Ang isang anonymous na sanggunian ng function ay maaaring iimbak tulad ng iba. Ipinakilala ng Perl 5.004 ang isang postfix notation para sa dereferencing function reference. Upang tumawag sa isang function sa pamamagitan ng reference, dati kailangan mong isulat ang &$funcname (@ARGS), kung saan ang $funcname ay ang pangalan ng function. Ang kakayahang i-save ang pangalan ng isang function sa isang variable ay nananatili ngayon: $funcname = "thefunc"; &$funcname(); gayunpaman, ang ganitong solusyon ay hindi kanais-nais para sa ilang kadahilanan. Una, gumagamit ito ng simboliko kaysa sa tunay na (matigas) na mga link, kaya sa paggamit ng mahigpit na "refs" na direktiba, hindi na ito kinakailangan. Karaniwang hindi inirerekomenda ang mga simbolikong link dahil hindi nila ma-access ang mga lexical na variable, mga global variable lang, at walang pagbibilang ng reference para sa mga ito. Pangalawa, hindi ito naglalaman ng data ng package, kaya maaaring tumawag ang pag-execute ng fragment sa isa pang package maling function. Sa wakas, kung ang function ay na-override sa isang punto (bagaman hindi ito madalas mangyari), simbolikong link makikipag-ugnayan ); if ($commands($string)) ($commands($string)->(); ) else ( print "No such command: $string\n"; ) Kung lumikha ka ng anonymous na function na tumutukoy sa isang lexical(m) variable mula sa naglalaman ng saklaw, tinitiyak ng reference counting scheme na ang memorya ng lexical variable ay hindi nade-deallocate kung may mga reference dito: sub counter_maker ( my $start = 0; return sub ( # Closure return $start++; # Lexical variable ); # mula sa naglalaman ng saklaw na saklaw ) $counter = counter_maker(); para sa ($i =0; $i Kahit na nakumpleto na ang counter_maker at ang $start ay wala na sa saklaw, hindi ito inilabas ni Perl dahil ang anonymous na subroutine (na sinangguni ng $counter) ay naglalaman pa rin ng reference sa $start. Kung tatawagan mo ang counter_maker muli, ang function ay magbabalik ng reference sa isa pang hindi kilalang gawain gamit ang ibang $start value: $counter1 = counter_maker(); 0 1 2 3 4 5 0 Ang mga pagsasara ay kadalasang ginagamit sa hindi direktang tinatawag na mga function (mga callback). Sa mga GUI, at sa programming na nakabatay sa kaganapan sa pangkalahatan, ang ilang partikular na piraso ng code ay nauugnay sa mga kaganapan sa keypress, mga pag-click ng mouse, mga kaganapan sa window display, atbp. Ang code na ito ay tinatawag na mas huli, marahil mula sa isang ganap na naiibang saklaw. Dapat na available ang mga variable na ginamit sa pagsasara sa oras ng tawag. Upang gumana nang maayos dapat ang mga ito ay leksikal, hindi pandaigdigan. Ginagamit din ang mga pagsasara sa mga function generator, na mga function na lumilikha at nagbabalik ng iba pang mga function. Ang function ng counter_maker ay isang generator. Narito ang isa pang simpleng halimbawa: sub timestamp ( my $start_time = time(); return sub ( return time() - $start_time ); ) $early = timestamp(); matulog 20; $mamaya = timestamp(); matulog 10; printf "Ito ay %d segundo mula noong maaga.\n", $early->(); printf "Ito" ay %d segundo mula noong nakaraan.\n", $later->(); 30 segundo na ang nakakaraan mula nang maaga. 10 segundo na ang nakalipas mula nang maglaon. Ang bawat timestamp na tawag ay bumubuo at bumabalik bagong feature

Inilalagay ang namespace ng isang module sa isa pa. Ito ay hindi isang built-in na function, ngunit isang paraan lamang na minana mula sa isang module (MODULE parameter) na kailangang i-export ang mga pangalan nito (LIST parameter) sa isa pang module.

Mag-import ng LISTAHAN NG MODULE

lokal

Ang local() function ay ginagamit upang ideklara at simulan ang isa o higit pang mga variable:

Lokal na EXPR lokal ($myvar, , %myhash); lokal na $pi = 3.14159; lokal ($pi, $exp) = (3.14159, 2.71828);

ngunit, hindi katulad ng my() function, hindi ito lumilikha ng mga lokal na variable, ngunit pansamantalang mga halaga para sa mga pandaigdigang variable sa loob:

• mga subroutine;
• isang bloke ng mga pahayag na nakapaloob sa mga kulot na tirante;
• ipinasa ang expression upang isagawa ang eval() function;
• file;

Depende sa kung saan ang local() function mismo ay tinatawag na magdeklara ng mga variable. Kung ang local() function ay ginagamit upang magdeklara ng maramihang mga variable, dapat na nakapaloob ang mga ito sa mga panaklong. Kung ang isang pandaigdigang variable na idineklara gamit ang function na ito ay dating nakatagpo bago ang deklarasyon at may ilang halaga, pagkatapos ay ang halagang ito ay naka-imbak sa nakatagong stack at ibinalik pagkatapos lumabas sa subroutine, block, eval() function, o file, ayon sa pagkakabanggit. Ang isang variable na idineklara ng local() function, o mas tiyak ang pansamantalang value nito, ay available sa anumang function na tinatawag sa loob ng subroutine, block, eval() function, o file kung saan ginawa ang deklarasyon. Ang nasabing variable ay tinatawag na dynamic, at ang saklaw nito ay tinatawag na dynamic na saklaw. Ang pangalan ay sumasalamin sa katotohanan na ang saklaw ng isang variable ay dynamic na nagbabago sa bawat tawag sa isang function na nag-a-access sa variable na iyon.

Halimbawa:

aking

Ang my() function ay ginagamit upang ideklara ang isa o higit pang mga variable bilang lokal:

at nililimitahan ang kanilang saklaw:

• subroutine;
• isang bloke ng mga pahayag na nakapaloob sa mga kulot na tirante;
• ipinasa ang expression upang isagawa ang eval() function;
• file, depende sa kung saan ang my() function mismo ay tinatawag upang magdeklara ng mga variable.

Kung ang EXPR expression ay naglalaman ng isang listahan ng mga variable, dapat itong nakapaloob sa mga panaklong:

Aking ($myvar, @mylist, %myhash);

Kasabay ng deklarasyon, maaaring masimulan ang mga variable:

Aking $pi = 3.14159; my ($pi, $exp) = (3.14159, 2.71828);

Ang mga variable na idineklara gamit ang my() function ay available sa kanilang saklaw lamang sa mga routine na tinukoy sa saklaw na iyon. Hindi available ang mga ito para sa mga gawaing tinukoy sa labas nito. Ang ganitong mga variable ay tinatawag na lexical, at ang saklaw mismo ay tinatawag na lexical o static na saklaw.

Halimbawa:

Sub f1(lokal ($x) = "aaaa"; my($y) = "bbbb"; print("f1: x = $xn"); print("f1: y = $ynn"); f2() ; print("f1: x = $xn"); print("f1: y = $ynn"); ); $x = "cccc"; $y = "dddd";

Ang resulta ng pagpapatupad halimbawang ito magkakaroon ng sumusunod na output:

F1: x = aaaa f1: y = bbbb f2: x = aaaa f2: y = f2: x = cccc f2: y = dddd f1: x = cccc f1: y = bbbb

Tulad ng makikita mo mula sa resulta sa itaas, ang function na f2() ay walang access sa variable na $y na ipinahayag gamit ang function my() sa loob ng function na f1(), at, sa kabaligtaran, ay may access sa variable na $x ipinahayag sa loob ng f1() gamit ang function local().

pakete

Tinutukoy ang isang hiwalay na pandaigdigang namespace (package): lahat ng hindi natukoy na mga dynamic na identifier (kabilang ang mga idineklara sa pamamagitan ng local() ngunit hindi my()) ay maiimbak dito. Upang ma-access ang mga ito sa labas ng isang package, dapat kang tumukoy ng prefix na kumakatawan sa pangalan ng package na sinusundan ng dalawang colon na "::". Ang saklaw ng mga variable ng package ay umaabot hanggang sa dulo ng statement block kung saan matatagpuan ang package o sa isang bagong deklarasyon ng package. Kung aalisin ang pangalan ng package, pinipilit nitong tukuyin ang lahat ng identifier, kabilang ang mga pangalan ng function.

Package [PACKAGE_NAME]

gamitin

Naglo-load ng module sa oras ng pag-compile; kung ang module ay hindi magagamit, ang pagsasama-sama ng buong programa ay hihinto.

Gamitin ang MODULE LIST gamitin ang MODULE gamitin ang MODULE VERSION LIST gamitin ang VERSION