Tunapounda vigezo katika programu na kuhifadhi data mbalimbali ndani yao, tunapoteza wakati programu inaisha. Ikiwa tunahitaji kuhifadhi data na kuitumia katika programu tunazoendeleza, tunaunda faili, kuandika data kwake na kuihifadhi kwenye diski. Takriban lugha yoyote ya upangaji humpa mpanga programu njia za kudhibiti faili na data iliyohifadhiwa ndani yake.
Faili katika programu ya Perl hupatikana kupitia vishikizo vilivyoundwa maalum, ambavyo vinaweza kuzingatiwa kama aina maalum ya kutofautisha. Ncha moja inaweza kuhusishwa na faili moja tu kwa wakati mmoja, ingawa mpini huo unaweza kuhusishwa na faili tofauti kwa mpangilio katika programu yote.
Aidha, maelezo yanaweza kuhusishwa sio tu na faili, bali pia na kituo cha programu ambacho hutoa mawasiliano kati ya taratibu. Katika sura hii, hatutagusa maswala ya mwingiliano wa programu na michakato mingine, lakini tutazingatia tu kufanya kazi na faili na yaliyomo. Kwa hivyo, wakati mwingine tutaita maelezo ya faili ya maelezo.
7.1. Vielezi vya faili
Kifafanuzi - ni jina la mfano ambalo linatumika katika programu ya Perl kuwakilisha faili, kifaa, soketi, au bomba la programu. Wakati kipini kinapoundwa, "humeambatishwa" kwa kitu sambamba cha data na kuiwakilisha katika shughuli za I/O. Tumetoa ufafanuzi kamili zaidi wa maelezo ili msomaji aelewe kwamba maelezo inakuwezesha kufanya kazi sio tu na data ya faili, lakini pia na data kutoka kwa vitu vingine maalum vya programu vinavyotekeleza kazi maalum za kupokea na kusambaza data. Wakati kipini kimefungwa kwenye faili, tutaiita kushughulikia faili.
Katika programu, maelezo ya faili mara nyingi huundwa wakati faili inafunguliwa na open() kazi, ambayo hupitishwa vigezo viwili - jina la maelezo na kamba iliyo na jina la faili na hali ya kufikia:
fungua(LOGFILE, "> /temp/logfile.log");
Taarifa hii huunda mpini unaoitwa LOGFILE na kuambatanisha na faili iliyo na jina lililobainishwa, ambalo hufunguliwa katika hali ya uandishi (mstari wa parameta wa pili huanza na herufi ">"). Katika sehemu hii hatutagusa masuala yanayohusiana na hali ya kufungua faili, lakini tutazingatia zaidi vifafanuzi. Katika sehemu inayofuata, tutazingatia njia za kufungua faili kwa undani zaidi.
Ncha, kama ilivyoonyeshwa, ni jina la faili la mfano na ni kitambulisho halali ambacho hakiwezi kuwa sawa na maneno yaliyohifadhiwa ya Perl. Mfano wetu huunda kifafanuzi cha LOGFILE ambacho "kinasimama" kwa shughuli za I/O kwenye faili ambayo imeambatishwa kwa (/temp/logfile.log). Kwa mfano, na chaguo la kukokotoa la uchapishaji linalojulikana, sasa tunaweza kuandika thamani ya kutofautisha kwa faili hii:
chapisha LOGFILE $var;
Ncha yoyote iliyoundwa inaingia kwenye jedwali la jina la mfano la Perl, ambalo pia lina majina ya anuwai na kazi zote. Walakini, kushughulikia sio kutofautisha, ingawa waandishi wengine huiita kutofautisha kwa faili. Jina la mpini halina viambishi awali vyovyote vinavyohusishwa na viambishi vya Perl ($, @, au %). Kwa hiyo, haiwezi kutumika moja kwa moja katika operesheni ya mgawo na kuhifadhiwa katika kutofautiana au kupitishwa kama parameter kwa kazi. Kwa madhumuni kama haya, lazima utumie kiambishi awali * kabla ya jina lake, ambacho kinarejelea aina ya data ya kimataifa. Kwa mfano, taarifa ya awali ya kuchapisha kwa faili iliyofafanuliwa na kifafanuzi cha LOGFILE inaweza kukamilishwa kwa kutumia taarifa zifuatazo, baada ya kuhifadhi marejeleo ya kifafanuzi katika kigezo cha $iogf:
$logf = *LOGFILE; chapisha $logf $var;
Katika operesheni ya kuchapisha, kigezo cha kwanza cha $iogf kinachukua nafasi ya maelezo ya faili ya LOGFILE ambayo thamani ya kigezo cha pili $var inachapishwa.
Katika mpango wowote wa Perl huwa kuna vishikio vitatu vilivyoainishwa awali (STDIN, STDOUT na STDERR) ambavyo vinahusishwa na vifaa vya kawaida vya kuingiza/kutoa na hutumiwa na baadhi. Kazi za Perl kama vielelezo chaguo-msingi vya ingizo au pato la faili. Kama tunavyojua tayari, kifafanuzi cha STDIN kinahusishwa na kifaa cha kawaida cha kuingiza data (kawaida kibodi), STDOUT na STDERR huhusishwa na kifaa cha kawaida cha kutoa matokeo (kwa kawaida skrini ya kufuatilia). Kifaa cha kawaida cha kuingiza kinatumiwa na o operesheni isipokuwa orodha ya faili imebainishwa kwenye safu ya amri ya simu ya hati ya Perl. Kifafanuzi cha STDOUT HUTUMIWA NA KAZI CHAGUO CHAPISHO NA kufa, na
STDERR - kazi ya kuonya. Vitendaji vingine pia hutumia vielezi vya faili vilivyoainishwa ili kutoa habari zao.
Wakati wa kupiga programu katika mazingira ya Unix na DOS, unaweza kuelekeza pembejeo na pato la kawaida kwa faili zingine kwa kutaja majina yao kwenye safu ya amri na viambishi awali > kwa faili ya pato na.< для файла ввода:
periprogram.pl
Wakati wa kutekeleza programu ya program.pi, data zote za awali lazima ziandaliwe katika faili ya in.dat. Matokeo yatahifadhiwa katika faili ya out.dat badala ya kuonyeshwa kwenye skrini ya kufuatilia.
Uelekezaji upya wa pembejeo na matokeo ya kawaida, pamoja na onyesho la kawaida la makosa, linaweza kufanywa moja kwa moja kwenye programu ya Perl. Ili kufanya hivyo, tumia orep() kazi ya kuhusisha maelezo yanayolingana na faili fulani ya diski:
fungua (STDIN, "in.dat"); open(STDOUT, ">out.dat"); open(STDERR, ">err.dat");
Sasa I/O zote za kawaida zitafanywa kupitia faili zilizoainishwa kwenye taarifa zilizo wazi. Kumbuka kuwa unapobatilisha faili za pato na makosa ya kawaida, majina ya faili hutanguliwa na ">" ili kuonyesha kuwa faili zimefunguliwa katika hali ya kuandika.
7.2. Ufikiaji wa faili
Kama tunavyojua tayari, kufikia faili kutoka kwa programu ya Perl, kushughulikia inahitajika. Maelezo ya faili huundwa na open() kazi, ambayo ni operesheni ya orodha ya Perl:
fungua DESCRIPTOR, FILE_NAME; fungua DESCRIPTOR;
Wakati operesheni ya wazi inafanywa na jina la faili lililotajwa katika vigezo, faili inayofanana inafunguliwa na maelezo ya faili hii huundwa. Unaweza kutumia usemi kama kielezi cha faili kwenye kitendakazi open() - thamani yake itakuwa jina la kielezi. Jina la faili limebainishwa moja kwa moja kama mfuatano halisi au kama usemi ambao thamani yake ni mfuatano. Uendeshaji wazi bila jina la faili hufungua faili ambayo jina lake limo katika kigezo cha scalar $DESCRIPTOR, ambacho hakiwezi kuwa kigezo cha kimsamiati kinachofafanuliwa na kazi(). Mfano 7.1 unaonyesha matumizi ya oparesheni ya open() kufungua faili.
#! peri -w
$var = "out.dat";
$FILE4 = "file4.dat";
fungua FILE1, "in.dat"; # Jina la faili limeainishwa kama kamba
fungua FILE2, $var; #Jina la faili limewekwa kubadilika
fungua FILE3, "/perlourbook/01/".$var; # Jina la faili linatathminiwa katika usemi
fungua FILE4; # Jina la faili katika utofauti wa $FILE4
Faili yoyote inaweza kufunguliwa katika mojawapo ya modi zifuatazo: kusoma, kuandika, au kuambatanisha hadi mwisho wa faili. Hii inafanywa kwa kuweka kiambishi awali sahihi kwa jina la faili:< (чтение), >(rekodi), "(ongeza). Ikiwa kiambishi awali kimeachwa, faili inafunguliwa kwa hali ya kusoma kwa chaguo-msingi. Taarifa imeandikwa kwa faili iliyofunguliwa katika hali ya kuandika (kiambishi awali >) mwanzoni mwa faili, ambayo inaongoza kwa uharibifu wa habari zilizomo ndani yake kabla ya kufunguliwa. Taarifa iliyo katika faili iliyofunguliwa katika hali ya kiambatisho (kiambishi awali ") haijaharibiwa; rekodi mpya huongezwa hadi mwisho wa faili. Unapofungua faili katika hali ya kuandika au kuongezea, ikiwa faili yenye jina maalum haipo, basi moja imeundwa, ambayo inatofautisha njia hizi za kufungua faili kutoka kwa hali ya kusoma, ambayo faili lazima iwepo. Vinginevyo, operesheni ya wazi inashindwa na kushughulikia sambamba haijaundwa.
Perl inakuwezesha kufungua faili katika hali moja zaidi - hali ya kusoma / kuandika. Ili kufanya hivyo, kabla ya kiambishi awali cha kusoma<, записи >au kuongeza » unapaswa kuweka ishara ya kuongeza +. Kumbuka tofauti kati ya njia tatu za kusoma/kuandika +<, +>na +". Njia za kwanza na za tatu huhifadhi yaliyomo kwenye faili inayofunguliwa, wakati wa kufungua faili kwa kutumia hali ya pili (+>) kwanza husafisha yaliyomo kwenye faili inayofunguliwa. Njia ya tatu inatofautiana na mbili za kwanza kwa kuwa uandishi kwa faili unafanywa kila wakati mwishoni mwa yaliyomo kwenye faili.
Kufungua faili na kuunda kushughulikia kwa open() inashughulikia karibu kila kitu modes muhimu kufanya kazi na faili. Hata hivyo, kipengele hiki hakikuruhusu kuweka haki za ufikiaji kwa faili ambazo zimeundwa, au hata kuamua kuunda faili ikiwa haipo. Kwa ufunguzi kama huo wa faili "nzuri", unaweza kutumia kazi ya sysopeno, ambayo inaruhusu programu kuweka vipengele vya kibinafsi vya hali ya uendeshaji wa faili: kusoma, kuandika, kuunda, kuongeza, kufuta maudhui, nk. Syntax ya kazi hii ni kama. ifuatavyo:
sysopen DESCRIPTOR, FILE_NAME, BENDERA [, PERMISSION];
Hapa, kigezo cha FILE_NAME kinawakilisha jina la faili bila viambishi vya kukokotoa open() ambavyo huamua jinsi faili inapaswa kufunguliwa. Mwisho umebainishwa na parameta ya tatu BENDERA - nambari inayowakilisha matokeo ya utendakazi wa busara AU (|) kwenye modi thabiti, imefafanuliwa katika moduli ya Fcnti. Orodha ya mara kwa mara inapatikana inategemea mfumo wa uendeshaji. Katika meza Jedwali 7.1 linaorodhesha vidhibiti vya modi vinavyopatikana karibu na mifumo yote ya uendeshaji.
Jedwali 7.1.
Vidhibiti vya hali ya ufikiaji wa faili
|
Mara kwa mara |
Maana |
|
0_RDOONLY |
Kusoma tu |
|
0_BAYA |
Kurekodi pekee |
|
O_RDWR |
Soma na andika |
|
O_CREAT |
Kuunda faili ikiwa haipo |
|
Kuhusu EXCL |
Inashindwa ikiwa faili tayari ipo |
|
0_APPEND |
Inaongeza % hadi mwisho wa faili |
Haki za ufikiaji(kigezo cha hiari cha RESOLUTION) kimewekwa mfumo wa octal na wakati wa kuziamua, thamani ya sasa ya mask ya upatikanaji wa mchakato iliyotajwa na kazi ya umasko inazingatiwa. Ikiwa parameta hii haijabainishwa, Perl hutumia thamani o666.
(Kwa ruhusa, angalia hati za Perl za mfumo wa uendeshaji uliosakinishwa kwenye kompyuta yako.)
Mfano 7.2 hukusanya utendakazi wa kufungua faili na chaguo la kukokotoa open() na utendakazi sawa wa KUFUNGUA KWA KUTUMIA kitendakazi cha sysopen().
tumia Fcnti;
#Kusoma tu
Fungua FF,"< file.txt";
sysopen FF, "file.txt", O_RDONLY;
# Andika tu (iliyoundwa ikiwa haipo,
# na kufuta yaliyomo ikiwa yapo)
Fungua FF, "> file.txt";
sysopen FF, "file.txt", 0_WRONLY | 0_UNDA | OJTRUNC;
# Ongeza hadi mwisho (iliyoundwa ikiwa haipo)
Fungua FF, "" file.txt";
Sysopen FF, "file.txt", OJJRONLY I 0_CREAT I O_APPEND;
# Soma/andika (faili lazima liwepo) fungua FF, "+< file.txt"; sysopen FF, "file.txt", O_RDWR;
# Soma / Andika (faili imefutwa)
Fungua FF, "+> file.txt";
sysopen FF, "file.txt", O_RDWR | 0_CREAT I OJTRUNC;
Wakati wa kufungua faili, kazi hufungua o na sysopen o inarudisha thamani o ikiwa faili ilifunguliwa kwa mafanikio na hali maalum, na. isiyofafanuliwa undef vinginevyo. Unapaswa kuangalia kila wakati ikiwa operesheni ya kufungua faili ilifanikiwa kwa kusitisha programu na die(). Chaguo hili la kukokotoa linaonyesha orodha ya vigezo vilivyopitishwa kwake na kukomesha hati ya Perl:
fungua(FF, "+< $file") or"die "Нельзя открыть файл $file: $!";
Tafadhali kumbuka kuwa ujumbe wa kazi ya die() hutumia kigezo maalum cha $!, ambacho huhifadhi ujumbe wa mfumo au msimbo wa hitilafu. Habari hii husaidia kugundua na kusahihisha makosa katika programu. Kwa mfano, ikiwa tofauti ya $fiie ina jina la faili ambayo haipo, basi wakati taarifa ya awali inatekelezwa, mtumiaji anaweza kuona ujumbe sawa na ufuatao:
Haiwezi kufungua file.txt: Hakuna faili au saraka kama hiyo katika mstari wa 4 wa D:\PERL\EX2.PL.
Maandishi ya Kiingereza ya ujumbe huu yanawakilisha taarifa iliyo katika Kigezo cha $!
Ili kukamilisha maelezo ya kufanya kazi na kazi ya wazi, inapaswa kuwa alisema kwamba ikiwa jina la faili linawakilisha kamba "-", basi faili ya kufungua inafanana na pembejeo ya kawaida STDIN. Hii ina maana kwamba ingizo kwa kutumia kifafanuzi cha faili iliyoundwa ni kutoka kwa kifaa cha kawaida cha kuingiza. Ikiwa jina la faili limebainishwa kama kamba ">-", basi hii inalingana na matokeo yaliyowashwa kifaa cha kawaida matokeo, iliyowakilishwa katika programu na maelezo ya STDOUT.
Jambo la mwisho tunalotaka kufunika kuhusu vipini vya faili ni kuunda kipini cha nakala. Ikiwa safu ya jina la faili inafuatwa na ampersand "&" baada ya kiambishi awali cha hali iliyo wazi, basi safu iliyobaki inachukuliwa kama jina la kielezi cha faili badala ya jina la faili inayofunguliwa. Katika kesi hii, nakala ya kujitegemea ya maelezo haya imeundwa kwa jina lililotajwa na parameter ya kwanza ya kazi ya wazi<). Оба дескриптора имеют общий указатель текущей позиции файла, но разные буферы ввода/вывода. Закрытие одного из дескрипторов не влияет на работу другого. В Programu za Perl Uwezo wa kuunda nakala ya kifafanuzi hutumiwa hasa kurejesha faili za kawaida za I/O baada ya kuelekezwa kwenye faili zingine (Mfano 7.3).
#! peri -w
# Unda nakala ya kifafanuzi cha STDOUT open(OLDOUT, ">&STDOUT");
# Elekeza upya pato la kawaida
open(STDOUT, "> file.out") au kufa "Haiwezi kuelekeza STDOUT: $!";
# Chapisha ili faili.out
chapisha "Habari katika STDOUTXn iliyoelekezwa";
# Funga kipini cha pato cha kawaida kilichoelekezwa kwingine karibu(STDOUT) au ufe "Haiwezi kufunga STDOUT: $!";
# Rejesha faili ya stdout
open(STDOUT, ">&OLDOUT") au kufa "Haijaweza kurejesha STDOUT: $!";
# Funga nakala ya maelezo ya pato la kawaida STDOUT close(OLDOUT) au ufe "Haijaweza kufunga OLDOUT: $!";
# Chapisha kwa kuchapisha faili ya pato la kawaida "Habari kwa STDOUTXn iliyopatikana";
Wakati faili imekamilika kufanya kazi nayo, imefungwa kwa kutumia kazi ya karibu. Kigezo pekee cha hiari kwa chaguo hili la kukokotoa ni kielezi kinachohusishwa na faili:
funga DESCRIPTOR;
Chaguo hili la kukokotoa litarejesha Kweli ikiwa bafa ya I/O itafutwa kwa mafanikio na kipini cha faili cha mfumo kimefungwa. Inaitwa bila parameter, kazi ya karibu inafunga faili inayohusishwa na kushughulikia sasa iliyowekwa na kuchagua o kazi.
Ikumbukwe kwamba si lazima kufunga faili katika programu kwa kutumia kazi ya karibu. Jambo ni kwamba kufungua faili mpya na mpini tayari unaohusishwa na faili fulani hufunga faili hiyo ya zamani. Kwa kuongeza, wakati programu inaisha, faili zote zilizo wazi ndani yake zimefungwa. Walakini, ufungaji huu usio wazi wa faili umejaa hitilafu zinazowezekana kwa sababu ya kutokuwa na uwezo wa kuamua ikiwa operesheni imekamilika kwa usahihi. Inaweza kutokea kwamba wakati wa kuandika kwa faili, diski itajaa, au unganisho na kifaa cha pato la mbali litavunjwa. Makosa kama haya yanaweza kupatikana kwa kufunga faili wazi na kuangalia yaliyomo kwenye tofauti maalum $!:
chumbani FILEIO) au kufa "Hitilafu ya kufunga faili: $!";
Kuna nuance moja zaidi inayohusishwa na kufunga faili kwa uwazi. Wakati wa kusoma kutoka kwa faili, tofauti maalum $. (isipokuwa thamani yake imebadilishwa wazi katika programu) huhifadhi nambari ya rekodi ya mwisho iliyosomwa. Wakati faili imefungwa kwa uwazi kwa kutumia kazi ya karibu, thamani ya kutofautiana hii imewekwa upya hadi sifuri, wakati faili imefungwa kabisa, inabaki sawa na idadi ya rekodi ya mwisho ya kusoma ya faili ya zamani na inaendelea kuongezeka wakati wa kusoma. uendeshaji kutoka kwa faili mpya.
Kusoma habari kutoka kwa faili hufanywa na operesheni ya o, operesheni ambayo ni maelezo ya faili. Katika muktadha wa scalar, mara ya kwanza operesheni hii inatekelezwa, inasoma rekodi ya kwanza ya faili, kuweka tofauti maalum $., ambayo inafuatilia idadi ya rekodi zilizosomwa, hadi 1. Simu zinazofuata kwa uendeshaji wa kusoma kutoka kwa faili yenye mpini sawa husababisha rekodi zifuatazo kusomwa kwa mfuatano. Katika muktadha wa orodha, operesheni hii inasoma maingizo yote yaliyosalia kwenye faili na kurudisha orodha ambayo vipengele vyake ni maingizo kwenye faili. Kitenganishi cha rekodi kinahifadhiwa katika tofauti maalum $/, na kwa chaguo-msingi ni herufi mpya "\n". Perl hukuruhusu kubainisha kitenganishi tofauti cha rekodi kwa kukabidhi tu herufi mpya ya kitenganishi cha rekodi kwa $/ variable. Mfano 7.4 unaonyesha baadhi ya mbinu za kusoma kutoka kwa faili.
#! peri -w
open(F2, "out.dat") au kufa "Hitilafu ya kufungua faili: $!";
mstari wa $ =
@pumziko =
$/=":"; Ninabainisha kitenganishi tofauti cha rekodi ya faili @f2 =
# Chapisha rekodi zilizosomwa za faili out.dat kwa($i=0; $i<=$#f2; $i++) { print "$f2[$i]\n";
}
$/ = "\n"; # Rejesha kitenganishi cha rekodi chaguo-msingi
funga(Fl) au ufe $!; funga(F2) au ufe $!;
open(F3, "out.dat") au kufa "Hitilafu ya kufungua faili: $!"; chapa
Maoni machache juu ya programu katika Mfano 7.4. Vigezo vya $iinel na $iine2 vinasoma mistari ya kwanza na ya pili ya faili ya in.dat, mtawalia, kwa kuwa kitenganishi cha rekodi chaguo-msingi "\n" kinatumika. Vipengee vya safu ya @rest huhifadhi safu ya tatu hadi ya mwisho ya faili sawa: katika opereta wa mgawo, operesheni ya kusoma.
Kabla ya kusoma rekodi za faili ya out.dat, kitenganishi kipya cha rekodi kinawekwa - ":" tabia. Ikiwa faili out.dat, kwa mfano, ina mstari mmoja tu
111:222:333:Mwisho
Kisha vitu vya safu @ f g itakuwa na maadili yafuatayo:
$f2 = "111:" $f2[l] = "222:" $f2 = "333:" $f2 = "Mwisho"
Wakati mwisho wa faili umefikiwa, operesheni ya o inarudisha thamani isiyofafanuliwa, ambayo inafasiriwa kama Uongo. Hali hii kawaida hutumiwa kupanga usomaji wa rekodi za faili katika kitanzi:
Wakati($line =
chapisha mstari wa $; f Huchapisha mstari unaofuata wa unaohusishwa
# na maelezo ya faili F1)
Kuandika kwa faili iliyofunguliwa kwa njia ya kuandika au kuongeza inafanywa na print() kazi na parameta ya kwanza kuwa maelezo ya faili:
Chapisha DESCRIPTOR OUTPUT_LIST;
Operesheni hii inaandika yaliyomo ya vipengee vya orodha kwa mpangilio ambao yamefafanuliwa katika simu ya kazi, na haiongezi kitenganishi cha rekodi hadi mwisho wa orodha. Mpangaji programu mwenyewe lazima azingatie hii:
$/=":"; # Kitenganishi cha rekodi
chapisha Fl @recll, $/; # Andika kwa faili ya rekodi ya kwanza
chapisha Fl @rec!2, $/; tt Andika kwa faili ya rekodi ya pili
Hairuhusiwi koma baada ya kushughulikia faili
Ikiwa kitendakazi cha kuchapisha hakibainishi kielezi cha faili, basi towe chaguo-msingi ni la faili ya pato la kawaida na kifafanuzi STDOUT. Mpangilio huu unaweza kubadilishwa kwa kutumia kitendakazi cha select(). Imeitwa bila vigezo, inarudisha kipini chaguo-msingi cha sasa kwa pato na print() na write() kazi. Ikiwa imepitishwa parameter moja, basi parameter hiyo lazima iwe maelezo ya faili. Katika kesi hii, pia inarudi kushughulikia chaguo-msingi ya sasa na kuibadilisha kwa kushughulikia iliyoainishwa na parameta iliyopitishwa kwake.
$oldfilehandle = chagua(Fl); Ninahifadhi maelezo ya sasa na
# chaguo-msingi na ukabidhi F1 mpya
chapisha mstari wa $; # Pato kwa chagua la kushughulikia F1 ($oldfilehandle); # Rejesha mpini wa zamani
# chapisha chaguomsingi $line; # Pato kwa mpini wa zamani
Faili katika Perl zinafasiriwa kama mitiririko ya baiti isiyo na muundo. Wakati wa kufanya kazi na faili kwa njia ya maelezo, inafuatiliwa nafasi ya sasa. Shughuli za kusoma / kuandika zinafanywa kutoka kwa nafasi ya sasa ya faili. Ikiwa, kwa mfano, rekodi ya urefu wa byte 80 ilisomwa, basi operesheni inayofuata ya kusoma au kuandika itaanza kutoka kwa byte 81 ya faili. Kuamua nafasi ya sasa katika faili, kitendakazi cha tell() kinatumika, kigezo pekee ambacho kinaweza kuwa kielezi cha faili. Inarudisha nafasi ya sasa katika faili inayohusishwa na kifafanuzi cha faili. Kazi sawa bila parameter inarudi nafasi ya sasa katika faili ambayo operesheni ya mwisho ya kusoma ilifanyika katika programu.
Msimamo wa sasa katika faili hubadilishwa moja kwa moja kulingana na shughuli za kusoma / kuandika zilizofanywa. Hii inaweza kubadilishwa kwa kutumia kipengele cha kutafuta, ambacho hupitishwa kielezi cha faili, kurekebisha, na asili kama vigezo. Kwa faili inayohusishwa na maelezo, nafasi mpya ya sasa imewekwa, inakabiliwa na idadi ya byte iliyoainishwa na paramu ya OFFSET inayohusiana na mahali pa kumbukumbu:
tafuta DESCRIPTOR, OFFSET, TO4KAJDTC4ETA;
Kigezo cha REFERENCE_POINT kinaweza kuchukua moja ya maadili matatu: o - mwanzo wa faili, 1 - nafasi ya sasa, 2 - mwisho wa faili. Kukabiliana kunaweza kuwa chanya au hasi. Kwa kawaida ni hasi kwa kukabiliana kutoka mwisho wa faili na chanya kwa kukabiliana kutoka mwanzo wa faili. Kuweka mahali pa kuanzia, unaweza kutumia viunga vya SEEK_SET, SEEK_CUR na SEEK_END kutoka kwa moduli yu::Seekabie, ambayo inalingana na mwanzo wa faili, nafasi ya sasa na mwisho wa faili. Kwa kawaida, unahitaji kuunganisha moduli hii kwenye programu kwa kutumia neno kuu la matumizi. Kwa mfano, taarifa zifuatazo zinaweka nafasi za faili za sasa kuwa sawa:
tumia 10::Inayotafutwa; tafuta FILE1, 5, 0; tafuta FILE2, 5, SEEK_SET;
Ili kwenda mwanzo au mwisho wa faili, tumia sifuri ya kukabiliana na pointi za marejeleo zinazolingana wakati wa kupiga kazi ya seek():
tafuta FILE1, 0, 0; # Nenda mwanzo wa faili utafute FILE1, 0, 2; § Nenda hadi mwisho wa faili
Mbali na uendeshaji wa kusoma rekodi za faili, Perl hutoa njia nyingine mbili za kusoma habari kutoka kwa faili: kazi za getc () na kusoma (). Ya kwanza inasoma byte moja kutoka kwa faili, wakati ya pili inasoma rekodi za urefu usiobadilika.
Kitendakazi cha getc hurejesha herufi katika nafasi ya sasa ya faili ambayo mpini wake unapitishwa kama kigezo, au thamani isiyobainishwa ikiwa mwisho wa faili umefikiwa au hitilafu hutokea. Ikiwa kazi inaitwa bila parameter, basi inasoma tabia kutoka faili ya kawaida ingiza STDIN.
getc; t Soma herufi kutoka STDIN
getcFl; # Soma herufi katika nafasi ya sasa ya faili na mpini F1
Read() kazi inachukua vigezo vitatu au vinne na syntax yake ni:
soma DESCRIPTOR, ARIABLE, LENGTH [, OFFSET] ;
Husoma idadi ya baiti zilizobainishwa na kigezo cha LENGTH katika kigezo cha kola kilichobainishwa na kigezo VARIABLE kutoka kwenye faili yenye mpini uliobainishwa na kigezo cha kwanza cha DESCRIPTOR. Thamani ya kurudi ni nambari halisi ya baiti zilizosomwa, o ikiwa usomaji utajaribiwa katika nafasi ya mwisho ya faili, na thamani isiyobainishwa ikiwa hitilafu itatokea. Kipimo cha OFFSET huamua idadi ya byte zilizohifadhiwa kutoka kwa yaliyomo ya kutofautiana kwa VARIABLE, yaani, rekodi ya data iliyosomwa kutoka kwa faili itaongezwa kwa yaliyomo ya kutofautiana baada ya byte kuamua na thamani ya parameter ya OFFSET. Thamani hasi ya kukabiliana -n (n ni nambari kamili) inamaanisha kuwa n byte za mwisho za yaliyomo kwenye kigezo VARIABLE hutupwa na rekodi iliyosomwa kutoka kwa faili huongezwa kwa laini iliyobaki. Mfano 7.5 unaonyesha usomaji wa rekodi za urefu usiobadilika, ikizingatiwa kuwa faili ya in.dat ina mistari mitatu ya data:
Moja mbili tatu
#! peri -w
open(Fl, "in.dat") au kufa "Hitilafu ya kufungua faili: $!";
$string = "1234567890";
soma Fl, $string, 6; Nilisoma ka sita kuwa kigeugeu bila kukabiliana
chapisha kamba ya $,"\n"; # $string = "OneXnTw"
soma Fl, $string, 6, length($string);
chapisha kamba ya $,"\n"; # $string = "Moja\nMbili\nTatu"
Urefu wa chaguo za kukokotoa hurejesha idadi ya vibambo (baiti) katika data ya mfuatano iliyohifadhiwa katika kigezo cha kigezo kilichopitishwa kwake kama kigezo. Baada ya utendakazi wa kwanza wa kusoma, yaliyomo kwenye utofauti wa kamba ya $ yaliharibiwa kwa sababu kazi ya kusoma iliitwa bila kukabiliana. Ambapo wakati wa usomaji wa pili, data iliyohifadhiwa katika tofauti ya kamba ya $ ilihifadhiwa kabisa.
Operesheni o, chapisha, soma, tafuta na eleza ni shughuli za I/O zilizoakibishwa, kumaanisha kuwa hutumia vihifadhi kuboresha kasi ya utekelezaji. Perl pia hutoa analogi za kazi zilizoorodheshwa za kufanya shughuli za kusoma kutoka kwa faili na kuandika kwa faili, ambayo haitumii buffers wakati wa kufanya shughuli zinazolingana na yaliyomo kwenye faili.
Vitendaji vya sysread na syswrite ni operesheni ya uingizwaji isiyo na buffer
KUHUSU NA KAZI
chapa, KAZI sysseek Inachukua nafasi ya FUNCTIONS tafuta na useme.
Vitendo vya kusoma na kuandika visivyo na buffer hupokea vigezo sawa, ambavyo vinalingana na vigezo vya kazi ya kusoma:
sysread DESCRIPTOR, ARIABLE, LENGTH [, OFFSET]; syswrite DESCRIPTOR, VARIABLE, LENGTH [.OFFset];
Maana ya vigezo vyote ni sawa na vigezo vya kazi ya read(). Thamani ya kurudi kwa chaguo hizi za kukokotoa ni nambari halisi ya baiti zilizosomwa/kuandikwa, o ikiwa mwisho wa faili ulifikiwa, au undef ikiwa hitilafu ilitokea.
Vigezo vya chaguo la kukokotoa la sysseek vinalingana kabisa na vigezo vya kitendakazi cha seek():
sysseek DESCRIPTOR, OFFSET, REFERENCE_POINT;
Kila kitu kinachosemwa kuhusu kutumia kipengele cha kutafuta kinatumika kikamilifu kwa mwenzake ambaye hajabahatishwa.
Utendakazi wa tell() uliobakiwa unatekelezwa na simu ifuatayo kwa kitendakazi cha sysseek:
$ position = sysseek Fl, 0, 1; # Nafasi ya sasa ya pointer ya faili
Mfano 7.6 unaonyesha matumizi ya vitendakazi vya I/O ambavyo havina buffer kuchakata yaliyomo kwenye faili.
#! peri -w tumia Fcntl;
# Fungua faili katika hali ya kusoma/kuandika sysopen Fl, "in.dat", OJRDWR;
# Soma kizuizi cha baiti 14
$soma = sysread Fl, $string, 14;
Onya "$read byte isome badala ya 14\n" ikiwa $read != 14;
# Weka msimamo wa sasa (kwa ka 15). $ position = sysseek Fl, 0, 1; die "Hitilafu ya kuweka: $!\n" isipokuwa kama imefafanuliwa $position;
# Andika kamba katika nafasi ya sasa $string = "Thamani mpya"; $written = syswrite Fl, $string, length($string);
die "Hitilafu ya kuandika: $!\n" ikiwa $written != length($string); # Kufunga faili
funga Fl au kufa $!;
Unapofanya kazi na vitendaji vya I/O ambavyo havina buffer, unapaswa kuangalia kila mara ili kukamilisha kusoma, kuandika, au utendakazi wa nafasi. Mfumo wa kawaida Kiolesura cha I/O, ambapo I/O iliyoakibishwa inatekelezwa, yenyewe hukagua na ina jukumu la kukamilisha shughuli zilizobainishwa ikiwa mchakato ulikatizwa katikati ya uandishi. Kwa I/O isiyo na buffer, hii lazima itunzwe na mtayarishaji programu.
7.3. Uendeshaji wa faili
Kabla ya kuchunguza kazi zinazofanya shughuli kwenye faili nzima, tutamkumbusha msomaji wa dhana za msingi zinazohusiana na shirika la mfumo wa faili wa UNIX na taratibu za kufikia faili. Vipengele vya utendakazi vya Perl viliundwa kufanya kazi na mfumo huu wa faili, ingawa kwa kiasi fulani mengi tunayojadili yanatumika kwa mifumo ya faili kwenye majukwaa mengine.
Uzoefu wa mtumiaji katika UNIX huanza na utaratibu wa usajili katika mfumo, wakati ambapo anaingia jina lake la kuingia na nenosiri. Jina la kuingia limepewa na msimamizi wa mfumo na kuhifadhiwa kwenye faili maalum ya akaunti. Nenosiri limewekwa na mtumiaji mwenyewe.
Jina la usajili linakumbukwa kwa urahisi na mtumiaji, lakini ni rahisi zaidi kwa mfumo kufuatilia watumiaji kwa kuwatambua sio kwa majina ya ishara ya usajili, lakini kwa vitambulisho vya nambari. Kwa hivyo, pamoja na jina la kuingia la mnemonic, kila mtumiaji wa UNIX pia amepewa kitambulisho cha nambari ya mtumiaji (uid - Kitambulisho cha Mtumiaji) na kitambulisho cha kikundi (gid - Kitambulisho cha Kikundi) ambacho ni chake. Thamani za uid na gid zimepewa mchakato unaoendesha mkalimani wa amri ya ganda ambayo huzinduliwa wakati mtumiaji anaingia. Vitambulishi hivi hupitishwa kwa mchakato mwingine wowote ambao mtumiaji huanza wakati wa kipindi chake cha UNIX.
Mfumo wa faili wa UNIX ni mti, wima za kati ambazo zinalingana na saraka, na majani yanahusiana na faili au saraka tupu. Kila faili inatambuliwa na jina lake kamili la kipekee, ambalo linajumuisha jina la njia kamili kutoka kwa mizizi ya mfumo wa faili kupitia nodes za kati (saraka) moja kwa moja kwenye faili. Saraka ya mizizi ina jina lililofafanuliwa awali, linalowakilishwa na herufi "/". Herufi sawa pia hutumiwa kutenganisha majina ya saraka katika mlolongo wa jina la faili lililohitimu kikamilifu, kwa mfano /bin/prog.exe.
Kila faili kwenye faili Mfumo wa UNIX inayojulikana na kiasi kikubwa cha habari kuliko, kwa mfano, faili katika mfumo wa faili wa FAT. Taarifa hii inajumuisha, lakini sio mdogo, mmiliki wa faili, kikundi ambacho mmiliki wa faili ni, ambaye ana haki ya kusoma faili, kuandika faili, kutekeleza faili, nk Taarifa hii inakuwezesha kufanya hivyo. weka haki tofauti za ufikiaji kwa faili.faili kwa kategoria zifuatazo za watumiaji: mmiliki wa faili, washiriki wa kikundi cha mmiliki, watumiaji wengine. Taarifa zote muhimu kuhusu faili huhifadhiwa katika muundo maalum wa data unaoitwa inode (mode). Inode huwekwa katika eneo maalum la diski ambayo huundwa wakati imeundwa katika mfumo wa UNIX.
Mchakato unapoanza, vitambulishi viwili vya watumiaji huhusishwa nayo: halisi na bora, na vitambulishi viwili sawa vya kikundi cha watumiaji. Vitambulisho halali vya mtumiaji na kikundi ni vitambulisho endelevu vinavyohusishwa na michakato yote iliyoanzishwa na mtumiaji. Vitambulishi vinavyofaa ni vitambulishi vya muda ambavyo vinaweza kuwekwa ili kutekeleza vitendo maalum. Kwa mfano, mtumiaji anapobadilisha nenosiri, programu ya passwd huweka otomatiki vitambulisho madhubuti vya mchakato ili kuhakikisha ufikiaji wa maandishi kwa faili ya nenosiri.
Mara vitambulishi vinavyofaa vinapohusishwa na mchakato, inakuwa chini ya vikwazo vya ufikiaji wa faili. Mchakato unaweza kufikia faili ikiwa tu vizuizi vya ufikiaji vilivyohifadhiwa na faili huruhusu.
Kwa kila mtumiaji aliyesajiliwa wa mfumo, saraka inayoitwa "nyumbani" ya mtumiaji imeundwa, ambayo ana ufikiaji usio na kikomo, pamoja na saraka na faili zote zilizomo ndani yake. Mtumiaji anaweza kuunda, kufuta na kurekebisha saraka na faili kutoka kwa saraka yake ya nyumbani. Ufikiaji wa faili zingine zote unawezekana, lakini unaweza kupunguzwa ikiwa mtumiaji hana upendeleo wa kutosha.
Mtumiaji yeyote anayeunda faili yake anachukuliwa kuwa yake mmiliki. Unaweza kubadilisha mmiliki wa faili kutoka hati ya Perl kwa kutumia chown() kazi. Kigezo cha chaguo hili la kukokotoa ni orodha ambayo vipengele vyake viwili vya kwanza lazima viwakilishe vitambulishi vipya vya nambari uid na gid. Vipengee vilivyobaki kwenye orodha ni majina ya faili ambazo mmiliki anabadilisha. Chaguo hili la kukokotoa hurejesha idadi ya faili ambazo uendeshaji wa mabadiliko ya mmiliki na kikundi ulifanikiwa.
@list = (234, 3, "filel.dat", "file2.dat");
$ nambari = chown(@orodha);
onya "Mmiliki wa sio faili zote amebadilika!" ikiwa $number != @list-2;
Chaguo za kukokotoa za chmodo hubadilisha ruhusa za faili zilizowakilishwa katika orodha iliyopitishwa kwake kama kigezo. Kipengele cha kwanza cha orodha hii lazima kiwe nambari ya oktali ya tarakimu tatu inayobainisha haki za ufikiaji kwa mmiliki, watumiaji katika kikundi cha mmiliki na watumiaji wengine. Kila tarakimu ya oktali inafafanua usomaji wa faili, uandishi wa faili, na utekelezaji wa faili (ikiwa faili inawakilisha programu inayoweza kutekelezwa) kwa vikundi vya watumiaji vilivyoorodheshwa hapo juu. Seti ya vijisehemu vya uwakilishi wake wa jozi huonyesha ruhusa zinazolingana za faili. Kwa mfano, ikiwa bits zote tatu zimewekwa (nambari ya octal 7), basi kikundi cha mtumiaji kinachofanana kina haki zote zilizoorodheshwa: wanaweza kusoma kutoka kwenye faili, kuandika kwa faili, na kutekeleza. Thamani ya 6 inafafanua ruhusa ya kusoma na kuandika, 5 inaruhusu kusoma kutoka kwa faili, kuitekeleza, lakini hairuhusu kuandika kwa faili hii, nk Kwa kawaida, faili isiyoweza kutekelezwa imeundwa na hali ya kufikia 0666 - watumiaji wote wanaweza kusoma na andika habari kwa faili , faili inayoweza kutekelezwa iko na mode 0777. Ikiwa mmiliki wa faili anataka kuzuia maandishi kwa faili na watumiaji sio kutoka kwa kikundi chake, basi taarifa ifuatayo inapaswa kutekelezwa:
Chmod 0664, "file.dat";
Thamani ya kurudi ya chaguo za kukokotoa za chmodo, kama vile chaguo za kukokotoa za chowno, ni idadi ya faili kwenye orodha ambayo operesheni ya kubadilisha ruhusa ilikamilishwa kwa mafanikio.
Katika muundo wa ingizo la faili, kuna sehemu tatu ambazo huhifadhi wakati wa ufikiaji wa mwisho (atime) kwa faili, muundo wake (mtime) wa faili na mabadiliko ya ingizo Xctime): Kazi ya utimeO inaweza kubadilisha wakati wa ufikiaji wa mwisho na urekebishaji wa faili. Kigezo chake ni orodha iliyo na majina ya faili zinazochakatwa, na vitu viwili vya kwanza vya orodha vikiwa maadili ya nambari ya ufikiaji mpya wa mwisho na wakati wa kurekebisha:
gfiles = ("filel.dat", "file2.dat");
$sasa = wakati;
Utime $now, $now, 6files;
Kijisehemu hiki cha msimbo hubadilisha muda wa mwisho wa ufikiaji na urekebishaji wa faili katika orodha ya @files hadi wakati wa sasa uliopatikana kwa kutumia chaguo la kukokotoa wakati.
Kumbuka kwamba wakati utendakazi wa utime o unatekelezwa, wakati wa urekebishaji wa mwisho wa kielezi cha faharisi (ctime) pia hubadilika - umewekwa sawa na wakati wa sasa. Thamani ya kurudi ni kiasi. Idadi ya faili ambazo utendakazi wa kubadilisha muda wa mwisho wa kufikia na urekebishaji ulifanikiwa.
Mfumo wa faili wa UNIX hukuruhusu kuunda viungo vya faili sawa. Hii inakamilishwa kwa kubainisha tu ingizo sawa kwa maingizo mawili ya saraka. Viungo vile huitwa kali(ngumu) viungo, Na mfumo wa uendeshaji haitofautishi kati ya ingizo la saraka iliyoundwa wakati faili imeundwa na marejeleo ya faili hiyo. Wakati faili inapatikana kwa kumbukumbu na kwa jina, sehemu za ingizo hubadilika. Faili inaharibiwa kimwili tu wakati kiungo kigumu cha mwisho cha faili kinaharibiwa.
Katika UNIX kuna aina nyingine ya kumbukumbu ya faili - viungo vya ishara. Viungo hivi vinatofautiana na viungo vigumu kwa kuwa vinarejelea kwa njia isiyo ya moja kwa moja faili ambayo jina lake limehifadhiwa kwenye kizuizi cha data cha kiungo cha ishara.
Viungo ngumu huundwa katika Perl na kazi ya linko, na viungo vya mfano vinaundwa na kazi ya symiinko. Syntax ya kazi hizi ni sawa - vigezo vyao viwili vinawakilisha jina la faili ambalo kiungo kinaundwa na jina jipya la faili ya kiungo:
kiungo OLD_FILE, NEW_FILE; symlink OLD_FIDE, NEW_FILE;
Ikiwa kiungo ngumu kimeundwa kwa ufanisi, kiungo o chaguo la kukokotoa litarejesha Kweli, vinginevyo Si kweli. Uundaji wa kiungo cha mfano na kazi ya symiinko inaambatana na kurudi kwa nambari i ikiwa operesheni imefanikiwa na vinginevyo.
Kitendakazi cha kiungo cha chaguo za kukokotoa ambacho hakitumiki hakitekelezwi katika mstari wa 2 wa D:\EX2.PL.
Chaguo za kukokotoa za ulinganifu hazitekelezwi katika mstari wa 2 wa D:\EX2.PL.
Unaweza kuondoa viungo vilivyopo kwa faili ukitumia kitendakazi cha kutenganisha o. Chaguo hili la kukokotoa huondoa kiungo kimoja kwa kila faili iliyoainishwa kwenye orodha yake ya vigezo. Ikiwa hakuna viungo vya faili, faili yenyewe inafutwa. Chaguo za kukokotoa hurejesha idadi ya faili ambazo operesheni ya kufuta ilifanikiwa. Kupigia simu kitendakazi cha kutenganisha bila orodha ya vigezo hutumia yaliyomo katika kigezo maalum $_ kama orodha ya vigezo. Kijisehemu kifuatacho cha msimbo kinafuta faili zote chelezo za saraka ya sasa:
Tenganisha<*.bak>;
Katika muundo wa ingizo, uwanja wa nlink una idadi ya viungo ngumu kwenye faili. Inaweza kutumika kwa kushirikiana na kitendakazi cha kutenganisha o ili kuondoa viungo vyote vya faili. Ikiwa hakuna viungo, basi uwanja huu una thamani ya 1 (jina la faili tu lililotajwa kwenye uundaji wa faili linarejelea ingizo la faili).
Shughuli mbili za mwisho zinazohusiana na faili ni kubadilisha jina na kupunguza faili. Kazi ya kubadilisha jina hubadilisha jina la faili iliyoainishwa na parameta ya kwanza kwa jina lililoainishwa na parameta ya pili ya kazi hii:
Badilisha jina "old.dat", "new.dat";
Taarifa hii itabadilisha jina la faili ya old.dat hadi new.dat faili. Kazi ya kubadilisha jina la faili inarudi i ikiwa operesheni itafaulu na o vinginevyo.
Chaguo za kukokotoa zilizopunguzwa hupunguza faili hadi urefu fulani. Ili kubainisha faili, unaweza kutumia ama jina la faili au kifafanuzi fungua faili:
punguza DESCRIPTOR, LENGTH; punguza FILE_NAME, LENGTH;
Chaguo za kukokotoa hurejesha Kweli ikiwa urefu wa faili umepunguzwa hadi nambari ya baiti zilizobainishwa katika kigezo cha LENGTH, au undef vinginevyo. Kupunguza faili haimaanishi tu kupunguza urefu wake, lakini pia kuiongeza. Hii ina maana kwamba thamani ya parameter ya pili ya kazi ya truncate inaweza kuwa kubwa kuliko urefu wa kweli wa faili, ambayo inakuwezesha kufanya "mashimo" kwenye yaliyomo kwenye faili, ambayo inaweza kutumika baadaye kuandika habari muhimu bila. kuharibu kile ambacho tayari kimeandikwa kwenye faili (Mfano 7.7).
#! peri -w
# Unda faili iliyo na "mashimo" ya($i=l;$i<=3;$i++H
open(F, "»out.dat") au kufa $!; chapisha F "Rekodi".$i;
funga F;
open(F, "»out.dat") au kufa $!; punguza F, 19*$i;
funga F;
) " tt Andika habari kwenye "mashimo" yaliyofunguliwa(F, "+
tafuta F, 0.1;
soma F,$reel,7;
tafuta F,0,l;
chapisha F"
Katika kila hatua ya kwanza kwa kitanzi katika Mfano 7.7, ka 7 za habari zimeandikwa hadi mwisho wa faili ya out.dat, na kisha urefu wake umeongezeka kwa byte 12, na kuunda nafasi tupu kwenye faili. Kinachofuata kwa kitanzi huingiza baiti 12 za habari kwenye "mashimo" haya yaliyoundwa bila kubatilisha habari iliyohifadhiwa kwenye faili. Kumbuka kuwa ili kubadilisha urefu wa faili, kitendakazi cha kupunguza lazima kiifunge na kuifungua tena. Hii ni kutokana na ukweli kwamba kazi ya truncate huongeza nafasi nyeupe kwa mwanzo wa faili, kusonga yaliyomo yake hadi mwisho ikiwa hutumiwa bila kufunga faili. Unaweza kujaribu programu katika Mfano 7.7 kwa kufungua faili kabla ya kutekeleza ya kwanza kwa kitanzi na kuifunga baada ya kitanzi kukamilika. Yaliyomo kwenye faili yatakupa wazo la kuona la jinsi kazi ya truncate inavyofanya kazi katika kesi hii. Kwa upande wetu, baada ya kutekeleza ya kwanza kwa kitanzi, yaliyomo kwenye faili ya out.dat inaonekana kama hii:
Rekodi! Entry2 Entry3
\
Wakati programu nzima itakamilika, faili itakuwa na mstari ufuatao:
EntryKYALIYOMO:1>Ingizo2<СОЫТЕЫТЗ:2>Rekodi3<СОМТЕ№ГЗ:3>
7.4. Kupata habari kuhusu faili
Tunajua kuwa katika mfumo wa faili wa UNIX, habari kuhusu faili huhifadhiwa kwenye ingizo lake. lina sehemu 13 ambazo nukuu maalum hutumiwa. Zote zimeorodheshwa kwenye jedwali. 7.2.
Jedwali 7.2.
Muundo wa inode
|
Shamba |
Maelezo |
|
|
Nambari ya kifaa kwenye mfumo wa faili |
||
|
Nambari ya inode |
||
|
Hali |
Hali ya faili (aina na ruhusa) |
|
|
Kiungo |
Idadi ya viungo ngumu kwa faili (kwa kukosekana kwa viungo ni sawa na 1) |
|
|
Kitambulisho cha nambari cha mmiliki wa faili |
||
|
Kitambulisho cha nambari cha kikundi cha mmiliki wa faili |
||
|
Rdev |
Kitambulisho cha Kifaa (kwa faili maalum pekee) |
|
|
Ukubwa |
Ukubwa wa faili kwa baiti |
|
|
Wakati |
Wakati wa mwisho wa kufikia faili tangu mwanzo wa enzi |
|
|
Mtime |
Wakati wa urekebishaji wa mwisho wa faili tangu mwanzo wa enzi |
|
|
Pamoja na wakati |
Muda tangu ingizo lilibadilika tangu kuanza kwa enzi |
|
|
Blksize |
Ukubwa wa kizuizi unaopendekezwa kwa shughuli za I/O |
|
|
Vitalu |
Idadi halisi ya vizuizi vilivyotengwa ili kushughulikia faili |
|
Perl hutumia kitendakazi cha stato kupata maadili ya sehemu za muundo wa ingizo la faili. Kigezo chake pekee kinaweza kuwa jina la faili au maelezo ya faili iliyofunguliwa kwenye programu. Inarudisha orodha ya vipengee 13 vilivyo na maadili ya sehemu za muundo wa ingizo la faili kwa mpangilio ambao zimeorodheshwa kwenye Jedwali. 7.2. Matumizi ya kawaida katika programu ya Perl yametolewa hapa chini
($dev,$ino,$mode,$nlink,$uid,$gid,$rdev,$size, $atime,$mtime,$ctime,$blksize,$blocks) = stat($filename);
Kugawia thamani za sehemu kwa orodha ya vigeu vya vipimo vilivyo na vitambulishi vinavyolingana na majina ya sehemu hufanya programu isomeke zaidi kuliko kugawa safu ya vipimo:
@inode = stat($filename);
Katika kesi ya mwisho, unaweza tu kupata thamani ya shamba sambamba kwa kutumia index, ambayo si rahisi kabisa, kwani unahitaji kukumbuka idadi ya shamba la muundo unaohitajika.
Ikiwa hakuna kigezo kilichobainishwa wakati wa kuita kitendakazi cha stato, hurejesha muundo wa ingizo la faili ambalo jina lake limo katika kigezo maalum cha $_.
Kazi ya habari ya faili inarudisha orodha ya maadili ya uwanja wa muundo wa ingizo la faili juu ya mafanikio katika muktadha wa orodha, au orodha tupu juu ya kutofaulu. Katika muktadha wa kozi, hurejesha thamani ya Boolean Kweli au Sivyo kulingana na matokeo ya utekelezaji wake.
Ili kurahisisha kutumia maelezo ya faili, kitendakazi cha stato huweka akiba ya thamani za sehemu zinazotokana zinapotekelezwa kwa mafanikio. Ikiwa utaita kazi hii na kielezi maalum cha faili _ (chini), itarudisha habari iliyohifadhiwa kwenye kashe kutoka kwa simu iliyotangulia. Hii hukuruhusu kuangalia sifa tofauti za faili bila kupiga kazi ya stat() tena au kuhifadhi matokeo yake katika anuwai za programu.
Kazi ya stato inaweza kutumika kupata muundo wa ingizo wa sio faili tu, lakini pia viungo ngumu kwake, pamoja na saraka, kwani pia ni faili ambazo vizuizi vya data vina. majina ya faili saraka na ingizo zao za nambari. Ili kupata habari juu ya viungo vya mfano, unapaswa kutumia is tat o kazi, ambayo inarudisha orodha ya maadili ya sehemu za muundo wa ingizo yenyewe, badala ya faili inayounganisha. Chaguo hili la kukokotoa hufanya kazi sawa na stat() kazi, ikiwa ni pamoja na matumizi ya mpini maalum _.
Mbali na kazi hizi mbili, ambazo hukuruhusu kupata habari kuhusu faili za mfumo, Perl hutoa seti ya shughuli zisizo za kawaida ambazo zinarudisha thamani ya uwanja mmoja tu wa muundo wa ingizo. Operesheni hizi zinarejelewa katika hati kama "-x oparesheni" kwa sababu majina yao yana kistari kikifuatwa na herufi moja. Wote ni waendeshaji wasio na majina na wana utangulizi wao katika misemo ngumu, ambayo tulizungumza juu ya Sura. 3. Orodha kamili ya shughuli zisizo za kawaida za kuangalia sifa za faili zimewasilishwa kwenye Jedwali. 7.3.
Jedwali 7.3.
Shughuli za ukaguzi wa faili zisizo na majina
|
Operesheni |
Sifa ya kuangalia |
||
|
G |
|||
|
W |
Uid/gid inayofaa inaweza kuandika kwa faili |
||
|
X |
Faili inaweza kutekelezwa kwa ufanisi uid/gid |
||
|
KUHUSU |
Mmiliki wa faili ndiye uid inayofaa |
||
|
R |
|||
|
W |
Uid/gid halali inaweza kuandikwa kwa faili |
||
Shughuli zisizo za kawaida hutumika kwa mfuatano ulio na jina la faili, kwa usemi ambao thamani yake iliyotathminiwa ni jina la faili, au kwa kifafanuzi cha faili ya Perl. Ikiwa parameter ya operesheni haijainishwa, basi inajaribu faili ambayo jina lake linapatikana katika kutofautiana maalum $_. Kila operesheni ya kuangalia sifa ya faili inarudisha 1 ikiwa faili ina sifa inayolingana, safu tupu "" vinginevyo, na undef ikiwa faili iliyobainishwa haipo.
Maneno machache kuhusu algorithm ya kutambua maandishi na faili za binary (operesheni -t na -v). Operesheni hizi huchunguza yaliyomo kwenye kizuizi cha kwanza cha faili kwa uwepo wa herufi "za ajabu" - mlolongo usio wa kawaida wa kutoroka au baiti zilizo na biti muhimu zaidi. Ikiwa idadi kubwa ya kutosha ya wahusika sawa hugunduliwa (zaidi ya 30%), basi faili inachukuliwa kuwa ya binary, vinginevyo maandishi. Faili yoyote iliyo na kizuizi cha kwanza tupu inachukuliwa kuwa ya binary.
Shughuli hizi zinapotumika kwa maelezo ya faili ya Perl, yaliyomo kwenye bafa ya I/O huangaliwa, badala ya kizuizi cha kwanza cha faili. Shughuli hizi zote mbili, zinazotumika kwa vifafanuzi vya faili, hurejesha thamani ya boolean Kweli ikiwa faili inayohusishwa na kifafanuzi ni tupu au imewekwa hadi mwisho wa faili.
Wakati wa kufanya shughuli za ukaguzi wa faili zisizo na jina, kazi ya stato kweli inaitwa bila uwazi, na matokeo ya hesabu yake yamehifadhiwa, ambayo hukuruhusu kutumia maelezo maalum ya faili _ kuharakisha ukaguzi wa faili nyingi:
Ikiwa(-s("jina la faili") && -T J (
^
Tunafanya kitu kwa faili za maandishi za saizi isiyo ya sifuri.
}
7.5. Uendeshaji wa Saraka
Kama tulivyoona hapo awali, katika saraka za UNIX ni faili zilizoumbizwa maalum ambazo zimewekwa alama kama saraka katika miundo yao ya ingizo (uwanja wa rdev). Yaliyomo kwenye vizuizi vya data ya saraka ni seti ya jozi inayojumuisha kitu kilichomo kwenye saraka na thamani ya nambari ya ingizo lake.
Kufanya kazi na saraka, Perl hutoa kazi za kufungua, kufunga, na kusoma yaliyomo kwenye saraka, syntax na semantiki ambazo ni sawa na syntax na semantiki ya shughuli zinazolingana na faili:
opendir DESCRIPTOR, DIR_NAME; closedir DESCRIPTOR; readdir MAELEZO;
Upataji wa yaliyomo kwenye saraka unafanywa, kama ilivyo kwa faili, kupitia o iliyoundwa na kazi ya opendir. saraka kushughulikia. Kumbuka kuwa vipini vya saraka vina nafasi yao ya majina iliyoundwa kwenye jedwali la alama ya Perl. Hii inamaanisha kuwa programu inaweza kuwa na maelezo ya faili na saraka na majina sawa bila kupingana na kila mmoja:
fungua FF, "/usr/out.dat" # Kishiko cha faili opendir FF, Vusr" # Ncha ya saraka
Maoni
Kutumia majina sawa kwa maelezo ya faili na saraka kunaweza kumchanganya mtumiaji. Walakini, kwa peri hakuna shida kama hiyo: mkalimani kila wakati anajua haswa ni kielezi gani cha kutumia.
Chaguo la kukokotoa la readdir la saraka iliyo wazi katika muktadha wa orodha hurejesha orodha ya majina ya faili zote kwenye saraka, au orodha tupu ikiwa majina yote tayari yamesomwa. Kazi sawa katika muktadha wa scalar hurejesha saraka ya jina la faili, au undef ikiwa majina yote ya faili yamesomwa.
Kitendaji cha rewinddiro huweka nafasi ya sasa katika saraka hadi mwanzo, ambayo inaruhusu majina ya faili za saraka kusomwa tena bila kuifunga. Parameta pekee ya kazi hii ni kushughulikia kwa saraka wazi.
Mfano 7.8 hukagua ikiwa faili zote kwenye saraka ni za binary (yaliyomo kwenye saraka ndogo haijaangaliwa).
#! peri -w
opendir FDIR, "/usr/prog"; while($name = readdir FDIR) ( inayofuata if -d $name; # Saraka
print("$name: binary\n") ikiwa -B $name; tt Faili ya binary ) imefungwa FDIR;
Kitendaji cha readdir kinarudisha jina la jamaa la faili. Ili kupata jina kamili la faili, lazima uiunda kwenye programu mwenyewe. Kwa mfano, ongeza jina la saraka ili kuangaliwa katika Mfano 7.8:
Chapisha("/usr/prog/$name: binaryXn") ikiwa -B $name; # Faili ya binary
Ili kuunda saraka mpya, tumia kazi ya mkdiro, vigezo ambavyo ni jina la saraka na hali ya ufikiaji (nambari ya octal):
mkdir
DIRECTORY_NAME, MODE;
Ikiwa jina la saraka isiyo na sifa imeelezwa, imeundwa kwenye saraka ya sasa iliyowekwa na kazi ya chdirf). Thamani ya kurudisha ya chaguo za kukokotoa za kuunda saraka ya mkdir ni Kweli ikiwa saraka iliundwa na Si kweli ikiwa hitilafu fulani ilitokea. Katika kesi ya mwisho, katika tofauti maalum $! maelezo ya kutofanya operesheni ya kuunda saraka huhifadhiwa.
Unaweza kufuta saraka kwa kutumia kazi ya rmdirf na parameta iliyo na kamba iliyo na jina la saraka. Ikiwa parameter haijainishwa, basi kutofautiana maalum $_ hutumiwa. Kama kazi ya kuunda saraka, chaguo hili la kukokotoa linarudisha Kweli ikiwa saraka ilifutwa kwa mafanikio na Sivyo vinginevyo, ikihifadhiwa kwenye $! maelezo ya kosa lililotokea.
* * *
Katika sura hii, tulijifunza jinsi ya kufikia yaliyomo kwenye faili na saraka kupitia vishikizo vinavyolingana. Tulijifunza jinsi ya kusoma na kuandika habari kwa faili, kuunda na kufuta saraka. Tulifahamiana na seti kubwa ya shughuli zisizo na jina la kupata habari kuhusu sifa za faili kutoka kwa sehemu za muundo wa ingizo.
Maswali ya kujidhibiti
1. Unawezaje kupata faili kutoka kwa programu ya Perl?
2. Orodhesha shughuli zinazokuruhusu kusoma yaliyomo kwenye faili na kuiandikia habari:
3. Ni njia gani za kufungua faili zipo na zinatofautianaje?
4. Njia ya kufikia faili ni nini na inawezaje kubadilishwa katika programu ya Perl?
5. Ushughulikiaji wa saraka ni nini na kwa nini inahitajika?
6. Unawezaje kupata majina ya faili zote kwenye saraka maalum?
Mazoezi
1. Tafuta makosa katika programu:
#1 kipindi -w
$var = (takwimu "filel.dat");
Fungua FILE1 ">filel.dat";
chapisha FILE1, "Urefu wa faili: " . $var. "\n";
2. Andika programu inayofuta saraka ambayo jina lake limepitishwa mstari wa amri. Ikiwa hati inaendeshwa bila vigezo, toa ujumbe unaoonyesha sintaksia sahihi ya kuiita. (Kidokezo: Unapaswa kwanza kuondoa faili zote kutoka kwa saraka za msingi, ikiwa zipo.)
3. Andika programu ya kunakili faili moja hadi nyingine. Toa kwa kuingiza majina ya faili kwa njia ya mstari wa amri na kutoka kwa skrini ya kufuatilia.
4. Andika programu ya kunakili yaliyomo kwenye saraka moja hadi saraka nyingine. Toa kwa kuingiza majina ya saraka kwa njia ya mstari wa amri na kutoka kwa skrini ya kufuatilia.
5. Andika programu ya kusoma mstari wa faili ya maandishi na nambari fulani. Zingatia hali ambapo nambari iliyobainishwa inazidi idadi ya mistari kwenye faili. Ikiwa nambari ya mstari ni hasi, basi mistari yote inapaswa kusomwa, kuanzia na nambari ya mstari sawa na thamani kamili ya thamani hasi iliyoingia.
Ukurasa wa nyumbani » PERL » Vitanzi na matawi.
Ingizo la faili na hitimisho.
PEKEE LA FILI NA PATO Perl iliundwa mahususi kuwa njia ya kutosha ya kusoma na kuandika kwa 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 viashiria vitatu vya kawaida ambavyo Perl hufungua kiotomati hati inapoendeshwa: STDJN, 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, ni lazima iite kitendakazi wazi. Inaonekana kama hii: open(FileHandle[, FileName]) Tofauti na kitendakazi cha ufunguaji cha maktaba ya C wakati wa kukimbia, kitendakazi cha Perl open 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. Jina la faili Operesheni Fungua faili ya kusoma tu (sawa na fopen) FILE> Unda faili ya kuandikwa (sawa na fopen) > FILE> Fungua faili ili kuambatanisha hadi mwisho (sawa na fopen) FILE> Unda faili ili isomwe. / andika (sawa na fopen) Fungua kituo kutoka kwa mchakato wa kutekeleza amri Fungua kituo kwa mchakato wa kutekeleza Jedwali la amri. 12.3. Makubaliano ya Kutaja Faili na Njia ya Ufikiaji wa Perl Kumbuka: Hali ya mtiririko wa bomba inaweza kuwa haipo kwenye mifumo yote. 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 kitendakazi cha kufunga, kama inavyoonyeshwa hapa chini: funga(FileHandle); Kipande cha programu kinaonyesha matumizi ya vitendaji vilivyo wazi na vilivyofungwa: open(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 kuzishughulikia. Perl hufanya ubadilishaji wa thamani ikiwa ni lazima. Katika chumba cha upasuaji Mfumo wa MS-DOS Perl inasaidia 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 kuwa na uwezo wa kutumia kazi ya binmode, pointer sambamba inaweza kufunguliwa. 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. open(InFile, "Test.dat") || kufa; wakati ($line =) ( chapisha mstari wa $; # Inachapisha mstari kutoka kwa faili ) funga(InFile); Wakati herufi ya pembejeo inapofikia mwisho wa faili, inarudi uwongo, ambayo ni kwa kesi hii inamaliza utekelezaji wa kitanzi cha wakati. Kuna herufi maalum (tupu) ya pembejeo, iliyoashiria, ambayo ina matumizi maalum sana lakini muhimu. Mara ya kwanza hati hutumia herufi tupu ya kuingiza, inachanganua hoja za safu ya amri. Ikiwa kamba ya @ARGV haina kitu, 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, inaendelea hadi inayofuata. Baada ya hati kusoma faili zote, ishara inarudi kuwa ya uwongo. Maandishi ya Perl yanaweza pia 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: @lines = ; Kuandika data kwa faili pia ni rahisi sana. Kwa kweli, ulifanya hivi kila wakati ulipotumia kitendakazi cha kuchapisha. Umbizo kamili la kazi ya kuchapisha ni kama ifuatavyo: Orodha ya kuchapisha; Kama kazi ya kuchapisha haipokei 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 towe: open(LogFile, ">>logfile.dat") || kufa; ############## ($m, $d, $y) = (wakati wa ndani(wakati)) ; chapisha LogFile "logi ya nahodha, Stardate ++m$/$d/$y\n"; funga(LogFile); Kumbuka: Kielekezi cha faili na orodha ya pato hazitenganishwi kwa koma. VIZUIZI VYA DATA YA KUSOMA NA KUANDIKA Wapangaji programu mara nyingi huzingatia. faili za maandishi kama mitiririko ya maandishi kwa sababu herufi moja hufuata nyingine hadi alama ya mwisho wa faili. Ikiwa hati inahitaji kufanya kazi na faili ambayo ina mwelekeo wa kuzuia badala ya kuelekeza mtiririko, basi hati inaweza kutumia vitendakazi vya sysread na syswrite. kuchakata vizuizi vilivyowekwa vya data. Vitendaji vya sysread na syswrite vina miundo ifuatayo: $result = sysread(FileHandle, $Var, Length[, Offset]);$result = syswrite(FileHandle, $Var, Length[, Offset]) ;Kama simu ya kukokotoa itabainisha utatuzi kutoka mwanzo wa faili (Offset), vitendakazi vitatafuta eneo ambapo vitaanzia shughuli za I/O. Sirasoma na syswrite hufanya kazi zote hupitisha data kwa kutumia kigezo cha 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 inabainisha kukabiliana tangu mwanzo wa faili (Offset), basi kazi hutafuta mahali kwenye faili ambayo huanza kufanya shughuli za I / O. Ikiwa unafanya kazi na vizuizi vya data, basi hati zinaweza pia kutumia vitendakazi vifuatavyo vya I/O: $result = seek(FileHandle, Position, Base); $matokeo = tell(FileHandle); $matokeo = eof(FileHandle); Kitendo cha kutafuta hufanya kazi sawa na fseek ya kitendakazi cha maktaba ya wakati wa utekelezaji. Kigezo cha Nafasi kinabainisha nafasi inayohusiana na asili, ambayo nayo inabainishwa na kigezo cha Msingi kama ifuatavyo: ? 0 Tafuta tangu mwanzo wa faili? 1 Tafuta kutoka kwa nafasi ya sasa? 2 Kutafuta kutoka mwisho wa faili 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 ambapo oparesheni ya kusoma au kuandika inafanywa. Hatimaye, chaguo za kukokotoa za eof, kama vile kitendakazi cha C, hurejesha thamani au thamani ambayo hati inaweza kutumia ili kubaini ikiwa mwisho wa faili umefikiwa. UCHAKATAJI WA DATA Mbili Ingawa Perl inalenga hasa usindikaji wa maandishi, inaweza pia kuchakata data 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 kufanya chochote na data, hati inalazimika kubadilisha data kuwa muundo wake wa scalar. KUHIFADHI DATA YA BINARY Wakati hati ya Perl inasoma kizuizi cha data ya jozi kwa kutumia chaguo za kukokotoa za sysread, huhifadhi data hiyo ya binary katika kigezo cha kutofautisha cha mfuatano wa scalar. Perl hajali data ni nini, iwe ina maadili yasiyofaa au yasiyo ya ASCII. Ndani kamba ya tabia Perl anakubali baiti kama baiti. Tofauti na C, Perl haitumii masharti ambayo hayatumiki tena. Ikiwa data inalingana na jedwali la nambari ya ASCII, basi hati inaweza kuichakata kama maandishi yoyote. Lakini ikiwa data ni thamani ya binary, basi hati lazima iipangue kabla ya Perl kuchakata data. KUCHUKUA NAMBA ZA DATA YA BINARI KUWA VIGEUZI VYA PERL Ili hati ifikie data ya jozi, ni lazima iipakue katika umbizo lake la kola. Hati za Perl hufungua data kwa kutumia chaguo la kukokotoa, ambalo lina umbizo lifuatalo: $result = unpack(Template, 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 mhusika unaoeleza jinsi ya kutafsiri thamani katika operesheni ya Usemi. Kipande kifuatacho cha programu kinaonyesha matumizi ya chaguo za kukokotoa: ($r, $g, $b) = unpack("C3", $color);# kitapakuliwa katika herufi 3 @longwords = unpack("L*", $ data); # hupakuliwa kwenye orodha ya maneno # marefu @stuff = unpack("S2L", $bin); # itapakuliwa katika kaptura 2 na ndefu Kila herufi katika 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 mstari. 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. Mchoro wa herufi Maelezo mfuatano wa ASCII usio na herufi batili A Mfuatano wa ASCII usio na herufi batili b Mshipi mdogo (wa kwanza wa chini kidogo) B Mfuatano wa biti (umuhimu zaidi kwanza) c herufi iliyotiwa sahihi ya baiti moja d Thamani ya nukta inayoelea, usahihi maradufu f Thamani ya nukta inayoelea, muundo mmoja wa usahihi h Mfuatano wa thamani za heksadesimali (biti za mpangilio wa chini kwanza) H Mfuatano wa thamani za heksadesimali (biti muhimu zaidi kwanza) i Nambari kamili iliyotiwa sahihi I Nambari kamili isiyotiwa saini l Nambari kamili iliyosainiwa ya aina ndefu L Sawa , bila herufi n Nambari fupi N Namba kamili p Kielekezi kwa kamba s Nambari fupi iliyotiwa sahihi S Nambari fupi isiyotiwa saini u Usimbaji wa mfuatano v Nambari fupi V Nambari fupi x Nambari fupi x Ruka mbele baiti moja X Ruka nyuma baiti moja @ Nenda kwenye nafasi iliyobainishwa katika mfuatano. Kichupo. 12.4. Alama za violezo INAPANGISHA DATA NDANI YA NAMBA AMBAZO Ili kutoa data ya jozi, hati lazima ipakie thamani za kadiri kwenye mifuatano ya herufi binary. Ili kufanya hivyo, tumia kazi ya pakiti, muundo ambao umeonyeshwa hapa chini: $result = pakiti (Kigezo, Orodha); Kipande kifuatacho cha programu kinaonyesha matumizi ya kitendakazi cha pakiti: $color = pack("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 DIRECTORies Perl haitoi tu anuwai ya utendakazi wa kushughulikia faili, lakini pia zingine nyingi sana. kazi zinazofaa kwa saraka za kuchanganua. Katika sehemu zifuatazo tutaangalia baadhi ya kazi kuu za kufanya kazi na saraka kwa undani. KUFUNGUA, KUSOMA NA KUFUNGA KREKTA Hati za Perl hukuruhusu kufungua na kusoma yaliyomo kwenye faili. Vile vile, hati hizi hufungua saraka na kusoma majina ya slaidi 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 ili kuonyesha orodha ya faili katika saraka ya sasa: opendir(Dir, $INC) || kufa; wakati ($file = readdir(Dir)) ( chapisha "$file \n" ) closedir(Dir); Kijisehemu hiki kinatumia muundo tofauti wa $INC, Orodha); $matokeo = sprintf(Muundo, Orodha); Kwa chaguo-msingi, chaguo za kukokotoa za printf hutuma pato lililoumbizwa kwa pato la kawaida la STDIO, na kitendakazi cha sprintf hurejesha mfuatano ulioumbizwa. Katika visa vyote viwili, umbizo la mfuatano unakaribia kufanana na vitendakazi vya lugha ya C, isipokuwa kwamba vitendaji vya lugha ya Perl haziauni 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); # itaonyesha 3.14 KUPIGA SIMU PROGRAM ZA NJE KUTOKA KATIKA ANDIKO LA LUGHA YA PERL Kuwa, kwa maana fulani, kibadala. maandishi ya shell Perl hutoa usaidizi kwa mwingiliano wa mfumo, pamoja na kupiga simu programu za nje. Sehemu zifuatazo zinajadili njia kadhaa za kupiga simu programu za nje kutoka kwa maandishi ya Perl. Fahamu, hata hivyo, kwamba kwa kuruhusu hati kutekeleza amri za mfumo, unafungua mashimo ya usalama kwenye mwenyeji wako. Shikilia kanuni ya jumla usitekeleze maagizo ya nje kutoka kwa hati ya Perl. Hata hivyo, ikiwa ni lazima utekeleze amri za nje kutoka kwa hati, unaweza kutumia mfumo wa utendaji uliojengewa ndani, kutekeleza au uma kwa madhumuni haya. MANENO YA KAWAIDA Katika sura hii yote, umeona mifano ya chaguo za kukokotoa za kuchezea mifuatano. Wengi wao hutegemea dhana ya maneno ya kawaida. Kama unaweza kuona kutoka kwa sehemu zifuatazo, hati za Perl hutumia sana maneno ya kawaida kwa usindikaji wa maandishi. Ikiwa usemi wa kawaida ni mpya kwako, usijali. Baada ya muda mfupi, baada ya kupitia sehemu chache za sura hii, maneno ya kawaida yatakuwa rahisi na rahisi kuelewa. MUHTASARI WA MANENO YA KAWAIDA Semi za kawaida ni neno zuri ambalo asili yake ni sayansi ya kompyuta na kutumika kuteua muundo unaojumuisha alama. Hati za Perl hutumia mifumo ya ishara ili tu kuchanganua data ya ingizo kwa kuigawanya katika sehemu. 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. SINTAX YA KAWAIDA YA MANENO Ili kupunguza ukubwa wa semi za kawaida, Perl hutumia herufi maalum. Jedwali 12.6 linaorodhesha baadhi ya herufi zinazotumiwa na hati za Perl katika misemo ya kawaida. Maelezo ya Alama. Inalingana na herufi yoyote (isipokuwa mstari mpya) (..) Je, unakusanya mfuatano wa vipengele + Inalingana na mchoro uliopita mara moja au zaidi? Inalingana na mchoro sifuri au mara moja * Inalingana na mchoro mara moja au sifuri [...] Inalingana na herufi kutoka seti iliyotolewa [^...] Inalingana na herufi kutoka kwa seti iliyopatikana kwa kukanusha (...|...| ...) Inalingana na mojawapo ya njia mbadala ^ Inalingana na mwanzo wa mfuatano $ Inalingana na mchoro mwishoni mwa mfuatano (n, m) Inalingana na mchoro n hadi m mara (n) Inalingana na mchoro haswa mara n (n, m) ) Inalingana na mchoro angalau mara n \n\t n.k. Inalinganisha mstari mpya, kichupo, n.k. \b Inalingana kwenye mpaka wa maneno \B Inalingana ndani ya mipaka ya maneno \d Inalingana na tarakimu \D Inalingana na isiyo ya tarakimu \s Inalingana na nafasi \S Inalingana na isiyo ya nafasi \w Inalingana na herufi au tarakimu \W Inalingana na herufi ambayo si herufi wala nambari. 12.6. Wahusika wanaotumiwa katika misemo ya kawaida Perl huweka misemo ya kawaida (mifumo) katika kufyeka, yaani, katika mikwaruzo, kwa mfano, kwa namna /muundo/. Kipande kifuatacho cha programu kinaonyesha misemo ya kawaida ya Perl: # misemo ifuatayo ya kawaida ni kweli ikiwa: /ig/ # mfuatano una "ig" /(b|d|f)ig/ # kamba ina "big", "dig" au "fig. " /+/ # mfuatano una nambari /*/ # mfuatano una kitambulisho Ikiwa maneno haya yanaonekana kutokuwa na 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 Hati za Perl hutumia misemo ya kawaida ili kurahisisha ulinganishaji wa mfuatano. Ili kuangalia ikiwa mfuatano una mchoro fulani, hati inaweza kutumia misemo ya kawaida kama hii: ikiwa ($str =~ /pattern/) Katika kesi hii, misemo ya kawaida hutathmini ikiwa muundo unapatikana katika safu ($str) . Ikiwa mfuatano una mchoro, basi usemi huo hurejesha thamani. Kwa mfano, usemi ufuatao hujaribu kama mfuatano una maandishi ya Upangaji Wavuti: ikiwa ($str =~ /Upangaji wa Wavuti/) Ili kujaribu ulinganifu kamili, usemi lazima uambatishe ulinganisho wa mwanzo na mwisho wa mfuatano. Kwa mfano, usemi ufuatao una thamani ya ukubwa ikiwa na iwapo tu kigezo $str kitachukua moja ya thamani tatu: ,) : ($str =~ /^ba(na) (2,4)$/) Vile vile, zifuatazo kujieleza kuwa kweli ikiwa na tu ikiwa $str ina neno na si sehemu ya neno lingine, kama vile . ($str =~ /\bthe\b/) KUTUMIA MANENO YA KAWAIDA KUCHAMBUA KIINGILIO Kadiri hati zako za Perl zinavyozidi kuwa changamano, kutakuwa na nyakati nyingi unapotaka kujua zaidi ya kukagua tu ikiwa mchoro unalingana na mfuatano au la. Kwa mfano, unaweza kutaka hati ili kurejesha thamani maalum ya kamba. Kwa kutumia herufi za kupanga () ndani ya usemi wa kawaida, hati inaweza kutoa thamani zinazolingana kutoka kwa mfuatano na kuunda orodha yao. Kwa mfano, kipande cha programu kifuatacho kinatumia 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))/; Katika kesi hii, unaweza kusoma maneno ya kawaida kama ifuatavyo: ? Ruka tabia yoyote maalum kwanza; ? andika herufi zote zisizo maalum kwa utofauti wa $m (kigezo cha kuwakilisha miezi); ? ruka tabia maalum; ? weka nambari zote kwenye kigezo cha $d (kigezo cha siku za kurekodi); ? ruka herufi zote ambazo sio nambari; ? andika tarakimu nne kwenye kigezo cha $y (kigezo cha kuwakilisha miaka). 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. 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 kamba iliyotolewa: $str =~ s/muundo/uingizwaji/; Kwa mfano, kauli ifuatayo itabadilisha neno na: $str =~ s/\bcolour\b/color/; Urekebishaji mdogo hukuruhusu kubadilisha maneno yote na: $str =~ s/\bcolour\b/color/g; Katika kesi hii, g mwishoni mwa usemi humwambia Perl kutumia uingizwaji wa kimataifa. Kwa kutumia kiambishi cha i, unaweza kubainisha kuwa utafutaji ni nyeti kwa ukubwa. Kinyume na kuangalia tu muundo unaolingana, usemi ufuatao pia hubadilisha: $str =~ tr/SearchList/ReplacementList/; Kwa mfano, kubadilisha herufi zote ndogo kwa herufi kubwa sawa kunaweza kufanywa hivi: $str =~ tr/a-z/A-Z/; # hubadilisha hali kutoka chini hadi juu. Chambua mfano ufuatao kwako: $letters = "abcde"; chapisha "$herufi\n" # Chapisha abcde $letter =~ tr/a-z/A-Z/; chapisha "$letters\n" # Chapisha MUHTASARI WA ABCDE Sura hii inatoa utangulizi wa upangaji programu wa Perl. Kwa kutumia dhana zilizojadiliwa hapa, unaweza kuandika maandishi tata ya CGI huko Perl. Sura inayofuata itakusaidia kupata ujuzi wa kuunda hati za CGI katika Perl ambazo zinaweza kuendeshwa seva 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 TAARIFA YA PERL Zifuatazo Tovuti itakusaidia kupata taarifa kuhusu maelezo unayovutiwa nayo kuhusu lugha ya Pcrl, hati juu yake, na vile vile habari maalum kuhusu rasilimali za lugha za Perl 5 na maktaba zake. Tumia Tovuti hizi kama kianzio cha utafutaji wako. http://www.shareware.com/top/Source-Code-table.html - SHAREWARE.COM - faili maarufu zaidi zilizo na misimbo ya programu. http://www.inxpress.net:80/~moewes/computer/perl95.html - Perl kwa Windows 95. http://www.mit.edu:8001/perl/perlapi.html - PERLAPI http://www. .genome.wi.mit.edu:80/ftp/pub/software/WWW/cgi_docs.html - CGI.pm - Maktaba ya Perl5.CGI http://www.metronet.com/0/perlinfo/perl5/manual/perl .html - PERL http://www.teleport.com/~rootbeer/perl.html - Viungo kwa wanafunzi wa PerlHakuna programu inayoweza kufanya kazi yenyewe bila kupokea na kutuma habari kwa mazingira ya nje. Perl hutoa njia kadhaa za programu kupata data ya nje na habari ya matokeo kutoka kwa hati inayoendesha. Wakati wa uendeshaji wa programu, unaweza kuhitaji kutekeleza amri fulani ya mfumo wa uendeshaji na kuchambua matokeo ya utekelezaji wake, kusoma data kutoka kwa faili ya nje au kikundi cha faili, kuandika matokeo ya mahesabu kwa faili ya nje au kuonyesha kwenye kufuatilia. skrini - vitendo hivi vyote vinatekelezwa na shughuli na kazi mbalimbali za lugha ya Perl.
Mwingiliano rahisi zaidi na mfumo wa uendeshaji ambao programu ya Perl inaendesha inakamilishwa kwa kuambatanisha kamba ya data katika nukuu za nyuma. Yaliyomo kwenye mstari huo hupitishwa kwa mfumo wa uendeshaji kwa ajili ya utekelezaji, ambayo inarudi matokeo ya amri katika mstari huo.
Ili kusoma kutoka kwa faili, tumia operesheni ya "almasi", ambayo hupitishwa kielezi cha faili kama operesheni. Katika sura hii hatutajadili pembejeo kutoka kwa faili kupitia kielezi chake, tukitoa uzingatiaji wa suala hili hadi sura inayofuata, ambayo imejitolea kabisa kufanya kazi na faili. Hapa tutazungumzia jinsi operesheni ya almasi inavyofanya kazi kwa kutokuwepo kwa operand inayowakilisha maelezo ya faili. Katika kesi hii, operesheni hii inaweza kusoma maingizo kutoka kwa faili ya kawaida ya pembejeo STDIN au kupokea habari iliyopitishwa kwenye programu kupitia mstari wa amri.
Ili kuonyesha faili ya kawaida ya pato la STDOUT, kazi ya kuchapisha tayari inajulikana kwetu, ambayo, hata hivyo, inaweza pia kutoa habari kwa faili iliyofafanuliwa na kielezi chake.
6.1. Operesheni ya kuingiza amri
Mfuatano wa herufi zilizoambatanishwa katika nukuu za nyuma " " ni njia rahisi tu ya kuandika oparesheni ya kuingiza amri ya mfumo wa uendeshaji qx() ambayo tayari tumeifahamu. (tazama sura ya 4).
Mkalimani wa Perl anapokumbana na mfuatano ulionukuliwa nyuma, hufanya ubadilishanaji wa safu na safu na kupitisha mfuatano unaotokana kama amri kwa mfumo wa uendeshaji kwa ajili ya utekelezaji. Mwisho huitekeleza na kurudisha matokeo ya pato la amri kwa kifaa cha kawaida cha kutoa, ambacho kwa kawaida ni skrini ya kufuatilia, kama kamba halisi. Kwa sababu ya "tabia" hii ya kamba halisi iliyonukuliwa nyuma, wakati mwingine huitwa pseudoliteral.
Uendeshaji wa uingizaji wa amri hutofautisha kati ya miktadha ya scalar na orodha ambayo inaweza kutekelezwa. Katika muktadha wa scalar, mstari mmoja unarudishwa ukiwa na matokeo yote ya ufuatiliaji wa amri iliyotekelezwa, ikiwa ni pamoja na mistari mipya katika kesi ya utoaji wa laini nyingi. Katika muktadha wa orodha, orodha ya maadili inarejeshwa, kila moja ikiwa na safu moja ya matokeo. Mfano 6.1 unaonyesha matumizi ya operesheni ya kuingiza amri katika miktadha inayofaa.
#! peri -w
$command = "dir";
$scalar = ~$command"; # Muktadha wa Scalar. ,
@list = "$command~; # Muktadha wa orodha.
Chapisha $ scalar;
Chapisha orodha ya $, orodha ya $, orodha ya $;
Sasa, tofauti na Mfano 6.1, kipengee cha safu ya $iist kina matokeo ya amri hadi mlolongo unaofuata wa CHARACTERS "<КАТАЛОГ>" NA KADHALIKA.
Amri iliyo katika pseudoliteral inatekelezwa wakati pseudoliteral inapotathminiwa. Tofauti iliyojumuishwa $? ina thamani ya nambari ya hali ya amri iliyotekelezwa.
(Angalia Sura ya 14 kuhusu kutafsiri maadili ya $? kigezo kilichojengwa ndani.)
Tungependa kuteka mawazo ya msomaji kwa mara nyingine tena kwa ukweli kwamba operesheni ya uingizaji wa amri inarudi pato kwa kifaa cha kawaida cha pato la mfumo wa uendeshaji. Unapoendesha amri, unaweza kuelekeza matokeo yake kwa kifaa kingine, kama vile faili. Ili kufanya hivyo, katika mstari baada ya jina la amri na vigezo vyote muhimu kwa utekelezaji wake, unapaswa kutaja ishara ">", ikifuatiwa na jina la faili. Katika kesi hii, hakuna kitu kitaonyeshwa kwenye skrini ya kufuatilia, na kwa hiyo hakuna kitu kitarejeshwa kwa pseudoliteral, yaani, baada ya kutekeleza amri hiyo, pseudoliteral itakuwa na thamani isiyojulikana (mfano 6.3).
#! peri -w - $/ = "<КАТАЛОГ>";
$list = "dir >file.dat~; # Output ni faili file.dat print $list; # Opereta hatachapisha chochote!
6.2. Operesheni o
Kwa msomaji wetu, operesheni hii sio mpya kabisa. Maneno machache yalisemwa juu yake katika sura ya 4; katika baadhi ya mifano tuliitumia kuingiza mtumiaji kwenye programu ya Perl. Kusudi lake kuu ni kusoma mstari kutoka kwa faili ambayo maelezo yake ni uendeshaji wa operesheni hii. (Operesheni ya operesheni ya o iko ndani ya mabano ya pembe.) Hatutaelezea sasa maelezo ya faili ni nini, kwa nini inahitajika, na hufanya kazi gani katika programu za Perl. Tutazingatia masuala haya kwa undani katika sura inayofuata, iliyojitolea kufanya kazi na faili. Hapa tutazingatia kesi maalum ya kutumia operesheni hii - operesheni na operand o tupu. Katika kesi hii, pembejeo hutoka kwa faili ya kawaida ya pembejeo au kutoka kwa kila faili iliyoorodheshwa kwenye mstari wa amri unapoendesha programu ya Perl. Lakini kabla ya kuendelea kuelezea utendakazi wa utendakazi wa ingizo na opereta tupu, wacha tukae juu ya dhana kadhaa muhimu kwa kuelewa zaidi.
Ili kuhakikisha kuwa programu za Perl zinaendeshwa kwa uthabiti katika mifumo tofauti ya uendeshaji, faili kadhaa za kawaida hufunguliwa zinapozinduliwa. Mmoja wao amekusudiwa kuingiza data kwenye programu na ameunganishwa na kifaa cha kawaida cha kuingiza - kibodi. Faili hii inaitwa faili ya kawaida ya ingizo na ina kifafanuzi STDIN. Ili kutoa taarifa kutoka kwa programu, faili ya pato ya kawaida huundwa, ambayo pia inahusishwa na kifaa cha pato la kawaida la mfumo wa uendeshaji, ambayo ni skrini ya kufuatilia kompyuta. Faili hii ya kawaida imepewa kifafanuzi STDOUT. Ili kuonyesha ujumbe mbalimbali kuhusu makosa yanayotokea wakati wa utekelezaji wa programu, faili ya makosa ya kawaida huundwa na kuhusishwa na kifaa cha kawaida cha pato. Faili hii ina kifafanuzi STDERR. Faili hizi hazihitaji kuundwa na kufunguliwa - tayari zipo wakati programu yetu inapoanza kutekeleza. Hizi wakati mwingine huitwa faili za I/O zilizofafanuliwa awali. Kwa hivyo, ikiwa tunasema, kwa mfano, pembejeo hiyo inatoka kwa faili ya kawaida (au kifaa cha kawaida), tunamaanisha faili ya kawaida ya uingizaji na maelezo ya STDIN.
Unapoendesha programu ya Perl kwenye mfumo wa UNIX au kutoka kwa mstari wa amri ya Windows, unaweza kupitisha vigezo. Chaguzi hizi zimeainishwa baada ya jina la faili iliyo na programu ya Perl, na imetenganishwa nayo na kutoka kwa kila mmoja kwa nafasi:
peri program.pl par2 rag3
Vigezo vinaweza kuwa swichi (kawaida herufi iliyo na kistari kinachoongoza, kama vile -v) ambacho huwekwa. modes fulani utendakazi wa programu, au majina ya faili ambazo programu lazima ichakatwe. Vigezo vyote vilivyopitishwa kwenye programu vinahifadhiwa katika safu maalum iliyojengwa @ARGV. Ikiwa hakuna vigezo vinavyopitishwa, basi safu hii haina kitu.
Operesheni ya o bila operesheni, inayotumika wakati huo na kwa vitanzi, hukagua ili kuona ikiwa safu @ARGV haina kitu mara ya kwanza inapotathminiwa. Ikiwa ni tupu, basi kipengele cha kwanza cha safu hii $ARGV[O] kimejazwa na herufi "-" na operesheni inasubiri pembejeo ya mtumiaji kutoka kwa faili ya kawaida ya uingizaji STDIN. Ikiwa safu ya @ARGV si tupu, basi ina vigezo vilivyopitishwa kwa programu wakati ilizinduliwa. Operesheni ya o inachukulia kila mmoja wao kama jina la faili na kwa kitanzi hupita kwa programu kwa mlolongo mistari yote ya faili zote zilizoainishwa kwenye safu ya amri. Hebu tuzingatie programu rahisi zaidi(mfano 6.4), inayojumuisha kitanzi kimoja cha wakati na uendeshaji<>, na uzingatie tabia yake chini ya njia tofauti za uzinduzi.
mimi! peri -w
Wakati (mstari wa $ =<>) {
chapisha mstari wa $; )
Inapoendeshwa bila vigezo, itasubiri ingizo la mtumiaji kutoka kwa kibodi na kuchapisha mistari iliyoingizwa na mtumiaji kwa kitanzi hadi mtumiaji akamilishe ingizo na mchanganyiko muhimu.
Ikiwa, mwanzoni, utaipitisha jina la faili, kwa mfano, faili iliyo na programu yenyewe,
peri examp6_4.pi examp6_4.pi
Kisha programu katika Mfano 6.4 itachapisha yaliyomo:
F! peri -w
Wakati (mstari wa $ =<>) {
Chapisha mstari wa $; )
Ikiwa unaendesha programu sawa kwa kutaja jina la faili ya programu mara mbili kwenye mstari wa amri,
peri examp6_4.pl examp6_4.pl examp6_4.pl
Kisha programu itachapisha maandishi yake mara mbili.
Wakati wa kufanya operesheni ya kuingiza kutoka kwa faili, kibadilishaji kilichojengwa ndani $. katika kila hatua ya kitanzi huhifadhi nambari ya safu ya faili iliyosomwa. Katika kesi ya kutaja majina kadhaa ya faili kwenye mstari wa amri wakati wa kuingiza mistari yao kwa mlolongo kwa kutumia o operesheni, tofauti hii inaendelea kuongeza thamani yake wakati wa kubadili kusoma mistari ya faili inayofuata, i.e., inazingatia yaliyomo kwenye faili zote kama faili moja.
Opereta ya o na safu ya @ARGV inaweza kutumika pamoja kuingiza yaliyomo kwenye faili nyingi kwenye programu bila kuhitaji zitajwe kwenye safu ya amri. Mahali popote kwenye programu kabla ya matumizi ya kwanza ya operesheni ya kuingiza kwenye kitanzi<>Unaweza kuingiza majina ya faili ambazo yaliyomo yanahitaji kuchakatwa kwenye safu ya SARGV:
@ARGV = ("filel.dat", "file2.dat","file3.dat"); kwa (;<>;) {
Waendeshaji wa usindikaji wa kamba za faili)
Kipande hiki cha programu kiko ndani kwa kitanzi itachakata kwa mpangilio mistari ya faili tatu filel.dat, file2.dat na file3.dat. Kipengele kingine cha kuvutia cha operesheni ya uingizaji wa o kinaonyeshwa hapa. Kwa kawaida, kamba iliyosomwa na operesheni hii imepewa kutofautisha kwa scalar, kama ilivyotokea katika Mfano wa 6.4, lakini ikiwa operesheni hii pekee inawakilisha usemi wa hali ya kitanzi, basi matokeo ya utekelezaji wake huhifadhiwa katika tofauti maalum iliyojengwa ndani $_. Kitanzi cha wakati cha Mfano 6.4 pia kinaweza kuandikwa kama hii:
Wakati (<>) (chapisha;
}
Hii pia inachukua faida ya ukweli kwamba kazi ya kuchapisha, bila vigezo vya chaguo-msingi, huchapisha yaliyomo ya $_ variable.
Ikiwa tunataka kupitisha funguo kadhaa za programu ambayo imeweka hali yake ya kufanya kazi, basi mwanzoni mwa programu tunapaswa kuweka kitanzi kinachoangalia yaliyomo kwenye safu ya @ARGV kwa uwepo wa funguo kwenye safu ya amri ya simu ya programu. . Njia moja ya hundi hiyo imetolewa katika Mfano 6.5, ambapo inadhaniwa kuwa programu inaweza kupewa funguo.
D, -s Na -e.
f! peri -w
wakati ($_ = $ARGV, /A -/) (
if(/ A -d/) ( chapisha $ARGV,"\n";)
if(/ A -s/) ( chapisha $ARGV-, "\n"; )
1£(/L -e/) ( chapisha $ARGV,"\n";)
kuhama; )
Wakati wa kutathmini usemi wa hali ya kitanzi, utofauti $_ umepewa thamani ya kipengele cha kwanza cha safu ya @ARGV na uwepo wa kistari "-" huangaliwa kama herufi ya kwanza ya yaliyomo kwenye utaftaji huu (operesheni / L. -/). Iwapo taarifa angalia yaliyomo katika utofauti wa $_ dhidi ya funguo zinazojulikana na uzionyeshe. (Katika programu halisi, taarifa hizi kwa kawaida hufafanua vigeu vingine ambavyo hutumika baadaye kufanya vitendo maalum kwa funguo zinazolingana.) kitendakazi cha kuhama huondoa thamani ya kwanza kutoka kwa safu ya @ARGV, kuhamisha vipengele vilivyobaki ndani yake nafasi moja hadi kushoto: pili inakuwa ya kwanza, ya tatu inakuwa ya pili, nk Mzunguko unarudiwa mpaka vigezo vinavyopitishwa kupitia mstari wa amri huanza na hyphen. . Utumizi mwingine wa operesheni<>inahusishwa na kupata katika programu majina ya faili katika saraka fulani ambayo inakidhi muundo fulani. Ikiwa uendeshaji wa operesheni hii ni mchoro wa jina la faili, basi katika muktadha wa scalar hurejesha jina la faili la kwanza linalopatikana katika saraka ya sasa, katika muktadha wa orodha hurejesha orodha ya majina ya faili yanayolingana na mchoro uliotolewa. (Unaweza kutumia metacharacter katika muundo: * kwa mfuatano wa herufi kiholela, ? kwa herufi moja isiyo ya kawaida.) Ikiwa hakuna faili zilizo na majina yanayolingana na mchoro zinazopatikana kwenye saraka, basi utendakazi hurejesha thamani isiyobainishwa. Kwa mfano, kufanya operesheni ifuatayo
$ kwanza =<*.pl>;
Itasababisha kuhifadhi katika kibadilishaji cha $first jina la faili ya kwanza kutoka kwa orodha ya faili zote kwenye saraka ya sasa na kiendelezi cha pi, ikiwa kuna faili zozote kwenye saraka, vinginevyo utofauti huu utakuwa na thamani isiyofafanuliwa. Katika orodha, faili zimepangwa mpangilio wa alfabeti. Operesheni sawa katika muktadha wa orodha
Gfiles=<*.pl>;
Hurejesha orodha ya faili zote zilizo na kiendelezi cha pi. Baada ya operesheni hii kukamilika, vipengee vya safu ya @files vina majina ya faili zote zilizo na kiendelezi cha pi.
Ukibainisha saraka kwa uwazi wakati wa kubainisha kiolezo cha faili, operesheni hii itarudisha orodha ya faili kutoka saraka maalum, ambao majina yao yanalingana na muundo uliotolewa. Kwa mfano, operesheni
@faili =;
Huhifadhi majina ya faili zote kwenye saraka ya /peri na kiendelezi cha pi kwenye safu ya @flies.
Operesheni hii inapotumika kwa muda au kwa usemi wa hali ya kitanzi, hurejesha kwa mpangilio jina linalofuata la faili linalolingana na muundo uliotolewa katika kila hatua ya kitanzi:
Wakati ($faili =<*.pl>) (
chapisha "$faili\n"; )
Inatumika yenyewe katika usemi wa hali, operesheni hii inarudisha jina la faili linalofuata katika kigezo cha $_. Kwa mfano, kipande kilichotangulia kinaweza kuandikwa tena kama ifuatavyo:
Wakati (<*.pl>) {
Chapisha $_, "\n"; )
Uendeshaji wa kupata majina ya faili yanayolingana na mchoro fulani unatekelezwa kwa kutumia kitendakazi cha ndani cha globu, kigezo pekee ambacho ni muundo wa jina la faili. Unaweza kutumia kazi hii mwenyewe kupata majina ya faili yanayolingana:
@scripts = glob "*.pl";
Katika muktadha wa scalar, inarudisha jina la faili ya kwanza inayolingana na muundo uliotolewa; katika muktadha wa orodha, inarudisha orodha ya majina ya faili zote. Inatumika bila kigezo, hutumia kigezo maalum $_ kama parameta.
6.3. Kazi chapa
Chaguo la kukokotoa la kuchapisha ndilo chaguo la kukokotoa linalotumika sana kwa uchapishaji wa taarifa kutoka kwa hati ya Perl. Syntax yake ni kama ifuatavyo:
chapisha DESCRIPTOR ORODHA;
Hapa, DESCRIPTOR inawakilisha mpini wa faili ambamo chaguo za kukokotoa hutoa data ya mfuatano inayowakilishwa na orodha ya towe. Inaweza kujumuisha vigeu, vipengee vya safu, na misemo ambayo hutathminiwa kama data ya mfuatano. Maelezo ya faili huundwa na kazi ya wazi ya 0.0, ambayo tutajadili katika sura inayofuata. Inaweza kuachwa, ambapo matokeo yatakuwa kwa faili ya kawaida ya pato STDOUT, isipokuwa faili tofauti ya towe imechaguliwa kwa kuchagua o. Kama ilivyoonyeshwa hapo awali, kifaa cha kawaida cha pato ni skrini ya kompyuta.
Kazi ya kuchapisha, wakati wa kutoa orodha yake, haimalizii na herufi mpya "\n". Hii inamaanisha kuwa kitendakazi kinachofuata cha kuchapisha kitaanza kuchapishwa mara tu baada ya herufi ya mwisho kuchapishwa na chaguo la kukokotoa la uchapishaji lililotangulia. Ikiwa tabia hii haitakiwi, basi orodha ya matokeo ya kila kitendakazi cha kuchapisha inapaswa kukomeshwa kwa njia ya mstari iliyo na herufi mpya, au ijumuishe moja. mhusika wa mwisho kipengele cha mwisho cha orodha ya pato. Mfano 6.6 inaonyesha pato kwa kutumia chaguo la kukokotoa la kuchapisha.
#! peri -w
chapisha "Kamba 1:";
Chapisha "Kamba ya 2:\n";
Chapisha "Kamba 3:", "\n";
chapisha STDOUT "Kamba ya 4:\n";
chapisha FILEOUT "Kamba 4:\n";
Matokeo ya kazi nne za kwanza za uchapishaji za Mfano 6.6 zimeonyeshwa hapa chini:
Mstari wa I: Mfuatano wa 2: Mstari wa 3: Mstari wa 4:
Chaguo za kukokotoa za uchapishaji wa pili huanza utoaji wake kwenye mstari ule ule ambapo chaguo za kukokotoa za kwanza ziliishia, bila herufi mpya katika orodha ya towe. Chaguo za kukokotoa za nne hubainisha kwa uwazi mpini wa kawaida wa faili wa pato STDOUT. Kuhusu kazi ya tano, wacha tuseme kwamba haitatoa chochote kwa faili yoyote iliyofafanuliwa na maelezo ya FILEOUT, kwani hakuna faili inayohusishwa na maelezo haya. Ili kufanya hivyo, kabla ya kutekeleza kazi ya mwisho ya uchapishaji, fungua faili na kazi ya wazi na ushirikishe maelezo ya FILEOUT nayo. Tutaacha maswali haya kwa sura inayofuata.
Chaguo la kukokotoa la kuchapisha, kama vile vitendaji vingine vingi vinavyofafanuliwa katika Perl, ni oparesheni ya orodha, na vipengele vyote vya orodha ya matokeo hutathminiwa katika muktadha wa orodha. Hali hii inapaswa kuzingatiwa wakati wa kutumia misemo yenye simu ndogo kama vipengele vya orodha ya matokeo.
Kila kitu ambacho kilisemwa kuhusu utendakazi wa orodha na matumizi yake kama maneno ya kujieleza katika Sura ya 4 pia inatumika, bila shaka, kwa chaguo la kukokotoa la uchapishaji. Ikiwa vigezo vyake, pamoja na maelezo ya faili, vimefungwa kwenye mabano, basi ujenzi kama huo wa kisintaksia unazingatiwa. muda na katika usemi ana kipaumbele cha juu mahesabu. Kwa mfano, kauli ifuatayo
Chapisha ($m + $n) ** 2;
Huchapisha jumla ya thamani za vigeu $m na $n, badala ya jumla yao kuwa mraba. Kikusanyaji cha peri, kinapogundua mabano ya kushoto baada ya tokeni ya kuchapisha, itapata mabano ya kulia na kushughulikia yaliyomo kama orodha ya vigezo vya chaguo la kukokotoa la kuchapisha. Na kwa kuwa ujenzi kama huo ni muda, operesheni ya kuchapisha jumla ya maadili ya anuwai itafanywa kwanza, na kisha matokeo ya operesheni hii (Kweli = 1) itakuwa mraba. Kuongeza maelezo ya hiari ya faili ya pato ya STDOUT kutarekebisha hitilafu kama hii:
chapisha STDOUT ($m + $n) ** 2; # Chapisha ($m + $n) ** 2
Ikiwa kipengele cha kukokotoa cha kuchapisha hakibainishi orodha ya pato, inabadilika chaguo-msingi kwa uchapishaji wa yaliyomo kwenye kigezo maalum $_ kwa faili iliyobainishwa na kigezo cha DESCRIPTOR:
chapa; # Inaonyesha yaliyomo ya $_ tofauti kwenye skrini ya kufuatilia, chapisha STDOUT; # Sawa na taarifa iliyopita, chapisha FILEOUT; # Hutoa yaliyomo katika kibadilishaji $_ kwa faili # iliyo na maelezo FILEOUT
* * *
Katika sura hii, tulitambulishwa kwa uwezo wa msingi wa I/O uliotolewa na Perl. Tulijifunza jinsi kwa urahisi na kwa urahisi unaweza kutekeleza amri ya mfumo wa uendeshaji na kupata matokeo ya matokeo yake kwenye skrini ya kufuatilia moja kwa moja kwenye programu ya Perl. Operesheni<>hukuruhusu sio tu kusoma rekodi kutoka kwa faili za nje, lakini pia kusindika kiotomatiki yaliyomo kwenye faili nyingi zilizoainishwa kwenye mstari wa amri unapoendesha hati ya Perl. Operesheni sawa hukuruhusu kutafuta faili ambazo majina yao yanalingana na muundo fulani. Ili kutoa habari kutoka kwa programu, kazi ya kuchapisha hutumiwa, ambayo inaweza kutoa sio tu kwa skrini ya kufuatilia (kifaa cha kawaida cha pato), lakini pia kwa faili ya nje.
Maswali ya kujidhibiti
1. Unawezaje kupata matokeo ya kutekeleza amri ya mfumo wa uendeshaji katika programu ya Perl?
3. Majina ya vigezo yanapitishwa wapi kwa hati ya Perl kupitia safu ya amri iliyohifadhiwa?
4. Je, inawezekana kupata majina ya faili katika saraka maalum inayolingana na muundo fulani katika programu ya Perl?
5. Uendeshaji wa orodha gani hutoa pato kwenye skrini ya kufuatilia?
6. Ni orodha gani ya matokeo ya uendeshaji kwa faili ya nje?
Mazoezi
1. Andika programu ambayo inakili faili moja hadi nyingine. Majina ya faili hupitishwa kwa programu inapozinduliwa kama vigezo vya mstari wa amri. (Kidokezo: tumia amri ya mfumo samahani.)
2. Andika programu inayoonyesha kwenye skrini yaliyomo kwenye faili ambazo majina yake yanatajwa kwenye mstari wa amri. Maonyesho ya yaliyomo katika kila faili lazima yatanguliwa na mstari ulio na jina la faili. (Kidokezo: tumia operesheni<>.)
3. Andika programu ya Perl inayofuta faili kwenye saraka maalum. Majina ya faili yanatajwa na template, ambayo, pamoja na jina la saraka, hupitishwa kwenye programu kupitia mstari wa amri wakati unapozinduliwa.
Perl hutumia seti mbili za kazi kufanya shughuli za kusoma/kuandika faili. Kazi za seti moja hutumia buffer - eneo fulani la kumbukumbu - kukusanya habari iliyosomwa / iliyoandikwa kwa faili, baada ya kuijaza au kufunga faili, data ya buffer imeandikwa kwa diski au kutumwa kwa programu. . Vipengele hivi, ambavyo ni pamoja na uchapishaji, mstari wa kusoma,<>, read , getc , seek and tell kimsingi ni vitendakazi vya kiolesura cha taratibu za stdio ya maktaba ya I/O iliyoakibishwa. Kutumia shughuli za I/O zilizoakibishwa huharakisha kusoma/kuandika data kwa faili. Seti ya pili ya vitendakazi, ambayo ni pamoja na sysread, syswrite na sysseek, fikia moja kwa moja vitendaji vya I/O vya mfumo wa uendeshaji, kufanya shughuli za moja kwa moja za kusoma/kuandika data bila kuzihifadhi kwenye bafa ya kati. Unaweza kufungua faili kwa ajili ya kufikiwa na vitendakazi vilivyoakibishwa na ambavyo havijatumiwa kwa kutumia mojawapo ya vitendakazi viwili - open() au sysopen() - wakati wa kufungua faili, hakuna kanuni kuhusu ni seti gani ya vitendakazi inapaswa kuchakata maelezo yaliyomo. Mahitaji pekee ni kwamba haipendekezi kuchanganya mbinu hizi mbili kwa faili sawa katika kikao sawa cha ufunguzi, kwa sababu hii inaweza kusababisha matokeo yasiyotabirika.
TAHADHARI Unapofanya kazi na faili sawa, hupaswi kuchanganya simu na vitendaji vya I/O vilivyoakibishwa na ambavyo havina buffered. Kitendo hiki kinaweza kusababisha migongano isiyotabirika. Ikiwa, kwa mfano, unahitaji kutumia kazi zisizo na buffered za kusoma / kuandika, na taarifa kutoka kwa faili tayari imesomwa na operesheni iliyohifadhiwa, basi unapaswa kuifunga faili, kuifungua tena na kutumia kazi zisizopigwa kufanya kazi nayo.
I/O iliyoakibishwa
Mara nyingi, programu huchakata faili za maandishi. Operesheni<>, ambayo uendeshaji wake ni kifafanuzi cha faili, husoma taarifa kutoka kwa faili katika "rekodi" nzima, ambazo kwa kawaida huwakilisha mistari katika faili ya maandishi. Inapotumika katika muktadha wa scalar, inasoma rekodi ya sasa ya faili kwa kuongeza tofauti maalum $., ambayo hufuatilia idadi ya rekodi zilizosomwa. Katika muktadha wa orodha, operesheni hiyo hiyo itasoma rekodi zote za faili ikiwa itafanywa kwenye faili hiyo kwanza, au rekodi zilizobaki ikiwa kumekuwa na usomaji mwingine kutoka kwa faili kabla yake, na kurudisha orodha ambayo vitu vyake ni rekodi zilizosomwa. ya faili. Kwa usahihi zaidi, tunaweza kusema kwamba operesheni<>katika muktadha wa orodha, husoma rekodi zilizobaki za faili, kuanzia nafasi yake ya sasa, ambayo inabadilishwa kabisa na kila operesheni ya kusoma, na inaweza kubadilishwa kwa uwazi kwa kutumia search() kazi, ambayo tutajua baadaye kidogo. Kuangalia mbele, wacha tuseme kwamba faili zote kwenye Perl hazina muundo wowote, lakini zinawakilishwa, kama katika C, na mkondo wa ka. Kitenganishi cha rekodi huhifadhiwa katika tofauti maalum $/, na kwa chaguo-msingi ni herufi mpya \n. Kwa hivyo, ikiwa mtumiaji hakuweka kitenganishi cha rekodi ya kawaida, basi chini ya kuingia kwa faili katika operesheni<>inamaanisha mstari katika faili ya maandishi. Kuweka kitenganishi tofauti cha rekodi hufanywa kwa kukabidhi $/ kutofautisha herufi mpya ya kitenganishi cha rekodi au mlolongo wa herufi. Orodha ya 6.9 inaonyesha baadhi ya mbinu za kusoma kutoka kwa faili kwa kutumia uendeshaji<>. Orodha 6.9. Kusoma kutoka kwa operesheni ya faili<>#! perl -w open (F1, "in.dat") au kufa "Hitilafu ya kufungua faili: $!"; open(F2, "out.dat") au kufa "Hitilafu ya kufungua faili: $!"; $line1 =KUMBUKA Wakati wa kuunda faili ya out.dat, ikiwa laini yake pekee itaisha na mpito kwa mstari mpya(kitufe cha Ingiza kinasisitizwa), kisha $f2 itakuwa na mstari "Mwisho\n".
Katika taarifa ya mwisho ya uchapishaji ya programu katika Orodha 6.9, uendeshajiONYO Lazima kusiwe na koma kati ya kifafanuzi cha faili na kipengele cha kwanza cha orodha ya matokeo. Hili likitokea, mkalimani wa perl atatupa kosa: Hakuna koma inayoruhusiwa baada ya kushughulikia faili.
Wakati wa kuandika habari kwa faili, print() kazi inaweza kuchukua fursa ya kipengele kingine muhimu. Ikiwa thamani ya kutofautiana maalum $ imetajwa, inaingizwa kati ya vipengele vya orodha ya pato. Kwa mfano, ikiwa tunataka maadili ya vipengele vya orodha kuonyeshwa si kama mtiririko unaoendelea wa wahusika, lakini kutengwa na nafasi, basi tunapaswa kuweka thamani ya kutofautiana hii maalum sawa na nafasi: $var1 = "11111"; Svar2 = "22222"; chapisha $var1, $var2, "\n"; $, = ""; chapisha $var1, $var2, "\n"; Taarifa ya kwanza ya kuchapisha itachapishwa: 1111122222 Wakati wa kutekeleza taarifa ya uchapishaji ya pili tutapata kamba: 11111 22222ATTENTION Wakati wa kuweka maadili ya vigezo maalum $\ na $, athari yao inatumika kwa simu zote zinazofuata kwa print() chaguo la kukokotoa.
Ikiwa kazi ya kuchapisha haielezei maelezo ya faili, basi pato la kawaida ni kwa faili ya kawaida ya pato na maelezo ya STDOUT, na ikiwa orodha ya pato haijainishwa, basi yaliyomo ya variable maalum $_ yanachapishwa. Mpangilio chaguo-msingi wa print() kishikio cha kitendakazi kinaweza kubadilishwa na chaguo la kawaida la kuchagua() chaguo la kukokotoa. Imeitwa bila vigezo, inarudisha kipinishi cha sasa cha faili chaguo-msingi kwa print() na write() kazi. Ikiwa imepitishwa parameter moja, basi parameter hiyo lazima iwe maelezo ya faili. Katika kesi hii, pia inarudi kushughulikia chaguo-msingi ya sasa na kuibadilisha kwa kushughulikia iliyoainishwa na parameta iliyopitishwa kwake. Mfano wa kutumia kitendakazi cha select() umetolewa hapa chini. # Hifadhi kipini chaguo-msingi cha sasa na uweke # F1 kwa mpini mpya chaguo-msingi $oldfilehandle = chagua (Fl); # Pato kwa faili inayohusishwa na Fl descriptor print $line; # Rejesha chagua chaguo-msingi la zamani ($oldfilehandle); # Pato kwa faili inayohusishwa na kielezi cha zamani cha kuchapisha $line; Kama ilivyobainishwa, faili katika Perl zinafasiriwa kama mitiririko ya baiti isiyo na muundo. Hiyo kwa msaada wa operesheni<> na kitendakazi cha print() kwa mtiririko huo tunasoma au kuandika mlolongo mzima wa ka, ambao tunauita "rekodi", kwa njia isiyohusishwa na muundo wowote wa faili. Ni kwamba shughuli hizi zimepangwa kwa namna ambayo mtu anasoma na pili anaandika mlolongo wa byte. Kwa kweli, tunaweza kusoma na kuandika habari kwa baiti ya faili moja kwa wakati. Kwa kila faili iliyo wazi, tofauti ya mfumo imeundwa ambayo inaendelea kufuatilia nafasi yake ya sasa, yaani, mahali kwenye faili ambayo kazi za kusoma zinasoma na kuandika habari. Kwa hiyo, tunaweza kusema kwamba shughuli za kusoma / kuandika zinafanywa kutoka kwa nafasi ya sasa ya faili. Wakati operesheni yoyote ya kusoma / kuandika inafanywa, pointer ya sasa ya nafasi ya faili inahamishwa na idadi ya baiti zilizosomwa au zilizoandikwa. Ikiwa, kwa mfano, rekodi ya 80-byte ilisomwa tangu mwanzo wa faili, basi operesheni inayofuata ya kusoma au kuandika itaanza kwenye nafasi ya ka 81 za faili. Kuamua nafasi ya sasa katika faili, kitendakazi cha tell() kinatumika, kigezo pekee ambacho kinaweza kuwa kielezi cha faili. Hurejesha nafasi ya sasa katika faili inayohusishwa na maelezo ya faili uliyopewa. Kazi sawa bila parameter inarudi nafasi ya sasa katika faili ambayo operesheni ya mwisho ya kusoma ilifanyika katika programu. Nafasi ya sasa katika faili inabadilishwa kiotomatiki kwa mujibu wa shughuli za kusoma/kuandika zilizofanywa, lakini pia inaweza kubadilishwa kwa uwazi kwa kutumia kitendakazi cha seek(), ambacho hupitishwa kama vigezo kifafanuzi cha faili, kukabiliana na asili. Kwa faili inayohusishwa na maelezo, nafasi mpya ya sasa imewekwa, inakabiliwa na idadi ya byte iliyotajwa na parameter ya OFFSET kuhusiana na hatua ya kumbukumbu: tafuta DESCRIPTOR, OFFSET, REFERENCE POINT; Kigezo cha REFERENCE_POINT kinaweza kuchukua moja ya maadili matatu: 0 - mwanzo wa faili, 1 - nafasi ya sasa, 2 - mwisho wa faili. Kukabiliana kunaweza kuwa chanya au hasi. Ni hasi kuhusiana na mwisho wa faili, chanya kuhusiana na mwanzo wa faili, na inaweza kuwa chanya au hasi kuhusiana na nafasi ya sasa. Unaweza pia kuweka sehemu za marejeleo kwa kutumia viunga vilivyoitwa SEEK_SET, SEEK_CUR, na SEEK_END, vilivyofafanuliwa katika Perl's IO::Sekable package, ambayo hufanya programu kusomeka zaidi. Vipengele hivi, kwa mpangilio ambao tumeorodhesha, vinalingana na mwanzo wa faili, msimamo wa sasa, na mwisho wa faili. Ili kutumia viunga vilivyotajwa vilivyotajwa, bila shaka, unahitaji kuunganisha moduli hii kwenye programu kwa kutumia neno kuu la matumizi. Kwa mfano, kauli zifuatazo zinaweka nafasi za sasa katika faili kuwa sawa: tumia IO::Inayotafutwa: tafuta FILE1, 5, 0; tafuta FILE2, 5, SEEK_SET; Lugha haina vitendaji maalum vya kuhamia mwanzo au mwisho wa faili. Ikiwa unahitaji kuweka faili mwanzoni au mwisho, unapaswa kutumia sifuri kukabiliana na pointi za kumbukumbu zinazofanana wakati wa kupiga kazi ya seek(): tafuta FILE1, 0, 0; # Nenda mwanzo wa faili utafute FILE1, 0, 2; # Sogeza hadi mwisho wa faili Kwa kuongeza shughuli zinazojulikana tayari za kusoma rekodi za faili<>na readline(), Perl hutoa kazi mbili zaidi za kusoma yaliyomo kwenye faili - getc() na read(). Ya kwanza inasoma byte moja kutoka kwa faili, wakati ya pili inasoma rekodi za urefu fulani, ambayo ni, mlolongo wa baiti za urefu fulani. Getc() chaguo za kukokotoa husoma na kurudisha herufi katika nafasi ya sasa ya faili ambayo mpini wake hupitishwa kwake kama kigezo, au thamani isiyobainishwa ikiwa mwisho wa faili umefikiwa au hitilafu hutokea. Ikiwa kazi inaitwa bila parameter, inasoma tabia kutoka kwa faili ya kawaida ya pembejeo STDIN. getc; # Soma mhusika kutoka STDIN getc F1; # Soma herufi katika nafasi ya sasa ya faili na # kushughulikia F1 Kazi ya kusoma () inasoma nambari fulani baiti kuanzia nafasi yake ya sasa. Inaweza kuitwa na vigezo vitatu au vinne, na wito wake ni wa fomu: soma DESCRIPTOR, VARIABLE, LENGTH [,OFFset]; Chaguo hili la kukokotoa husoma idadi ya baiti zilizobainishwa na thamani kamili ya kigezo cha LENGTH kwenye kigezo cha kola kilichobainishwa na kigezo VARIABLE kutoka kwenye faili yenye mpini uliobainishwa na kigezo cha kwanza cha DESCRIPTOR. Thamani ya kurudi ni nambari halisi ya baiti zilizosomwa, 0 ikiwa usomaji unajaribiwa katika nafasi ya mwisho ya faili, na haijafafanuliwa ikiwa makosa mengine yanatokea. Kigezo cha hiari cha OFFSET huamua baada ya ambayo byte ya yaliyomo ya VARIABLE rekodi iliyosomwa kutoka kwa faili itahifadhiwa. Inaweza pia kuwa na thamani hasi ya kukabiliana -n (n ni nambari kamili). Hii inamaanisha kuwa n byte za mwisho za yaliyomo katika kigezo cha VARIABLE hutupwa na rekodi iliyosomwa kutoka kwa faili huongezwa kwa laini iliyobaki. Orodha ya 6.10 inaonyesha rekodi za usomaji za urefu fulani kutoka kwa faili ya in.dat iliyo na laini tatu za data: ******** * PERL * ******** Orodha ya 6.10. Soma rekodi za urefu maalum #! perl -w open(F1, "in.dat") au kufa "Hitilafu ya kufungua faili: $!"; $str = "1234567890"; soma F1, $str, 9; # Soma baiti tisa kwenye # variable $str bila uchapishaji wa kukabiliana na $str,"\n"; # $str = "********\n" soma F1, $str, 8, urefu ($str); chapisha $str,"\n"; # $str - "*******\n* PERL *" Programu katika Orodha ya 6.10 hutumia kitendakazi cha urefu () ili kubainisha idadi ya vibambo (baiti) zilizo katika kigezo cha kubadilika. Baada ya operesheni ya kwanza ya kusoma, yaliyomo kwenye $str variable yaliharibiwa kwa sababu kazi hii ya read() iliitwa bila kuchanganya. Katika usomaji wa pili, data iliyohifadhiwa katika tofauti ya $str ilihifadhiwa kabisa. Kumbuka kuwa laini mpya iliyo katika safu ya kwanza ya faili ya in.dat pia inazingatiwa wakati read() inasoma rekodi za urefu fulani. Haupaswi kusahau kuhusu hali hii wakati wa kusoma habari kutoka kwa faili ya "mistari mingi" kwa kutumia kazi ya kusoma ().I/O isiyo na buffer
Kazi za kusoma kutoka kwa faili sysread(), kuandika kwa faili syswrite() na kuweka pointer kwa nafasi ya sasa ya faili sysseek() ni analogues za read(), print() na seek() kazi tulizozingatia, lakini. , tofauti na mwisho, wanapata moja kwa moja kazi zinazofanana za uendeshaji wa mfumo, badala ya kazi za maktaba ya kawaida ya C I/O, na hivyo kupitisha buffer iliyoundwa na kazi hizi kwa kufanya shughuli za kusoma na kuandika kwenye faili. Kumbuka kuwa hakuna sawa na kitendakazi cha tell() kilichohifadhiwa; utendakazi wake unatekelezwa na sysseek() chaguo la kukokotoa. Wakati wa kupiga simu zisizo na kazi za kusoma na kuandika, hupitishwa seti sawa ya vigezo, vinavyolingana kabisa na vigezo vya kazi ya kusoma: sysread DESCRIPTOR, VARIABLE, LENGTH [, OFFSET]; syswrite DESCRIPTOR, ARIABLE, LENGTH [, OFFSET]; Thamani ya kurudi kwa chaguo hizi za kukokotoa ni nambari halisi ya baiti zilizosomwa au kuandikwa kwa faili kwa mtiririko huo, 0 ikiwa mwisho wa faili umefikiwa, au undef ikiwa hitilafu hutokea. Ipasavyo, seti ya vigezo vya kazi ya sysseek() inalingana kikamilifu na vigezo vilivyopitishwa kwa kutafuta() kitendakazi: sysseek DESCRIPTOR, OFFSET, REFERENCE_POINT; Kila kitu kilichosemwa kuhusu kutumia search() kazi ya kukokotoa inatumika kikamilifu kwa mwenzake ambaye hajatumiwa. Utendaji ulioakibishwa wa tell() unatekelezwa kwa kuita sysseek() chaguo za kukokotoa kama ifuatavyo: $position = sysseek Fl, 0, 1; # Nafasi ya sasa ya kielekezi cha faili Mpango unaonyesha matumizi ya vitendaji vya I/O ambavyo havijatumika kuchakata yaliyomo kwenye faili. #! perl -w tumia Fcntl; # Kufungua faili katika hali ya kusoma / kuandika sysopen F1, "in.dat", O_RDWR; # Soma block ya 14 byte $ read = sysread F1, $ string, 14; onya "$soma baiti soma badala ya 14\n" ikiwa $read != 14; # Weka nafasi ya sasa (kwa ka 15) $position = sysseek Fl, 0, 1; die "Hitilafu ya kuweka: $!\n" isipokuwa kama imefafanuliwa $position; # Andika kamba katika nafasi ya sasa $string = "Thamani Mpya"; $written = syswrite F1, $string, urefu ($string); die "Hitilafu ya kuandika: $!\n" ikiwa $written != length($string); # Kufunga faili funga F1 au kufa $!; Unapofanya kazi na vitendaji vya I/O ambavyo havina buffer, unapaswa kuangalia kila mara ili kukamilisha kusoma, kuandika, au utendakazi wa nafasi. Mfumo wa kawaida wa I/O, ambao I/O iliyoakibishwa inatekelezwa, yenyewe inakagua kukamilika kwa shughuli zilizoainishwa na inawajibika ikiwa mchakato kwa sababu fulani uliingiliwa katikati ya uandishi. Ukiwa na I/O isiyo na buffer, hii lazima itunzwe na mtayarishaji programu.Kila wakati unahitaji kufikia faili kwenye diski, unahitaji kuunda kushughulikia mpya na kuifungua. Ili kufungua maelezo, tumia chaguo la kukokotoa:
open(file_handle, njia)
Njia inabainisha faili gani ya kufungua, hivyo ikiwa njia kamili haijainishwa, kwa mfano kutoka:/windows/system/, kazi ya wazi itajaribu kufungua faili kwenye saraka ya sasa. Ikifaulu, chaguo la kukokotoa hurejesha thamani isiyo ya sifuri (Kweli); isipofaulu, inarudisha undef (Siyo), kwa mfano:
ikiwa (fungua(MYFILE, "mydatafile")) (
#Imetekelezwa baada ya kufunguliwa kwa mafanikio
) mwingine (
chapisha "Hitilafu katika kufungua faili mydatafile\n";
toka 1;
}
Katika programu nyingi za Perl, syntax sawa ya "fungua au ripoti kosa" inaweza kutekelezwa kwa kutumia chaguo la kukokotoa kufa
. Kitendaji cha kufa husimamisha programu na kuonyesha ujumbe wa makosa:
Alikufa katika mstari wa script_name xxx
Hapa jina la maandishi ni jina la programu ya Perl, xxx ni nambari ya mstari ambayo kazi ya kufa ilipatikana. Kazi za kufa na wazi mara nyingi hutumiwa pamoja kama ifuatavyo:
open(MYTEXT, "novel.txt") || kufa;
Programu hiyo inafungua faili au itaacha kutekeleza. Ikiwa kufungua kutashindikana, kurudisha sivyo, kiendeshaji cha kimantiki AU (| |) kitaanza kutumika. Matokeo yake, hoja iko upande wa kulia wa operator (katika kesi hii, kazi ya kufa) itahesabiwa. Ikiwa chaguo la kukokotoa litatekelezwa kwa mafanikio, upande wa kulia wa usemi wa kimantiki hautathminiwi. Wakati mwingine aina nyingine ya mantiki AU hutumiwa - au.
Ili kufunga kushughulikia, tumia kazi karibu
:
funga(MYTEXT);
Ukijaribu kufungua faili kwa kubainisha mojawapo ya maelezo ambayo tayari yamefunguliwa kama vigezo vya chaguo la kukokotoa lililo wazi, basi kifafanuzi hiki hufungwa kwanza na kisha kufunguliwa tena.
Kazi kufa
orodha ya hoja inaweza kupitishwa ambayo itachapishwa badala yake ujumbe wa kawaida. Ikiwa ujumbe hauna herufi mpya, basi maandishi kwenye script_name line xxx huongezwa hadi mwisho, kwa mfano:
kufa "Hitilafu ya kufungua faili";
# Ujumbe "Hitilafu ya kufungua faili kwenye script_name line xxx" inaonyeshwa
die "Hitilafu katika kufungua faili\n"
; # Inaonyesha "Hitilafu ya kufungua faili"
Perl ina tofauti maalum $!
Ujumbe ulio na ujumbe wa hitilafu uliotokea wakati wa operesheni ya mwisho ya mfumo (kwa mfano, disk I/O). Katika muktadha wa nambari, $! inarudi kidogo nambari ya kuzungumza makosa. Katika muktadha wa kamba, kutofautisha $! inarudisha ujumbe wa makosa ya mfumo wa uendeshaji:
open(MYFILE, "myfile") || die "Hitilafu katika kufungua faili yangu: $!\n";
Ikiwa kitendakazi hiki hakiwezi kufungua faili kwa sababu haipo, ujumbe ufuatao utaonyeshwa:
Hitilafu wakati wa kufungua myfile: faili au saraka katika njia haipo.
Usitumie utofauti wa $! kuangalia mafanikio ya kazi ya mfumo. Thamani ya tofauti hii imedhamiriwa mara moja baada ya uendeshaji wa mfumo (kama vile I/O) kukamilika, na tu wakati operesheni hiyo inashindwa. Katika visa vingine vyote, kutofautisha $! inaweza kuwa na maana ya kiholela isiyo na maana.
Wakati mwingine unahitaji kuonyesha ujumbe wa onyo katika programu na uendelee kuitekeleza. Ili kutoa maonyo, tumia chaguo la kukokotoa onya
, sawa na kufa, isipokuwa kwamba utekelezaji wa programu unaendelea:
ikiwa (! fungua(MYFILE("pato")) (
onya "Hitilafu ya kufungua pato la faili: $!";
) mwingine (
# Inasoma data ya faili...
}
Perl ina njia kadhaa za kusoma faili zilizofafanuliwa na vipini. Ya kawaida ni kutumia opereta ya pembejeo ya faili, inayoitwa pia operator wa angular <>
. Ili kusoma habari kutoka kwa faili, weka tu maelezo yake kwenye mabano ya pembe na upe dhamana hii kwa kutofautisha, kwa mfano:
open(MYFILE, "myfile") || kufa "Hitilafu ya kufungua faili yangu: $!";
$line=
Opereta ya angular katika muktadha wa scalar inasoma mstari mmoja kutoka kwa faili. Ikiwa faili itaisha, operator wa angular anarudi undef. Line ndani faili ya maandishi ni mfuatano wa herufi zilizotenganishwa na kiondoa laini maalum. Katika UNIX, ishara hii ni tabia ya kulisha mstari (ASCII code 10), katika DOS na Mlolongo wa Windows herufi za kurudi kwa gari na mlisho wa laini (misimbo ya ASCII: 13 na 10). Kielekezi cha kidhibiti cha laini kinaweza kurekebishwa katika Perl ili kufikia athari kadhaa za kupendeza.
Unaweza kutumia nambari ifuatayo kusoma na kuchapisha yaliyomo kwenye faili nzima (mfano unadhania kuwa MYFILE ni kipini cha faili wazi):
wakati (imefafanuliwa($a=
chapisha $a;
}
Ili kusoma habari kutoka kwa faili, ni rahisi kutumia kitanzi cha muda. Ikiwa kitanzi cha wakati kinatumia opereta ya angular badala ya usemi wa masharti, Perl hupeana kamba ya kuingiza kiotomatiki kwa utofauti maalum $_ na kurudia kitanzi hadi faili iishe:
wakati (
chapisha $_;
}
Katika kesi hii, wakati opereta ana jukumu la kugawa kamba iliyoingizwa kwa tofauti $_ na kuangalia ikiwa mwisho wa faili umefikiwa. Tabia hii ya kuvutia hutokea tu kwa kitanzi cha muda na tu wakati usemi wa masharti una opereta angular. Usisahau kwamba data iliyosomwa kutoka kwa faili, pamoja na maandishi yenyewe, pia ina wahusika wa mwisho wa mstari. Ikiwa unahitaji maandishi tu, tumia kitendakazi cha chomp ili kuondoa miisho ya mstari.
Katika muktadha wa orodha, mwendeshaji wa angular husoma faili nzima na kuikabidhi kwenye orodha. Kila mstari wa faili umepewa kipengele sambamba cha orodha au safu, kama inavyoonyeshwa hapa chini:
open(MYFILE, "novel.txt") || kufa "$!";
@yaliyomo=
funga(MYFILE);
Mfano huu husoma data yote kutoka kwa faili ya novel.txt kupitia mpini wa MYFILE na kuikabidhi kwa safu ya @contents. Hii inapeana safu ya kwanza ya faili ya novel.txt kwa kipengele cha kwanza cha safu ya @contents: $contents . Mstari wa pili umepewa $contents, nk.
Ili kuandika data kwa faili, kwanza unahitaji kufungua faili yenyewe kwa kuandika. Syntax ya kufungua faili kwa maandishi ni karibu sawa na ya kusoma:
open( handle, ">njia")
oren(kielezi, ">>njia")
Sintaksia ya mstari wa kwanza tayari inajulikana kwetu, isipokuwa ishara >
mbele ya njia. Alama hii inamwambia Perl kwamba data mpya inapaswa kuandikwa kwa faili ambayo njia yake inafuata. Hii inafuta data iliyopo kwenye faili na kufungua kishikio maalum cha kuandika. Katika mfano wa pili wahusika >>
inamwambia Perl kuwa faili imefunguliwa kwa maandishi, lakini ikiwa faili tayari iko, data mpya inaongezwa baada ya data iliyopo. Hapa kuna mifano:
# Data mpya imeandikwa juu ya data ya zamani, ikiwa ipo
open(NEWFH, ">output.txt") || die "Hitilafu ya kufungua output.txt: $!";
# Data mpya imeongezwa kwa data iliyopo.
open(APPFH, ">>logfile.txt") || die "Hitilafu katika kufungua logfile.txt: $!";
Mara tu unapomaliza kufanya kazi na faili ambayo imefunguliwa kwa maandishi, kipaumbele cha kwanza ni kufunga faili na kuachilia kipini chake. Kazi ya karibu inauambia mfumo wa uendeshaji kuwa kuandika kwa faili imekamilika na data inapaswa kuwekwa kwenye eneo lake la hifadhi ya kudumu kwenye diski, kwa mfano:
funga(NEWFH);
funga (APPFH);
Mara faili inapofunguliwa kwa kuandika, kuweka data ndani yake ni rahisi sana. Hii inafanywa kwa kutumia kazi inayojulikana chapa
. Kufikia sasa, tumetumia kipengele cha kuchapisha ili tu kuonyesha data kwenye skrini. Kimsingi, kazi hii inaweza kutumika kuandika data kwa faili yoyote. Syntax ya taarifa ya kuchapisha, iliyoundwa kutoa data kwa faili, ni rahisi sana:
kipini cha kuchapisha LIST
open(LOGF, ">>logi faili") || kufa "$!";
ikiwa (! Chapisha LOGF "Rekodi imefanywa", scalar(wakati wa ndani), "\n") (
onya "Hitilafu katika kuandika faili ya kumbukumbu: $!";
}
funga(LOGF);
Unaweza kufungua faili nyingi kwa kusoma au kuandika kwa wakati mmoja, kama inavyoonyeshwa katika mfano ufuatao:
open(SOURCE, "sourcefile") || kufa "$!";
open(DEST, ">lengwa") || kufa "$!";
@yaliyomo=
chapisha DEST $ contents; # Iandike kwa faili nyingine
funga(DEST);
funga(CHANZO);
Mfano huu hufanya nakala rahisi ya faili. Kwa njia, unaweza kufupisha nambari kwa kuchanganya shughuli za kusoma na kuandika katika taarifa moja:
chapisha DEST
Kwa kuwa kazi ya kuchapisha inatarajia orodha kupitishwa kama kigezo, taarifa
Wakati wa kurekodi data ya jozi kama vile faili za GIF, faili za EXE, hati za MS Word, n.k., hakuna ubadilishaji wa data unaohitajika. Kwa hivyo, ili kuhakikisha kuwa sio Perl au mfumo wa uendeshaji hufanya ubadilishaji kama huo, lazima utumie kitendakazi kabla ya kuandika data ya binary kwa faili. binmode
. Inaashiria maelezo ya faili kama mara mbili
binafsi Kazi ya binmode inaitwa baada ya faili kufunguliwa, lakini kabla ya ingizo au matokeo kutokea:
open(FH, "camel.gif") || kufa "$!";
binmode (FH); # Hushughulikia inakuwa ya binary.
Mara faili inapofunguliwa, chaguo za kukokotoa za binmode zinaweza tu kutumika kwenye mpini wake mara moja. Wakati wa kufunga na kufungua tena faili ya binary, itabidi upigie simu kitendakazi cha binmode tena. Kutumia binmode kwenye mifumo ambayo haitofautishi kati ya maandishi na faili za binary(kwa mfano, kwenye UNIX), haisababishi hatua yoyote.
Kabla ya kufungua faili, ni wazo nzuri kuhakikisha kuwa iko, kuangalia kuwa sio saraka, na kwamba hii haitasababisha ujumbe wa makosa uliokataliwa. Perl ina maalum waendeshaji mtihani wa faili
. Zote zina syntax sawa:
-X kipini cha faili
- Njia ya X
Hapa X ndio operesheni maalum ya jaribio na faili_handle ndio kipini kinachojaribiwa. Faili inaweza kujaribiwa bila kufungua kushughulikia.
| -r
| -g "faili" | Kweli ikiwa "faili" inasomeka |
| -w
| -w $a | Ni kweli ikiwa kuandika kwa faili ambayo jina lake limo katika kigezo $a kunaruhusiwa |
| -e
| -e "faili" | Kweli ikiwa "faili" ipo |
| -z
| -z "faili" | Ni kweli ikiwa "faili" lipo lakini ni tupu |
| -s
| -s "faili" | Hurejesha ukubwa wa "faili" katika baiti, ikiwa ipo |
| -f
| -f "faili" | Ni kweli ikiwa "faili" ni faili ya kawaida (sio saraka) |
| -d
| -d "katalogi" | Kweli ikiwa "catalog" inabainisha saraka |
| -T
| -T "faili" | Kweli ikiwa kigezo cha 'faili' kinabainisha faili ya maandishi |
| -B
| -B "faili" | Kweli ikiwa kigezo cha 'faili' kinabainisha faili ya binary |
| -M
| -M "faili" | Hurejesha idadi ya siku ambazo zimepita tangu marekebisho ya mwisho ya "faili" |
chapisha "Tutahifadhi wapi data?";
$filename=
chomp $ filename;
ikiwa (-s $jina la faili) (
onya "Yaliyomo kwenye faili ya $ yatapotea!\n";
onya "Imebadilishwa",
-M $jina la faili, "siku zilizopita.\n";
}
