Jeg håper det er unødvendig å skrive en slik fil, men jeg tror du må tenke på hva du kan gjøre med dem, som du kan se av tittelen på artikkelen, i Perl. Vel, la oss komme i gang...
Denne artikkelen vil diskutere:
Hva er filmanipulatorer, og hva spises de med
Tilgang til filer utføres ved hjelp av filmanipulatorer, som så å si er et synonym for en fil. De er ikke variabler, og derfor kan de ikke direkte tilordnes andre variabler eller sendes i funksjoner (for dette må du, som de sier, gå den andre veien).
Det finnes også standard Perlov-filmanipulatorer. De heter STDIN (standard inngang), STDOUT (standard utgang) og STDERR (standard feilstrøm). For eksempel sendes parametere til skriptet fra skjemaet via STDIN (forutsatt at POST-metoden brukes).
Hvis du trenger å lage en kopi av en filmanipulator (ikke en fil, men bare en manipulator for tilgang til filen), kan du bruke den åpne funksjonen (vi vil snakke om det mer detaljert senere).
Eksempel: åpen (FYLL, "fil.txt"); åpen (FAIL, "<&FILL");
Om å tilordne filhåndtak til variabler:
$ handle = * FYLL; eller send den til en funksjon: some_sub (* FILL);
Og til slutt vil jeg si at filmanipulatorer i Perl ikke bare brukes til å kommunisere med, faktisk, en fil. De kan assosieres med en prosess, socket, etc. Men dette er ikke emnet for artikkelen.
Filmanipulering
Filen åpnes med åpne-funksjonen.
Åpne (FFF, "> file.txt");
La oss finne ut av det. Funksjonen har tre parametere: FFF - navnet på filmanipulatoren (du spesifiserer det), tilgangsmodusen ">" og "file.txt" - navnet på filen du trenger. Det er tre hovedmoduser: ">" - opptak, "<"- чтение, ">> "- legger til filen.
Det er også en sysopen-funksjon. Å jobbe med det er ikke mye vanskeligere enn med åpen, men med dens hjelp kan du "fortelle" systemet mer detaljert om intensjonene dine (det vil si hva du vil gjøre med filen).
Sysopen har tre nødvendige parametere og en valgfri.
For eksempel: sysopen (FH, $ navn, $ flagg, $ param);
FH er faktisk en filmanipulator, $navn er et filnavn i sin rene form (uten ">", osv.). I $-flagg setter du tallet oppnådd ved å kombinere konstantene beskrevet nedenfor gjennom ELLER (|):
Dette er selvfølgelig ikke en fullstendig liste, men de mest nødvendige og mest brukte konstantene er listet opp her.
Til slutt, $ param. Denne parameteren spesifiserer filtilgangsmasken og er skrevet i oktal. Vanligvis er verdien 0666 (standardverdien, det vil si hvis $ param er utelatt), eller 0777. Den første verdien brukes for vanlige filer, den andre for kataloger og kjørbare filer.
Et eksempel på å åpne en fil for skriving (hvis den ikke finnes, blir den opprettet):
Sysopen (FH, "data.txt", O_WRONLY | O_TRUNC | O_CREATE);
Vi skriver til filen ved å bruke utskriftsfunksjonen.
Skriv ut (FFF "oppa! Skriv til fil!");
Her er FFF navnet på filhåndtaket, og den siterte strengen er teksten som vi ønsker å skrive til filen knyttet til FFF.
Hvis filen ikke eksisterte før forsøket på å åpne filen, vil åpne-funksjonen opprette den, og hvis filen var, og den ikke var tom, etter utskriftsfunksjonen ovenfor, vil ingenting forbli i den fra den forrige informasjonen , og tullet som jeg skrev inn der vil bli skrevet ...
Som nevnt er det tre standard filhåndtak, og med filhåndtaket nede vil utskriftsfunksjonen sendes ut til STDOUT (det samme gjelder printf- og skrivefunksjonene). For å endre utgangsretningen gir Perl en valgfunksjon (men ikke bare for dette). Eksempel:
Åpne (F1, "> one.txt"); print "Filen er åpen! Vi skriver til STDOUT."; $ old_point = velg (F1); print "Skriver til one.txt-filen"; velg ($ old_point); print "Skriver til STDOUT igjen."; lukk (F1);
Vi lukker filen med lukkefunksjonen.
Lukk (FFF);
Prinsippet om å rydde opp etter seg er innpodet i alle fra barndommen. La oss ikke glemme dette i programmering, selv om når prosessen der denne filen ble åpnet slutter, lukkes filen automatisk.
Fillås
Først, for hva? Og for det faktum at hvis flere prosesser samtidig ønsker å få tilgang til en fil, dessuten for skriving, og de også ønsker å skrive noe der (et mareritt), så forestill deg hva det ville vært hvis ikke denne fantastiske låsemekanismen. Det tillater, grovt sett, å sette prosesser i kø. Vi gjør dette:
Åpne (FIL, "> fil.dat"); flokk (FIL, 2); lukk (FIL);
Vi har allerede snakket om åpne- og lukkefunksjonene, men la oss dvele litt mer detaljert ved flokk. Den mottar to parametere - en filmanipulator og, billedlig talt, en blokkeringskategori.
Om opplåsing: låsen frigjøres automatisk når prosessen som kalles av det gjeldende skriptet avsluttes, eller når filmanipulatoren lukkes, som er "bundet" til den låste filen. Hvis du slipper låsen manuelt, vær forsiktig - du gir en annen prosess muligheten til å gjøre hva den vil med (ADVARSEL!) En fil du ikke har lukket! Konsekvensene kan være mildt sagt ubehagelige, men grovt sett – uforutsigbare (uforutsigbare for deg).
Arbeide med strenger i en fil
Siden det er nettopp de filene som inneholder strenginformasjon som er av størst interesse for, faktisk, en person, så skal vi nå snakke om dem.
For å lese linjer fra en fil, bruk filmanipulatoren "følger med" i<>.
For eksempel:
Åpne (FIL, "data.txt"); samtidig som (
Med mindre annet er spesifisert, brukes standardvariabelen "$ _" inne i en slik sløyfe, og linjenummeret skrives til "$.". Siden slutten av strengen er indikert med et spesialtegn, for eksempel "\ n", for å få selve strengen (uten en slik "hale"), må du avkorte den med chomp-funksjonen.
Åpne (FIL, "data.txt"); samtidig som (
@ strenger =
Fortell og søk-funksjonene brukes til å flytte rundt i filen.
Åpne (FIL, "data.txt"); $ posisjon = fortelle (FIL); print "Nåværende posisjon i fil $ posisjon. \ n"; søk (FIL, $ posisjon + 10,1); print "Og nå har vi flyttet 10 byte til slutten av filen fra gjeldende posisjon. \ n"; $ posisjon = fortelle (FIL); print "Nå er gjeldende posisjon i filen $ posisjon. \ n";
Resultat:
Nåværende posisjon i filen er 0. Og nå har vi flyttet 10 byte til slutten av filen. Nå er gjeldende posisjon i filen 10.
Tell tar et filhåndtak som en parameter, og søk tar tre parametere. Den første er filmanipulatoren, den andre er forskyvningen i byte, og den tredje er retningen til forskyvningen. Det er tre forskyvningsretninger: 0 - fra begynnelsen av filen, 1 - fra gjeldende posisjon, 2 - fra slutten av filen.
Dette er ikke å si at dette er alt Perl tilbyr oss for å jobbe med filer. Forhåpentligvis får jeg tid til å skrive om hvordan man jobber med kataloger, vanskelighetene ved å jobbe med binære filer, en objektorientert tilnærming til å administrere filer og innholdet deres.
Hovedside »PERL» Løkker og greiner.
Filinngang og utgang.
FILINNGANG OG FILUTGANG Perl er spesielt utviklet for å være et tilstrekkelig middel for å lese og skrive tekstfiler. Men som du vil lære senere, utfører Perl tilfeldig tilgang og I/O-funksjonene til binærfiler. Filoperasjoner krever et filhåndtak, som er en variabel som tilsvarer en bestemt fil. Som standard har hvert Perl-skript tre standardpekere som Perl automatisk åpner når skriptet kjøres: STDJN, STDOUT, STDERR. Disse tre standardpekerne tilsvarer standardstrømmene STDIN, STDOUT, STDERR i programmeringsspråket C. I tillegg kan Perl-skriptet åpne flere pekere for andre spesifikke filer. ÅPNING AV FILER OG ANDRE STRØMMER For at skriptet skal bruke filen, må det kalle opp funksjonen. Det ser slik ut: åpen (FileHandle [, Filnavn]) I motsetning til åpne funksjonen til C runtime-biblioteket, inneholder ikke den åpne funksjonen til Perl en modusparameter i funksjonskallet. Perl bestemmer modusen for å åpne en fil basert på filnavnet. Tabell 12.3 illustrerer forholdet mellom filåpningsmodus og filnavn. Filnavn Handling Åpne fil for skrivebeskyttet (ligner på fopen-funksjon) FIL> Opprett fil for skriving (som fopen-funksjon)> FIL> Åpne fil for å legge til på slutten (som fopen-funksjon) FIL> Opprett fil for lesing/skriving ( som funksjon fopen) Åpne en kanal fra prosessen som utfører kommandoen Åpne en kanal til prosessen som utfører kommandoen Tab. 12.3. Konvensjoner for navne- og tilgangsmodus for Perl-filer Merk: Det kan hende at rørstrømmodusen ikke eksisterer på alle systemer. Hvis et filnavn utelates i et kall for å åpne, antar Perl at filnavnet finnes i strengvariabelen $ FileHandle. Når skriptet er ferdig med å bruke filen, lukkes den ved å bruke lukkefunksjonen, som vist nedenfor: close (FileHandle); Fragmentet av programmet illustrerer bruken av åpne- og lukkefunksjonene: åpen (InFile, "test.dat") || dø; # åpen for lesing # test.dat åpen (OutFile, "> test.dat") || dø; # create test.dat $ AuxFile = ">> test.dat"; åpen (Aux, $ AuxFile) || dø; # åpner for tillegg # test.dat close (InFile); lukk (OutFile); lukke (Aux); Merk at filpekere ikke har de vanlige ett-tegns prefikser. Som du vil se senere, kan Perl-skript lagre pekernavn som skalarstrenger og sende en peker til enhver funksjon som kan håndtere dem. Perl konverterer verdiene etter behov. I MS-DOS-operativsystemet støtter Perl en tilleggsfunksjon kalt hinmode, som lar fil-I/O bytte mellom tekst- og binærmodus. På de fleste systemer er skillet mellom tekst og binære moduser irrelevant. For MS-DOS-operativsystemet er imidlertid nylinjetegnet en sekvens av to tegn (CR + LF). Siden de fleste programmer ikke forventer å møte to tegn på slutten av en linje, må I/O-systemet utføre konverteringen. For å bruke binmode-funksjonen kan den tilsvarende pekeren åpnes. Binmode-funksjonen har følgende format: binmode (FileHandle); LINJE-FOR-LINJE LESE OG SKRIVE DATA Den enkleste måten for et skript å lese en linje fra en fil på er å bruke en operator. I Perl blir en filpeker omgitt av trekantede parenteser et input-symbol. Følgende kodebit illustrerer for eksempel hvordan du bruker inndatategnet til å lese og vise innholdet i Test.dat-filen. åpen (InFile, "Test.dat") || dø; while ($ line =) (skriv ut $ line; # Skriver ut en linje fra en fil) close (InFile); Når inndatategnet når slutten av filen, returnerer det false, som i dette tilfellet avslutter while-løkken. Det er angitt et spesielt (tomt) inndatategn, som har en veldig spesiell, men nyttig bruk. Første gang skriptet bruker et tomt inndatategn, analyserer det kommandolinjeargumentene. Hvis @ARGV er tom, leses inndatategnet fra STDIN. Hvis i stedet @ARGV ikke er tom, åpner Perl den første av filene spesifisert i @ARGV og leser innholdet i filen. Når Perl er ferdig med å behandle en fil, går den videre til den neste. Etter at skriptet har lest alle filene, returnerer symbolet usann. Perl-skript kan også bruke inndatategnet til å lese hele innholdet i en fil inn i en matrise slik at hver linje i filen blir et element i matrisen. For eksempel leser følgende setning fra STDIN-filen inn i @lines-arrayen: @lines =; Å skrive data til en fil er også ganske enkelt. Faktisk gjorde du dette hver gang du brukte utskriftsfunksjonen. Det komplette formatet for utskriftsfunksjonen er som følger: print List; Hvis utskriftsfunksjonen ikke mottar en filpeker som et argument, sender den utdata til STDOUT. Følgende kodebit illustrerer bruken av utskriftsfunksjonen for å legge til data til en utdatafil: open (LogFile, ">> logfile.dat") || dø; ############## ($ m, $ d, $ y) = (lokal tid (tid)); skriv ut loggfilen "Captain"s logg, Stjernedato ++ m $ / $ d / $ y \ n "; lukk (LogFile); Merk: Filpekeren og utdatalisten er ikke atskilt med komma. LESE OG SKRIVE DATABLOKKER Programmerere ofte vurdere tekstfiler som tekststrømmer ganske enkelt fordi det ene tegnet følger det andre til slutten av filen. Hvis skriptet skal operere på en fil som er blokkorientert i stedet for trådorientert, kan skriptet bruke sysread og syswrite-funksjoner for å behandle faste blokker med data Sysread- og syswrite-funksjonene har følgende formater: $ result = sysread (FileHandle, $ Var, Length [, Offset]); $ result = syswrite (FileHandle, $ Var, Length [, Offset] ); Hvis funksjonskallet spesifiserer en offset fra begynnelsen av filen (Offset), vil funksjonene se etter hvor de vil starte I/O. Sysread- og syswrite-funksjonene overfører begge data ved hjelp av en skalarstrengvariabel. Siden funksjonene behandle faste minneblokker, så kunne dataene ut inneholder binære verdier, inkludert nuller og slutt-på-fil-markører. Hvis en offset fra begynnelsen av filen (Offset) er spesifisert i funksjonskallet, søker funksjonen etter et sted i filen som den begynner å utføre I/O-operasjoner fra. Hvis du jobber med datablokker, kan skriptene også bruke følgende I/O-funksjoner: $ resultat = seek (FileHandle, Position, Base); $ resultat = fortelle (FileHandle); $ resultat = eof (FileHandle); Seek-funksjonen fungerer akkurat som fseek, en funksjon av kjøretidsbiblioteket C. Posisjonsparameteren spesifiserer posisjonen i forhold til origo, som igjen spesifiseres av Base-parameteren som følger:? 0 Søker du fra begynnelsen av filer? 1 Søker du fra gjeldende posisjon? 2 Søk fra slutten av filen Perls tell-funksjon fungerer nøyaktig som ftell-commit i C runtime-biblioteket. Den returnerer gjeldende posisjon i filen som lese- eller skriveoperasjoner utføres fra. Til slutt returnerer eof-funksjonen, som C-funksjonen feof, en verdi eller, som skriptet kan bruke for å fastslå at slutten av filen er nådd. BINÆR DATABEHANDLING Selv om Perl primært er fokusert på tekstbehandling, kan den også håndtere binære data. Skript kan flytte binære data i biter ved å bruke strengvariabler og utføre byte I/O-operasjoner ved å bruke sysread- og syswrite-funksjonene. Men for å gjøre noe med dataene, blir skriptet tvunget til å konvertere dataene til dets skalære formater. LAGRE BINÆRE DATA Når et Perl-skript leser en blokk med binære data ved å bruke sysread-funksjonen, lagrer det binære data i en skalarstrengvariabel. Perl bryr seg ikke om hva dataene er, om de inneholder nuller eller ikke-ASCII-verdier. Innenfor en tegnstreng godtar Perl byte som byte. I motsetning til C, bruker ikke Perl nullterminerte strenger. Hvis dataene tilsvarer ASCII-kodetabellen, kan skriptet behandle det som hvilken som helst tekst. Men hvis dataene er binære, må skriptet pakke dem ut før Perl kan behandle dataene. UTPAKKING AV BINÆRE DATATRENGER TIL PERL-SPRÅKVARIABLER For at et skript skal få tilgang til binære data, må det pakkes ut ved å endre til skalarformatet. Perl-skript pakker ut data ved å bruke unpack-funksjonen, som har følgende format: $ result = unpack (mal, uttrykk); Expression er en regulær strengvariabel som inneholder binære data som leses av sysread, men kan også være et uttrykk som skal tolkes som en streng. Mal er en jokertegnstreng som beskriver hvordan du tolker verdiene i Expression-operanden. Følgende programbit illustrerer bruken av utpakkingsfunksjonen: ($ r, $ g, $ b) = pakke ut ("C3", $ farge); # pakker ut i 3 tegn @longwords = pakke ut ("L *", $ data ); # vil pakke ut i en liste med lange # ord @stuff = unpack ("S2L", $ bin); # vil pakkes ut i 2 shorts og lange. Hvert mønsterkarakter kan følges av et tall som indikerer hvor mange ganger det tegnet skal brukes. Hvis det i stedet for et tall er en stjerne (*), vil operasjonen bli utført for alle gjenværende data på linjen. Hvis nummeret ikke er angitt, utføres det én gang. Skriptet kan plassere et hvilket som helst antall maltegn i malstrengen. Tabell 12.4 viser symbolene inkludert i Template-strengparameteren, sammen med en beskrivelse av hvordan hver enkelt påvirker utførelsen av utpakkingsfunksjonen. Mønstertegn Beskrivelse a ASCII-streng uten nulltegn A ASCII-streng uten nulltegn b Bitstreng (minst signifikant bit først) B Bitstreng (mest signifikant bit først) c Signert ett bytetegn C Usignert ett bytetegn d Flytende kommaverdi, dobbel presisjon f Flytende kommaverdi, enkelt presisjonsmønster h Streng med heksadesimale verdier (minst signifikante siffer først) N Streng med heksadesimale verdier (mest signifikante siffer først) i Signert heltall I Usignert heltall l Signert heltall lang L Samme, bare uten tegn n Kort heltall N Langt heltall p Peker til streng s Signert kort heltall S Ufortegn kort heltall u Strengdekoding v Kort heltall V Langt heltall x Hopp én byte fremover X Hopp én byte bakover @ Gå til den angitte posisjonen på linjen Tab. 12.4. Malsymboler PAKKE DATA I BINÆRE STRENGER For å sende ut binære data, må skriptet pakke skalarverdier inn i strenger med binære tegn. For å gjøre dette, bruk pakkefunksjonen, hvis format er vist nedenfor: $ resultat = pakke (mal, liste); Følgende kodebit illustrerer bruken av pakkefunksjonen: $ color = pack ("C3", $ r, $ g, $ b); $ data = pack ("L *", @longword); $ bin = pack ("S2L", @stuff); Pakkefunksjonen bruker de samme jokertegnene som utpakkefunksjonen, med unntak av a-tegnene. A, u, x, X, @. ARBEIDE MED KATALOGER Perl tilbyr ikke bare et bredt spekter av funksjoner for å behandle filer, men også flere svært praktiske funksjoner for å skanne kataloger. I de følgende avsnittene skal vi se på noen av de grunnleggende funksjonene for å jobbe med kataloger i detalj. ÅPNING, LESE OG SLUKKING AV KATALOGER Perl-skript lar deg åpne og lese innholdet i filer. På samme måte åpner disse skriptene kataloger og leser navnene på lysbildene de inneholder. For å åpne en katalog bruker skript opendir-funksjonen, og sender inn en katalogpeker og sti til den. Skriptet bruker readdir-funksjonen til å lese en liste over filer i en katalog. Til slutt brukes closedir-funksjonen for å lukke katalogen. Følgende kodebit illustrerer bruken av readdir-funksjonen for å vise en liste over filer i gjeldende katalog: opendir (Dir, $ INC) || dø; while ($ file = readdir (Dir)) (skriv ut "$ file \ n") closedir (Dir); Denne kodebiten bruker variabelen $ INC Format, List); $ resultat = sprintf (Format, Liste); Som standard sender printf formatert utdata til STDIO standardutdata, og sprintf returnerer formatert streng. I begge tilfeller er formatet på strenger nesten identisk med funksjonene til C-språket, bortsett fra at Perl-funksjonene ikke støtter lengdespesifikasjonen (*). Følgende kodebit illustrerer bruken av funksjonene printf og sprintf. $ presisjon = 2; $ pi = 3,1415; printf ("%. 2f \ n", $ pi); # vil skrive ut 3.14 printf ("%. $ (presisjon) f", $ pi); # vil sende ut 3.14 RINGE EKSTERNE PROGRAMMER FRA ET PERL-SKRIPT. Perl er på en måte en erstatning for shell-skript, og gir støtte for systemkommunikasjon, inkludert å starte eksterne programmer. De følgende delene diskuterer flere måter å kalle eksterne programmer fra Perl-skript. Husk imidlertid at ved å tillate skript å utføre systemkommandoer, åpner du sikkerhetshull på nettstedet ditt. Følg den generelle regelen om ikke å utføre eksterne kommandoer fra et Perl-skript. Men hvis du blir tvunget til å utføre eksterne kommandoer fra et skript, kan du bruke de innebygde system-, exec- eller gaffelfunksjonene til dette formålet. VANLIGE UTTRYKK Gjennom dette kapittelet har du sett eksempler på funksjoner for å behandle strenger. Mange av dem er basert på begrepet regulære uttrykk. Som du kan se i de følgende delene, bruker Perl-skript utstrakt bruk av regulære uttrykk for å behandle tekst. Hvis regulære uttrykk er nytt for deg, så ikke bekymre deg. I løpet av kort tid etter at du har blitt kjent med flere avsnitt i dette kapittelet, vil regulære uttrykk være enkle og greie for deg. OVERSIKT OVER VANLIGE UTTRYKK Regelmessige uttrykk er et fancy begrep som har sin opprinnelse i informatikk og som brukes til å referere til et mønster av tegn. Perl-skript bruker symbolske mønstre ganske enkelt for å analysere inndataene ved å dele dem fra hverandre. Ofte kan et skript analysere input basert på mellomrom, kommaer, tabulatorer og andre skilletegn. Men når inndataene har et vilkårlig format, gjør regulære uttrykk det beste for denne oppgaven. REGULÆR UTTRYKKSSYNTAKS For å redusere størrelsen på regulære uttrykk bruker Perl spesialtegn. Tabell 12.6 viser noen av tegnene som brukes av Perl-skript i regulære uttrykk. Symbolbeskrivelse. Matcher et hvilket som helst tegn (unntatt et linjeskifttegn) (..) Grupperer en sekvens av elementer + Matcher forrige mønster en eller flere ganger? Matcher mønsteret null eller én gang * Matcher mønsteret én eller null ganger [...] Matcher et tegn fra det gitte settet [^ ...] Matcher et tegn fra settet oppnådd ved negasjon (... | ... | ...) Matcher et av alternativene ^ Matcher begynnelsen av linjen $ Matcher mønsteret på slutten av linjen (n, m) Matcher mønsteret n til m ganger (n) Matcher mønsteret nøyaktig n ganger (n) ,) Matcher mønsteret minst n ganger \ n \ t osv. Matcher nylinje, tabulatorer osv. \ b Matcher ved ordgrense \ B Matcher innenfor ordgrenser \ d Matcher siffer \ D Matcher ikke-siffer \ s Matcher mellomrom \ S Matcher mellomrom \ w Matcher bokstav eller siffer \ W Matcher en tegn som verken er en bokstav eller et tall Tab. 12.6. Symboler brukt i regexps Perl plasserer regulære uttrykk (mønstre, mønstre) i skråstreker, det vil si i skrå streker, for eksempel i formen / mønsteret /. Følgende kodebit illustrerer Perl regulære uttrykk: # følgende regulære uttrykk er sanne hvis: / ig / # string inneholder "ig" / (b | d | f) ig / # string inneholder "big", "dig "eller" fig "/ + / # streng inneholder et tall / * / # streng inneholder en identifikator Hvis disse uttrykkene virker meningsløse for deg, ikke bekymre deg. I dette kapittelet skal vi se på noen få regulære uttrykk. For nå, bare husk at Perl setter regex mellom de to skråstrekene fremover, som vist ovenfor. BRUKE VANLIGE UTTRYKK FOR Å SØKE EFTER SØKEORD Perl-skript bruker regulære uttrykk for å gjøre strengsammenlikninger enklere. For å sjekke om en streng inneholder et gitt mønster, kan et skript bruke regex som følger: if ($ str = ~ / pattern /) I dette tilfellet evalueres regex hvis mønsteret finnes i streng ($ str) ... Hvis strengen inneholder et mønster, returnerer uttrykket en verdi. Følgende uttrykk tester for eksempel om strengen inneholder teksten Web Programmering: if ($ str = ~ / Web Programmering /) For å teste for en fullstendig samsvar, må uttrykket binde sammenligningen til begynnelsen og slutten av strengen. For eksempel har følgende uttrykk en størrelsesverdi hvis og bare hvis variabelen $ str har en av tre verdier:,): ($ str = ~ / ^ ba (na) (2,4) $ /) På samme måte, følgende uttrykk er sant hvis og bare hvis $ str inneholder et ord og ikke er en del av et annet ord som f.eks. ($ str = ~ / \ bthe \ b /) BRUKE VANLIGE UTTRYKK FOR AT ANALYSE INNTAG Etter hvert som Perl-skriptene dine blir mer komplekse, vil det være mange ganger du vil vite mer enn bare å sjekke om et mønster samsvarer med en streng eller ikke. .. For eksempel vil du kanskje at skriptet skal hente en bestemt strengverdi. Ved å bruke grupperingstegnene () i et regulært uttrykk, kan skriptet trekke ut verdiene som samsvarer med mønsteret fra strengen og danne en liste fra dem. For eksempel bruker følgende kodebit regulære uttrykk for å trekke ut måneder, dager og år fra en liste: $ str = "1. januar 1997,"; ($ m, $ d, $ y) = $ str = ~ / \ s * (\ S *) \ s + (\ d +) \ D + (\ d (4)) /; I dette tilfellet kan du lese regulære uttrykk slik:? Hopp over et spesialtegn først; ? skriv alle ikke-spesielle tegn til variabelen $ m (variabelen for å angi måneder); ? hopp over spesialtegn; ? legg alle sifre i $ d variabel (variabel for opptaksdager); ? hopp over alle ikke-numeriske tegn; ? skriv fire sifre til variabelen $ y (variabelen for å indikere år). Perl støtter også en annen form for mønstertilpasning, ved å bruke (= ~)-operatoren, som legger til negasjon til resultatet: (! ~). Denne operatoren tilsvarer! ($ Str = ~ / mønster /). VANLIGE UTTRYKK FOR Å SØKE OG ERSTATTE STRENGER Så langt har du brukt mønstertilpasningsoperatorer. Det viser seg at Perl støtter to andre regulære uttrykk som endrer strengvariabelen som testes. I den følgende setningen erstatter Perl delen av strengen som samsvarer med mønsteret med den gitte strengen: $ str = ~ s / pattern / replacement /; For eksempel erstatter følgende setning et ord med: $ str = ~ s / \ bcolour \ b / color /; En liten modifikasjon lar deg erstatte alle ord med: $ str = ~ s / \ bcolour \ b / color / g; I dette tilfellet forteller g-en på slutten av uttrykket Perl om å gjøre global substitusjon. Ved å bruke i-suffikset kan du gjøre søket skille mellom store og små bokstaver. I motsetning til bare å se etter samsvar, utfører følgende uttrykk også erstatning: $ str = ~ tr / SearchList / ReplacementList /; For eksempel, å erstatte alle små bokstaver med de samme store bokstavene kan gjøres slik: $ str = ~ tr / a-z / A-Z /; # endrer store og små bokstaver, fra nedre til øvre. Analyser selv følgende eksempel: $ letters = "abcde"; skriv ut "$ bokstaver \ n" # Skriver ut abcde $ bokstaver = ~ tr / a-z / A-Z /; skriv ut "$ bokstaver \ n" # Utskrifter ABCDE SAMMENDRAG Dette kapittelet gir en introduksjon til programmering i Perl. Ved å bruke konseptene som er diskutert her, kan du skrive komplekse CGI-skript i Perl. Det neste kapittelet vil hjelpe deg å få taket på å lage Perl CGI-skript som du kan kjøre på din egen server. Før du går videre, sørg for at du forstår følgende nøkkelbegreper:? Perl er et tolket programmeringsspråk som brukes av programmerere til å skrive skript for nettet og Internett. ? Perls konstruksjoner ligner på mange måter de til C, men Perl tilbyr mange tilleggsmuligheter, spesielt for håndtering av strenger og filer som er vanskelige å finne i C. ? Perl er det primære språket for å skrive CGI-programmer for nettet og Internett, først og fremst på grunn av fleksibiliteten, kompakt stil og høy sikkerhet. VIKTIG NETTSTEDER FOR PERL-INFORMASJON Følgende nettsteder vil hjelpe deg med å finne informasjon om informasjon om Pcrl-språket, skript i det og spesifikk informasjon om Perl 5-ressurser og -biblioteker. Bruk disse nettstedene som utgangspunkt for søket. http://www.shareware.com/top/Source-Code-table.html - SHAREWARE.COM - de mest populære filene med programkoder. http://www.inxpress.net:80/~moewes/computer/perl95.html - Perl for 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 - Perl5.CGI-bibliotek http://www.metronet.com/0/perlinfo/perl5/manual/perl .html - PERL http://www.teleport.com/~rootbeer/perl.html - Linker for Perl-eleverNår vi lager variabler i et program og lagrer ulike data i dem, mister vi dem når programmet avsluttes. Hvis vi trenger å lagre data og bruke dem i programmer under utvikling, lager vi en fil, skriver data til den og lagrer den på disk. Nesten alle programmeringsspråk gir programmereren midler til å manipulere filer og dataene som er lagret i dem.
Filer i et Perl-program får tilgang gjennom spesiallagde deskriptorer, som kan betraktes som en spesiell type variabel. Én deskriptor om gangen kan assosieres med én og bare én fil, men gjennom hele programmet kan den samme beskrivelsen assosieres sekvensielt med forskjellige filer.
Dessuten kan en deskriptor ikke bare assosieres med en fil, men også med et rør som gir kommunikasjon mellom prosesser. I dette kapittelet skal vi ikke berøre spørsmålene om interaksjon mellom programmer og andre prosesser, men vurdere kun å jobbe med filer og deres innhold. Derfor vil vi noen ganger referere til beskrivelser som filbeskrivelser.
7.1. Filbeskrivelser
Beskrivelse - er et symbolsk navn som brukes i et Perl-program for å representere en fil, enhet, socket eller pipe. Når en deskriptor opprettes, "festes" den til det tilsvarende dataobjektet og representerer det i I/O-operasjoner. Vi har gitt den mest komplette definisjonen av en deskriptor slik at leseren forstår at en deskriptor lar deg jobbe ikke bare med fildata, men også med data fra andre spesielle programobjekter som implementerer spesifikke oppgaver med å motta og overføre data. Når en deskriptor er vedlagt en fil, vil vi referere til den som en filbeskrivelse.
I et program opprettes en filbeskrivelse oftest når en fil åpnes ved hjelp av funksjonen åpne () som sendes to parametere - beskrivelsesnavnet og en streng med filnavnet og tilgangsmodus:
åpen (LOGFILE, "> /temp/logfil.log");
Denne setningen oppretter en deskriptor kalt LOGFILE og legger den til en fil med det angitte navnet, som åpnes i skrivemodus (den andre parameterstrengen begynner med en ">"). I denne delen vil vi ikke berøre spørsmål knyttet til filåpningsmodus, men konsentrere vår oppmerksomhet om beskrivelser. I neste avsnitt vil vi vurdere modusene for å åpne en fil mer detaljert.
Deskriptoren, som angitt, er et symbolsk filnavn og er en gyldig identifikator som ikke kan være det samme som reserverte Perl-ord. Eksempelet vårt lager en LOGFILE-deskriptor som "erstatter" filen den er knyttet til i I/O-operasjoner (/temp/logfile.log). For eksempel, ved å bruke utskriftsfunksjonen vi kjenner til, kan vi nå skrive verdien av en variabel til denne filen:
print LOGFILE $ var;
Enhver generert deskriptor går inn i Perl symbolske navnetabell, som også inneholder navnene på alle variabler og funksjoner. Deskriptoren er imidlertid ikke en variabel, selv om noen forfattere refererer til den som en filvariabel. Deskriptornavnet inneholder ikke noen av Perl-variabelprefiksene ($, @ eller%). Derfor kan den ikke brukes direkte i en tilordningsoperasjon og lagres i en variabel eller sendes som en parameter til en funksjon. For slike formål må du bruke prefikset * foran navnet, som gir en referanse til den globale datatypen. For eksempel kan den forrige setningen for å skrive ut til en fil definert av LOGFILE-beskrivelsen utføres ved å bruke følgende setninger, etter å ha lagret referansen til beskrivelsen i $ iogf-variabelen:
$ logf = * LOGFILE; print $ logf $ var;
I utskriftsoperasjonen overstyrer den første $ iogf-variabelen filbeskrivelsen LOGFILE, som verdien til den andre $ var skrives ut i.
Ethvert Perl-program har alltid tre forhåndsdefinerte deskriptorer (STDIN, STDOUT og STDERR) som er assosiert med standard input/out-enheter og brukes av noen Perl-funksjoner som standard input- eller outputfilbeskrivelser. Som vi allerede vet, er STDIN assosiert med en standard inndataenhet (vanligvis et tastatur), STDOUT og STDERR er assosiert med en standard utenhet (vanligvis en monitorskjerm). Standard input brukes av o-operasjonen hvis ingen liste over filer er spesifisert på kommandolinjen for å starte et Perl-skript. STDOUT-beskrivelsen er STANDARDBRUKT AV FUNKSJONENE print AND die, og
STDERR - ved advarsel funksjon. Andre funksjoner bruker også forhåndsdefinerte filbeskrivelser for å vise informasjonen deres.
Når du kaller programmer i Unix- og DOS-miljøer, kan du omdirigere standard input og output til andre filer ved å spesifisere navnene deres på kommandolinjen med prefiksene> for utdatafilen og< для файла ввода:
peri program.pl
Ved utføring av program.pi-programmet må alle kildedata forberedes i in.dat-filen. Utdataene vil bli lagret i out.dat-filen og ikke vist på LCD-skjermen.
Omdirigering av standard input og output, og standard feilvisning, kan gjøres direkte i et Perl-program. For å gjøre dette, bruk åpne ()-funksjonen for å knytte den tilsvarende forhåndsdefinerte beskrivelsen til en diskfil:
åpen (STDIN, "in.dat"); åpen (STDOUT, "> ut.dat"); åpen (STDERR, "> err.dat");
Nå vil all standard I/O gjøres gjennom filene som er spesifisert i de åpne uttalelsene. Merk at når du overstyrer standard utdata- og feilfiler, blir filnavnene prefiksert med en ">" for å indikere at filene er åpnet i skrivemodus.
7.2. Filtilgang
Som vi allerede vet, trengs et håndtak for å få tilgang til en fil fra et Perl-program. Filbeskrivelsen er opprettet av funksjonen åpne () som er en Perl-listeoperasjon:
åpne DESCRIPTOR, FILE_NAME; åpne DESCRIPTOR;
Når åpningsoperasjonen utføres med filnavnet spesifisert i parameterne, åpnes den tilsvarende filen og en deskriptor for denne filen opprettes. Et uttrykk kan brukes som en filbeskrivelse i den åpne ()-funksjonen - verdien vil være navnet på beskrivelsen. Filnavnet angis direkte som en streng-literal eller et uttrykk hvis verdi er en streng. Åpningsoperasjonen uten filnavn åpner en fil hvis navn er inneholdt i skalarvariabelen $ DESCRIPTOR, som ikke kan være en leksikalsk variabel definert av tu ()-funksjonen. Eksempel 7.1 viser bruken av operasjonen åpne () for å åpne filer.
#! peri -w
$ var = "out.dat";
$ FILE4 = "fil4.dat";
åpne FIL1, "in.dat"; # Filnavn spesifisert av streng
åpne FIL2, $ var; # Filnavnet "er gitt av en variabel
åpne FILE3, "/perlourbook/01/".$var; # Filnavnet beregnes i uttrykket
åpne FILE4; # Filnavn i $ FILE4 variabel
Enhver fil kan åpnes i en av følgende moduser: les, skriv eller legg til på slutten av filen. Dette gjøres ved å legge til riktig prefiks til filnavnet:< (чтение), >(oppføring), "(tillegg). Hvis prefikset er utelatt, åpnes filen som standard i lesemodus. Å skrive informasjon til en fil åpnet i skrivemodus (prefiks>) utføres i begynnelsen av filen, noe som fører til ødeleggelse av informasjonen i den før den åpnes. Informasjonen i filen åpnet i tilleggsmodus ("prefiks") slettes ikke, nye poster legges til på slutten av filen. Hvis en fil med det angitte navnet ikke eksisterer når en fil åpnes i skrive- eller tilføy-modus, opprettes den, noe som skiller disse modusene for filåpning fra lesemodus, der filen må eksistere. Ellers mislykkes den åpne operasjonen og det tilsvarende håndtaket opprettes ikke.
Perl lar deg åpne en fil i en modus til - lese-/skrivemodus. For å gjøre dette, før leseprefikset<, записи >eller tillegg", bør du sette plusstegnet +. La oss merke oss forskjellene mellom de tre lese-/skrivemodusene +<, +>og + ". Den første og tredje modusen lagrer innholdet i filen som åpnes, mens åpning av en fil med den andre modusen (+>) først sletter innholdet i filen som åpnes. Den tredje modusen skiller seg fra de to første ved at filen alltid skrives til slutten av filinnholdet.
Å åpne en fil og lage en deskriptor for den med funksjonen åpne () dekker alle praktisk talt viktige arbeidsmåter med en fil. Men funksjonene til denne funksjonen lar deg ikke angi tilgangsrettigheter for de opprettede filene, samt generelt bestemme om du vil opprette en fil hvis den ikke eksisterer. For en slik "subtil" åpning av filer kan du bruke sysopeno-funksjonen, som lar programmereren selv stille inn de individuelle komponentene i fildriftsmodusen: lesing, skriving, opprettelse, tilføyelse, sletting av innhold osv. Syntaksen til dette funksjonen er som følger:
sysopen DESCRIPTOR, FILE_NAME, FLAG [, TILLATELSE];
Her representerer FILE_NAME-parameteren navnet på filen uten funksjonsprefiksene åpne () som bestemmer hvordan filen åpnes. Sistnevnte er spesifisert av den tredje parameteren FLAG - et tall som representerer resultatet av den bitvise ELLER (|) operasjonen på moduskonstanter, definert i Fcnti-modulen. De tilgjengelige konstantene avhenger av operativsystemet. Bord 7.1 viser moduskonstantene som finnes i nesten alle operativsystemer.
Tabell 7.1.
Konstanter for filtilgangsmodus
|
Konstant |
Betydning |
|
0_KUN |
Bare lesing |
|
0_FEIL |
Bare ta opp |
|
O_RDWR |
Lese og skrive |
|
O_CREAT |
Opprett en fil hvis den ikke eksisterer |
|
Om EKSKL |
Feil hvis filen allerede eksisterer |
|
0_APPEND |
Legger til % til slutten av filen |
Tilgangsrettigheter(valgfri parameter OPPLØSNING) settes i oktalt system, og når de bestemmes, blir gjeldende verdi av prosesstilgangsmasken satt av umasko-funksjonen tatt i betraktning. Hvis denne parameteren ikke er spesifisert, bruker Perl verdien o666.
(For tillatelser, les Perl-dokumentasjonen for operativsystemet som er installert på datamaskinen.)
I eksempel 7.2 er operasjonene for å åpne filer med funksjonen åpne () og tilsvarende ÅPNING MED BRUK AV funksjonen sysopen () samlet.
bruk Fcnti;
# Bare lesing
Åpne FF, "< file.txt";
sysopen FF, "fil.txt", O_RDONLY;
# Record only (opprettet hvis den ikke eksisterer,
# og sletter innholdet hvis det finnes)
Åpne FF, "> file.txt";
sysopen FF, "file.txt", 0_WRONLY | 0_CREAT | OJTRUNC;
# Legg til til slutt (opprettet hvis den ikke eksisterer)
Åpne FF, "" file.txt ";
Sysopen FF, "file.txt", OJJRONLY I 0_CREAT I O_APPEND;
# Les/skriv (filen må eksistere) åpne FF, "+< file.txt"; sysopen FF, "file.txt", O_RDWR;
# Les / skriv (filen er slettet)
Åpne FF, "+> file.txt";
sysopen FF, "file.txt", O_RDWR | 0_CREAT I OJTRUNC;
Når en fil åpnes, returnerer funksjonene åpne o og sysopen o hvis filen ble åpnet med den spesifiserte modusen, og undef ellers. Du bør alltid sjekke suksessen til filåpningsoperasjonen ved å avslutte programkjøringen med die ()-funksjonen. Denne funksjonen viser listen over parametere som er sendt til den og avslutter utførelsen av Perl-skriptet:
åpen (FF, "+< $file") or"die "Нельзя открыть файл $file: $!";
Merk at funksjonsmeldingen terning () bruker spesialvariabelen $ !, som lagrer systemmeldingen eller feilkoden. Denne informasjonen hjelper til med å oppdage og rette feil i programmet. For eksempel, hvis $ fiie-variabelen inneholder navnet på en fil som ikke eksisterer, kan brukeren se en melding som ligner på følgende når du utfører forrige setning:
Filen file.txt kan ikke åpnes: Ingen slik fil eller katalog på D: \ PERL \ EX2.PL linje 4.
Den engelske teksten i denne meldingen representerer informasjonen i $!-variabelen.
For fullstendigheten av beskrivelsen av å jobbe med den åpne funksjonen, bør det sies at hvis filnavnet representerer strengen "-", tilsvarer filen som åpnes standardinngangen STDIN. Dette betyr at input med den genererte filbeskrivelsen er fra standard input. Hvis filnavnet er spesifisert som strengen "> -", tilsvarer dette utdata til standardutdata, representert i programmet av STDOUT-beskrivelsen.
Det siste vi ønsker å fremheve med hensyn til filbeskrivelser er opprettelsen av en duplikatbeskrivelse. Hvis og-tegnet "&" følger prefikset for åpen modus i filnavnstrengen, behandles resten av strengen som navnet på filbeskrivelsen, og ikke som navnet på filen som skal åpnes. I dette tilfellet opprettes en uavhengig kopi av denne beskrivelsen med navnet gitt av den første parameteren til den åpne funksjonen.<). Оба дескриптора имеют общий указатель текущей позиции файла, но разные буферы ввода/вывода. Закрытие одного из дескрипторов не влияет на работу другого. В программах Perl возможность создания копии дескриптора в основном применяется для восстановления стандартных файлов ввода/вывода после их перенаправления на другие файлы (пример 7.3).
#! peri -w
# Lag en kopi av STDOUT-beskrivelsen åpen (OLDOUT, "> & STDOUT");
# Omdiriger standardutgang
åpen (STDOUT, "> file.out") eller dø "Kan ikke omdirigere STDOUT: $!";
# Skriv ut til fil file.out
print "Informasjon til omdirigert STDOUTXn";
# Lukk den omdirigerte standardutdatabeskrivelsen lukk (STDOUT) eller dø "Kan ikke lukke STDOUT: $!";
# Gjenopprett standard utdatafil
åpne (STDOUT, "> & OLDOUT") eller dø "Kan ikke gjenopprette STDOUT: $!";
# Lukk kopien av standard utdatabeskrivelse STDOUT lukke (OLDOUT) eller dø "Kan ikke lukke OLDOUT: $!";
# Skriv ut til den gjenopprettede standard utdatafilen skriv ut "Informasjon til den gjenopprettede STDOUTXn";
Etter fullført arbeid med filen lukkes den av lukkefunksjonen. Den eneste valgfrie parameteren til denne funksjonen er beskrivelsen knyttet til filen:
lukk DESCRIPTOR;
Denne funksjonen returnerer True hvis I/O-bufferen er tømt og systemfilbeskrivelsen lukkes. Kalt opp uten en parameter, lukker funksjonen filen som er knyttet til gjeldende håndtak angitt av valgfunksjonen.
Det skal bemerkes at det ikke er nødvendig å lukke filer i programmet med lukkefunksjonen. Poenget er at å åpne en ny fil med en beskrivelse som allerede er knyttet til en fil, lukker den gamle filen. Dessuten, når programmet avsluttes, lukkes alle åpne filer i det. En slik implisitt lukking av filer er imidlertid full av potensielle feil på grunn av manglende evne til å fastslå om denne operasjonen ble fullført riktig. Disken kan bli full mens du skriver til filen, eller tilkoblingen til den eksterne utdataenheten kan gå tapt. Slike feil kan "fanges" ved å bruke eksplisitt lukking av filen og sjekke innholdet i spesialvariabelen $ !:
closet FILEIO) eller dø "Feil ved lukking av fil: $!";
Det er en nyanse til knyttet til eksplisitt lukking av filer. Når du leser fra en fil, vil spesialvariabelen $. (hvis verdien ikke er eksplisitt endret i programmet) lagrer nummeret på den siste leste filposten. Når filen eksplisitt lukkes av lukkefunksjonen, tilbakestilles verdien av denne variabelen til null, mens når filen lukkes implisitt, forblir den lik nummeret på den siste leste posten til den gamle filen og fortsetter å vokse under lesing operasjoner fra den nye filen.
Lesing av informasjon fra en fil utføres av o-operasjonen, hvis operand er en filbeskrivelse. I en skalar kontekst, ved første utførelse, leser denne operasjonen den første posten i filen, og setter spesialvariabelen $., som holder styr på antall poster lest til 1. Etterfølgende kall til leseoperasjonen fra filen med samme deskriptor resulterer i sekvensielle lesninger av følgende poster. I en listekontekst leser denne operasjonen alle de gjenværende postene i filen og returnerer en liste over postene i filen. Postseparatoren er lagret i spesialvariabelen $ / og er nylinjetegnet "\ n" som standard. Perl lar deg sette en annen postseparator ved ganske enkelt å tilordne et nytt postseparatortegn til $ /. Eksempel 7.4 viser noen triks for å lese fra en fil.
#! peri -w
åpen (F2, "out.dat") eller dø "Feil ved åpning av fil: $!";
$ linel =
@rest =
$ / = ":"; I Spesifiser en annen filpostseparator @ f2 =
# Skriv ut lesefilposter out.dat for ($ i = 0; $ i<=$#f2; $i++) { print "$f2[$i]\n";
}
$ / = "\ n"; # Gjenopprett standard postseparator
lukke (Fl) eller dø $ !; lukk (F2) eller dø $ !;
åpen (F3, "out.dat") eller dø "Feil ved åpning av fil: $!"; skrive ut
Flere kommentarer til programmet i eksempel 7.4. Den første og andre linjen i in.dat-filen leses inn i henholdsvis variablene $ iinel og $ iine2, siden standard "\ n"-postseparator brukes. Elementene i @rest-matrisen lagrer linjer fra den tredje til den siste av den samme filen: i en tilordningssetning, en leseoperasjon
Før du leser out.dat-poster, settes en ny postseparator - tegnet ":". Hvis out.dat-filen, for eksempel, bare inneholder én linje
111: 222: 333: Slutt
Deretter elementene i matrisen @ f g vil inneholde følgende verdier:
$ f2 = "111:" $ f2 [l] = "222:" $ f2 = "333:" $ f2 = "Slutt"
Når slutten av filen er nådd, returnerer o-operasjonen en udefinert verdi, som tolkes som falsk. Denne omstendigheten brukes vanligvis til å organisere lesingen av filposter i en løkke:
Mens ($ linje =
print $ linje; f Skriver ut neste linje i den koblede
# med filbeskrivelse F1)
Skriving til en fil som er åpnet i skrive- eller tilføy-modus utføres av utskriftsfunksjonen () med den første parameteren som en filbeskrivelse:
Skriv ut DESCRIPTOR OUTPUT_LIST;
Denne operasjonen skriver innholdet i listeelementene i den rekkefølgen de er definert i funksjonskallet, og legger ikke til en postseparator på slutten av listen. Programmereren må ta seg av dette:
$ / = ":"; # Record separator
skriv ut Fl @recll, $ /; # Skriver den første posten til en fil
skriv ut Fl @rec! 2, $ /; tt Skriv andre post til fil
Ingen komma tillatt etter filehandle
Hvis ingen filbeskrivelse er spesifisert i utskriftsfunksjonen, blir utskriften som standard gjort til standard utdatafil med STDOUT-beskrivelsen. Denne innstillingen kan endres med funksjonen velg (). Kalt uten parametere, returnerer den gjeldende standardbeskrivelsen for utskrift av funksjonene print () og skriv (). Hvis en enkelt parameter sendes til den, må denne parameteren være en filbeskrivelse. I dette tilfellet returnerer den også gjeldende standardbeskrivelse og erstatter den med beskrivelsen spesifisert av parameteren som er sendt til den.
$ oldfilehandle = velg (Fl); I Lagre gjeldende beskrivelse ved
# standard og ny F1-tilordning
print $ linje; # Utgang for å håndtere F1 velg ($ oldfilehandle); # Gjenoppretter gammel beskrivelse
# standard utskrift $ linje; # Utdata til gammel beskrivelse
Filer i Perl tolkes som ustrukturerte strømmer av byte. Når du arbeider med en fil gjennom en deskriptor, spores den nåværende posisjon. Lese-/skriveoperasjoner utføres fra gjeldende filposisjon. Hvis for eksempel en 80-byte-post ble lest, vil neste lese- eller skriveoperasjon starte ved 81 byte av filen. For å bestemme gjeldende posisjon i filen, bruk tell ()-funksjonen, den eneste parameteren som kan være en filbeskrivelse. Den returnerer gjeldende posisjon i den tilknyttede filen. Den samme funksjonen uten en parameter returnerer gjeldende posisjon i filen som den siste leseoperasjonen ble utført for i programmet.
Gjeldende posisjon i filen endres automatisk i henhold til lese-/skriveoperasjonene som utføres. Det kan endres ved å bruke seek o-funksjonen, som sendes som parametere en filbeskrivelse, en offset og et referansepunkt. For filen knyttet til beskrivelsen settes en ny gjeldende posisjon, forskjøvet med antall byte spesifisert av OFFSET-parameteren i forhold til opprinnelsen:
søk DESCRIPTOR, OFFSET, TO4KAJDTC4ETA;
Parameteren COUNT_POINT kan ha en av tre verdier: o - begynnelsen av filen, 1 - gjeldende posisjon, 2 - slutten av filen. Forskyvningen kan være enten positiv eller negativ. Den er vanligvis negativ for en offset fra slutten av filen og positiv for en offset fra begynnelsen av filen. For å angi startpunktet kan du bruke konstantene SEEK_SET, SEEK_CUR og SEEK_END fra modulen u:: Seekabie, som tilsvarer begynnelsen av filen, gjeldende posisjon og slutten av filen. Naturligvis er det nødvendig å koble denne modulen til programmet ved å bruke nøkkelordet bruk. For eksempel setter følgende utsagn de samme gjeldende posisjonene i filer:
bruk 10 :: Søkbar; søk FIL1, 5, 0; søk FIL2, 5, SEEK_SET;
For å flytte til begynnelsen eller slutten av filen, bruk en nullforskyvning i forhold til de tilsvarende referansepunktene når du kaller opp søke()-funksjonen:
søk FIL1, 0, 0; # Gå til begynnelsen av filsøk FILE1, 0, 2; § Hopp til slutten av filen
I tillegg til å lese postene til en fil om, gir Perl to andre måter å lese informasjon fra en fil på: getc () og read () funksjonene. Den første leser én byte fra filen, mens den andre leser poster med fast lengde.
Getc-funksjonen returnerer tegnet ved gjeldende filposisjon, hvis håndtak ble sendt til det som en parameter, eller en udefinert verdi hvis slutten av filen nås eller det oppstår en feil. Hvis funksjonen kalles uten en parameter, leser den et tegn fra standardinndatafilen STDIN.
getc; t Les tegn fra STDIN
getc Fl; # Les tegnet ved gjeldende posisjon til filen med beskrivelse F1
Les ()-funksjonen sendes tre eller fire parametere og dens syntaks er:
les DESCRIPTOR, VARIABLE, LENGTH [, OFFSET];
Den leser antallet byte spesifisert av LENGTH-parameteren inn i skalarvariabelen spesifisert av VARIABLE-parameteren fra filen med beskrivelsen spesifisert av den første DESCRIPTOR-parameteren. Returverdien er det faktiske antallet byte som er lest ved forsøk på å lese ved slutten av filen, og udefinert hvis det oppstår en feil. OFFSET-parameteren bestemmer antall byte som skal lagres fra innholdet i VARIABLE-variabelen, det vil si at registreringen av dataene som leses fra filen vil bli lagt til innholdet i variabelen etter byten spesifisert av verdien til OFFSET parameter. En negativ forskyvningsverdi -n (n er et heltall) betyr at de siste n bytene fra innholdet i VARIABLEN blir forkastet og posten som er lest fra filen legges til den gjenværende linjen. Eksempel 7.5 viser lesing av poster med fast lengde under antagelsen om at in.dat-filen inneholder tre datalinjer:
En to tre
#! peri -w
åpen (Fl, "in.dat") eller dø "Feil ved åpning av fil: $!";
$ string = "1234567890";
les Fl, $ streng, 6; Jeg leser seks byte inn i en variabel uten forskyvning
skriv ut $ streng, "\ n"; # $ string = "OneXnTw"
les Fl, $ streng, 6, lengde ($ streng);
skriv ut $ streng, "\ n"; # $ string = "En \ nTo \ nTre"
Lengdefunksjonen returnerer antall tegn (byte) i strengdata lagret i en skalarvariabel som sendes til den som en parameter. Etter den første leseoperasjonen ble innholdet i strengvariabelen $ ødelagt fordi denne lese o-funksjonen ble kalt uten offset. Mens ved den andre lesingen ble de lagrede dataene i $-strengvariabelen fullstendig lagret.
O, skriv ut, les, søk og fortell er bufrede I/O-operasjoner, det vil si at de bruker buffere for å fremskynde utførelse. Perl tilbyr også analoger av de listede funksjonene for å utføre leseoperasjoner fra en fil og skrive til en fil, som ikke bruker buffere når de utfører tilsvarende operasjoner med filinnholdet.
Sysread- og syswrite-funksjonene er ubuffrede erstatningsoperasjoner
OM OG FUNKSJONER
skrive ut, en FUNKSJON sysseek Erstatter FUNKSJONER søk og fortell.
De ubufrede lese- og skrivefunksjonene mottar de samme parameterne, som tilsvarer parameterne til lesefunksjonen:
sysread DESCRIPTOR, VARIABLE, LENGTH [, OFFSET]; syswrite DESCRIPTOR, VARIABLE, LENGTH [. OFFSET];
Betydningen av alle parametere er lik parameterne til lese ()-funksjonen. Returverdien til disse funksjonene er det sanne antallet byte som er lest/skrevet, på slutten av filen, eller udefinert ved feil.
Parametrene til sysseek-funksjonen er nøyaktig de samme som for seek ()-funksjonen:
sysseek DESCRIPTOR, OFFSET, COUNT_POTE;
Alt som har blitt sagt om bruken av søke om funksjon overføres fullt ut til dens ubuffrede motpart.
Funksjonaliteten til den bufrede tell ()-operasjonen implementeres av følgende kall til sysseek-funksjonen:
$ posisjon = sysseek Fl, 0, 1; # Nåværende posisjon til filpekeren
Eksempel 7.6 viser bruken av ubuffrede I/O-funksjoner for å behandle innholdet i en fil.
#! peri -w bruk Fcntl;
# Åpne en fil i lese-/skrivemodus sysopen Fl, "in.dat", OJRDWR;
# Leser en blokk på 14 byte
$ read = sysread Fl, $ string, 14;
Advar "Les $ read bytes i stedet for 14 \ n" hvis $ read! = 14;
# Stille inn gjeldende posisjon (med 15 byte). $ posisjon = sysseek Fl, 0, 1; die "Posisjoneringsfeil: $! \ n" med mindre $ posisjon er definert;
# Skrive en streng på gjeldende posisjon $ string = "Ny verdi"; $ skrevet = syswrite Fl, $ streng, lengde ($ streng);
die "Skrivefeil: $! \ n" hvis $ skrevet! = lengde ($ streng); # Lukker filen
lukk Fl eller dø $ !;
Når du arbeider med ubuffrede I/O-funksjoner, må du alltid kontrollere at en lese-, skrive- eller posisjoneringsoperasjon er fullført. Standard I/O-systemet, som bufret I/O implementeres gjennom, sjekker seg selv og er ansvarlig for å fullføre de spesifiserte operasjonene hvis prosessen ble avbrutt midt i en skriving. For ubuffret I/O bør dette tas hånd om av programmereren.
7.3. Filoperasjoner
Før vi undersøker funksjoner som utfører handlinger på hele filer, minner vi leseren om det grunnleggende knyttet til organiseringen av UNIX-filsystemet og filtilgangsprosedyrer. Perls funksjoner ble designet for å fungere med dette spesielle filsystemet, men til en viss grad gjelder mye av diskusjonen her også for filsystemer på andre plattformer.
Brukerens arbeid i UNIX begynner med påloggingsprosedyren, hvor han skriver inn påloggingsnavn og passord. Påloggingsnavnet tildeles av systemadministratoren og lagres i en spesiell kontofil. Passordet settes av brukeren selv.
Registreringsnavnet huskes lett av brukeren, men det er mer praktisk for systemet å holde oversikt over brukere, og identifisere dem ikke ved symbolske registreringsnavn, men med numeriske identifikatorer. Derfor, i tillegg til en mnemonisk pålogging, blir hver UNIX-bruker også tildelt en numerisk bruker-ID (uid - User IDentifier) og en gruppe-ID (gid - Group IDentifier) som den tilhører. Uid- og gid-verdiene er tilordnet prosessen som kjører skallet, som startes når brukeren logger på. De samme identifikatorene sendes videre til enhver annen prosess som startes av brukeren under UNIX-økten.
UNIX-filsystemet er et tre, der mellomnodene tilsvarer kataloger, og bladene til filer eller tomme kataloger. Hver fil identifiseres med sitt unike fulle navn, som inkluderer hele banenavnet (banenavnet) fra roten til filsystemet gjennom mellomnoder (kataloger) direkte til filen. Rotkatalogen har et forhåndsdefinert navn, representert med tegnet "/". Det samme tegnet brukes også til å skille katalognavn i hele filnavnkjeden, for eksempel /bin/prog.exe.
Hver fil i UNIX-filsystemet er preget av betydelig mer informasjon enn for eksempel en fil i FAT-filsystemet. Denne informasjonen inkluderer spesielt informasjon om eieren av filen, gruppen som eieren av filen tilhører, hvem som har rett til å lese filen, skrive til filen, kjøre filen osv. Denne informasjonen lar deg for å angi ulike tilgangsrettigheter til filen for følgende kategorier av brukere: fileier, medlemmer av eierens gruppe, andre brukere. All relevant informasjon om en fil lagres i en spesiell datastruktur kalt en inode (modus). Indeksbeskrivelser er plassert i et spesielt område på disken, dannet når den formateres i UNIX-systemet.
Når en prosess starter, er to bruker-IDer knyttet til den: ekte og effektive, og to like brukergruppe-IDer. Gyldige bruker- og gruppe-ID-er er vedvarende ID-er knyttet til alle prosesser som er startet av brukeren. Effektive identifikatorer er midlertidige identifikatorer som kan settes til å utføre spesifikke handlinger. For eksempel, når en bruker endrer et passord, setter passwd-programmet automatisk de effektive prosess-IDene for å gi skrivetilgang til passordfilen.
Når en prosess har assosiert identifikatorer, gjelder filbegrensninger. En prosess kan bare få tilgang til filen hvis tilgangsbegrensningene som er lagret i filen tillater det.
For hver registrerte bruker av systemet opprettes det en såkalt "hjemmekatalog" for brukeren, som han har ubegrenset tilgang til, samt til alle kataloger og filer som finnes i den. Brukeren kan opprette, slette og endre kataloger og filer fra hjemmekatalogen. Tilgang til alle andre filer er potensielt mulig, men den kan begrenses dersom brukeren ikke har tilstrekkelige rettigheter.
Enhver bruker som lager sin egen fil regnes som hans Eieren. Du kan endre eieren av en fil fra et Perl-skript ved å bruke chown ()-funksjonen. Parameteren til denne funksjonen er en liste, hvor de to første elementene må representere de nye numeriske identifikatorene uid og gid. Resten av listeelementene er navnene på filene som eieren blir endret for. Denne funksjonen returnerer antall filer som eier- og gruppeendringsoperasjonen var vellykket.
@list = (234, 3, "filel.dat", "fil2.dat");
$ tall = chown (@list);
advar "Ikke alle filer har endret eier!" hvis $ tall! = @ liste-2;
Chmodo-funksjonen endrer tillatelsene for filene i listen som sendes til den som en parameter. Det første elementet i denne listen må være et tresifret oktalt tall som spesifiserer tillatelsene for eieren, brukerne i eierens gruppe og andre brukere. Hvert oktale siffer definerer retten til å lese filen, skrive til filen og kjøre den (hvis filen representerer et kjørbart program) for brukergruppene ovenfor. Bitene satt i binæren representerer de tilsvarende filtillatelsene. For eksempel, hvis alle tre bitene er satt (oktalt tall 7), så har den tilsvarende brukergruppen alle de oppførte rettighetene: den kan lese fra en fil, skrive til en fil og kjøre den. En verdi på 6 bestemmer retten til å lese og skrive, 5 lar deg lese fra en fil, kjøre den, men tillater ikke skriving til denne filen osv. Vanligvis opprettes en ikke-kjørbar fil med tilgangsmodus 0666 - alle brukere kan lese og skrive informasjon til filen , den kjørbare filen - med modusen 0777. Hvis eieren av filen ønsker å begrense skriving til filen til brukere som ikke er i gruppen hans, bør følgende setning utføres:
Chmod 0664, "file.dat";
Returverdien til chmodo-funksjonen, som chowno-funksjonen, er antallet filer fra listen som endringen av tilgangsrettigheter var vellykket.
Det er tre felt i filen inode struktur som lagrer tidspunktet for siste tilgang (atime) til filen, dens modifikasjon (mtime) av filen, og endringen av inoden Xctime): UtimeO-funksjonen kan endre tidspunktet for siste tilgang og endring av filen. Parameteren er en liste som inneholder navnene på filene som behandles, og de to første elementene i listen er numeriske verdier for den nye tiden for siste tilgang og endring:
gfiles = ("filel.dat", "fil2.dat");
$ nå = tid;
Utime $ nå, $ nå, 6filer;
Denne kodebiten endrer siste tilgangs- og endringstidspunkt for filer fra @files-listen til gjeldende tidspunkt oppnådd ved bruk av tidsfunksjonen.
Merk at når utime o-funksjonen utføres, endres også tidspunktet for siste inodemodifikasjon (ctime) - det settes lik gjeldende tid. Den returnerte verdien er telling. Antall filer der operasjonen med å endre siste tilgang og endringstid var vellykket.
UNIX-filsystemet lar deg lage lenker til den samme filen. Dette oppnås ved ganske enkelt å spesifisere den samme inoden for to katalogoppføringer. Slike lenker kalles vanskelig(hard) lenker, og operativsystemet skiller ikke mellom katalogoppføringen som ble opprettet når filen ble opprettet og referanser til den filen. Når en fil åpnes med referanse og navn, endres inodefeltene. Fysisk blir filen ødelagt først når den siste harde lenken til filen er ødelagt.
På UNIX er det en annen type filreferanser - symbolske lenker. Disse koblingene skiller seg fra harde lenker ved at de indirekte refererer til en fil hvis navn er lagret i datablokken til den symbolske lenken.
Harde lenker opprettes i Perl av linko-funksjonen, og symbolske lenker av symiinko-funksjonen. Syntaksen for disse funksjonene er den samme - deres to parametere representerer navnet på filen som skal kobles til og det nye navnet på lenkefilen:
lenke OLD_FILE, NEW_FILE; symbolkobling OLD_FIDE, NEW_FILE;
Hvis den harde koblingen er opprettet, returnerer koblingsfunksjonen True, ellers False. Når symiinko oppretter en symbolsk lenke, returnerer den i hvis operasjonen lykkes, og ellers.
Funksjonen Ustøttet funksjonskobling er ikke implementert på D: \ EX2.PL linje 2.
Symlink-funksjonen er uimplementert på D: \ EX2.PL linje 2.
Du kan fjerne eksisterende koblinger til en fil ved å bruke funksjonen for å fjerne koblingen. Denne funksjonen fjerner én lenke til hver fil spesifisert i parameterlisten. Hvis det ikke er noen lenker til filen, slettes selve filen. Funksjonen returnerer antall filer som sletteoperasjonen var vellykket. Å kalle opp koblingsfunksjonen uten en parameterliste bruker innholdet i spesialvariabelen $ _ som parameterliste. Følgende kodebit sletter alle sikkerhetskopier av filene i gjeldende katalog:
Fjern tilknytningen<*.bak>;
I inodestrukturen inneholder nlink-feltet antall harde lenker til filen. Den kan brukes sammen med fjernkoblingsfunksjonen for å fjerne alle lenker til en fil. Hvis det ikke er noen koblinger, er dette feltet satt til 1 (bare filnavnet angitt da det ble opprettet refererer til inoden til filen).
De to siste operasjonene knyttet til filer er å gi nytt navn og avkorte en fil. Rename-funksjonen endrer navnet på filen spesifisert av den første parameteren til navnet spesifisert av den andre parameteren i denne funksjonen:
Gi nytt navn til "old.dat", "new.dat";
Denne uttalelsen vil gi nytt navn til den gamle.dat-filen til den nye.dat-filen. Rename file-funksjonen returnerer i ved suksess og o ellers.
Den trunkerte funksjonen avkorter filen til den angitte lengden. For å spesifisere en fil, kan du bruke både filnavnet og den åpne filbeskrivelsen:
avkorte DESCRIPTOR, LENGTH; avkort FILE_NAME, LENGTH;
Funksjonen returnerer True hvis fillengden ble trunkert til antall byte spesifisert i LENGTH-parameteren, eller udefinert på annen måte. Å avkorte en fil betyr ikke bare å redusere lengden, men også å øke den. Dette betyr at verdien av den andre parameteren til avkortingsfunksjonen o kan være større enn den sanne lengden på filen, som lar deg lage "hull" i innholdet i filen, som senere kan brukes til å skrive nødvendig informasjon uten å ødelegge informasjonen som allerede er skrevet til filen (eksempel 7.7).
#! peri -w
# Lag en fil med hull for ($ i = l; $ i<=3;$i++H
åpne (F, "" out.dat ") eller dø $ !; print F "Skriv" $ i;
lukke F;
åpne (F, "" out.dat ") eller dø $ !; avkorte F, 19 * $ i;
lukke F;
) "tt Skrive informasjon til hull" åpen (F, "+
søk F, 0,1;
les F, $ hjul, 7;
søk F, 0, l;
skriv ut F "
Ved hvert trinn i den første for-løkken i eksempel 7.7 skrives 7 byte med informasjon til slutten av out.dat-filen, og deretter økes lengden med 12 byte, noe som skaper en tom plass i filen. Den neste for loop setter inn 12 byte med informasjon i disse opprettede "hullene" uten å overskrive informasjonen som er lagret i filen. Merk at avkortingsfunksjonen må lukkes og åpnes på nytt for å endre lengden på filen. Dette skyldes det faktum at avkortingsfunksjonen legger til mellomrom til begynnelsen av filen, og flytter innholdet til slutten, hvis den brukes uten å lukke filen. Du kan eksperimentere med programmet i eksempel 7.7 ved å åpne filen før du kjører den første for loop, og lukke den etter at loopen er ferdig. Innholdet i filen vil gi deg en visuell representasjon av hvordan avkortingsfunksjonen fungerer i dette tilfellet. I vårt tilfelle, etter å ha utført den første for loop, ser innholdet i out.dat-filen slik ut:
Ta opp! Rekord2 Rekord3
\
Når hele programmet er ferdig, vil filen inneholde følgende linje:
KINNHOLD: 1> 2<СОЫТЕЫТЗ:2>RecordZ<СОМТЕ№ГЗ:3>
7.4. Henter informasjon om en fil
Vi vet at i UNIX-filsystemet lagres informasjon om en fil i inoden. består av 13 felter som det brukes spesielle betegnelser for. Alle er oppført i tabellen. 7.2.
Tabell 7.2.
Inode struktur
|
Felt |
Beskrivelse |
|
|
Filsystemets enhetsnummer |
||
|
Inodenummer |
||
|
Modus |
Filmodus (type og tillatelser) |
|
|
Nlink |
Antall harde lenker til filen (i mangel av lenker er 1) |
|
|
Den numeriske ID-en til eieren av filen |
||
|
Den numeriske gruppe-ID-en til eieren av filen |
||
|
Rdev |
Enhets-ID (kun for spesielle filer) |
|
|
Størrelse |
Filstørrelse i byte |
|
|
En gang |
Tidspunkt for siste tilgang til filen siden begynnelsen av epoken |
|
|
Mtime |
Tidspunktet filen sist ble endret siden begynnelsen av epoken |
|
|
Med tiden |
Tidspunkt for modifikasjon av inoden siden begynnelsen av epoken |
|
|
Blksize |
Foretrukket blokkstørrelse for I/O-operasjoner |
|
|
Blokker |
Faktisk antall tildelte blokker for filallokering |
|
Stato-funksjonen brukes til å få verdiene til feltene til en fils inodestruktur i Perl. Den eneste parameteren kan enten være filnavnet eller beskrivelsen av filen som åpnes i programmet. Den returnerer en liste med 13 elementer som inneholder verdiene til feltene i filen inodestruktur i den rekkefølgen de er oppført i tabellen. 7.2. Typisk bruk i et Perl-program er vist nedenfor
($ dev, $ ino, $ modus, $ nlink, $ uid, $ gid, $ rdev, $ størrelse, $ atime, $ mtime, $ ctime, $ blksize, $ blokker) = stat ($ filnavn);
Å tilordne feltverdier til en liste over skalarvariabler med identifikatorer som tilsvarer feltnavnene bidrar til bedre programlesbarhet enn å tilordne skalarer til en matrise:
@inode = stat ($ filnavn);
I sistnevnte tilfelle kan du få verdien av det tilsvarende feltet bare ved å bruke indeksen, noe som ikke er veldig praktisk, siden du må huske nummeret på det nødvendige strukturfeltet.
Hvis ingen parameter er spesifisert når stato-funksjonen kalles, returnerer den inodestrukturen til filen hvis navn er inneholdt i spesialvariabelen $ _.
Funksjonen for å få informasjon om en fil om suksess i en listekontekst returnerer en liste over feltverdier i filinodestrukturen, eller en tom liste ved feil. I skalarsammenheng returnerer den den boolske verdien True eller False, avhengig av resultatene av utførelsen.
For å gjøre det enklere å bruke informasjon om filen, cacher stato-funksjonen, etter suksess, de oppnådde feltverdiene. Hvis du kaller denne funksjonen med den spesielle filbeskrivelsen _ (understrekingstegn), vil den returnere informasjonen som er lagret i hurtigbufferen fra forrige samtale. Dette lar deg sjekke ulike attributter til en fil uten å kalle stat () igjen eller lagre resultatene av dens kjøring i programvariabler.
Stato kan brukes til å få inodestrukturen til ikke bare en fil, men også harde lenker til den og kataloger, siden de også er filer hvis datablokker inneholder navn på katalogfiler og deres inodenummer. For å få informasjon om symbolske lenker, bruk is tat o-funksjonen, som returnerer en liste over feltverdier i inodestrukturen til selve lenken, ikke filen den refererer til. Denne funksjonen fungerer på samme måte som stat (), inkludert bruken av den spesielle _-deskriptoren.
I tillegg til disse to funksjonene, som gir informasjon om systemfiler, gir Perl et sett med unære operasjoner som returnerer verdien av bare ett felt i inodestrukturen. Disse operasjonene blir referert til i dokumentasjonen som "-x-operasjoner" fordi navnene deres består av en bindestrek etterfulgt av et enkelt tegn. Alle av dem er unære navngitte operasjoner og har sin egen prioritet i komplekse uttrykk, som vi snakket om i kap. 3. En fullstendig liste over unære operasjoner for å kontrollere filattributter er presentert i Tabell. 7.3.
Tabell 7.3.
Unære navngitte filvalideringsoperasjoner
|
Operasjon |
Attributtet som kontrolleres |
||
|
G |
|||
|
W |
Effektiv uid / gid kan skrive til fil |
||
|
NS |
Filen kan kjøres av en effektiv uid / gid |
||
|
O |
Filen eies av den effektive uid |
||
|
R |
|||
|
W |
En gyldig uid / gid kan skrive til en fil |
||
Unære operasjoner brukes på en streng som inneholder et filnavn, et uttrykk som evalueres til et filnavn, eller en Perl-filbeskrivelse. Hvis operasjonsparameteren ikke er spesifisert, tester den filen, hvis navn er inneholdt i spesialvariabelen $ _. Hver returnerer 1 hvis filen har det tilsvarende attributtet, en tom streng "" ellers, og udefinert undef hvis filen spesifisert i parameteren ikke eksisterer.
Noen få ord om algoritmen for å oppdage tekst og binære filer (operasjoner -t og -v). Disse operasjonene analyserer innholdet i den første blokken av filen for "rare" tegn - uvanlige escape-sekvenser eller bytes med de mest signifikante bitene satt. Hvis et tilstrekkelig stort antall slike tegn blir funnet (mer enn 30%), anses filen som binær, ellers tekst. Enhver fil med en tom første blokk behandles som binær.
Hvis disse operasjonene brukes på Perl-filbeskrivelser, kontrolleres innholdet i I/O-bufferen, ikke den første blokken i filen. Begge disse operasjonene, når de brukes på filbeskrivelser, returnerer den boolske verdien True hvis filen knyttet til beskrivelsen er tom eller satt til slutten av filen.
Når du utfører unære navngitte operasjoner for å sjekke en fil, kalles stato-funksjonen faktisk implisitt, og resultatene av beregningen bufres, noe som lar deg bruke en spesiell filbeskrivelse _ for å øke hastigheten på flere filkontroller:
If (-s ("filnavn") && -Т J (
^
Vi gjør noe for tekstfiler som ikke er null.
}
7.5. Operasjoner med kataloger
Som vi bemerket tidligere, på UNIX, er kataloger spesialformatfiler, merket som kataloger i deres inodestrukturer (rdev-feltet). Innholdet i katalogdatablokker er et sett med par som består av et objekt i en katalog og den numeriske verdien til inoden.
For å jobbe med kataloger tilbyr Perl funksjoner for å åpne, lukke og lese innholdet i en katalog, hvis syntaks og semantikk ligner syntaksen og semantikken til de tilsvarende filoperasjonene:
opendir DESCRIPTOR, DIRECTORY_NAME; lukket DESCRIPTOR; readdir DESCRIPTOR;
Tilgang til innholdet i katalogen utføres, som for en fil, gjennom opendir o kataloghåndtak. Merk at det opprettes et navneområde for katalogbeskrivelser i Perl-symboltabellen. Dette betyr at fil- og katalogbeskrivelser med samme navn kan eksistere i programmet uten å komme i konflikt med hverandre:
åpen FF, "/usr/out.dat" # Filbeskrivelse opendir FF, Vusr "# Katalogbeskrivelse
Kommentar
Å bruke samme navn for fil- og katalogbeskrivelser kan være forvirrende for brukeren. Det er imidlertid ikke noe slikt problem for peri: tolken vet alltid nøyaktig hvilken deskriptor som skal brukes.
Readdir o-funksjonen for en åpen katalog i en listekontekst returnerer en liste over navnene på alle filene i katalogen, eller en tom liste hvis alle navn allerede er lest. Den samme funksjonen, i skalarsammenheng, returnerer neste filnavn i katalogen, eller udefinert hvis alle filnavn er lest.
Rewinddiro-funksjonen setter gjeldende katalogposisjon til begynnelsen, som tillater omlesing av katalogfilnavn uten å lukke den. Den eneste parameteren til denne funksjonen er håndtaket til den åpne katalogen.
Eksempel 7.8 sjekker om alle filene i katalogen er binære (innholdet i underkatalogene er ikke sjekket).
#! peri -w
opendir FDIR, "/ usr / prog"; while ($ navn = readdir FDIR) (neste hvis -d $ navn; # Directory
print ("$ navn: binær \ n") hvis -B $ navn; tt Binær) closedir FDIR;
Readdir-funksjonen returnerer det relative filnavnet. For å få hele navnet på filen må du selv lage den i programmet. Legg for eksempel til navnet på katalogen for å sjekke i eksempel 7.8:
Skriv ut ("/ usr / prog / $ navn: binaryXn") hvis -В $ navn; # Binær fil
For å opprette en ny katalog, bruk mkdiro-funksjonen, hvis parametere er katalognavnet og tilgangsmodus (oktalt nummer):
mkdir
DIRECTORY_NAME, MODE;
Hvis et ufullstendig katalognavn er spesifisert, opprettes det i gjeldende katalog som er angitt av chdirf-funksjonen). Returverdien til mkdirs nye katalogopprettingsfunksjon er True hvis katalogen ble opprettet og False hvis det oppstod en feil. I sistnevnte tilfelle vil spesialvariabelen $! en forklaring beholdes for ikke å fullføre opprettelseskatalogoperasjonen.
Du kan slette en katalog ved å bruke rmdirf-funksjonen) med en parameter som inneholder en streng med katalognavnet. Hvis parameteren ikke er spesifisert, brukes spesialvariabelen $ _. I likhet med opprett katalogfunksjonen, returnerer denne funksjonen True hvis katalogen ble slettet og False ellers ved å skrive $! en forklaring på feilen som oppsto.
* * *
I dette kapittelet har vi lært hvordan du får tilgang til innholdet i filer og kataloger gjennom de tilsvarende beskrivelsene. Vi lærte å lese og skrive informasjon til filer, opprette og slette kataloger. Vi ble kjent med et stort sett med unære navngitte operasjoner for å få informasjon om filattributter fra feltene til inodestrukturen.
Spørsmål for selvkontroll
1. Hvordan får man tilgang til en fil fra et Perl-program?
2. List opp operasjonene som lar deg lese innholdet i filen og skrive informasjon til den:
3. Hva er modusene for å åpne en fil og hvordan er de forskjellige?
4. Hva er en fils tilgangsmodus og hvordan kan jeg endre den i et Perl-program?
5. Hva er en katalogbeskrivelse og hvorfor er den nødvendig?
6. Hvordan kan du få navnene på alle filene i en bestemt katalog?
Øvelser
1. Finn feil i programmet:
# 1 peri -w
$ var = (stat "filel.dat");
Åpne FIL1 "> filel.dat";
skriv ut FIL1, "Fillengde:". $ var. "\ n";
2. Skriv et program som fjerner en katalog hvis navn sendes gjennom kommandolinjen. Hvis skriptet kjøres uten parametere, bør du vurdere å vise en melding som indikerer riktig syntaks for å starte det. (Merk: Fjern først alle filer fra de underliggende katalogene, hvis noen.)
3. Skriv et program for å kopiere en fil til en annen. Vurder å skrive inn filnavn både via kommandolinjen og fra monitorskjermen.
4. Skriv et program for å kopiere innholdet i en katalog til en annen katalog. Vurder å skrive inn katalognavn både via kommandolinjen og fra monitorskjermen.
5. Skriv et program for å lese linjen i en tekstfil med gitt nummer. Vurder tilfeller der det angitte linjenummeret overstiger antall linjer i filen. Hvis linjenummeret er negativt, skal alle linjer leses, og starter med linjen med tallet lik den absolutte verdien av den angitte negative verdien.
Mange Perl-programmerere håndterer tekstfiler som konfigurasjoner eller loggfiler, så det er viktig å lære å jobbe med filer så tidlig som mulig for å få nyttig kunnskap.
La oss først lære hvordan du skriver data til en fil, siden det ser ut til å være den mest enkle oppgaven.
Før du skriver til en fil, må du åpen det, det vil si, be operativsystemet (Windows, Linux, OSX, etc.) om å åpne en kanal der programmet ditt kan "kommunisere" med filen. For å gjøre dette har Perl en funksjon
åpen
(med litt merkelig syntaks). bruk streng; bruk advarsler; mitt $ filnavn = "rapport.txt"; åpen (min $ fh, ">", $ filnavn) eller "Kan ikke åpne" $ filnavn "$!"; print $ fh "Min første rapport generert med perl \ n"; lukk $ fh; skriv ut "ferdig \ n";Dette er et godt fungerende eksempel, og vi kommer tilbake til det senere, men la oss først prøve et enklere eksempel:
Et enkelt eksempel
bruk streng; bruk advarsler; åpen (min $ fh, ">", "report.txt"); print $ fh "Min første rapport generert med perl \ n"; lukk $ fh; skriv ut "ferdig \ n";Også her trengs det en forklaring. Funksjon åpen tar 3 parametere.
Den første, $ fh, er en skalarvariabel som vi forklarer i det åpne () kallet. Vi kunne ha deklarert det tidligere, men det er vanligvis lettere å deklarere det direkte i samtalen, selv om det kan se litt rart ut ved første øyekast. Den andre parameteren bestemmer hvordan vi åpner filen. I dette tilfellet setter vi et større enn-tegn (>), som betyr at filen åpnes for skriving. Den tredje parameteren er banen til filen vi ønsker å åpne.
Når denne funksjonen kalles, tilordner den en spesiell nøkkel til $ fh kalt filhåndtaket. Vi bryr oss ikke om innholdet i denne variabelen i seg selv; vi vil bare bruke det i det følgende. Viktigst, merk at innholdet i filen fortsatt er på disken, og IKKE legger inn $ fh-variabelen.
Når filen er åpen, kan vi bruke $ fh-pekeren i print ()-setningen. Dette ser nesten ut som print () i andre deler av opplæringen vår, men vi sender filpekeren som den første parameteren, og etter det Nei(!) komma.
Dette print () kallet vil skrive teksten til filen vår.
Så i neste linje lukker vi filpekeren. Dette er strengt tatt ikke påkrevd i Perl. Perl vil automatisk og korrekt lukke alle filpekere når variabelen går utenfor scope, det vil si som en siste utvei, når skriptet er ferdig. Men uansett, det anses som god praksis å eksplisitt lukke filer.
Den siste linjeutskriften "ferdig \ n" er bare nødvendig for å klargjøre følgende eksempel:
Feil under behandling
La oss ta det forrige eksemplet og erstatte filnavnet med en ikke-eksisterende bane. For eksempel:
Åpne (min $ fh, ">", "noen_merkelig_navn / rapport.txt");
Nå, hvis vi kjører dette skriptet, vil vi se en feilmelding:
Skriv ut () på lukket filhåndtak $ fh ved ... ferdig
Faktisk er dette bare en advarsel; skriptet fortsetter å kjøre, og derfor vil vi se ordet "ferdig" på skjermen.
Dessuten vil vi bare se en advarsel fordi vi eksplisitt har bedt om å vise advarsler ved å bruke advarsler om bruk. La oss prøve å kommentere bruksadvarslene og se at nå er skriptet stille når et mislykket forsøk på å åpne filen. Så du vil ikke engang merke det før klienten, eller enda verre, sjefen din, begynner å klage.
I alle fall er det et problem. Vi prøvde å åpne filen. Det gikk ikke, men vi prøvde likevel å spille inn noe der.
Vi bør sjekke om åpne () lyktes før vi fortsetter.
Heldigvis returnerer selve oppfordringen til å åpne () TRUE ved suksess og FALSE ved fiasko, så vi kan gjøre dette:
Åpne eller dø
åpne (min $ fh, ">", "noen_merkelig_navn / report.txt") eller dø;Dette er et "standard formspråk" åpne eller dø... Dette er veldig vanlig i Perl.
die er et funksjonskall som vil gi et unntak og dermed avslutte skriptet vårt.
«åpne eller dø» er et boolsk uttrykk. Som du vet fra forrige del av opplæringen, er "eller" forkortet i Perl (som på mange andre språk). Dette betyr at hvis venstre side returnerer TRUE, er det umiddelbart klart at hele uttrykket vil være TRUE, så høyre side blir ikke utført i det hele tatt. På den annen side, hvis venstre side returnerer FALSE, blir høyre side utført, og resultatet av utførelsen vil være resultatet av hele uttrykket.
I dette tilfellet bruker vi denne forkortelsesfunksjonen i uttrykket vårt.
Hvis åpen () lykkes, vil den returnere TRUE og høyre side vil aldri bli utført. Skriptet vil bare gå videre til neste linje.
Hvis åpen () mislykkes, vil den returnere FALSE. Da utføres også uttrykket til høyre for eller. Dette gir et unntak og skriptet avsluttes.
I dette eksemplet sjekker vi ikke den endelige verdien av det boolske uttrykket, vi trenger det ikke. Vi brukte kun dette uttrykket for "bivirkningen".
Hvis vi kjører skriptet med denne endringen, får vi en feilmelding:
Døde kl...
og vi vil IKKE se "ferdig".
Forbedrer feilmeldingen
I stedet for bare å kalle die uten parameter, kan du legge til en forklaring på hva som skjedde.
Åpne (min $ fh, ">", "some_strange_name / report.txt") eller dø "Jeg kan ikke åpne filen" some_strange_name / report.txt "";
Jeg kan ikke åpne filen "some_strange_name / report.txt" ...
Det er bedre, men på et tidspunkt vil noen prøve å endre banen til riktig katalog ...
Åpne (min $ fh, ">", "correct_directory_with_type / report.txt") eller dø "Jeg kan ikke åpne filen" some_strange_name / report.txt "";
Men feilmeldingen vil være gammel, fordi banen ble endret bare i det åpne ()-anropet, men ikke i meldingen.
Så det ville være bedre å bruke en variabel som filnavn:
Mitt $ filnavn = "noen_merkelig_navn / rapport.txt"; åpen (min $ fh, ">", $ filnavn) eller "Kan ikke åpne filen" $ filnavn "";
Vi har nå den riktige feilmeldingen, men vi vet fortsatt ikke hvorfor det skjedde. La oss gå ett skritt videre og bruke $! - en innebygd Perl-variabel - for å returnere det systemet fortalte oss om feilen:
Mitt $ filnavn = "korrekt_katalog_med_type / rapport.txt"; åpne (min $ fh, ">", $ filnavn) eller dø "Kan ikke åpne filen" $ filnavn "$!";
Denne koden vil gi
Kan ikke åpne filen "correct_directory_with_type / report.txt" Ingen slik fil eller katalog ...
Mye bedre på denne måten.
La oss nå gå tilbake til det opprinnelige eksemplet.
Mer?
Åpne samtaler med større enn-innlogging kan høres forvirrende ut, men hvis du er kjent med kommandolinjeviderekoblinger, vil du forstå hva det betyr. Hvis ikke, se for deg at det er en pil som viser retningen på dataflyten: til filen til høyre.
Ikke latin?
Hvis du trenger å jobbe med ikke-ASCII-tegn, bør du lagre dem i UTF-8. For å gjøre dette, må du fortelle Perl at du åpner filen i UTF-8-koding.
Åpne (min $ fh, ">: koding (UTF-8)", $ filnavn) eller "Kan ikke åpne filen" $ filnavn "";
Hver gang du trenger tilgang til en fil på disken, må du opprette et nytt håndtak og åpne det. Åpne-funksjonen brukes til å åpne beskrivelsene:
åpen (filbeskrivelse, bane)
Banen spesifiserer hvilken fil som skal åpnes, så hvis den fullstendige banen ikke er spesifisert, for eksempel med: / windows / system /, vil åpne-funksjonen prøve å åpne filen i gjeldende katalog. Ved suksess returnerer den åpne funksjonen en verdi som ikke er null (True), ved feil returnerer den undef (False), for eksempel:
if (åpen (MINFIL, "mindatafil")) (
# Utført ved vellykket åpning
) annet (
print "Feil ved åpning av mindatafil \ n";
utgang 1;
}
I mange Perl-programmer kan denne "åpne eller rapporter en feil"-syntaksen implementeres ved hjelp av funksjonen dø
... Die-funksjonen stopper programkjøringen og viser en feilmelding:
Døde på script_name line xxx
Her er skriptnavnet navnet på Perl-programmet, xxx er linjenummeret der dysefunksjonen ble oppdaget. Die og åpne funksjoner brukes ofte sammen som følger:
åpen (MINTEKST, "novel.txt") || dø;
Programmet åpner enten filen eller slutter å kjøre. Hvis åpning mislykkes, og returnerer en falsk verdi, trer den logiske ELLER-operatoren (| |) i kraft. Som et resultat vil argumentet som ligger på høyre side av operatøren bli beregnet (i dette tilfellet formfunksjonen). Hvis den åpne funksjonen lykkes, blir ikke høyre side av det boolske uttrykket evaluert. Noen ganger bruker de en annen form for logisk ELLER - eller.
For å lukke håndtaket, bruk funksjonen Lukk
:
lukk (MINTEKST);
Hvis du prøver å åpne en fil, og spesifiserer en av de allerede åpne beskrivelsene som parametere for den åpne funksjonen, så lukkes denne beskrivelsen først og åpnes deretter på nytt.
Funksjoner dø
en liste med argumenter kan sendes for å skrives ut i stedet for standardmeldingen. Hvis meldingen ikke inneholder et linjeskifttegn, legges teksten på script_name line xxx til på slutten av meldingen, for eksempel:
die "Feil ved åpning av fil";
# Viser meldingen "Feil ved åpning av fil på script_name line xxx"
die "Feil ved åpning av fil \ n"
; # "Feil ved åpning av fil" vises
Perl gir en spesiell variabel $!
som inneholder en feilmelding som oppsto under siste systemoperasjon (som disk I/O). I en numerisk sammenheng, $! returnerer et meningsløst feilnummer. I en strengkontekst vil variabelen $! returnerer operativsystemets feilmelding:
åpen (MINFIL, "minfil") || die "Feil ved åpning av filen min: $! \ n";
Hvis denne funksjonen ikke kan åpne filen på grunn av dens fravær, vil følgende melding vises:
Feil ved åpning av minfil: en fil eller katalog i banen eksisterer ikke.
Ikke bruk $-variabelen! for å verifisere suksessen til systemfunksjonen. Verdien av denne variabelen er definert umiddelbart etter utførelse av en systemoperasjon (for eksempel I / O) og bare når operasjonen mislykkes. I alle andre tilfeller vil variabelen $! kan ha en helt vilkårlig meningsløs betydning.
Noen ganger må du vise en advarsel i programmet og fortsette kjøringen. For å generere advarsler, bruk funksjonen varsle
som ligner på die, bortsett fra at programkjøringen fortsetter:
if (! åpen (MINFIL ("utdata")) (
advarsel "Feil ved åpning av filutgang: $!";
) annet (
# Leser fildata ...
}
Perl har flere måter å lese filer definert av beskrivelser på. Det vanligste er å bruke filinndataoperatoren, også kalt vinkeloperatoren <>
... For å lese informasjon fra en fil, sett bare beskrivelsen i vinkelparentes og tilordne denne verdien til en variabel, for eksempel:
åpen (MINFIL, "minfil") || die "Feil ved åpning av filen min: $!";
$ linje =
Vinkeloperatoren i skalarsammenheng leser én linje fra en fil. Hvis filen slutter, returnerer vinkeloperatoren undef. En streng i en tekstfil er en sekvens av tegn avgrenset av et spesielt linjeslutttegn. I UNIX er denne funksjonen et linjeskifttegn (ASCII-kode 10), i DOS og Windows, en sekvens av vognretur- og linjeskifttegn (ASCII-koder: 13 og 10). Standard linjeterminator kan endres i Perl for å oppnå noen interessante effekter.
Du kan bruke følgende kode for å lese og vise innholdet i en hel fil (eksemplet forutsetter at MYFILE er en åpen filbeskrivelse):
while (definert ($ a =
skriv ut $ a;
}
Det er praktisk å bruke en while-løkke for å lese informasjon fra en fil. Hvis du bruker vinkeloperatoren i en while-løkke i stedet for et betinget uttrykk, tilordner Perl automatisk den angitte strengen til spesialvariabelen $ _ og gjentar loopen til filen slutter:
samtidig som (
skriv ut $ _;
}
I dette tilfellet er while-operatøren ansvarlig for å tilordne den angitte strengen til $ _-variabelen og sjekke tegnet for å nå slutten av filen. Denne interessante oppførselen skjer bare i en while-løkke, og bare når det betingede uttrykket består av en vinkeloperator. Ikke glem at i dataene som leses fra filen, i tillegg til selve teksten, er det også slutttegn. Hvis du bare vil ha tekst, bruk chomp-funksjonen for å bli kvitt tegnene på slutten av linjen.
I sammenheng med en liste, leser vinkeloperatøren hele filen og tilordner den til listen. Hver linje i filen er tilordnet det tilsvarende elementet i listen eller matrisen, som vist nedenfor:
åpen (MINFIL, "novel.txt") || dø "$!";
@ innhold =
lukk (MINFIL);
Dette eksemplet leser alle data fra novel.txt-filen gjennom MYFILE-beskrivelsen og tilordner den til @contents-matrisen. Dette tilordner den første linjen i novel.txt til det første elementet i @contents: $ contents-matrisen. Den andre linjen er tilordnet $ innhold, etc.
For å skrive data til en fil, må du først åpne selve filen for skriving. Syntaksen for å åpne en fil for skriving er nesten den samme som for lesing:
åpen (håndtak, "> bane")
oran (descrvptor, ">> bane")
Syntaksen til den første linjen er allerede kjent for oss, med unntak av symbolet >
før stien. Dette symbolet forteller Perl at nye data skal skrives til filen som følger banen. I dette tilfellet slettes allerede eksisterende data i filen og den angitte beskrivelsen åpnes for skriving. I det andre eksemplet, symbolene >>
be Perl om å åpne filen for skriving, men hvis filen allerede eksisterer, legges de nye dataene til etter de eksisterende dataene. Her er noen eksempler:
# Nye data overskriver gamle data, hvis noen
åpen (NEWFH, "> output.txt") || die "Feil ved åpning av output.txt: $!";
# Nye data legges til eksisterende.
åpen (APPFH, ">> loggfil.txt") || die "Feil ved åpning av logfile.txt: $!";
Etter å ha fullført arbeidet med en fil som er åpen for skriving, blir det av største betydning å lukke denne filen og frigjøre dens beskrivelse. Lukkfunksjonen informerer operativsystemet om at skrivingen til filen er fullført, og at dataene skal plasseres på den permanente lagringsplassen på disken, for eksempel:
lukk (NEWFH);
lukk (APPFH);
Når filen er åpen for skriving, er det veldig enkelt å legge inn data i den. Dette gjøres med den kjente funksjonen skrive ut
... Så langt har utskriftsfunksjonen blitt brukt av oss kun for å vise data på skjermen. I prinsippet kan denne funksjonen brukes til å skrive data til en hvilken som helst fil. Syntaksen for utskriftssetningen for å sende ut data til en fil er veldig enkel:
skriv ut beskrivelsesLISTE
åpen (LOGF, ">> loggfil") || dø "$!";
hvis (! Skriv ut LOGF "Opptak gjort", skalar (lokal tid), "\ n") (
advarsel "Feil ved skriving til loggfil: $!";
}
lukk (LOGF);
Du kan åpne flere filer samtidig for lesing eller skriving, som vist i følgende eksempel:
åpen (KILDE, "soursefile") || dø "$!";
åpen (DEST, "> destinasjon") || dø "$!";
@ innhold =
skriv ut DEST $-innhold; # Skriv den til en annen fil
lukk (DEST);
lukk (KILDE);
Dette eksemplet gjør en enkel kopi av filene. Forresten, du kan redusere koden noe ved å kombinere lese- og skriveoperasjoner i én setning:
skriv ut DEST
Siden utskriftsfunksjonen forventer at en liste sendes som en parameter, vil operatøren
Når du skriver binære data som GIF, EXE, MS Word-dokumenter, etc., er ingen datakonvertering nødvendig. Derfor, slik at verken Perl eller operativsystemet gjør slike konverteringer, før du skriver binære data til en fil, må du bruke funksjonen bin-modus
... Den markerer filbeskrivelsen som dobbel
personlig. Binmode-funksjonen kalles opp etter å ha åpnet filen, men før inndata eller utdata er gjort:
åpen (FH, "camel.gif") || dø "$!";
binmode (FH); # Håndtaket blir binært.
Når en fil er åpnet, kan binmode-funksjonen bare brukes på beskrivelsen én gang. Å lukke og gjenåpne binæren vil kreve at du kaller opp binmode-funksjonen igjen. Å bruke bin-modus på systemer der det ikke er noe skille mellom tekst og binære filer (som UNIX) har ingen effekt.
Før du åpner en fil, er det en god idé å forsikre seg om at den faktisk eksisterer, for å sjekke om det er en katalog, og om dette vil resultere i en feilmelding om tillatelse nektet. Perl har spesiell fil testerklæringer
... De har alle lignende syntaks:
-X filbeskrivelse
-X-bane
Hvor X er den spesifikke testoperasjonen, og file_descriptor er beskrivelsen som testes. Filen kan testes uten å åpne håndtaket.
| -r
| -r "fil" | Sant hvis les "fil" er tillatt |
| -w
| -w $ a | Sant hvis skriving til filen hvis navn er inneholdt i $ a er tillatt |
| -e
| -e "fil" | Sant hvis "fil" eksisterer |
| -z
| -z "fil" | Sant hvis "fil" eksisterer, men er tom |
| -s
| -s "fil" | Returnerer størrelsen på "fil" i byte, hvis en finnes |
| -f
| -f "fil" | Sant hvis "fil" er en vanlig fil (ikke en katalog) |
| -d
| -d "katalog" | Sant hvis parameteren "katalog" spesifiserer en katalog |
| -T
| -T "fil" | True hvis filparameteren spesifiserer en tekstfil |
| -B
| -B "fil" | True hvis filparameteren spesifiserer en binær fil |
| -M
| -M "fil" | Returnerer antall dager som har gått siden siste endring av "filen" |
print "Hvor skal vi lagre dataene?";
$ filnavn =
chomp $ filnavn;
if (-s $ filnavn) (
advarsel "Innholdet i $-filen vil gå tapt! \ n";
advare "Det har blitt endret"
-M $ filnavn, "dager siden. \ N";
}
