Hifadhi faili kwenye diski.

Hatua ya 2 - Kuunda Hati

Hati iliyo hapa chini inachukua data iliyoingia, kuihifadhi kwenye faili na kuonyesha ujumbe ulio na kiungo cha faili na jina lililohifadhiwa. Andika maandishi ya programu katika kihariri na uyahifadhi katika faili ya testform.pl katika saraka ya cgi-bin ya seva yako ya wavuti. Hakikisha kuwa safu ya kwanza ya programu ina njia sahihi ya programu ya mkalimani (kupata programu kwenye UNIX, tumia amri ya perl; kwenye Windows, tafuta faili perl.exe). Pia hakikisha kuwa njia ya faili ya pato ni njia sahihi ya eneo la uhifadhi wa hati la seva ya wavuti. Hatimaye, sahihisha URL ili ilingane na anwani ya seva yako.

Hatua ya 3 - Kujaribu Hati

Baada ya kuangalia hati kuibua kwa makosa - kutokuwepo kwa ";" mwishoni mwa mistari, uwepo wa mabano na nukuu ambazo hazijaoanishwa, n.k., endesha hati ili kuangalia moja kwa moja kutoka mstari wa amri, baada ya kwenda kwenye saraka ya cgi-bin. Hapa kuna mifano ya jinsi hii inafanywa:

Ikiwa hati ina makosa, utaona ujumbe kama

Katika kesi hii, angalia maandishi karibu na mstari maalum. Kumbuka kwamba sababu ya kosa inaweza kuwa kadhaa, wakati mwingine wengi kabisa, mistari ya juu. Hifadhi hati iliyosahihishwa na ijaribu hadi itatoa matokeo sahihi:

Hatua ya 4 - Kujaribu Hati kwa kutumia Fomu

Ikiwa hati inafanya kazi yenyewe, unaweza kuijaribu na fomu:

1. Hakikisha seva ya wavuti inafanya kazi.
2. Fungua kivinjari chako.
3. Andika URL ambapo fomu yako iko (kumbuka kuwa mstari lazima uanze na http://, sio faili://.
4. Ingiza jina lako kwenye uwanja wa fomu na ubofye kitufe cha "Jisajili".
5. Unapaswa kuona ujumbe kama huu:

Asante kwa kujaza fomu
Bofya hapa kuona mchango wako.

Huu ni ukurasa unaozalishwa na hati kwenye kuruka. Ikiwa unapokea ujumbe wa hitilafu ya seva, angalia kwamba hati iko kwa usahihi na thamani ya parameter ya hatua katika lebo ya fomu ni sahihi.

1. Ikiwa utaona ukurasa unaozalishwa kwa usahihi, bofya kiungo. Unapaswa kuona ukurasa mpya iliyoundwa na hati ambayo inaonekana kama hii:

Jina la Novikov

Ikiwa hauoni hii, angalia kuwa njia katika utofauti wa $targetfile ni sahihi na URL katika mstari wa mwisho wa hati ni sahihi. Vinginevyo, fomu na hati hufanya kazi kwa pamoja. Umefaulu kuunda programu yako ya kwanza ya wavuti.

Majadiliano: Kuweka hati

Kama ilivyoelezwa tayari, sehemu ya kwanza ya hati ina mipangilio ambayo inajumuisha vipengele kadhaa. Mstari wa kwanza unafafanua njia ya mpango wa mkalimani:
#!/usr/local/bin/perl kwa UNIX
au
\Faili za Programu\Perl5\perl.exe za Win32

Pia, mwanzoni mwa script, kwa urahisi, unaweza kuweka maoni kuhusu nini script hii inalenga.

Maoni yanaweza kupatikana popote kwenye programu na kuanza na ishara #:
#Haya ni maoni au
fungua(NAMEFILE, ">$testfile"); #Fungua faili kwa kuandika...

Pia ni mazoezi mazuri kufafanua vibadilishio vyote na vigeu vya kimataifa mwanzoni mwa hati. (Ninakushauri kusajili njia zote kama vigezo, hasa ikiwa programu ina mistari zaidi ya 50, kwa urahisi wa kubadilisha eneo la faili). Kwa mfano:
ukurasa wa nyumbani = "http://server_name/home/index.html";

Vigezo vyote vya kawaida katika Perl huanza na herufi $. Kuna aina zingine nyingi za anuwai, kama vile safu na kadhalika.

Mistari yote ya programu isipokuwa ya kwanza na maoni lazima iishe na ";".

Majadiliano: Kusoma data kutoka kwa fomu

Sasa tunahitaji "kusoma" ingizo la mtumiaji kwenye anuwai za Perl. Baada ya mtumiaji kubofya kitufe cha Wasilisha kwenye fomu, kivinjari hutuma seva jina la hati na data iliyochukuliwa kutoka kwa fomu. Data hupitishwa kwa hati kwenye uingizaji wa kawaida.

Wacha tufikirie kuwa fomu hiyo ina sehemu zifuatazo:

Katika kesi hii, data itatumwa kwa hati katika muundo ufuatao:
user_name=Andy+Novikov&co_name=TeleSputnik&phone=(812)+123-45-67

Hati ya Perl lazima ichanganue kamba hii kipande kwa kipande na kuihifadhi katika vigeuzo kwa uchakataji zaidi. Mistari inayofanya vitendo hivi ni ya kawaida kabisa:
soma(STDIN, $bafa, $ENV("CONTENT_LENGTH"));

Mstari huu husoma data kutoka kwa ingizo la kawaida na kuiweka katika kigezo cha $buffer. Urefu wa mfuatano hupitishwa kwa hati kupitia utofauti wa mazingira CONTENT_LENGTH.

Mara tu data inapowekwa katika utofauti wa $buffer, unaweza kuigawanya katika anuwai tofauti na maadili yao yanayolingana:
@jozi = mgawanyiko(/&/, $bafa);

Sasa tunayo safu ya @pairs na vijiti vifuatavyo vya kamba:
user_name=Andy+Novikov
co_name=TeleSputnik
simu=(812)+123-45-67

Sasa tunahitaji kuvunja mistari hii kuwa jozi za thamani ya parameta:
foreach $pair (@pairs) ( ($jina, $value) = split(/=/, $pair); $value =~ tr/+/ /; # badilisha pluses na nafasi $value =~ s/%() /pakiti("C", hex($1))/km; thamani ya $=~ s///g; $input($name) = thamani ya $; )

Kwa njia hii unapata safu ya vigezo, index ambayo ni thamani ya parameter ya jina la uwanja wa fomu, na thamani ni data iliyoingia kwenye uwanja unaofanana.

Majadiliano: Nini cha kufanya na data?

Hatua inayofuata ni usindikaji wa data. Lakini jinsi gani? Yote inategemea kile unachotaka kufanya na data. Katika mfano wetu, kulingana na data iliyopokelewa, tunaunda HTML mpya hati. Hapo chini tutaangalia mifano rahisi ya kile kinachoweza kufanywa na data iliyopatikana. Tafadhali kumbuka kuwa hatujaribu kuthibitisha yaliyomo kwenye sehemu. Ingawa katika maandishi halisi hii ni hatua inayohitajika na wakati mwingine ni muhimu.

Majadiliano: Kuandika kwa faili

Moja ya mambo unaweza kufanya na data ni kuandika kwa faili. Perl hutoa seti ya kazi za kufungua, kuchakata na kufunga faili. Kwa njia hii unaweza kuunda hati mpya ya HTML, kuongeza data kwa tayari HTML iliyopo hati au uhifadhi data katika faili ya maandishi kwa usindikaji zaidi.

Kazi ya kufungua faili inaonekana kama hii:
fungua (HANDLE, "jina"); # Fungua faili kwa kusoma wazi(HANDLE, ">jina"); # Fungua faili kwa ajili ya kuandika wazi(HANDLE, ">>jina"); # Fungua faili ili kuongezea hadi mwisho

HANDLE ni jina lolote la muda ambalo utatumia kama kitambulisho cha faili wakati wa kufanya shughuli. Mara tu faili imefunguliwa, unaweza kuiandikia kwa kutumia kazi ya kuchapisha:
chapisha HANDLE "Maandishi haya yatawekwa kwenye faili kama yalivyo.\n"; chapisha HANDLE "Katika kesi hii, kutofautiana ", $ variable," itawekwa katika maandishi."; chapisha HANDLE "Kigezo cha kubadilika cha $ kinaweza kuwekwa katika maandishi hata hivyo.\n"; chapisha HANDLE "Nukuu na herufi zingine maalum \; zinahitaji \"kukata\".\n";

Baada ya kukamilisha shughuli na faili, unahitaji kuifunga:
funga(HANDLE);

Baada ya hayo, data zote zilizorekodiwa zitahifadhiwa kwenye diski.

Kabla ya kuandika faili, lazima uhakikishe kuwa seva ya wavuti ina ufikiaji wa saraka ambayo faili iko na ina ruhusa ya kuandika kwa faili hii.

Kumbuka kwamba kazi ya karibu inapaswa kuwa karibu iwezekanavyo kwa kazi ya mwisho ya kuandika kwa faili. Hii ni kutokana na ukweli kwamba seva ya wavuti inaendesha katika mazingira ya watumiaji wengi, na script inaweza kuendeshwa wakati huo huo na watumiaji kadhaa. Unapofungua faili kwa ajili ya kuandika, (faili) imefungwa na matukio mengine ya script hayataweza kuifungua, ambayo itasababisha kuchelewa kutekeleza ombi.

Mfano: Kuunda ukurasa mpya wa HTML

Mfano ufuatao unaweza kuonekana kuwa mgumu mwanzoni, lakini inachofanya ni kuandika habari fulani kwa faili.

Kwa sababu ya ukweli kwamba tunaunda ukurasa wa wavuti, faili ina vitambulisho vya HTML pamoja na katika maandishi wazi. Kumbuka kwamba \n huingiza tu mstari mpya kwenye maandishi kwa utazamaji rahisi wa faili iliyotengenezwa baadaye.

Ingizo zote kutoka kwa fomu zimo katika vigeu vya $input(field_name). Wakati wa kuchapisha, vigezo vile lazima viwekwe kwenye nukuu na kutenganishwa na koma.

Mfano: Ongeza hadi mwisho wa faili

Kuandika kwa faili iliyopo ni rahisi unapotaka kuambatisha taarifa mpya hadi mwisho wa faili. Kwa mfano, ili kuongeza maelezo mapya ya mtumiaji kwenye faili iliyoundwa hapo juu, utahitaji hati ifuatayo:

Mfano: Kuongeza katikati ya faili iliyopo

Kazi ngumu zaidi ni kuingiza data mpya katikati ya faili. Ona kwamba katika mfano wa kwanza tuliingiza mstari wa maoni kwenye faili ambayo ilionekana kama hii:

Maoni haya yatatumika kama kialamisho kwetu ambapo tunahitaji kuingiza data mpya. Mfano huu hauna suluhisho la kifahari kabisa, lakini ni rahisi kutekeleza na kuelewa. Anatumia faili ya muda, ingawa unaweza kufanya bila hiyo:

Mfano: Kutuma data kwa barua pepe

Wakati mwingine unaweza kutaka data iliyoingizwa kwenye fomu kutumwa kwa anwani ya barua pepe.

Ili kufanya hivyo, utahitaji programu ya kutuma barua na interface ya mstari wa amri. Chini ya UNIX hii inaweza kuwa barua pepe au barua. Katika mfano huu, data inatumwa kwa kutumia programu ya kutuma barua pepe. Badala ya kuandika kwa faili, tunatumia kuandika kwa bomba lililo wazi maalum:

Majadiliano: Kuunda kurasa za wavuti kwa kuruka

Sehemu muhimu ya mwisho ya hati ya Perl ni kutuma matokeo kwa mtumiaji. Hii inafanikiwa kwa uchapishaji sawa, lakini bila faili au kitambulisho cha kituo. Kila kitu ambacho kimechapishwa kwa fomu za kawaida za pato hati ya sasa kwenye dirisha la kivinjari. Kwa mfano:

Makini na mstari wa kwanza. Mstari huu una taarifa kuhusu aina ya data iliyorejeshwa. Uhamisho mara mbili wa hisa unahitajika katika kesi hii. Ukurasa huu utarejeshwa kwa mtumiaji mara tu baada ya kubofya kitufe cha Wasilisha.

Tafadhali kumbuka kuwa hii ni moja tu ya mifano mingi ya jinsi ukurasa unavyoweza kuonekana kwa kuruka. Kimsingi, unaweza kutoa hati ya HTML ya sura na maudhui yoyote.

Ukurasa wa nyumbani » PERL » Vitanzi na matawi.

Kuunda Hati za CGI Kwa Kutumia PERL.

Aina za data hutumiwa katika programu wakati wa kutangaza vigezo. Kwa kifupi, aina ya data inafafanua seti ya maadili ambayo kutofautisha kunaweza kuchukua, pamoja na seti ya shughuli ambazo programu inaweza kufanya juu yake. Kwa lugha Data ya Perl inaweza kuwa nambari au mfuatano wa herufi.

Thamani moja inaitwa idadi ya scalar au scalar tu. Ifuatayo ni mifano ya maadili ya scalar ambayo hutumiwa katika Perl:
- Desimali: 127 au 127.0 au 1.27E2
- Heksadesimali: Ox7F au 0x7f
Octal: 0177 (0 ya kwanza inaonyesha octal inatumika)
- Kamba: "Hujambo Ulimwengu\n" au "Hujambo Ulimwengu"

Kwa mfano, amri ifuatayo hutumia debugger ya Perl kuchapisha nambari ya octal 0177, ambayo inalingana na nambari ya decimal 127:

D.B.<4>r0177 127

Perl hutafsiri data katika umbizo lake la ndani. Perl anapochapisha thamani za oktali au heksadesimali, kwanza huzibadilisha hadi umbizo la desimali, kama inavyoonyeshwa.

Kumbuka: Kama utakavyojifunza, hati ya Perl hukuruhusu kutumia kitendakazi cha printf kuchapisha thamani katika umbizo linaloweza kupigiwa simu, kama vile octal au hexadecimal.

Umbizo la sehemu inayoelea ya usahihi maradufu hutumiwa kama uwakilishi wa ndani wa nambari zote. Kwa maneno mengine, hakuna nambari kamili kati ya fomati za ndani. Walakini, katika hali nyingi unaweza kupuuza hii na Perl atafanya kila kitu sawa. Kwa mfano, ikiwa unatumia idadi katika muktadha ambapo nambari kamili pekee ndizo zinazoeleweka, Perl itapunguza nambari yenyewe kiotomatiki.

Kumbuka: Ikiwa unapanga programu katika C na umetumia mgawanyiko kamili na upunguzaji kamili kiotomatiki, basi wakati wa kupanga programu katika Perl, lazima ukumbuke kutekeleza upunguzaji kwa mikono kwa kutumia int() kazi.

Amri ifuatayo inaonyesha jinsi Perl hushughulikia nambari kamili na za kuelea:

Chapisha 6&3; # itachapisha 2 chapa 6.9 & 3.1 # chapa 7 / 2 # itachapisha 2.3333 sio nambari kamili ya int(7/3) # itachapisha 2

Vile vile Perl hubadilisha nambari za sehemu zinazoelea hadi nambari kamili: hati inapotumia nambari kamili, pia inabadilisha nambari kuwa mifuatano na kinyume chake wakati ubadilishaji kama huo unaeleweka. Kwa mfano, ikiwa hati hutumia nambari katika muktadha ambapo mifuatano pekee inaeleweka, kama vile wakati wa kuunganisha mifuatano, inabadilisha nambari kuwa mifuatano. Vivyo hivyo, ikiwa unataka kutumia mifuatano ambapo nambari pekee ndizo zinazoeleweka, Perl huzibadilisha kuwa nambari. Unapofanya kazi na maandishi ya Perl, kwa kawaida sio lazima kuwa na wasiwasi juu ya uwakilishi wa ndani wa maadili ya scalar.

Perl pia inasaidia dhana ya maadili ya boolean, lakini haina aina maalum ya kuzielezea. Kama ilivyo kwa C, thamani ya nambari inachukuliwa kuwa kweli ikiwa sio sifuri. Zaidi ya hayo, thamani ya mfuatano inachukuliwa kuwa kweli ikiwa si sawa na "" au "0". Baadhi ya waendeshaji Boolean kama vile<>> (kubwa kuliko), rudisha moja kama thamani<истинно>na sifuri - kama<ложно>.

Kwa hivyo, hati yako inapaswa kutibu tu maadili yasiyo ya sifuri ya aina zote mbili za kamba na nambari kama maadili ya boolean.<истинно>. Maandishi ya Perl yanaweza kuweka pamoja maadili ya scalar na kuunda orodha. Ikiwa hati huhifadhi orodha katika anuwai fulani, basi kigezo hiki kinakuwa safu.

VIGEZO

Perl inaauni aina tatu za vigeu: scalar, safu, na safu shirikishi. Kama ilivyo katika lugha C, majina tofauti huandikwa kwa tofauti kati ya herufi ndogo na herufi kubwa. Kwa hivyo, majina ya VAR, Var na var yanaelezea anuwai tofauti. Hati inaweza kuwa na tofauti ya scalar inayoitwa var na safu ya anuwai pia inayoitwa var. Watatofautiana katika Perl kulingana na muktadha.

Kumbuka: Vigezo vya Perl havijachapishwa, kwa vile viko katika C. Kwa mfano, kutofautiana kwa scalar kunaweza kuwa na aina yoyote ya scalar, na utumaji wa aina ni moja kwa moja. Pia, kama unavyoweza kuwa umegundua, vijiti katika Perl sio lazima kutangazwa. Ikiwa utofauti haujatangazwa, Perl huchukulia kama kimataifa. Chini utajifunza kuhusu tamko la vigezo na upeo wao.

AINA ZA SALAR

Kama ilivyoonyeshwa, tofauti ya scalar inaweza kuwa na thamani moja. Katika Perl, majina ya kutofautisha ya scalar kila wakati huanza na ($). Usemi ufuatao unapeana utofauti wa scalar $age thamani ya 35 na utofauti $nataja thamani ya kamba. . Kazi ya kuchapisha basi hutumika kuchapisha thamani ya kila kigezo:

Umri wa $ = 35; $name = "Bob"; chapisha ($jina,"ni",$age);

Ukihifadhi misemo hii katika faili inayoitwa SALAR.PL, unaweza kuendesha programu kama hii:

C:\PERL> Perl SALAR.PL Bob ana miaka 35

SAFU

Kama ilivyoelezwa hapo juu, safu ni vigeu ambavyo huchukua orodha ya thamani za scalar kama thamani. Maandishi yafuatayo ya programu ya Perl yanaonyesha tamko la viambajengo vya safu na kuanzishwa kwao:

@days = ("Jua","Mon","Jumanne","Wed","Thu","Ijumaa","Jumamosi"); chapa(@siku); # itachapisha chapa ya "SunMonTueWedThuFriSat"($days); # itachapisha "Thu" @weekdays = @siku; thamani # ("Mon","Tue","Wed","Thu","Fri") @emptylist = (); Orodha # ya kusubiri

Rejea kwa vigeu vya aina<массив>kwa kawaida huanza na ishara ya (@) na hufuatwa na thamani katika mabano ya mraba (). Kama ilivyo katika upangaji wa C, fahirisi za safu za hati huwa ni viwezo vya aina kamili, ambavyo kwa kawaida huanza na thamani isiyo na maana. Utaona vighairi kwa sheria hizi mbili katika mifano itakayofafanuliwa katika sura hii. Semi ya tatu ($days) ni mfano wa mkusanyiko unaorejelea thamani ya kadiri. Kwa kuwa ina kipengele kimoja tu, thamani inayotokana ni scalar.

Ikiwa unatumia ishara ya ($) badala ya ishara ya (@), hati itarejelea thamani ya scalar. Ujumbe huu ni muhimu sana. Mabano ya mraba yanaonyesha kuwa hati inarejelea safu. Alama ya $, kwa upande wake, inaonyesha marejeleo ya thamani ya scalar. Kuanzisha safu ya @weekdays hufanywa kwa kuchagua sehemu ya safu ya @days. Katika mfano uliopita, safu ya @days ilitumika bila faharasa. Faharasa inapoachwa, Perl inarejelea safu nzima. Vile vile, katika mfano uliopita, safu ya @days ilianzishwa na orodha ya maandishi.

Mbali na kugawa maandishi halisi kama maadili kwa safu, hati inaweza pia kugawa maadili ya vigeu au hata safu zingine kwa safu, kama inavyoonyeshwa hapa chini:

@stuff = ($age, $name) @FriendsOfMine = ("Joe","Mary", @FriendsOfYours);

Mfano ufuatao hutumia sehemu za safu:

@wikendi = @siku ; matokeo # ("Jua","Sat") yamechapishwa (@siku); # itatoa "MonTueWedThuFriSunSat"

Ikiwa hati hutumia kigezo cha safu katika muktadha wa kola, basi thamani ni idadi ya vipengele vya safu. Muktadha wa scalar ni ule ambao tu maadili ya scalar ndio yenye maana. Kwa mfano, usemi ufuatao hutumia muktadha wa safu ya vitu ili kubainisha idadi ya vipengele vilivyomo katika safu. Ikiwa idadi ya vitu ni kubwa kuliko au sawa na 2, basi hati inaonyesha ujumbe na inamaliza utekelezaji:

(@mambo >= 2) || kufa "Vitu vingi!\n";

Kitendakazi cha kufa huelekeza Perl kusitisha utekelezaji na kutoa ujumbe maalum. Ikiwa ujumbe haujajumuishwa, basi chaguo la kukokotoa linamaliza hati.

Perl pia inasaidia muundo maalum wa kutofautisha wa $# ambao unarudisha thamani ya mwisho ya faharasa katika safu. Kwa mfano, yafuatayo kwa usemi hutumia $[ kubainisha thamani ya faharasa ya kuanzia ya safu, na $# kubainisha kipengele cha mwisho cha safu. Katika kesi hii, kwa kutumia kwa kujieleza, maadili ya kila moja ya vitu yanaonyeshwa:

Kwa ($i =$[; $i<= $#stuff; $i++) { print $stuff[$i]; }

Iliyoandikwa kwa kitanzi inaweza kubadilishwa na usemi ufuatao sawa:

Chapisha @vitu;

NAFASI YA MUKTADHA WA VIGEZO VYA AINA YA SCALAR NA VECTOR

Kumbuka kuwa opereta wa ujenzi wa orodha (,) inaonekana sawa kabisa na opereta wa tathmini ya mpangilio (,). Ni opereta gani inatumika inategemea muktadha ambayo inaonekana, haswa ikiwa kutofautisha ni scalar au safu. Perl hutumia muundo wa orodha katika muktadha wa safu na tathmini ya mfuatano kwa mikwaju. Fikiria maneno yafuatayo:

@an_array = (1,2,3,4,5); $a_scalar = (1,2,3,4,5);

Usemi wa kwanza huanzisha safu, huku usemi wa pili ukiweka utofautishaji wa kadiri $a_scalar hadi 5, ukitupilia mbali thamani nne za kwanza. Fikiria maneno mawili yafuatayo:

Chapisha $assoc(1,2); chapisha @assoc(1,2);

Kesi ya kwanza itachapisha thamani moja ya safu ya ushirika na funguo mbili, wakati ya pili itachapisha maadili mawili ya safu ya ushirika na ufunguo mmoja. Kati ya misemo miwili ifuatayo, ya kwanza inakili orodha, wakati ya pili inapeana thamani ya scalar sawa na saizi ya safu:

@x = @orodha; $x = @orodha;

ASSOCIATIVE ARRAYS

Safu shirikishi ni sawa na safu za kawaida kwa kuwa ni orodha ya vigeu vya kadiri. Tofauti ni kwamba safu lazima itumie nambari kamili kama fahirisi wakati wa kuchagua vipengee vya safu, ilhali safu shirikishi inaweza kutumia thamani za aina yoyote kuchagua. vipengele vya safu. Thamani za faharisi za safu ya ushirika huitwa funguo. Fikiria mifano ifuatayo:

umri wa $("Bob") = 35; umri wa $("Mariamu") = 25; $, = ""; # badilisha kitenganishi cha pato cha kuchapisha opereta @ages("Bob","Mary"); # itachapisha vitufe vya kuchapisha "25 35"(%ages); # itachapisha "Bob Mary" kwa $name (funguo(%ages)) ( chapisha "$name is $ages($keys)\n"; )

Kama unavyoona, programu inapeana maadili kwa tofauti "$," (kigezo cha scalar ambacho jina lake ni koma). Hati hutumia usemi huu ili taarifa ya kuchapisha inapotumiwa baadaye, data ya pato isiunganishwe. na kila mmoja. Vigezo maalum kama vile "$," vimejadiliwa baadaye katika sura hii. Safu za ushirika zinatambuliwa kwa kutumia braces curly. Kama ilivyo kwa safu, faharasa hazitumiki wakati wa kurejelea safu nzima ya ushirika. Kwa mfano, link@ages("Bob", "Mary") hutumia faharasa kwenye mabano, ambayo huelekeza kwenye safu shirikishi. @ kiambishi awali kinaonyesha kuwa tunazungumza juu ya safu. Vile vile, kutumia ishara ya dola mbele ya safu inaonyesha kwamba kiasi cha scalar kinatumiwa.

Kumbuka: Ikiwa funguo mbili zimebainishwa, basi pamoja na @ ishara hii inaonyesha kuwa tunazungumza juu ya sehemu ya safu ya ushirika na matokeo yanapaswa kuwa katika mfumo wa orodha. Usemi huu ni sawa na #ages("Bob"), #ages("Mary"). ambayo ina thamani (35, 25).

Usemi wa funguo za kuchapisha(%ages) huita opereta ya vitufe, ambayo hurejesha orodha kamili ya vitufe katika safu shirikishi. Marejeleo ya %mia yenye ishara ya asilimia kama kiambishi awali inamaanisha kuwa marejeleo hurejelea safu nzima ya ushirika. Kumbuka kuwa kitanzi cha for loop kinarejelea vigeu vilivyoambatanishwa katika nukuu mbili. Hatimaye, mfano wa mwisho uliojadiliwa pia hutumia opereta wa funguo na kutambulisha a for loop ili kuchapisha michanganyiko yote ya safu shirikishi. Kitanzi cha for loop kinarejelea vigeu vilivyoambatanishwa katika nukuu mbili. Perl, kwa upande wake, itachukua nafasi ya maadili yaliyorejelewa na anuwai wakati inachanganua kamba. Watayarishaji wa programu huita mchakato huu kuwa mbadala au ukalimani.

Kumbuka: Perl haifasiri vigeu vilivyo na mifuatano iliyonukuliwa moja.

PERL OPERATORS

Ingawa data ya Perl na aina tofauti ni tofauti kabisa na zile za C, waendeshaji na misemo ya Perl inapaswa kuhisi kujulikana zaidi. Waendeshaji C wote wapo katika Perl isipokuwa aina ya opereta, opereta ya *ptr contents, na var.member au var->member operator. Kwa kuongeza, Perl huanzisha waendeshaji wengi wapya kwa ajili ya matumizi katika shughuli kama vile kulinganisha kamba na uendeshaji wa kamba.

WAENDESHA HESABU

Waendeshaji hesabu hufanya kazi kwa nambari za nambari na matokeo yao ni nambari. Ikiwa usemi unajumuisha utendaji wa mfuatano, Perl hubadilisha thamani za mfuatano kuwa nambari kabla ya kutathmini usemi. Perl hubadilisha mifuatano kuwa nambari kwa njia sawa na kazi ya C atof() katika maktaba za wakati wa kutekelezwa. Perl kwa sasa inasaidia waendeshaji hesabu wafuatao:
- + nyongeza
- - kutoa au kubadilisha ishara
- * kuzidisha
- / mgawanyiko (kwa nambari za sehemu zinazoelea tu)
- % modulo (kwa nambari kamili pekee)

Wacha tuangalie mifano ya shughuli zifuatazo za hesabu huko Perl:

$ x = 2.5; $y = 3; chapisha ($x + 2*$y); # itachapisha chapa 8.5 (7 / $y); # itachapisha 2.3333333 int (7 / $y); # itachapisha chapa 2 (7 % $y); # itachapisha chapa 1 (7.5 % $y); # itachapisha 1

Kumbuka: Katika Perl, opereta mgawanyiko daima husababisha nambari ya sehemu inayoelea, na matokeo ya kuchukua modulo ya nambari moja nyingine ni nambari kamili, na operesheni zote mbili hubadilishwa kwanza kuwa aina kamili.

Fikiria operesheni ifuatayo ya modulo:

Chapisha (7.9% 3.6); # itatoa 1 sawa (7% 3) = 1

Perl pia inasaidia waendeshaji wa kuongeza na kupunguza:
- ++ punguzo katika kiambishi awali au fomu ya kiambishi cha posta
- - nyongeza katika fomu ya kiambishi awali au kiambishi. Hebu tuangalie mifano ya shughuli za kuongeza na kupunguza:

$ x = 4; +$x; chapisha $x; # itachapisha 5 $y = $x-; # itapungua x baada ya kugawa y thamani ya x chapisha "$y $x" # chapisha 5 4

Hatimaye, Perl hutoa opereta wa hesabu kwa ufafanuzi (**). Fikiria mifano ifuatayo ya kutumia operesheni ya upanuzi:

$ x = 2 ** 3; # matokeo 8 $x = 2 ** 0.5; # mzizi wa mraba wa 2 $ x = -2 ** -3; # 1/(-2 mchemraba), tokeo -1/8 (-0.125)

WAENDESHAJI BITCH

Waendeshaji Bitwise hufanya kazi kwenye uwakilishi wa binary wa nambari kamili na huwa na matokeo kamili. Ikiwa operesheni ni mfuatano au sehemu, Perl kwanza huibadilisha kuwa nambari kamili na kuchakata oparesheni kwa kutumia uwakilishi wa 32-bit. Waendeshaji wote wa C bitwise wanawakilishwa katika Perl:
- | kidogo AU
- & kidogo NA
- ^ kipekee kidogo AU
- ~ bit inversion
- << сдвиг влево
- >> kuhama kulia

Fikiria mifano ifuatayo ya shughuli za busara kidogo:

$ x = 5; #101 katika binary $y = 3; #011 katika toleo la jozi $x | $y; # 7 (111) chapisha $x & $y; # 1 (001) chapisha $x ^ $y # 6 (110) chapisha $x & ~1; # 4 (100) chapa $x<< 2 # 20 (10100) print $x >> 1 # 2 (10)

Kama ilivyo kwa C, tabia ya waendeshaji zamu ya kulia inategemea utekelezaji wa lugha wakati operesheni ni mbaya.

KULINGANISHA OPERATORS

Waendeshaji kulinganisha hulinganisha maadili ya operesheni mbili. Kama tu wakati wa kufanya kazi na waendeshaji hesabu, Perl hubadilisha uendeshaji wa kamba kuwa uendeshaji wa nambari kabla ya kufanya ulinganisho. Ili kuruhusu hati kulinganisha mifuatano ambayo si nambari, Perl ina waendeshaji wa ziada kulinganisha kamba. Waendeshaji hawa hulinganisha mifuatano kwa kutumia thamani za ASCII. Ikiwa nambari ya nambari inatolewa kama operesheni ya ulinganisho wa mfuatano, inabadilishwa kwanza kuwa mfuatano. Jedwali 12.1 linaorodhesha waendeshaji kulinganisha:

Thamani ya Mfuatano wa Namba = = eq sawa!= nе si sawa > gt kubwa kuliko< it меньше чем >= gе kubwa kuliko au sawa na<= lе меньше или равно <=>cmp sio sawa (matokeo yaliyosainiwa)

Jedwali 12.1. Waendeshaji wa kulinganisha wa Perl.

Matokeo ya operesheni ya kulinganisha ni moja ikiwa kulinganisha ni kweli na sifuri vinginevyo. Walakini, operesheni ya mwisho (<=>au cmp) inaweza kurudisha thamani -1, 0, au 1 kulingana na ikiwa thamani ya operesheni ya kwanza ni ndogo kuliko, sawa na, au kubwa kuliko ya pili.

Kumbuka: Opereta wa Perl's cmp anatenda sawa na kazi ya maktaba ya C ya wakati wa kukimbia ya Strcmp() .

Fikiria mfano ufuatao wa kulinganisha:

$ x = 5; # x ni sawa na kuchapisha 5 ($x< 4); # если false, то выведет 0

WAENDESHAJI WA KImantiki

Waendeshaji kimantiki huchanganua misemo ya Boolean na thamani za kurejesha<истинно>au<ложно>matokeo yake. Perl huchukulia uendeshaji wa shughuli za kimantiki kama maadili ya Boolean, i.e. kama kweli au uongo.

Waendeshaji wa kimantiki wa Perl ni pamoja na yafuatayo:

Perl daima huchakata misemo ya boolean kutoka kushoto kwenda kulia. Mbali na hilo. Perl huacha kutathmini kila wakati ikiwa tathmini iliyofanywa tayari inatosha kuamua thamani ya matokeo. Kwa kuongeza waendeshaji wa kimantiki wa jumla, Perl inasaidia waendeshaji wa ziada wa kimantiki:

Opereta ya kimantiki ya kukanusha (!) inabadilisha thamani ya thamani ya Boolean na thamani yake kinyume. Kama vile katika C, Perl ana mwendeshaji wa masharti (
-:) hutumia operesheni tatu. Usemi unaotumia opereta wa masharti una fomu ifuatayo:

Hali
- matokeo ya kweli: matokeo ya uwongo

Vile vile, usemi ufuatao hutumia opereta wa masharti kumpa Bob ufikiaji kamili na kila mtu mwingine ufikiaji mdogo:

$access = ($user eq "Bob"
- "Kamili" : "Mdogo");

Opereta mfuatano<,>(pia inajulikana kama opereta koma) si opereta mwenye mantiki kabisa kwa sababu haichunguzi ukweli wa uendeshaji wake. Perl hutathmini utendakazi wa opereta mfuatano kutoka kushoto kwenda kulia na kurejesha thamani ya operesheni ya kulia zaidi. Mfano ufuatao unaonyesha matumizi ya opereta koma katika kitanzi cha.

Kwa ($i=0, $j=10; $i<10; $i++, $j-) { print i$," ",$j }

WAENDESHAJI STRING

Kwa kuwa Perl ni lugha ya kuchakata maandishi, haishangazi kuwa inajumuisha waendeshaji wa ziada wa kudhibiti mifuatano. Wafuatao ni waendeshaji wa usindikaji wa kamba:
-. mshikamano wa kamba
- x marudio
- =~ muundo tofauti unaolingana
- !~ sawa na ile iliyotangulia, lakini pamoja na kukanusha matokeo

Taarifa mbili za kwanza zinaonyeshwa kwa urahisi na mfano:

Chapisha "b". "ya" x 2. "a"; # itachapisha "ndizi"

Kama inavyoonyeshwa, usemi huu hutumia upatanisho wa kamba na opereta replication kuchapisha kamba .Waendeshaji wawili wa mwisho hutumika kujaribu kama operesheni ya mfuatano inajumuisha mchoro fulani. Suala hili linajadiliwa kwa undani katika sehemu<Регулярные выражения>. Mfano ufuatao unaonyesha matumizi yao:

$var = "ndizi"; chapisha ($var =~ /ana/)
- KWELI: UONGO;

Katika hali hii, mfuatano wa mfuatano wa jaribio la utokeaji wa mfuatano (=~) ulitumiwa kuangalia ikiwa muundo ana uko katika kigezo cha $var. Katika kesi hii, usemi huchukua thamani<истинно>.

WAENDESHA KAZI

Ikiwa unajua lugha ya programu ya C, basi aina za waendeshaji wa mgawo wa Perl zinapaswa kujulikana kwako. Kama ilivyo kwa C, waendeshaji hawa hulazimisha Perl kufanya shughuli maalum kwa maadili ambayo yanaonekana upande wa kulia wa mwendeshaji na kisha kutekeleza mgawo:

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

LVALUES Katika Perl, kama katika C, lvalue ni jina la kile kinachoonekana kwenye upande wa kushoto wa opereta wa mgawo. Kwa hivyo, lvalue inawakilisha chombo ambacho kinaweza kupewa thamani, kwa mfano, lvalue inaweza kuwa kutofautiana. Kwa mfano, hati ya Perl haiwezi kugawa thamani kwa mfuatano wa herufi, kama vile usemi = 32 kwa sababu sio thamani. Walakini, hati inaweza kugawa thamani kwa $Bob, kama vile $Bob = 32, kwani $Bob ni lvalue. Katika Perl, huluki yoyote ambayo inaweza kutumika kama lvalue kawaida ni. Kwa mfano, usemi ufuatao hupakia na kufunua orodha ya maadili, na orodha ya vigeu katika kisa cha kwanza na scalars tatu katika pili zikiwa lvalues:

@color = ($r, $g, $b); Kifurushi # cha rangi ($r, $g, $b) = @color; # kuondoa sanduku la rangi

Unapofanya kazi na orodha katika Perl, mwendeshaji wa kazi haitumiki kwa orodha nzima. Hati inaweza kugawa maadili kwa vipengele vya orodha ya mtu binafsi, kama inavyoonyeshwa hapa chini:

@vitu = (100,200,300);

Katika kesi hii, operator hutoa thamani kwa vipengele vitatu vya orodha. Vile vile, usemi ufuatao unafungua vipengele vya orodha, ukitoa thamani za vipengele viwili vya kwanza kwa vigezo viwili vya scalar, na salio la safu kwa orodha ya orodha:

($arg1,$arg2,@rest) = @ARGV; # unaweza kuchanganya scalars na safu

OPERESHENI ZA KUFANYA KAZI NA ORODHA

Operesheni za kufanya kazi na orodha ni pamoja na zifuatazo:

Mjenzi wa orodha - .. mwendeshaji wa upeo - opereta wa urudufishaji wa x

Tayari umetumia kijenzi cha orodha kuanzisha safu na kuunda orodha ya vigeu vinavyotumika kama lvalues. Opereta wa masafa hurejesha kama thamani yake mfuatano wa nambari kamili ambao huanza kutoka kwa operesheni ya kushoto na kuendelea hadi na kujumuisha operesheni ya kulia. Hati mara nyingi hutumia opereta wa upeo kwa kushirikiana na kiunda orodha kuunda orodha. Kwa mfano, usemi ufuatao hutumia opereta wa upeo kuunda orodha inayoitwa @digits ambayo ina nambari sifuri hadi tisa:

@ tarakimu = 0..9; Orodha # (1,2,3,4,5,6,7,8,9)

Vile vile, usemi huu unaweza kutumia opereta wa wigo kuunda wigo wa mabadiliko ya safu za fahirisi. Tuseme orodha @days ina siku za wiki (kuanzia Jumapili). Usemi ufuatao unapeana maadili ya orodha ya @weekdays kuanzia Jumatatu hadi Ijumaa:

@wikendi = @siku;

Mwishowe, usemi ufuatao hutumia waendeshaji wa eneo mbili kuunda orodha ya nambari za hexadecimal:

@hex_digits = (0..9,a..f);

Opereta replication huunda tu nakala za operesheni fulani na idadi maalum ya nyakati. Kwa mfano, usemi ufuatao unarudia orodha ya maadili 1, 2, 3 mara tatu:

OPERATORS ZA KUFANYA KAZI NA FAILI

Perl ina orodha pana ya waendeshaji kwa kufanya kazi na faili. Kuna angalau waendeshaji 27 wanaorudisha taarifa maalum kuhusu faili bila hata kuifungua. Taarifa nyingi za Perl zinalenga mifumo ya UNIX, lakini taarifa zifuatazo hufanya kazi kwenye mfumo wowote:

D huangalia uwepo wa saraka
--e huamua uwepo wa faili
--s inabainisha saizi ya faili
--w huamua ikiwa faili iliyotolewa inaweza kuandikiwa

Waendeshaji faili mbili zinazofuata hurejesha thamani ya boolean. Opereta wa tatu hurejesha saizi ya faili kwa baiti. Maandishi yafuatayo yanaonyesha matumizi ya waendeshaji hawa:

Ikiwa (-e,"perl.exe") ( chapisha "Ukubwa wa faili ni:" -s "perl.exe"; ) vinginevyo ( print "can\" t find perl.exe\n"; ) (-w "SomeFile ") || kufa "Haiwezi kuandika kwa SomeFile\n";

VIPAUMBELE VYA UTEKELEZAJI WA OPERATORIA

Kama lugha yoyote ya programu, Perl huamua vipaumbele vya utekelezaji wa waendeshaji, kwa msaada ambao mlolongo wa utekelezaji wao umeamriwa. Jedwali 12.2 linaorodhesha vipaumbele vya waendeshaji kutoka juu hadi chini kabisa:

Jedwali 12.2. Utangulizi wa waendeshaji wa Perl kutoka juu hadi chini kabisa

Katika hati yako, unaweza kubadilisha mpangilio ambao taarifa zinatekelezwa kwa kutumia mabano.

PERL CONSTRUCTS

Perl inaauni misemo yote ya C kwa kutumia umbizo linalokaribia kufanana. Kwa mfano, udhibiti huunda ikiwa, wakati, fanya. kwa na goto hutumika kwa namna moja katika lugha zote mbili. Kama utaona baadaye, taarifa ya kuendelea ina maana tofauti kidogo katika Perl. Thamani yake ya zamani sasa inaitwa ijayo, na taarifa ya mapumziko sasa inaitwa mwisho. Perl hatekelezi taarifa ya kubadili. Kwa kuongeza, baadhi ya maneno ya lugha ya C yanaweza kupatikana katika Perl katika miundo mingine, na maneno mengi mapya yameongezwa.

WAENDESHAJI RAHISI NA WA KUUNGANISHA

Usemi rahisi ni mchanganyiko wowote halali wa waendeshaji na waendeshaji. Katika Perl, mwendeshaji ni usemi unaoishia na semicolon. Kama ilivyo katika lugha ya programu ya C, taarifa zote huisha na semicolon. Unapotoa maandishi ya programu kwa kitatuzi, unaweza kuacha nusu-koloni kwa sababu kitatuzi kitakupa wewe. Maandishi yafuatayo yanaonyesha mwendeshaji rahisi wa mgawo huko Perl:

$Title = "Utayarishaji wa Mtandao"; !}

Kama vile upangaji wa C, hati za Perl zinaweza kuwa na vizuizi vya taarifa, au taarifa kiwanja, ambazo zimewekwa ndani ya viunga vilivyopinda (()), kama inavyoonyeshwa hapa chini:

(#Waendeshaji#Kizuizi kingine cha waendeshaji)

Hati zako zitafanya matumizi makubwa ya vizuizi vya maagizo pamoja na taarifa ngumu zaidi. Kama ilivyo kwa C, hati za Perl zinaweza kutumia vizuizi vya taarifa kufafanua wigo wa anuwai za kawaida. Hata hivyo, ufafanuzi wa vigezo vya ndani katika block sio moja kwa moja. Hati lazima itumie neno kuu la ndani ili kuzitangaza. Tutaangalia wigo wa viambajengo kwa undani baadaye katika sura hii.

WAENDESHAJI WENYE MASHARTI

Mifano mingi ya hapo awali ilitumia taarifa ya if. Katika Perl, taarifa ya if inakaribia kufanana na kauli ya if katika C. Tofauti, hata hivyo, ni kwamba katika C, taarifa ya if inaweza kutumia taarifa rahisi bila viunga vilivyopinda, ambapo katika Perl, taarifa lazima ziambatanishwe katika viunga vilivyopindapinda, kutengeneza block.

Ikiwa (expr) taarifa; // inakubalika kwa C lakini sio kwa Perl ikiwa (expr) ( taarifa; # hivi ndivyo unapaswa kuifanya kwa Perl)

Vile vile, taarifa nyingine ya Perl inafanya kazi tofauti kidogo na taarifa inayolingana katika C. Katika Perl, taarifa lazima ziambatanishwe katika viunga vilivyopinda na kuunda kizuizi:

// Mfano katika C haukubaliki katika Perl ikiwa (expr1) statament1; vinginevyo ikiwa (expr2) taarifa2; jambo lingine 3;

Ifuatayo inaonyesha kuwa Perl hukuruhusu kutumia muundo wa elsif:

Ikiwa (expr1) ( taarifa1; ) elsif (expr2) ( taarifa2; ) vinginevyo ( ststement3; )

OPERATOR ISIPOKUWA

Katika lugha ya programu C, watayarishaji programu hutumia ukanushaji wa kimantiki (!) ili kubadilisha thamani ya Boolean, kama inavyoonyeshwa hapa chini:

Ikiwa (!(expr)) // Kukanusha katika C ( taarifa; )

Pamoja na utumiaji wa kukanusha kimantiki, hati za Perl mara nyingi huwa na taarifa isipokuwa, ambayo hufanya kitu sawa na nambari ya C hapo juu.

Isipokuwa (expr) ( taarifa; )

Kumbuka: Tofauti na C, Perl haina taarifa ya kubadili.

FANYA OPERATOR

Kesi moja maalum ya waendeshaji wa block ni waendeshaji wa do, ambayo inaruhusu kizuizi cha taarifa kurudisha maadili. Thamani ambayo taarifa ya do inarejesha ni thamani ya usemi wa mwisho uliotathminiwa ndani ya kizuizi. Kwa mfano, kauli ifuatayo ya do inalinganisha ubadilishaji wa mfuatano $Month na miezi ya mwaka na kuweka kigezo cha $DayCount kwa idadi ya siku katika mwezi:

$DayCount = fanya (kama ($Month eq "Septemba" || $Month eq "April" || $Month eq "June" || $Month eq "November") (30; ) elsif ($Month eq "Februari" ) ($Mwaka & 3
- 28:29; # Angalia mwaka wa kurukaruka) mwingine ( 31; ));

Kumbuka kuwa Perl inahitaji semicolon mwishoni mwa do block. Usichanganye zuio la kufanya na kauli ya kufanya wakati, ambayo itajadiliwa baadaye katika sura hii.

MIZUNGUKO NA MATAWI

Perl anaunga mkono kwa, wakati, na kufanya taarifa za kitanzi zenye tofauti ndogo kutoka kwa utekelezaji wake katika C. Tofauti kubwa ni kwamba Perl inahitaji taarifa zitumike katika vizuizi vilivyofungwa kwenye brashi zilizopinda. Pia, kama utakavyoona, Perl huongeza uundaji wa kitanzi ili kutoa aina mpya. Katika mifano ifuatayo, kwa, wakati, na kufanya vitanzi hufanya kazi sawa katika C na Perl:

Kwa($i = 0; $i< 100;$i++) { printf("%d\n", $i) ; } while ($i >0) ( printf("%d\n", $i-); ) fanya ( printf("%d\n", $i++); ) huku ($i< 0);

Muundo wa vitanzi katika C ni tofauti na ule wa Perl kwa kuwa Perl haina taarifa ya mapumziko, na taarifa ya kuendelea hufanya kazi tofauti kabisa. Kwa bahati nzuri, Perlo hutoa muundo mpya, rahisi zaidi na angavu zaidi:

Ili kuelewa muundo wa kitanzi huko Perl, unahitaji kuelewa utumiaji wa kizuizi kinachoendelea. Fikiria wakati kitanzi kifuatacho, ambacho kina kizuizi cha kuendelea:

$ i = 100; wakati ($i > 0) ( chapisha $i; ) endelea ($i-)

Unaweza kufikiria kuendelea kuzuia kama usemi wa tatu katika kitanzi ambacho hutekelezwa kila marudio. Vile vile, Perl hutekeleza kizuizi cha kuendelea mwishoni mwa kila marudio. Walakini, kama utakavyojifunza baadaye, kizuizi cha kuendelea kinaipa hati udhibiti zaidi wa mchakato kuliko a for loop hutoa. Wakati kitanzi cha Perl kinatumia taarifa inayofuata, kizuizi cha kuendelea bado kinatekelezwa ikiwa kipo. Walakini, ikiwa kitanzi kinatumia taarifa ya kufanya upya, kizuizi cha kuendelea hakitekelezwi.

TAGS

Katika hati ya Perl, lebo humaanisha tu jina linalolingana na nafasi fulani ndani ya hati. Majina ya lebo huisha na koloni (kwa mfano, kitanzi cha nje:). Kwa kutumia taarifa ya goto, hati inaweza kuruka hadi kwenye lebo. Zaidi ya hayo, waendeshaji wa mwisho, wanaofuata, na wa kufanya upya wanaweza kutumika kurukia lebo. Msimbo ufuatao unaonyesha matumizi ya opereta wa mwisho kuruka hadi kwenye lebo:

Outerloop: wakati ($i > 0) ( wakati ($j > 0) ( #Mchakato mwingine hapa ikiwa ($needToAboutLoop) ( outerloop ya mwisho; ) ) )

Katika kesi hii, maagizo yana tawi la mwisho la kuruka kwenye kitanzi cha nje na kumaliza kitanzi.

MPAKA KITANZI

Muundo mwingine wa kitanzi huko Perl ni kitanzi cha mpaka, ambacho ni kinyume cha kitanzi cha wakati. Kumbuka, katika kitanzi cha muda, taarifa zinatekelezwa mradi tu hali iliyoainishwa imetimizwa. Katika kitanzi cha mpaka, kwa upande mwingine, maagizo yanatekelezwa hadi hali itakapotimizwa. Kwa mfano, fikiria kitanzi cha muda kama kile kilichoonyeshwa kwenye ukurasa unaofuata.

Wakati (!(expr)) ( taarifa; )

Kwa kutumia kitanzi hadi, unaweza kuunda kitanzi kinachofanana kilichoonyeshwa hapa chini:

Hadi ( expr ) ( taarifa; )

Vile vile, taarifa ifuatayo ya kufanya huku inatumia kiendeshaji cha kukanusha kimantiki kuzunguka hadi usemi fulani wa Boolean utathmini kuwa kweli:

Fanya ( taarifa; ) huku (!(expr));

Kwa kutumia do hadi kujenga, unaweza kuunda kitanzi kinachofanana bila kutumia ukanushaji wa kimantiki:

Fanya ( taarifa; ) hadi (expr);

KWA NA FOREACH CYCLES

Perl inasaidia kwa vitanzi kwa njia sawa na C:

Kwa (taarifa1; usemi; taarifa2) (taarifa3;)

Kwa mfano, nambari ifuatayo hutumia kitanzi kuchapisha maadili ya nambari kutoka 0 hadi 100:

Kwa (tarakimu $ = 0; $ tarakimu<=100; $digit++) { print $digit, " "; }

Zaidi ya hayo, Perl inajumuisha muundo wa kitanzi cha foreach ambacho huruhusu hati kurudia juu ya orodha na safu. Hebu tuangalie mfano:

@list = ("a","b","c"); foreach $arg (@list) ( chapisha "Kipengee cha orodha: $arg\n"; ) mbele $i (1..10) ( chapisha "iteration $i\n" )

Katika kesi ya kwanza, kitanzi cha foreach kilirudiwa kupitia maadili ya @list variable. Katika mfano wa pili, kitanzi cha foreach kinarudia nambari katika safu kutoka 1 hadi 10. Kitanzi cha foreach kinaweza kuwa na orodha ya neno halisi au safu, kama inavyoonyeshwa kwenye mfano uliopita. Baada ya kurudia mara moja kwa kitanzi, tofauti maalum ya scalar ($ arg katika kesi ya kwanza na $i katika kesi ya pili) inachukua thamani kutoka kwa orodha iliyotolewa ya vipengele. Upeo wa kutofautiana kwa scalar katika kitanzi cha foreach ni mdogo kwa mwili wa kitanzi. Kwa hivyo, tofauti ya kitanzi cha scalar, foreach, haitapingana na jina la kutofautisha sawa lililofafanuliwa nje ya kitanzi. Nambari ifuatayo hutumia kibadilishaji kinachoitwa $i ndani na nje ya kitanzi cha mbele:

$ i = 1001; foreach $i (1..9) ( chapisha "$i\n"; kitanzi # kitachapisha 123456789 ) kuchapisha "$i\n";

Kama unavyoona kutoka kwa mfano huu, kigezo cha $i kinachotumiwa kupanga marudio ya kitanzi hakipingani na utofauti wa $i uliofafanuliwa nje ya kitanzi. Kipengele cha kitanzi cha foreach ambacho hati zako zinaweza kunufaika nacho ni uwezo wa kurekebisha vipengele vya safu. (Kuwa mwangalifu unapotekeleza kipengele hiki!) Zingatia kitanzi kifuatacho cha foreach, ambacho huongeza thamani 10 kwa kila kipengele cha safu:

@orodha = 1..5; foreach $i (@list) ( $i += 10; ) $, = " "; chapisha @orodha; # itatoa 11 12 13 14 15

Hebu tufanye maelezo machache ya mwisho kuhusu kitanzi cha mbele. Perl hushughulikia majina ya mbele na kama visawe. Kwa hivyo, unaweza kutumia majina haya kwa kubadilishana katika maandishi. Perl, kwa upande wake, itaamua aina ya kitanzi kulingana na muktadha wake.

OPERATOR WA KAZI BILA MASHARTI GOTO

Perl hutumia opereta wa goto, ambayo ni sawa na opereta wa lugha ya programu C. Ufuatao ni mfano wa kutumia opereta wa goto kuchapisha nambari kutoka 1 hadi 10:

$ i = 1; kitanzi: chapisha $i++, ""; ikiwa ($i<=10) { goto loop; }

MABADILIKO YA OPERATOR

Perl hutumia aina maalum za if, isipokuwa, wakati, na hadi inaunda ili kudhibiti maendeleo ya hesabu. Katika hali fulani, miundo hii maalum inaweza kufanya msimbo wako kuwa wazi na rahisi kusoma. Ili kufanya msimbo iwe rahisi kusoma na maana yake wazi zaidi, inashauriwa kuchagua muundo unaofaa wa kurekodi. Fikiria usemi wa saa unaotumia kitendakazi cha kufa ili kusitisha hati ikiwa thamani ya tofauti ya $count ni chini ya 10:

Ikiwa ($count< 10) { die; }

Kwa kuweka kitendakazi cha kufa kabla ya taarifa ya if, kama inavyoonyeshwa hapa chini, idadi ya mistari ya msimbo itapunguzwa:

Kufa ikiwa ($count< 10);

Vile vile, usemi huo unaweza kuandikwa kama ifuatavyo:

($count >= 10) || kufa;

Katika hali hii, ikiwa kigezo cha $count ni kikubwa kuliko au sawa na 10, Perl atasimamisha tathmini zaidi kwenye mstari huo na chaguo la kukokotoa la kufa halitekelezwi. Vinginevyo, ikiwa kigezo cha $count ni chini ya 10, baada ya kutathmini sehemu ya kwanza ya usemi, msimbo huendesha kazi ya kufa na hivyo kuhitimisha utekelezaji wa hati . Mwishowe, katika mfano ufuatao, kutumia isipokuwa ujenzi pia kunapunguza idadi ya mistari hadi moja:

Kufa isipokuwa ($count >= 10);

Vivyo hivyo, wakati vitanzi vifuatavyo vinafanana:

$ i = 0; wakati ($i< 10) { $i++; } $i = 0; $i++ while ($i < 10);

Kama unavyoona, kwa kutumia muundo wa muundo, hati hukuruhusu kupunguza idadi ya mistari kwenye kiingilio cha kitanzi hadi moja. Vivyo hivyo, zifuatazo hadi vitanzi ni sawa:

$ i = 10; hadi ($i >= 10) ( $i++; ); $ i = 10; $i++ hadi ($i>=10);

Kumbuka: Katika visa vyote vinne, hata kama usemi wa kutathmini unakuja baada ya taarifa kutekelezwa, Perl kwanza hutathmini hali na kisha kutekeleza taarifa hiyo.

KUZALISHA MANENO YENYE NGUVU KWA KUTUMIA KAZI YA EVAL

Kwa sababu Perl ni lugha iliyotafsiriwa, hati zako zinaweza kutumia Perl kutengeneza msimbo<налету>, yaani, kwa nguvu, wakati wa utekelezaji wa hati. Hivi ndivyo hasa kitatuzi cha Perl (ambacho chenyewe ni programu ya Perl inayoitwa Perldb.PL) inavyofanya kazi. Wakati wa kubuni hati, unaweza kutumia msimbo huo unaobadilika kuunda vigeu vinavyobadilika au hata kuunda taratibu maalum. Perl hutathmini misemo inayobadilika kwa kutumia chaguo la kukokotoa la kutathmini. Mfano ufuatao huunda maagizo yanayobadilika kwa kugawa thamani ya kigezo kwa maandishi, ambayo kwa hakika yana maagizo yanayohitajika ya Perl. Maagizo zaidi hutumia kazi ya eval kutekeleza maagizo haya:

$perl_statement = "chapisha "Hujambo, ulimwengu\n";"; eval $perl_statement; # itachapisha Hello, dunia $i = 1001; $varname = "$i"; chapisha eval $varname; # itachapisha thamani ya $i

Kumbuka: Kuna hatari katika kutumia kitendakazi cha eval katika hati, haswa ikiwa hati itapitisha data iliyotolewa na mtumiaji kwa chaguo la kukokotoa la eval. Kutumia kazi ya eval, hati inaweza kutekeleza amri ya kiholela ya Perl, pamoja na amri za mfumo. Hii inampa mtumiaji udhibiti wa programu, ambayo inaweza kuwa hatari sana kwenye Mtandao na Wavuti.

SUBROUTINES

Kama lugha zote za programu zilizopangwa, Perl inasaidia taratibu. Njia ndogo inaweza kufafanuliwa kwa kutumia neno kuu ndogo kama inavyoonyeshwa hapa chini:

Demo_ndogo ( chapisha "demo_sub inaitwa\n"; ) &demo_sub; simu # ndogo

Katika kesi hii, maagizo huunda utaratibu mdogo unaoitwa demo_sub. Ili kuita utaratibu mdogo, hati inaweka ampersand (&) mbele ya jina la utaratibu mdogo. Unapopiga simu kwa utaratibu mdogo katika Perl, mabano yanaweza kuachwa. Unaweza kuweka utaratibu mahali popote ndani ya msimbo wa chanzo wa hati kwa sababu Perl atachanganua msimbo wote wa chanzo kabla ya kutekeleza hati. Unaweza kutangaza utaratibu mdogo katika msimbo wa chanzo mara baada ya matumizi ya kwanza ya subroutine (rejeleo la mbele). Taratibu ndogo zinaweza kuwa na hoja na kurudisha thamani. Kijisehemu kifuatacho cha msimbo kina utaratibu unaoitwa show_value ambao huchapisha thamani iliyopokelewa na utaratibu kama kigezo:

Thamani_ndogo ( chapisha "Kitambulisho cha thamani ", $_; ) &show_value(1001);

Hapo awali, utaratibu wa Perl hautangazi vigezo vya kuhifadhi hoja. Badala yake, safu tofauti inayoitwa @_ inapitishwa kwa utaratibu, ambayo ina maadili ya parameta. Kwa upande mwingine, utaratibu hufikia maadili ya hoja kwa kutumia nukuu ifuatayo kwa vipengele vya safu: $_, $_, n.k. Hata hivyo, njia hii ya kupitisha vigezo inaweza kuharibu usomaji wa msimbo, na kwa hiyo taratibu nyingi hutumia kunakili. ya hoja kwa vigezo vya ndani. Sawa na mfano uliopita, utaratibu ufuatao wa show_fwo_values ​​unaonyesha maadili ya vigezo viwili:

Maonyesho_maadili_ndogo ( chapisha "Kigezo cha kwanza ", $_, "\n"; chapisha "Kigezo cha pili ", $_, "\n"; ) &onyesha_thamani_mbili(1001, 2002);

Hatimaye, kazi inayofuata, show_all_values, inachapisha maadili ya vigezo vyote vinavyopokea. Chaguo za kukokotoa hutumia safu kufafanua nambari kama kigezo:

Maonyesho madogo_ya_maadili ( kwa ($i = 0; $i< @_; $i++) { print "Parametr ", $i, " is ", $_[$i], "\n"; } } & show_all_values(1001,2002,3003,4004);

Kama ilivyoelezwa, taratibu za Perl zinaweza kurejesha maadili. Taarifa ya kurudi hutumiwa kwa hili. Tofauti na lugha ya C, Perl hauhitaji matumizi ya taarifa ya kurejesha. Ikiwa utaratibu hauna taarifa ya kurejesha, basi usemi wa mwisho uliotathminiwa utachukuliwa kama thamani ya kurejesha. Mfano ufuatao unaongeza vigezo viwili na kurudisha matokeo:

Viongezeo_vidogo ( return $_ + $_; ) chapisha "Matokeo ni: ", &add_values(1001,2002);

MAKTABA YA SUBROUTINES

Tofauti na C, Perl haiungi mkono wazo la maktaba. Hata hivyo, ina utaratibu unaoruhusu hati kutumia msimbo wa chanzo kutoka kwa faili nyingine. Kwa mfano, tuseme unahifadhi utaratibu wa add_valuesl katika faili inayoitwa addvalue.pl. Kwa kutumia taarifa ya mahitaji, hati nyingine ya Perl inaweza kufikia utaratibu huo, kama inavyoonyeshwa hapa chini:

Inahitaji "addvalue.pl"; chapa &add_values(10,11);

Unaweza kufikiria taarifa ya need kuwa sawa na taarifa ya #include ya C preprocessor. Ili kupata faili chanzo, Perl anatafuta kwanza katika saraka chaguo-msingi ya maktaba ya Perl (angalia maagizo ya usakinishaji kwa maelezo), na kisha katika saraka ya sasa. Unaweza pia kutumia njia kamili au jamaa iliyoambatanishwa na jina la faili. Perl anakumbuka ni faili gani zilizoombwa na taarifa ya kuhitaji na kuzipakia mara moja tu, hata kama faili hizo zimefikiwa mara nyingi. Kuna maktaba nyingi za kawaida zinazopanua uwezo wa lugha ya Perl. Sasa ni wakati mzuri wa kuzunguka kwenye saraka ambapo faili za maktaba ya Perl huhifadhiwa ili kupata wazo la uwezo wanaotoa.

KUTUMIA VIFURUSHI ILI KUTENGA SUBROUTINES

Ikiwa una taratibu nyingi, hasa za kawaida unazohifadhi katika faili tofauti, migongano ya majina tofauti inaweza kutokea wakati jina moja la kutofautiana linatumiwa kwa madhumuni tofauti. Perl husaidia kuzuia hili na vifurushi. Kama unavyojua, kwa kutangaza anuwai za kawaida kwa subroutines, unaweza kuzuia migongano ya majina. Hata hivyo, ikiwa taratibu nyingi zitashiriki data mahususi, data hiyo inaweza kuhitaji upeo wa kimataifa, ambao unaweza kusababisha migongano ya majina. Kwa kutumia vifurushi, unaweza kupanga data ya kimataifa katika nafasi za majina ya kibinafsi, nje ya ambazo vigeu vya kimataifa havionekani, yaani, haijulikani. . Fikiria mfano rahisi hapa chini, ambapo taratibu mbili (zilizo katika faili tofauti) hutumia nafasi za kibinafsi, za kibinafsi.

# Msimbo katika faili one.pl sub_one ( kifurushi demo_one; $some_data = 10; ) # * * * * * * * * # Msimbo katika faili two.pl sub_one ( kifurushi demo_two; $some_data = 20; )

Kama unavyoona, utaratibu wa kwanza hutumia jina la kifurushi demo_one, utaratibu wa pili hutumia jina la kifurushi demo_two. Taratibu zote mbili zinaweza kuweka na kutumia utofauti wa $some_data bila kusababisha mgongano wa jina kati ya kigezo kimoja cha kimataifa na kingine. Hati<знает>jina la kifurushi ambamo kibadilishaji kinakaa na kupanga ufikiaji wake, hutumia jina la kifurushi kama kiambishi awali cha jina la kutofautisha. Mfano ufuatao unaongeza jina la kifurushi package_one au package_two kama kiambishi awali kwa jina la kutofautisha some_data:

&ndogo_moja; &ndogo_mbili; chapisha "Variable 1 $package_one"some_data\n" chapisha "Variable 2 $package_two"some_data\n"

Unapotumia vifurushi vya Perl, unaweza kuunda nafasi ya kipekee ya majina ndani ya faili ya chanzo cha sasa kwa kuweka taarifa ya kifurushi mwanzoni mwa faili, kama inavyoonyeshwa hapa chini:

Pakiti_jina_la_kifurushi $some_data = 1; sub some_sub ( rudisha $some_data; )

Katika kesi hii, tofauti ya $some_data inapatikana tu kwenye kifurushi na kwa hivyo inalindwa dhidi ya ufikiaji usio sahihi. Kutumia kifurushi kwa hivyo huipa data wigo sawa na katika lugha ya programu ya C, ambapo anuwai za ulimwengu zina wigo wao katika faili ya msimbo wa chanzo ambamo hutangazwa. Unapoita utaratibu kutoka kwa faili nyingine ya hati, lazima utumie jina la kifurushi:

Inahitaji "some_package.pl"; chapisha &some_package_name"some_sub;

UCHAKATO WA SAFU

Katika mifano iliyopita, ulijifunza jinsi ya kuunda maandishi ya kamba kwa kutumia tafsiri tofauti. Pia ulijifunza jinsi ya kuambatanisha herufi halisi na viambatisho vya kamba. Katika sehemu hii, unaona kwamba Perl hutoa seti kubwa ya vitendakazi ambavyo hati zinaweza kutumia kuchezea mifuatano.

KAZI YA KUKATA

Kitendaji cha kukata huondoa herufi ya mwisho ya mfuatano. Ina muundo ufuatao:

$ tabia = chop (Str);

Kazi ya kukata inarudisha tabia iliyoondolewa. Hati za Perl hutumia sana chop ili kuondoa herufi mpya na za mwisho wa mstari.

KAZI YA INDEX

Kazi ya faharasa hutafuta mfuatano mdogo uliotolewa katika mfuatano. Yeye ana umbizo linalofuata:

$location = index(Str, SubStr[, Offset]);

Kazi ya faharasa hurejesha faharasa ya utokeaji wa kwanza wa kamba ndogo (SubStr) katika mfuatano (Str). Offset inaweza kwa hiari kubainishwa baada ya hapo utafutaji unaanza. Ikiwa kifungu kidogo kitapatikana, thamani -1 inarudishwa. Katika mfano ufuatao, kipengele cha kukokotoa cha faharisi hutafuta matukio ya kifungu kidogo cha "na" baada ya herufi ya tatu kwenye kamba "ndizi":

Chapisha faharasa("ndizi","na",3); #Machapisho 4.

Kitendakazi cha rindex hutafuta tukio la mwisho, kulia kabisa la kamba ndogo katika mfuatano na kurejesha thamani ya nafasi ya herufi ya kwanza ya kamba ndogo. Chaguo la kukokotoa lina umbizo lifuatalo:

$location = rindex(Str, SubStr);

Chaguo hili la kukokotoa linafanana na kitendakazi cha faharasa, isipokuwa kwamba hurejesha tukio la mwisho badala ya lile la kwanza. Kwa mfano, mfano ufuatao hutumia kitendakazi cha rindex ili kubaini utokeaji wa mwisho wa kamba ndogo "na" katika mfuatano "ndizi":

Chapisha rindex("ndizi","na"); #Machapisho 4

UREFU KAZI

Chaguo la kukokotoa la urefu hurejesha idadi ya vibambo kwenye mfuatano. Ina muundo ufuatao:

$len = urefu(Str);

Mfano ufuatao hutumia kitendakazi cha urefu kuchapisha idadi ya herufi kwenye mfuatano:

Urefu wa kuchapisha ("ndizi"); #Machapisho 6

SUBSTR KAZI

Kitendakazi cha substr kinatumika kuondoa sehemu ya mfuatano. Ina muundo ufuatao:

$ substring = substr(Str, Offset[,Len]);

Chaguo za kukokotoa hurejesha mfuatano mdogo, yaani, sehemu ya mfuatano ambao urefu wake hauzidi thamani iliyobainishwa na kigezo cha hiari cha Len. Mstari mdogo uliorejeshwa wa str huanza kwa herufi katika nafasi iliyobainishwa na Offset. Ikiwa parameta ya Len imeachwa, basi kamba iliyorejeshwa ina herufi hadi na ikijumuisha mwisho wa mstari. Ikiwa parameta ya Offset ni hasi, basi kukabiliana huhesabiwa kutoka mwisho wa mstari. Mwishowe, hati inaweza kutumia substr kama lvalue kufanya operesheni ya mgawo. Kijisehemu kifuatacho cha msimbo kinaonyesha matumizi ya kitendakazi cha substr.

Chapisha substr("chungwa",3); #Pato "nge" chapa substr("chungwa",-2); # Huchapisha "ge" print substr("chungwa",2,2); # Chapisha "an" $str = "apple"; substr($str,-3) = "ricot"; chapisha $str; # Inachapisha "apricot"

Kumbuka: Kutumia viendeshaji vya kujieleza vya kawaida vya Perl mara nyingi kuna ufanisi zaidi kuliko kutumia vitendakazi vya substr. Maneno ya kawaida yatajadiliwa baadaye katika sura hii.

JIUNGE NA KAZI

Chaguo za kukokotoa za kuunganisha huunganisha orodha ya vipengele kwenye mfuatano, kikitenganisha kila kipengele na herufi fulani. Ina muundo ufuatao:

$new_string = join(Str,List);

Chaguo za kukokotoa za uunganisho hubadilisha kila kipengele cha orodha kuwa mfuatano na kuunganisha mifuatano. Kijisehemu kifuatacho cha msimbo kinaonyesha matumizi ya chaguo za kujumuisha:

$str = join(",", 0..4,10,20); # Orodha itakuwa "0,1,2,3,4,10,20" $strn = join ("\t", $a, $b, $c);# Inachanganya orodha

KAZI YA KUPASUKA

Kitendakazi cha mgawanyiko hugawanya yaliyomo kwenye mfuatano katika orodha ya vipengele. Ina muundo ufuatao:

Gawanya(Delimeter, Str[,Limit]);

Hoja ya Delimeter inabainisha herufi ya kugawanyika, kama vile nafasi, neno, kichupo, n.k. e. Kigezo cha hiari cha Kikomo kinabainisha idadi ya juu zaidi ya vipengele ambavyo orodha inaweza kuwa nayo. Mfano ufuatao unaonyesha matumizi ya kitendakazi cha mgawanyiko.

KAZI ZA KUSAKA ORODHA

Katika mifano iliyojadiliwa hapo awali katika sura hii, tulijifunza jinsi ya kuunda orodha, kuihifadhi kama thamani ya kigezo, kurudia vipengele vyote vya orodha, na kufikia kipengele mahususi cha orodha. Katika sehemu hii, utajifunza vipengele vichache zaidi vinavyopanua uwezo wako wa kufanya kazi kwenye orodha.

TENA KAZI

Chaguo za kukokotoa za kinyume hugeuza vipengele vya orodha. Ina muundo ufuatao:

@new_list = reverse(@Orodha);

Chaguo za kukokotoa za kinyume hugeuza orodha na kurudisha orodha mpya inayotokana. Mfano ufuatao unaonyesha matumizi ya kitendakazi cha nyuma:

@orodha = kinyume (1..5); # Matokeo 5,4,3,2,1 @list = reverse(@list); # Matokeo 1,2,3,4,5

PANGA KAZI

Chaguo za kukokotoa hupanga vipengele vya orodha. Ina muundo ufuatao:

@new_list = panga(@Orodha);

@new_list = panga(Subroutine @List);

@new_list = sort(BlockStatement @List);

Chaguo za kukokotoa huweka vipengele kwenye orodha, na kuviagiza kulingana na nambari za herufi za kawaida kwenye jedwali la ASCII. Kama chaguo la kukokotoa la kinyume, chaguo la kukokotoa la kupanga hurejesha orodha mpya kama thamani yake na haiathiri orodha asili. Mfano ufuatao unaonyesha matumizi ya chaguo la kukokotoa:

@list = aina(1,5,2,3,4); # Matokeo 1,2,3,4,5 @list = sort(1,2,10); # 1,10,2 kupanga katika ASCII

Katika subroutine au block, unaweza kubadilisha utaratibu ambao aina ni kazi. Mfano ufuatao unaonyesha matumizi ya chaguo za kukokotoa.

@list = panga (($a<=>$b) (2,1,10)); # @orodha 1,2,10 @list = sort(($b<=>$a)) (2,1,10); # @list 10,2,1 ndogo mycomp ( $b<=>$a ) @list = sort(mycomp (2,1,10)); # @orodha 10,2,1

KAZI ZA KUFANYA KAZI NA ARRAYS

Kama unavyojua, safu ni muundo wa data ulio na thamani moja au zaidi ya aina moja, kwa mfano, majina 100 ya wanafunzi. Perl ina vitendaji kadhaa vilivyojumuishwa ambavyo hukusaidia kufanya kazi na vitu vya safu. Sehemu zifuatazo zinashughulikia kazi kadhaa za msingi za usindikaji wa safu.

KAZI ZA KUSUKUMA NA POP

Hati za Perl hutumia hadithi za kushinikiza na pop ili kuongeza na kuondoa vipengee kutoka mwisho wa safu. Kwa maneno mengine, vitendaji vya kushinikiza na pop huruhusu hati kufanya shughuli zilizopangwa kwa msingi wa mwisho, wa kwanza. Kitendaji cha kushinikiza kina muundo ufuatao:

Sukuma(@ARRAY, ORODHA);

Kijisehemu kifuatacho kinaonyesha matumizi ya kitendakazi cha kusukuma:

@orodha = (); push(@orodha,10,20); # @list sasa ni (10,20) push(@list,1..3); # orodha ni sasa (10,20,1,2,3)

Kinyume chake, chaguo la kukokotoa la pop huondoa kipengele ambacho mara ya mwisho kilisukumwa kwenye rafu na kurudisha thamani ya kipengele hicho. Kitendaji cha pop kina muundo ufuatao:

Thamani ya $ = pop(@ARRAY);

Kipande kifuatacho cha programu kinaonyesha matumizi ya kitendakazi cha pop:

# Wacha tuchukue @list kutoka kwa mfano uliopita wa kuchapisha pop(@list); # Chapisha pop 3 za kuchapisha (@orodha); # Imechapishwa 2 # Sasa @orodha (10,20)

KAZI YA MABADILIKO

Chaguo za kukokotoa za shift huondoa na kurudisha kipengele kutoka mwanzo wa safu. Kazi hii ni sawa na kazi ya pop na tofauti pekee ambayo inafanya kazi tangu mwanzo wa safu kulingana na kanuni ya FIFO (<первым вошел, первым вышел>) Kitendakazi cha shift kina umbizo lifuatalo:

thamani ya $ = shift(@ARRAY);

Kipande kifuatacho cha programu kinaonyesha matumizi ya kitendakazi cha kuhama:

# Wacha tuchukue @list kutoka kwa mfano uliopita

Chapisha shift(@orodha); # Chapisha mabadiliko 10 ya kuchapisha (@orodha); # Imechapishwa 20 # Sasa @list()

KAZI YA UNSHIFT

Chaguo za kukokotoa za unshift huongeza kipengele kimoja au zaidi mwanzoni mwa safu. Inayo nambari ifuatayo:

Unshift(@Array, Orodha);

Kipande kifuatacho cha programu kinaonyesha matumizi ya kitendakazi cha unshift:

# @list = () unshift(@list,5,10,20); # @orodha (5,10,20) unshift(@orodha, 1..3); # @orodha (1,2,3,5,10,20)

KAZI YA SPLICE

Maandishi ya Perl hutumia kitendakazi cha splice kuondoa vipengee kwenye orodha, na kuzibadilisha na vipengee vya orodha nyingine. Ina muundo ufuatao:

Splice(@Array, Offset[, Hesabu[, Orodha]]);

Chaguo za kukokotoa za sehemu huondoa nambari iliyobainishwa ya vipengee (Hesabu) kutoka kwa safu (@Array), kuanzia na kipengee kilichoelekezwa kwa thamani ya kurekebisha (Offset), na kubadilisha vipengele na vipengele vya orodha nyingine (Orodha). Ikiwa simu ya kukokotoa haijabainisha kigezo cha Hesabu, chaguo za kukokotoa hurejesha vipengele hadi mwisho wa safu. Ikiwa simu ya chaguo la kukokotoa haielezei orodha ambayo vipengele vyake vinachukua nafasi ya vipengele vya awali, basi kazi haiongezi vipengele vyovyote kwenye orodha ya awali. Usemi ufuatao unaonyesha matumizi ya kazi ya splice:

@orodha = 1..10; kiungo(@orodha,1,8,5,6); # @orodha = (1,5,6,10)

KAZI YA SALAR

Kazi ya scalar huamua idadi ya vipengele katika orodha. Ina muundo ufuatao:

Matokeo = scalar(Orodha);

Kwa kawaida, hati za Perl hazihitaji kutumia kazi ya kukokotoa na safu, kwa sababu hati inapofikia safu kwa kuiandika katika muktadha wa kozi, hurejesha idadi ya vipengele vya safu. Walakini, hati zinaweza kutumia chaguo la kukokotoa katika hali ambapo muktadha haueleweki au ikiwa orodha si safu. Usemi ufuatao unaonyesha matumizi ya kitendakazi cha scalar.

@orodha = 1..10; chapisha scalar(@orodha); # Huchapisha saizi ya @list

KAZI YA GREP

Chaguo za kukokotoa za grep huchuja vipengee vya orodha ambavyo usemi fulani hutathmini<ложно>. Ina muundo ufuatao:

@list = grep(Maelezo, Orodha);

Chaguo za kukokotoa za grep hurudia kupitia vipengele vya orodha, na kuzibadilisha kama hoja katika usemi fulani. Kazi ya grep inapeana usemi wa sasa wa kipengee cha orodha kwa tofauti $_ na kutathmini usemi uliotolewa. Ikiwa usemi unaotokana ni kweli, basi chaguo la kukokotoa la grep huongeza kipengele hicho kwenye orodha inayotokana. Kipande kifuatacho cha programu kinaonyesha matumizi ya chaguo la kukokotoa la grep:

@list = grep($_ & 1, 1..10); # @orodha (1,3,5,7,9) @list = ("a", "" "b"); # @list("a"," ","b") @list = grep($_ eq "", @list); # @list("a","b")

Kumbuka: Ikiwa usemi, hurekebisha tofauti. $_, basi orodha asili pia itarekebishwa.

KAZI ZA KUSAKATA SAFU SHIRIKA

Kama inavyojulikana, safu shirikishi ni zile safu ambazo index sio thamani ya nambari, lakini, kwa mfano, jina. Perl ina vitendaji kadhaa vilivyojumuishwa ambavyo hurahisisha hati kushughulikia safu shirikishi.

KAZI YA FUNGUO

Chaguo za kukokotoa za vitufe hurejesha thamani kuu zinazolingana na safu shirikishi. Ina muundo ufuatao:

@key_list = funguo(%Array);

Chaguo za kukokotoa funguo hurejesha safu ya funguo kama orodha ya kawaida. Kipande kifuatacho cha programu kinaonyesha matumizi ya kazi ya funguo:

umri wa $("Bob") = 25; miaka $("Maria") = 30; $ages("Zack") = 15; @list = funguo(%ages); # @list itakuwa "Zack", "Bob", "Mary" @list = funguo za kupanga %umri # @ orodha "Bob", "Mary", "Zack" kwa $key (panga vitufe %ages) ( chapisha "$ ufunguo ni $ages($key)\n" )

KAZI YA MAADILI

Utendaji wa thamani hurejesha safu ya kawaida inayojumuisha thamani za safu shirikishi. Ina muundo ufuatao:

@value_list = maadili(%Array)

Utendaji wa thamani hurejesha safu ya safu shirikishi za thamani kama orodha ya kawaida. Kipande kifuatacho cha programu kinaonyesha matumizi ya kazi ya maadili:

# Tumia maadili kutoka kwa mfano uliopita %ages = ("Bob", 25, "Mary", 30, "Zack", 15); @list = panga maadili% umri; # @orodha (15, 25, 30) @list = umri %; # @list("Zack", 15, "Bob", 25, "Mary", 30)

KILA KAZI

Kila chaguo la kukokotoa hujirudia kupitia vipengele katika safu shirikishi. Ina muundo ufuatao:

@key_values ​​= kila (%Array);

Wakati wowote hati inapoita kila chaguo la kukokotoa, hurejesha orodha ya vipengele viwili ambavyo vina jozi ya thamani-msingi. Kazi inapofika mwisho wa orodha, inarudisha orodha tupu. Wakati mwingine kazi inapoitwa, mchakato wa kurudia utaanza tena. Kipande kifuatacho cha programu kinaonyesha matumizi ya kila kitendakazi:

# Tumia maadili kutoka kwa mfano uliopita %ages = ("Bob", 25, "Mary", 30, "Zack", 15); wakati (($name, $age) = kila %age) (# umri wa kuchapisha chapisha "$key is $ages($key)\n";)

FUTA KAZI

Chaguo za kukokotoa huondoa vipengele vya safu shirikishi. Ina muundo ufuatao:

Futa $Array(Ufunguo)

Taarifa ifuatayo hutumia kipengele cha kufuta ili kuondoa kipengele kinacholingana na ufunguo wa Bob kutoka kwa safu ya ushirika ya $Employees:

Futa Wafanyakazi wa $("Bob")

HOJA ZA MSTARI WA AMRI

Maandishi ya Perl yanaweza kufikia kwa urahisi hoja za mstari wa amri. Wakati wowote hati inapoendeshwa, Perl huweka hoja za safu ya amri ya hati katika utofauti wa orodha ya @ARGV. Kipande kifuatacho cha programu kinatumika kuchapisha hoja za mstari wa amri kwenye onyesho:

Wakati ($arg = shift @ARGV) ( chapisha "$arg\n"; )

KUPATIKANA NA MBINU ZA ​​MAZINGIRA

Kupata anuwai za mazingira katika hati za Perl pia ni rahisi sana. Wakati wowote hati inapoendeshwa, Perl huweka nakala za anuwai za mazingira katika safu ya ushirika inayoitwa %ENV. Taarifa ifuatayo hutumia safu ya %ENV kuonyesha saraka ya sasa:

Chapisha "$ENV(PATH)\n"; # Chapisha saraka ya sasa

Kando na kurejesha thamani kutoka kwa safu ya %ENV, hati zinaweza pia kurekebisha vipengele vya mkusanyiko. Mabadiliko kama haya kwenye safu ya %ENV yatabadilisha mpangilio wa kutofautisha wa mazingira kwa mchakato wowote wa mtoto ulioundwa na hati. Kwa mfano, taarifa ifuatayo hutumia safu ya %ENV kubadilisha njia ya sasa:

$ENV(PATH) = "c:\\myxec;".$ENV(PATH);

Kumbuka: Mabadiliko ya hati kwenye safu ya %ENV hayataathiri zile asili. vigezo vya mazingira. Kwa maneno mengine, baada ya hati kumaliza kufanya kazi, anuwai za mazingira ya mfumo hazitabadilika.

PEMBEJEO LA FAILI NA PATO

Perl iliundwa mahsusi kuwa zana ya kutosha ya kusoma na kuandika faili za maandishi. Walakini, kama utajifunza baadaye, Perl haifanyi ufikiaji wa nasibu na vitendaji vya faili ya binary vya I/O. Uendeshaji wa faili unahitaji kushughulikia faili, ambayo ni tofauti inayolingana na faili maalum. Kwa chaguo-msingi, kila hati ya Perl ina viashirio vitatu vya kawaida ambavyo Perl hufungua kiotomati hati inapoendeshwa: STDIN, STDOUT, STDERR. Viashiria hivi vitatu vya kawaida vinalingana na mitiririko ya kawaida ya STDIN, STDOUT, STDERR ya lugha ya programu C. Zaidi ya hayo, hati ya Perl inaweza kufungua vielelezo vya ziada kwa faili zingine mahususi.

KUFUNGUA FAILI NA VITIRISHO VINGINE

Ili hati itumie faili, lazima iite kazi iliyo wazi. Inaonekana kama hii:

Fungua(FileHandle[, FileName])

Tofauti na kitendakazi cha ufunguaji cha maktaba ya C wakati wa kukimbia, kitendakazi wazi cha Perl hakina kigezo cha modi katika simu ya kukokotoa. Perl huamua hali ya kufungua faili kulingana na jina la faili. Jedwali 12.3 linaonyesha uhusiano kati ya hali ya kufungua faili na jina la faili.

Jedwali 12.3. Makubaliano ya kutaja faili ya Perl na njia za ufikiaji

Ikiwa jina la faili limeachwa kutoka kwa simu iliyo wazi ya kukokotoa, Perl anadhania kuwa jina la faili liko katika utofauti wa mfuatano wa $FileHandle. Hati inapomaliza kutumia faili, huifunga kwa kutumia kazi ya karibu kama inavyoonyeshwa hapa chini:

Funga(FileHandle);

Kipande cha programu kinaonyesha matumizi ya vitendakazi wazi na vilivyofungwa:

Fungua(InFile, "test.dat") || kufa; # imefunguliwa kwa ajili ya kusoma # test.dat open(OutFile, ">test.dat") || kufa; # tengeneza test.dat $AuxFile = ">>test.dat"; open(Aux, $AuxFile) || kufa; # hufungua ili kukamilika # test.dat close(InFile); funga (OutFile); karibu (Aux);

Kumbuka kwamba viashiria vya faili havina viambishi vya kawaida vya herufi moja. Kama utakavyojifunza baadaye, hati za Perl zinaweza kuhifadhi majina ya vielekezi kama mifuatano mikali na kupitisha kiashirio kwa chaguo la kukokotoa linaloweza kuzichakata. Perl hufanya ubadilishaji wa thamani ikiwa ni lazima.

Kwenye MS-DOS, Perl hutumia kipengele cha ziada kinachoitwa hinmode ambacho huruhusu ingizo/tokeo la faili kubadili kati ya maandishi na modi za binary. Katika mifumo mingi, tofauti kati ya maandishi na njia za binary haijalishi. Hata hivyo, kwa mfumo wa uendeshaji wa MS-DOS, tabia ya mstari mpya ni mlolongo wa wahusika wawili (CR + LF). Kwa kuwa programu nyingi hazitarajii kukutana na wahusika wawili mwishoni mwa mstari, mfumo wa I/O lazima ufanye ubadilishaji. Ili kutumia kazi ya binmode, pointer sambamba lazima ifunguliwe. Kitendakazi cha binmode kina umbizo lifuatalo:

Binmode(FileHandle);

DATA YA KUSOMA NA KUANDIKA LINE-LINE

Njia rahisi zaidi ya hati kusoma mstari kutoka kwa faili ni kutumia opereta . Katika Perl, kielekezi cha faili kilichozungukwa na mabano ya pembetatu kinakuwa ishara ya ingizo. Kwa mfano, kipande kifuatacho cha programu kinaonyesha matumizi ya herufi ya ingizo kusoma na kuonyesha maudhui ya faili ya Test.dat.

Fungua(InFile, "Test.dat") || kufa; wakati (mstari wa $ = ) ( chapisha mstari wa $; # Huchapisha mstari kutoka kwa faili ) funga(InFile);

Wakati herufi ya pembejeo inapofikia mwisho wa faili, inarudi uwongo, ambayo katika kesi hii inamaliza utekelezaji wa kitanzi cha wakati. Kuna herufi maalum (tupu) ya kuingiza iliyoonyeshwa na<>, ambayo ina programu maalum lakini muhimu. Mara ya kwanza hati hutumia herufi tupu ya kuingiza<>, inachanganua hoja za mstari wa amri. Ikiwa kamba @ARGV ni tupu, basi herufi ya ingizo<>inasoma kutoka STDIN. Ikiwa badala yake @ARGV sio tupu, basi Perl hufungua faili ya kwanza iliyoainishwa katika utofauti wa @ARGV na kusoma yaliyomo kwenye faili. Perl anapomaliza kuchakata faili moja, husogea hadi inayofuata. Baada ya hati kusoma faili zote, ishara<>inarudisha uwongo. Maandishi ya Perl pia yanaweza kutumia herufi ya ingizo kusoma yaliyomo ndani ya faili katika safu ili kila safu ya faili iwe sehemu ya safu. Kwa mfano, taarifa ifuatayo inasoma kutoka kwa faili ya STDIN hadi safu ya @lines:

@mistari = ;

Kuandika data kwa faili pia ni rahisi sana. Kwa kweli, ulifanya hivi kila wakati ulipotumia kitendakazi cha kuchapisha. Umbizo kamili la kitendakazi cha kuchapisha ni kama ifuatavyo:

Orodha ya Machapisho;

Ikiwa kitendakazi cha kuchapisha hakipokei kielekezi cha faili kama hoja, hutuma matokeo kwa STDOUT. Kipande kifuatacho cha programu kinaonyesha matumizi ya chaguo la kukokotoa chapa ili kuambatanisha data kwenye faili ya towe:

Fungua(LogFile, ">>logfile.dat") || kufa; ############## ($m, $d, $y) = (wakati wa ndani(wakati)) ; chapisha LogFile "logi ya Kapteni", Tarehe ya nyota ++m$/$d/$y\n"; funga(LogFile);

Kumbuka: Kielekezi cha faili na orodha ya pato hazitenganishwi na koma.

VITALU VYA DATA YA KUSOMA NA KUANDIKA

Watengenezaji programu mara nyingi huchukulia faili za maandishi kama mitiririko ya maandishi kwa sababu herufi moja hufuata nyingine hadi alama ya mwisho wa faili. Ikiwa hati lazima ifanye kazi na faili ambayo ina mwelekeo wa kuzuia badala ya mwelekeo wa uzi, basi hati inaweza kutumia vitendakazi vya sysread na syswrite kuchakata vizuizi visivyobadilika vya data. Vitendaji vya sysread na syswrite vina muundo ufuatao:

$matokeo = sysread(FileHandle, $Var, Length[, Offset]); $matokeo = syswrite(FileHandle, $Var, Length[, Offset]);

Ikiwa simu ya chaguo la kukokotoa itabainisha kukabiliana tangu mwanzo wa faili (Offset), basi vipengele vitatafuta eneo ambalo wataanza shughuli za I/O. Sysread na syswrite hufanya kazi zote mbili za kupitisha data kwa kutumia tofauti ya scalar aina ya kamba. Kwa sababu chaguo za kukokotoa huchakata vizuizi visivyobadilika vya kumbukumbu, data inaweza kuwa na thamani za mfumo shirikishi, ikijumuisha sufuri na vialamisho vya mwisho wa faili. Ikiwa simu ya kazi inataja kukabiliana tangu mwanzo wa faili (Offset), basi kazi hutafuta eneo katika faili ambayo huanza kufanya shughuli za I / O. Ikiwa unafanya kazi na vizuizi vya data, basi hati zinaweza pia kutumia kazi zifuatazo I/O:

$matokeo = search(FileHandle, Position, Base); $matokeo = tell(FileHandle); $matokeo = eof(FileHandle);

Kitendakazi cha kutafuta hufanya kazi sawasawa na kitendakazi cha C wakati wa utekelezaji wa maktaba fseek. Kigezo cha Nafasi kinabainisha nafasi inayohusiana na asili, ambayo nayo inabainishwa na kigezo cha Msingi kama ifuatavyo:

Perl's tell hufanya kazi sawasawa na utendaji wa ftell wa maktaba ya wakati wa utekelezaji wa C. Chaguo hili la kukokotoa hurejesha nafasi ya sasa katika faili ambayo oparesheni ya kusoma au kuandika inafanywa. Hatimaye, chaguo za kukokotoa za eof, kama vile chaguo la kukokotoa la lugha C, huleta thamani<истинно>au<ложино>, ambayo hati inaweza kutumia kuamua wakati mwisho wa faili umefikiwa.

UCHUNGUAJI WA DATA NYINGI

Ingawa Perl inalenga hasa usindikaji wa maandishi, inaweza pia kuchakata data ya binary. Hati zinaweza kuhamisha data ya jozi katika vipande kwa kutumia vigeu vya kamba, na kufanya shughuli za I/O kwa kutumia vitendakazi vya sysread na syswrite. Walakini, ili kutimiza chochote<полезное>na data, hati inalazimishwa kubadilisha data kuwa yake<родные>muundo wa scalar.

UHIFADHI WA DATA NYINGINE

Hati ya Perl inaposoma kizuizi cha data ya jozi kwa kutumia chaguo za kukokotoa za sysread, huweka data hiyo ya binary katika muundo tofauti wa kamba. Perl hajali kama hizi zimetolewa, iwe zina null au zisizo za ASCII maadili. Ndani ya mfuatano wa herufi, Perl hupokea baiti kama baiti. Tofauti na C, Perl haitumii masharti ambayo hayatumiki tena. Ikiwa data ni ASCII, hati inaweza kuichakata kama maandishi yoyote. Lakini ikiwa data ni ya mfumo wa jozi, hati lazima itengeneze kabla ya Perl kuchakata data.

KUCHUKUA NAMBA ZA DATA YA BINARI KUWA VIGEUZI VYA PERL

Ili hati ipate ufikiaji wa data ya mfumo wa jozi, lazima iipangue katika umbizo lake la kola. Hati za Perl hufungua data kwa kutumia kitendakazi cha kufungua, ambacho kina umbizo lifuatalo:

$matokeo = unpack(Kigezo, Expression);

Usemi ni mfuatano wa kawaida wa mfuatano ambao unashikilia data ya jozi iliyosomwa na chaguo za kukokotoa za sysread, lakini pia inaweza kuwa usemi ambao lazima ufasiriwe kama mfuatano. Kiolezo ni mfuatano wa kiolezo cha herufi kinachoeleza jinsi ya kutafsiri thamani katika operesheni ya Usemi. Kipande kifuatacho cha programu kinaonyesha matumizi ya chaguo la kukokotoa la kukokotoa:

($r, $g, $b) = unpack("C3", $color);# itapanua katika herufi 3
- @longwords = unpack("L*", $data); # hupakuliwa kwenye orodha ya maneno # marefu @stuff = unpack("S2L", $bin); # itapakuliwa ndani ya kaptula 2 na ndefu

Kila herufi ya muundo inaweza kufuatwa na nambari inayoonyesha ni mara ngapi ya kutumia herufi hiyo. Ikiwa kuna nyota (*) badala ya nambari, operesheni itafanywa kwa data yote iliyobaki kwenye safu. Ikiwa nambari haijatolewa, basi inafanywa mara moja. Hati inaweza kuweka idadi yoyote ya vibambo muundo kwenye mfuatano wa Kiolezo. Jedwali la 12.4 linaorodhesha herufi zilizojumuishwa kwenye kigezo cha mfuatano wa Kiolezo pamoja na maelezo ya athari ambayo kila mmoja wao anayo kwenye utekelezaji wa chaguo la kukokotoa la kukokotoa.

Jedwali 12.4. Alama za muundo

KUPAKA DATA NDANI YA NAMBA NYINGI

Ili kutoa data ya mfumo wa jozi, hati lazima ipakie thamani za scalar kwenye mifuatano ya herufi binary. Ili kufanya hivyo, tumia kazi ya pakiti, muundo ambao umepewa hapa chini:

$matokeo = pakiti(Kiolezo, Orodha);

Kipande kifuatacho cha programu kinaonyesha matumizi ya kitendakazi cha pakiti:

$color = pakiti("C3", $r, $g, $b); $data = pakiti("L*", @longword); $bin = pakiti("S2L", @stuff);

Kitendakazi cha pakiti hutumia herufi za muundo sawa na chaguo za kukokotoa za kukokotoa, isipokuwa kwa herufi. A, u, x, x, @.

KUFANYA KAZI NA KATALOGU

Perl sio tu hutoa anuwai ya kazi za usindikaji wa faili, lakini pia zingine sana kazi zinazofaa kuchanganua saraka. Katika sehemu zifuatazo tutaangalia baadhi ya kazi kuu za kufanya kazi na saraka kwa undani.

KUFUNGUA, KUSOMA NA KUFUNGA KUREKTA

Maandishi ya Perl hukuruhusu kufungua na kusoma yaliyomo kwenye faili. Vile vile, hati hizi hufungua saraka na kusoma majina ya faili zilizomo. Ili kufungua saraka, maandishi hutumia kazi ya opendir, kupitisha pointer ya saraka na njia yake. Ili kusoma orodha ya faili zilizomo kwenye saraka, hati hutumia kazi ya kusoma. Hatimaye, kazi ya kufungwa inatumiwa kufunga saraka. Kipande kifuatacho cha programu kinaonyesha matumizi ya kitendakazi cha readdir kuonyesha orodha ya faili kwenye saraka ya sasa:

Opendir(Dir, $INC) || kufa; wakati ($file = readdir(Dir)) ( chapisha "$file \n" ) closedir(Dir);

Kijisehemu hiki hutumia $INC kutofautisha kufikia saraka ya sasa. Kwa kubadilisha $INC hadi $ARGV, hati inaonyesha orodha ya faili zilizomo kwenye saraka uliyotaja kwenye safu ya amri.

Kwa kuongezea kazi za saraka zilizojadiliwa hapo juu, Perl hutoa seti ya vitendakazi ambavyo hukuruhusu kuweka faharisi ya sasa katika orodha ya saraka:

$matokeo = rewinddir(DirHandle); $matokeo = telldir(DirHandle); $matokeo = seekdir(DirHandle, Position);

PATO ILIYOUMBWA

Katika sura hii, ulijifunza njia kadhaa za kupangilia pato la hati kwa kutumia kitendakazi cha kuchapisha. Sawa na C, Perl pia inaauni vitendaji vya printf na sprintf. Kwa kuongezea, Perl pia inasaidia kutoa ripoti kulingana na safu kwa kutumia violezo vya fomu.

KUTUMIA KAZI YA KUCHAPA

Maandishi katika sura hii yalitumia sana kazi ya uchapishaji. Kwa kuongeza, Perl hutoa vigezo maalum vinavyoathiri uendeshaji wa kazi ya uchapishaji. Jedwali 12.5 linaonyesha kwa ufupi vigezo hivi maalum.

Jedwali 12.5. Vigezo maalum vinavyodhibiti kazi ya uchapishaji

Ili kutumia anuwai hizi maalum, unawapa tu maadili unayotaka. Kwa mfano, kipande kifuatacho cha programu kinatumia $ kutofautisha kubainisha kitenganishi kati ya vipengee vya uchapishaji:

Inabadilika kuwa utofauti wa $ unaathiri mistari yote, sio tu ile iliyochapishwa. Walakini, mara nyingi utaitumia kubadilisha pato la thamani kwa chaguo la kukokotoa la kuchapisha.

TOTO LA DATA ILIYOUMBWA KWA KAZI YA PRINTF

Kwa chaguo-msingi, kitendakazi cha printf hutuma pato lililoumbizwa kwa STDIO, na kitendakazi cha sprintf hurejesha mfuatano ulioumbizwa. Katika visa vyote viwili, umbizo la mfuatano linakaribia kufanana na vitendakazi vya lugha C, isipokuwa kwamba vitendaji vya lugha ya Perl havitumii kibainishi cha urefu (*). Kipande kifuatacho cha programu kinaonyesha matumizi ya kazi za printf na sprintf.

Usahihi wa $ = 2; $ pi = 3.1415; printf("%.2f\n", $pi); # itachapisha 3.14 printf("%.$(precision)f", $pi); # itatoa 3.14

KUPIGA SIMU PROGRAM ZA NJE KUTOKA KWA MAANDIKO KATIKA PERL

Kuwa, kwa maana, badala maandishi ya shell Perl hutoa usaidizi kwa mwingiliano wa mfumo, pamoja na kupiga simu programu za nje. Sehemu zifuatazo zinajadili njia kadhaa za kuita programu za nje kutoka kwa hati za Perl. Fahamu, hata hivyo, kwamba kwa kuruhusu hati kutekeleza amri za mfumo, unafungua mashimo ya usalama kwenye mwenyeji wako. Kama kanuni ya jumla, usitekeleze amri za nje kutoka kwa hati ya Perl. Walakini, ikiwa utalazimika kufanya amri za nje kutoka kwa hati, unaweza kutumia mfumo wa utendaji uliojengwa ndani, exec au uma kwa madhumuni haya.

MANENO YA KAWAIDA

Katika sura hii yote, umeona mifano ya kazi za kuchakata kamba. Wengi wao hutegemea dhana ya maneno ya kawaida. Kama unavyoona kutoka kwa sehemu zifuatazo, hati za Perl hutumia sana misemo ya kawaida kwa usindikaji wa maandishi. Ikiwa maneno ya kawaida ni mapya kwako, basi usijali. Baada ya muda mfupi, baada ya kupitia sehemu chache za sura hii, maneno ya kawaida yatakuwa rahisi kuelewa.

MUHTASARI WA MANENO YA KAWAIDA

Semi za kawaida ni neno zuri ambalo lilianzia katika sayansi ya kompyuta ili kurejelea muundo wa wahusika. Maandishi ya Perl hutumia muundo wa herufi kwa urahisi kuchanganua data ya ingizo, kuivunja vipande vipande. Mara nyingi hati inaweza kuchanganua ingizo kulingana na nafasi, koma, vichupo na vikomo vingine. Lakini wakati data ya pembejeo ina umbizo la kiholela, basi misemo ya kawaida hukabiliana vyema na kazi hii.

SINTAksiA YA KAWAIDA YA MANENO

Ili kupunguza saizi ya misemo ya kawaida, Perl hutumia herufi maalum. Jedwali 12.6 linaorodhesha baadhi ya herufi zinazotumiwa na hati za Perl katika misemo ya kawaida.

Jedwali 12.6. Alama zinazotumika katika misemo ya kawaida

Perl huweka maneno ya kawaida (mifumo) katika kufyeka, yaani, katika kufyeka, kwa mfano, kwa fomu /pattern/. Kipande kifuatacho cha programu kinaonyesha misemo ya kawaida ya Perl:

# misemo ifuatayo ya kawaida ni kweli ikiwa: /ig/ # kamba ina "ig" /(b|d|f)ig/ # kamba ina "kubwa", "chimba" au "fig" /+/ # kamba ina nambari /*/ # mfuatano una kitambulisho

Ikiwa maneno haya hayana maana kwako, usijali. Katika sura hii, tutaangalia misemo kadhaa ya kawaida. Kwa sasa, kumbuka tu kwamba Perl huweka misemo ya kawaida kati ya mikwaju miwili ya mbele, kama inavyoonyeshwa hapo juu.

KUTUMIA MANENO YA KAWAIDA KUTAFUTA MANENO MUHIMU

Maandishi ya Perl hutumia misemo ya kawaida kufanya ulinganisho wa kamba rahisi. Ili kuangalia ikiwa kamba ina muundo fulani, hati inaweza kutumia misemo ya kawaida kama hii:

Ikiwa ($str =~ /muundo/)

Katika kesi hii, maneno ya kawaida huchukua thamani<истинно>ikiwa muundo unapatikana kwenye kamba ($str). Ikiwa mfuatano una mchoro, basi usemi hurejesha thamani<ложно>. Kwa mfano, usemi ufuatao hujaribu kama mfuatano una maandishi ya WebProgramming:

Ikiwa ($str =~ /Utayarishaji wa Wavuti/)

Ili kuangalia inayolingana kabisa, usemi lazima uunganishe ulinganisho na mwanzo na mwisho wa mfuatano. Kwa mfano, usemi ufuatao una thamani<истинно>, ikiwa na ikiwa tu $str kutofautisha kunachukua moja ya maadili matatu: , ) :

($str =~ /^ba(na) (2,4)$/)

Vile vile, usemi ufuatao ni kweli ikiwa na tu ikiwa $str ina neno na si sehemu ya neno lingine kama vile .

($str =~ /\bthe\b/)

KUTUMIA MANENO YA KAWAIDA KUCHAMBUA DATA YA INGIA

Maandishi yako ya Perl yanapokuwa magumu zaidi, kutakuwa na visa vingi ambapo unataka kujua zaidi ya kuangalia tu ikiwa muundo unalingana na kamba au la. Kwa mfano, unaweza kutaka hati kutoa thamani maalum ya mfuatano. Kwa kutumia vibambo vya kupanga () ndani ya usemi wa kawaida, hati inaweza kutoa thamani zinazolingana kutoka kwa mfuatano na kuunda orodha yao. Kwa mfano, kipande kifuatacho cha programu hutumia misemo ya kawaida kutoa miezi, siku na miaka kutoka kwenye orodha:

$str = "Januari 1, 1997,"; ($m, $d, $y) = $str =~ /\s*(\S*)\s + (\d+)\D + (\d(4))/;

Perl pia inasaidia aina nyingine ya ulinganishaji wa muundo, kwa kutumia opereta (=~), ambayo inaongeza ukanushaji wa matokeo: (!~). Opereta huyu ni sawa na usemi!($str=~/pattern/).

MANENO YA KAWAIDA KWA KUTAFUTA NA KUBADILISHA NAMBA

Kufikia sasa, umetumia viendeshaji vinavyolingana na muundo. Inabadilika kuwa Perl anaunga mkono misemo mingine miwili ya kawaida ambayo hurekebisha utofauti wa kamba unaojaribiwa. Katika taarifa ifuatayo, Perl anabadilisha sehemu ya kamba inayolingana na muundo na kamba uliyopewa:

$str =~ s/muundo/uingizwaji/;

Kwa mfano, maagizo yafuatayo yatachukua nafasi ya neno juu :

$str =~ s/\bcolor\b/color/;

Marekebisho madogo hukuruhusu kubadilisha maneno yote juu :

$str =~ s/\bcolor\b/color/g;

Katika kesi hii, g mwishoni mwa usemi humwambia Perl kwamba uingizwaji wa ulimwengu unahitajika.

Kwa kutumia kiambishi cha i, unaweza kubainisha kuwa utafutaji ni nyeti kwa ukubwa. Kinyume na kuangalia tu muundo, usemi ufuatao pia hufanya badala:

$str =~ tr/SearchList/ReplacementList/;

Kwa mfano, kubadilisha herufi zote ndogo na herufi sawa herufi kubwa inaweza kufanywa kwa njia hii:

$str =~ tr/a-z/A-Z/; # hubadilisha kipochi kutoka chini hadi juu

Fikiria mwenyewe mfano ufuatao:

Barua za $ = "abcde"; chapisha "$herufi\n" # Chapisha abcde $letter =~ tr/a-z/A-Z/; chapisha "$herufi\n" # Chapisha ABCDE

MUHTASARI

Sura hii inatoa utangulizi wa programu ya Perl. Kwa kutumia dhana zilizojadiliwa hapa, unaweza kuandika maandishi tata ya CGI huko Perl. Sura inayofuata itakusaidia kupata ujuzi wa kuunda hati za CGI huko Perl ambazo unaweza kuendesha kwenye seva yako mwenyewe. Kabla ya kuendelea zaidi, hakikisha unaelewa dhana muhimu zifuatazo:

Perl ni lugha ya programu iliyotafsiriwa inayotumiwa na watengeneza programu kuandika hati za Wavuti na Mtandao.

Miundo ya Perl inafanana na ya C kwa njia nyingi, lakini Perl hutoa huduma nyingi za ziada, haswa kwa kushughulikia kamba na faili ambazo ni ngumu kupata katika C.

Perl ndiyo lugha ya msingi ya kuandika programu za CGI kwa Wavuti na Mtandao, haswa kwa sababu ya kubadilika kwake, mtindo wa kompakt, na usalama wa hali ya juu.

TOVUTI MUHIMU KWA HABARI KUHUSU PERL

Tovuti zifuatazo zitakusaidia kupata taarifa kuhusu maelezo unayopenda kuhusu lugha ya Pcrl, hati zake na taarifa mahususi kuhusu rasilimali za lugha za Perl 5 na maktaba zake. Tumia Tovuti hizi kama kianzio cha utafutaji wako.

MUHTASARI

Katika sura hii, ulijifunza jinsi ya kutumia Perl kuandika hati ngumu za CGI. Kwa kutumia teknolojia ambayo umeifahamu, unaweza kutoa huduma za programu za kiwango cha kitaalamu kwa wateja wako ambao wangependa biashara yao iwakilishwe kwenye Wavuti. Sura ya 14 inakuletea lugha ya Java. Kama utaona Lugha ya Java inafaa kwa kuunda Tovuti zenye uhuishaji na medianuwai. Zaidi ya hayo, Sura ya 14 inatanguliza lugha nyingine ya kuandika hati za JavaScript. Hata hivyo, kabla ya kuendelea na Sura ya 14, hakikisha unaelewa dhana muhimu zifuatazo:
- Perl ni lugha ya upangaji inayobadilika na kunyumbulika ambayo inaweza kutumika kutengeneza hati za CGI za Wavuti na vile vile programu za kitamaduni za matumizi ya kila siku.

• Perl inafaa kwa usindikaji wa maneno, ufikiaji wa hifadhidata, inaweza kubebeka na hutoa usalama wakati wa kufanya kazi kwenye mitandao. Tabia hizi zote ni muhimu kwa programu ya Wavuti.
• Maandishi ya Perl hutumia sana misemo ya kawaida kwa usindikaji wa maandishi.
• Maandishi mengi kwenye Wavuti sasa yameandikwa katika Perl. Walakini, lugha kama vile JavaScript na VBScript zinaweza kuingilia ukiritimba wa Perl.

1. Kutumia maandishi yaliyotengenezwa tayari

Ikiwa tayari umeandika maandishi ya CGI, basi kabla ya kuyanakili kwa seva, lazima ufanye yafuatayo:

• Hakikisha kuwa maandishi yanaonyesha njia sahihi kwa mkalimani:

Perl: /usr/bin/perl
Chatu: /usr/local/bin/python

• Ikiwa hati yako inahitaji ufikiaji wa hifadhidata ya MySQL, basi lazima ubainishe vigezo vya ufikiaji (tazama nakala)
• Katika sura Usimamizi wa seva ya wavuti wezesha moduli ya CGI.

Sasa unaweza kunakili hati zako kwa seva.
Faili lazima zipakiwe kwenye saraka kikoa chako/cgi. Faili kutoka kwenye saraka hii zitapatikana kwenye http://your_domain/cgi-bin/file_name. Ili hati za CGI zizinduliwe kutoka kwa saraka ya mizizi ya tovuti kikoa chako/hati, unahitaji kuunda faili ya .htaccess ndani yake na maudhui yafuatayo:

AddHandler cgi-script .cgi .pl .py
Chaguzi+ExecCGI

Haki za ufikiaji lazima ziwekwe kwa hati 755 au -rwxr-xr-x.
Haki za ufikiaji zinaweza kubadilishwa kwa kutumia paneli ya kudhibiti.

2. Kuandika hati rahisi ya CGI

Fikiria kuandika rahisi Hati ya CGI katika Perl.
Ikiwa unatumia Windows OS, basi kufanya kazi na msimbo wa script unahitaji kutumia mhariri maalum wa maandishi, kwa mfano, Notepad ++. Ni bora kutotumia programu ya kawaida ya Windows Notepad. Ili kuonyesha jinsi hati ya CGI inavyofanya kazi, unahitaji kuunda faili mbili. Faili ya kwanza ni hati ya HTML iliyo na fomu ya kuingiza maandishi:

Faili ya pili ni hati ya CGI

#!/usr/bin/perl
tumia CGI;
chapisha "Aina ya Maudhui: maandishi/html\n\n";
$my_cgi = CGI mpya;
$your_name = $my_cgi->param("jina");
chapisha "Hello $ your_name !!!";

Faili ya kwanza unaweza kuweka kwenye saraka kikoa chako/hati. Unapaswa kuweka faili ya pili kwenye saraka kikoa chako/cgi. Hakikisha umeangalia haki za hati yako ya CGI. Lazima ziwekewe -rwxr-xr-x au 755 .

3. Tazama moduli za PERL zilizowekwa

Ili kuangalia moduli za PERL zilizosanikishwa, lazima ufanye hatua zifuatazo kwa mlolongo:

• na endesha amri:

Hii itaunda faili ya modules.pl

• Sasa unahitaji kuihariri, ili kufanya hivyo, bofya Ingiza na uandike yafuatayo:

#!/usr/bin/perl -w

tumia ExtUtils::Imesakinishwa;

$installed = ExtUtils::Imesakinishwa->mpya();
foreach $module ($installed->modules())(
printf "Moduli: %s\t\tVersion: %s\n", $module, $installed->toleo($module);
}

Ili kuondoka kwenye kihariri na kuhifadhi maandishi uliyoandika hivi punde, bonyeza Esc kisha: wq

• Tunaweza kuangalia modules zilizowekwa:

perl ./modules.pl

4. Kuweka moduli za ziada za PERL

Unaweza kusakinisha moduli za ziada za PERL kutoka kwa msimbo wa chanzo kwenye upangishaji wako. Kabla ya kuanza ufungaji, unganisha toleo la hivi punde PHP katika sehemu Usimamizi wa seva ya wavuti→Udhibiti moduli ya PHP paneli dhibiti ya kupangisha, hii itaunganisha seti iliyosasishwa ya programu, ambayo inaweza kujumuisha moduli ya Perl unayohitaji.
Kabla ya usakinishaji, unahitaji kuweka vigezo vya mazingira ili moduli zilizowekwa zipatikane kwa mkalimani.

• Ili kufanya hivyo, tengeneza ndani saraka ya nyumbani.bashrc faili kwa kutumia amri:

paka >> ~/.bashrc<< "EOF"
PERL5LIB=$HOME/PERL/lib:$HOME/PERL/lib/perl5
kuuza nje PERL5LIB

MANPATH=$HOME/PERL/share/man
kuuza nje MANPATH
EOF

• Ili mabadiliko yatekeleze, endesha amri:

chanzo ~/.bashrc

Ili kusakinisha moduli iliyochaguliwa kwa PERL, lazima uendeshe mlolongo ufuatao wa amri:

• kwenye ukurasa http://search.cpan.org/ pata moduli inayohitajika, kwa mfano, Wavu::SMPP na nakili kiungo ili kupakua kumbukumbu na misimbo ya chanzo cha moduli,
• unganisha kwa mwenyeji wako kupitia SSH na uende kwenye saraka kwa faili za muda

• pakia kumbukumbu kwa mwenyeji wako kwa kutumia kiungo kilichopatikana kwa kutumia wget

wget http://search.cpan.org/CPAN/authors/id/S/SA/SAMPO/Net-SMPP-1.12.tar.gz

• fungua kumbukumbu na uende kwenye saraka na misimbo ya chanzo cha moduli

tar -xf Net-SMPP-1.12.tar.gz
cd Net-SMPP-1.12

Ufungaji lazima ufanyike katika saraka tofauti, kwa mfano, /nyumbani/kuingia/PERL, Wapi Ingia- kitambulisho cha huduma ya kupangisha kwa kubainisha tofauti ya INSTALL_BASE.

• Makefile.PL tumia amri:

perl Makefile.PL INSTALL_BASE=$HOME/PERL
fanya
kufanya kufunga

• Ili kusakinisha moduli kwa kutumia faili Build.PL tumia amri:

perl Build.PL
./Build --install_base $HOME/PERL
./Jenga kusakinisha --install_base $HOME/PERL

Ili kutumia moduli zilizosanikishwa kwenye hati ya Perl, unahitaji kuziunganisha kwa kuongeza mistari ifuatayo kwenye faili ya hati:

tumia lib "/home/login/PERL/lib";
tumia lib "/home/login/PERL/lib/perl5";
tumia Net::SMPP;

Ili seva ya wavuti ya Apache ifanye kazi na moduli za ziada, unahitaji kuwezesha moduli kwenye paneli yako ya kudhibiti upangishaji env_moduli na ongeza mistari ifuatayo kwenye faili .htaccess kwenye saraka ya mizizi ya tovuti au kwenye saraka iliyo na maandishi ya CGI:

SetEnv PERL5LIB /home/login/PERL/lib:/home/login/PERL/lib/perl5

ambapo kuingia ni kitambulisho cha huduma ya mwenyeji.

5. Makosa yanayowezekana

Hitilafu 403

Ikiwa utaona ujumbe wa hitilafu 403 wakati wa kufikia hati, hii ina maana kwamba hati ina haki za kufikia zisizo sahihi. Hati za CGI lazima ziwe na seti ya sifa ya utekelezaji (ruhusa 755 au -rwxr-xr-x). Sifa zinaweza kubadilishwa kwa kutumia Kidhibiti Faili cha Paneli ya Kudhibiti.

Hitilafu 500

Ikiwa, unapoendesha hati yako, utaona ujumbe kuhusu kosa la 500, hii ina maana kwamba kuna hitilafu katika hati kutokana na ambayo mtafsiri wa Perl hawezi kukamilisha kazi yake kwa mafanikio. Hitilafu inaweza kuwa ama kosa la kisintaksia (kwa mfano; umesahau mahali fulani - kisha funga nukuu au brace curly), na mantiki, kwa mfano, kama matokeo ya baadhi ya matendo yako, mgawanyiko kwa sifuri hutokea Ili kuelewa sababu ya kosa, unahitaji kuangalia mtandao. faili za kumbukumbu za seva, ambazo zimehifadhiwa kwenye saraka ya /var /log/.