HTML DoInclude("D:/InetPub/wwwroot/_menu.htm"); skrive ut<

De skriver til oss:

Du er i ferd med å ta en reise inn i verden av Perl-programmering. Reisen din vil bli desto morsommere på grunn av tilstedeværelsen av et stort antall eksempler som vil bli møtt underveis. Begynnelsen av vår reise dekker de grunnleggende begrepene språk. Etter hvert vil du lære nok om Perl til å lage små programmer. På slutten av reisen vår vil du allerede ha den nødvendige kunnskapen for å kunne lage fullverdige applikasjoner.

Snakker du andre programmeringsspråk? Hvis ja, vil det være en glede for deg å lære Perl. Hvis ikke, så ikke skynd deg, prøv alle de foreslåtte øvelsene og eksemplene og ikke vær redd for å eksperimentere!

Opprinnelse

Perl var resultatet av en manns innsats, og etter hans egen innrømmelse, resultatet av hans latskap. Dette er et unikt språk, hvis essens ikke kan formidles med en enkel beskrivelse av tekniske detaljer. Perl er en sinnstilstand.

En av språkets særheter er navnet. Den har flere definisjoner. Perl sto opprinnelig for Practical Extraction Report Language. Imidlertid kaller programmerere det veldig ofte Phatologically Eclectic Rubbish Lister eller til og med Praktisk talt Alt Virkelig Likable.

La oss bruke noen minutter på å forstå hva Perl er og hvilke oppgaver som ble tildelt den da den ble opprettet. Tilbake i 1986 jobbet Larry Wall med problemet med å generere rapporter fra et stort antall tekstfiler som overlappet med hverandre. Som Unix-programmerer, og fordi oppgaven innebar å manipulere innholdet i tekstfiler, prøvde han først å bruke Awk. Men det ble raskt klart at Awk ikke var egnet for jobben, og siden han ikke hadde andre kandidater til å løse problemet, var det eneste som gjensto å finne opp sitt eget verktøy som kunne brukes i fremtiden.

I stedet for å kaste bort tid, fant Larry ganske enkelt opp et nytt programmeringsspråk og skrev en tolk for det. Dette virker som et paradoks, men det er ikke helt sant - det du gjør er alltid mye arbeid, men hvis du gjør det riktig, vil dette arbeidet definitivt lønne seg.

Larry tilbød snart skapelsen sin til Usenet-nyhetsleserfellesskapet. Brukere med tilgang til Usenet ga Perls skaper effektiv tilbakemelding, og spurte hvordan de skulle gjøre dette, det og det andre. Larry hadde ikke engang tenkt å stille mange av disse problemene til sitt lille nye programmeringsspråk.

Det nye programmeringsspråket hadde vekt på systemkontroll og tekstbehandling. Etter flere revisjoner kan den allerede bruke vanlige uttrykk, signaler og nettverkskontakter. Den ble kjent som Perl og ble raskt populær blant Unix-programmerere, og snart resten av oss.

Larry vedlikeholder ikke lenger Perl alene, men beholder sin eksklusive tittel som hovedutvikler.

Perl-programmer ligner veldig på C-programmer, kanskje fordi Perl ble skrevet i C, og kanskje fordi Larry fant noen C-konstruksjoner nyttige. Men Perl er mindre pedantisk og mye mer konsis enn C.

Perl er utformet for å hjelpe programmereren med å utføre rutineoppgaver som er for vanskelige eller dårlig bærbare for skallet, og for grove eller vanskelige å kode for C (eller et annet språk).

Når du har mestret Perl, kan du finne ut at du bruker merkbart mindre tid på å sitere forskjellige skallparametere (eller utføre C-deklarasjoner riktig) og mer tid på å lese Usenet-nyheter og gå på ski nedover fjellet. fordi Perl er et fantastisk verktøy for å hjelpe deg å bli en programmerer. "Noen av de gamle" sa: "Du bør ikke lære et programmeringsspråk som ikke radikalt endrer din forståelse av programmering." Vær trygg, når du først har lært Perl, vil du se på programmering fra et helt annet perspektiv.

De kraftige konstruksjonene til dette språket lar deg lage svært effektive løsninger og universelle verktøy med minimal innsats. Disse verktøyene kan fortsatt brukes fordi programmer skrevet i Perl er svært bærbare og klare til bruk. Som et resultat vil du ha enda mer tid til å lese Usenet-nyheter og gå på barer med venner.

Perl er veldig flink til å håndtere oppgaver på lavt nivå, spesielt siden den femte versjonen av språket ble utgitt.

Kostnad og lisens

Perl er gratis. For å være mer presis, er Perl distribuert under GNU Public License. Den komplette kildekoden og dokumentasjonen er helt gratis å kopiere, kompilere og skrive ut. Alle programmene du skriver i Perl er dine, og du kan gjøre hva du vil med dem.

I tillegg til UNIX-datamaskiner, finnes Perl også for andre plattformer - Windows, DOS, Atari, Amiga, etc.

Har du installert Perl?

Det er veldig enkelt å finne ut om du har Perl. Bare utfør følgende kommando på kommandolinjen:

Hvis du mottar en feilmelding eller har versjon 4 av Perl, kontakt systemadministratoren din eller installer Perl selv.

Ditt første Perl-program

Ditt første Perl-program illustrerer utskrift av en tekstlinje til skjermen. For å begynne må du lage en enkel tekstfil som vil inneholde Perl-programmet. Deretter kjører du programfilen.

Et Perl-program er en vanlig tekstfil som inneholder flere språkkonstruksjoner. Sistnevnte ligner vanligvis på en blanding av C, Unix shell script og engelsk. Generelt er det akkurat slik det egentlig er.

Perl-koden kan være ganske variert. Her er noen grunnleggende regler:

Innledende mellomrom i linjen ignoreres. Du kan plassere språksetningen hvor du vil: på begynnelsen av linjen, innrykket (anbefalt), eller til og med justert til høyre (men i dette tilfellet vil det være ekstremt vanskelig å lese programteksten og forstå noe som helst);

En språkkonstruksjon må ende med semikolon med mindre det er den siste konstruksjonen i en blokk eller fil, eller er en eval-setning;

Mellomrom, tabulatorer, tomme linjer er irrelevante - ett mellomrom er like godt som hundre mellomrom. Dette betyr at du kan dele opp språkkonstruksjonen i flere linjer for klarhet. En streng er vanligvis en serie tegn omgitt av anførselstegn. Kapittel 2, "Tall og strengbokstaver," inneholder en mer detaljert beskrivelse av strenger;

Alt etter "#"-tegnet ignoreres med mindre det er innenfor en linje. Bruk denne funksjonen til å gi nyttige kommentarer til koden din. Det skal bemerkes at det ikke er flere linjers kommentarer (for eksempel som i C-språket) i Perl.

I likhet med et shell-skript, består et Perl-program av alle Perl-setningene som er tilstede i en fil, sett sammen som ett stort program som skal kjøres. Det er ikke noe konsept for en hovedfunksjon, som i C, i Perl.

Datatyper brukes i programmer når variabler deklareres. Kort sagt, en datatype definerer settet med verdier som en variabel kan ta, samt settet med operasjoner som et program kan utføre på den. I Perl kan data være et tall eller en streng med tegn.

En verdi kalles en skalar mengde eller ganske enkelt en skalar. Følgende er eksempler på skalarverdier som brukes i Perl:
- Desimal: 127 eller 127,0 eller 1,27E2
- Heksadesimal: Ox7F eller 0x7f
- Oktal: 0177 (første 0 indikerer at oktal er brukt)
- String: "Hello World\n" eller "Hello World"

For eksempel bruker følgende kommando Perl debugger for å skrive ut oktaltallet 0177, som tilsvarer desimaltallet 127:

D.B.<4>r 0177 127

Perl oversetter dataene til sitt interne format. Når Perl skriver ut oktale eller heksadesimale verdier, konverteres de først til desimalformat, som vist.

Merk: Som du vil lære, lar Perl-skriptet deg bruke printf-funksjonen til å skrive ut verdier i et anropbart format, for eksempel oktalt eller heksadesimalt.

Dobbel presisjons flyttallformat brukes som intern representasjon av alle tall. Det er med andre ord ikke noe heltall blant de interne formatene. Men i de fleste tilfeller kan du ignorere dette og Perl vil gjøre alt riktig. For eksempel, hvis du bruker mengder i en kontekst der bare heltallsverdier gir mening, vil Perl automatisk avkorte selve tallet.

Merk: Hvis du programmerer i C og har brukt heltallsdivisjon med heltallsavkorting automatisk, må du ved programmering i Perl huske å utføre avkortingen manuelt ved å bruke funksjonen int().

Følgende kommando illustrerer hvordan Perl håndterer heltall og flyttall:

Skriv ut 6&3; # vil skrive ut 2 print 6.9 & 3.1 # print 7 / 2 # vil skrive ut 2.3333 ikke et heltall print int(7/3) # vil skrive ut 2

På samme måte som Perl konverterer flyttall til heltall: når et skript bruker heltallsverdier, konverterer det også tall til strenger og omvendt når en slik konvertering gir mening. For eksempel, hvis skriptet bruker tall i en kontekst der bare strenger gir mening, for eksempel når strenger sammenkobles, konverterer det tallene til strenger. På samme måte, hvis du vil bruke strenger der bare tall gir mening, konverterer Perl dem til tall. Når du arbeider med Perl-skript, trenger du vanligvis ikke bekymre deg for den interne representasjonen av skalarverdier.

Perl støtter også konseptet med boolske verdier, men har ikke en spesiell type for å beskrive dem. Som i C, anses en numerisk verdi som sann hvis den ikke er null. I tillegg behandles en strengverdi som sann hvis den ikke er lik "" eller "0". Noen boolske operatorer som f.eks<>> (større enn), returner én som verdi<истинно>og null - som<ложно>.

Derfor bør skriptet ditt ganske enkelt behandle ikke-null-verdier av både streng- og numeriske typer som boolske verdier<истинно>. Perl-skript kan gruppere skalarverdier og lage en liste. Hvis et skript lagrer en liste i en variabel, blir denne variabelen en matrise.

VARIABLER

Perl støtter tre typer variabler: skalarer, matriser og assosiative matriser. Som i C skrives variabelnavn med et skille mellom små og store bokstaver. Dermed beskriver navnene VAR, Var og var forskjellige variabler. Et skript kan ha en skalarvariabel kalt var og en matrisevariabel også kalt var. De vil være forskjellige i Perl i henhold til konteksten.

Merk: Perl-variabler er ikke-type, slik de er i C. For eksempel kan en skalarvariabel inneholde alle typer skalarer, og typecasting er automatisk. Dessuten, som du kanskje allerede har lagt merke til, trenger variabler i Perl ikke nødvendigvis deklareres. Hvis en variabel ikke er deklarert, behandler Perl den som global. Nedenfor vil du lære om deklarasjonen av variabler og deres omfang.

SKALARE VARIABLER

Som nevnt kan en skalarvariabel inneholde en enkelt verdi. I Perl begynner skalarvariabelnavn alltid med en ($). Følgende uttrykk tildeler skalarvariabelen $age verdien 35 og variabelen $name strengverdien . Utskriftsfunksjonen brukes deretter til å skrive ut verdien av hver variabel:

$alder = 35; $name = "Bob"; print ($navn,"er",$alder);

Hvis du lagrer disse uttrykkene i en fil som heter SCALAR.PL, kan du kjøre programmet slik:

C:\PERL> Perl SCALAR.PL Bob er 35

ARRASER

Som nevnt ovenfor er arrays variabler som tar en liste over skalarverdier som en verdi. Følgende Perl-programtekst illustrerer erklæringen av arrayvariabler og deres initialisering:

@days = ("søn","man","tir","ons","tor","fre","lør"); print(@dager); # vil skrive ut "sønmånedonsdag torsfredag" print($dager); # vil skrive ut "tor" @weekdays = @days; # verdi ("man","tir","ons","tor","fre") @emptylist = (); # venteliste

Referanse til typevariabler<массив>begynner vanligvis med et (@)-tegn og etterfølges av verdier i hakeparenteser (). Som i C-programmering er array-indekser for skript alltid heltallsvariabler, som vanligvis starter med en nullverdi. Du vil se unntak fra disse to reglene i eksemplene som vil bli forklart i dette kapittelet Det tredje uttrykket ($days) er et eksempel på en matrise som refererer til en skalarverdi. Siden den inneholder bare ett element, er den resulterende verdien en skalar.

Hvis du bruker tegnet ($) i stedet for tegnet (@), vil skriptet referere til en skalarverdi. Dette notatet er veldig viktig. Firkantede parenteser indikerer at skriptet refererer til en matrise. $-tegnet indikerer på sin side en referanse til en skalarverdi. Initialisering av @weekdays-matrisen gjøres ved å velge en del av @days-matrisen. I forrige eksempel ble @days-matrisen brukt uten en indeks. Når indeksen er utelatt, refererer Perl til hele matrisen. På samme måte, i forrige eksempel, ble @days-matrisen initialisert med en liste over bokstaver.

I tillegg til å tilordne bokstaver som verdier til en matrise, kan skriptet også tilordne verdiene til variabler eller til og med andre matriser til matriser, som vist nedenfor:

@stuff = ($alder, $navn) @FriendsOfMine = ("Joe","Mary", @FriendsOfYours);

Følgende eksempel bruker deler av matriser:

@helg = @dager ; # resultat ("søn", "lør") utskrift (@dager); # vil sende ut "mantsdag ons tor fredag ​​søn lørdag"

Hvis et skript bruker en matrisevariabel i sammenheng med en skalar, er verdien antall matriseelementer. En skalarkontekst er en der bare skalarverdier er meningsfulle. For eksempel bruker det følgende uttrykket skalarkonteksten for tingmatrisen for å bestemme antall elementer i matrisen. Hvis antallet elementer er større enn eller lik 2, viser skriptet en melding og avslutter kjøringen:

(@ting >= 2) || die "For mye ting!\n";

Die-funksjonen instruerer Perl til å avslutte kjøringen og gi en spesifisert melding. Hvis meldingen ikke er inneholdt, avslutter funksjonen ganske enkelt skriptet.

Perl støtter også en spesiell $#-variabelkonstruksjon som returnerer den siste indeksverdien i en matrise. For eksempel bruker følgende for uttrykk $[ for å bestemme startindeksverdien til en matrise, og $# for å bestemme det siste elementet i matrisen. I dette tilfellet, ved å bruke for uttrykk, vises verdiene til hvert av elementene:

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

Skrevet for loop kan erstattes med følgende ekvivalente uttrykk:

Skriv ut @ting;

KONTEKSTS ROLLE FOR SKALARE OG VEKTORTYPEVARIABLER

Legg merke til at listekonstruksjonsoperatoren (,) ser nøyaktig ut som den sekvensielle evalueringsoperatoren (,). Hvilken operator som brukes avhenger av konteksten den vises i, spesielt om variabelen er en skalar eller en matrise. Perl bruker listekonstruksjon i sammenheng med matriser og sekvensiell evaluering for skalarer. Tenk på følgende uttrykk:

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

Det første uttrykket initialiserer matrisen, mens det andre uttrykket setter skalarvariabelen $a_scalar til 5, og forkaster de fire første verdiene. Tenk på følgende to uttrykk:

Skriv ut $assoc(1,2); skriv ut @assoc(1,2);

Det første tilfellet vil skrive ut én verdi av en assosiativ matrise med to nøkler, mens den andre vil skrive ut to verdier av en assosiativ matrise med én nøkkel. Av de følgende to uttrykkene kopierer det første en liste, mens det andre tildeler en skalarverdi lik størrelsen på matrisen:

@x = @liste; $x = @liste;

ASSOSIATIVE ARRASER

Assosiative arrays ligner på vanlige arrays ved at de er en liste over skalarvariabler. Forskjellen er at en matrise må bruke heltallsverdier som indekser når man velger matriseelementer, mens en assosiativ matrise kan bruke verdier av enhver type for å velge array-elementer. Indeksverdiene for en assosiativ matrise kalles nøkler. Tenk på følgende eksempler:

$ages("Bob") = 35; $ages("Mary") = 25; $, = " "; # endre utdataseparator for utskriftsoperatør print @ages("Bob","Mary"); # vil skrive ut "25 35" utskriftsnøkler (%ages); # vil skrive ut "Bob Mary" for $name (keys(%ages)) (skriv ut "$name is $ages($keys)\n"; )

Som du kan se, tildeler programmet verdier til variabelen "$," (en skalarvariabel hvis navn er et komma). Skriptet bruker dette uttrykket slik at når utskriftssetningen brukes senere, vil ikke utdataene slå seg sammen med hverandre. Spesielle variabler som "$," diskuteres senere i dette kapittelet. Assosiative arrays identifiseres ved hjelp av krøllete klammeparenteser. Som med matriser, brukes ikke indekser når det refereres til en hel assosiativ matrise. For eksempel bruker link@ages("Bob", "Mary") indekser i parentes, som peker til en assosiativ matrise. @-prefikset indikerer at vi snakker om en matrise. På samme måte indikerer bruk av et dollartegn foran en matrise at en skalar mengde brukes.

Merk: Hvis to nøkler er spesifisert, så indikerer dette sammen med @-tegnet at vi snakker om en del av en assosiativ matrise og resultatet skal være i form av en liste. Dette uttrykket tilsvarer #ages(" Bob"), #ages("Mary"). som har verdien (35, 25).

Print keys(%ages)-uttrykket kaller nøkkeloperatøren, som returnerer hele listen over nøkler i den assosiative matrisen. En %ages-referanse med et prosenttegn som prefiks betyr at referansen refererer til hele den assosiative matrisen. Merk at for-løkken refererer til variabler i doble anførselstegn. Til slutt, det siste eksemplet som ble diskutert bruker også nøkkeloperatoren og introduserer en for-løkke for å skrive ut alle kombinasjonene av den assosiative matrisen. For-løkken refererer til variabler i doble anførselstegn. Perl vil på sin side erstatte verdiene referert til av variablene mens den analyserer strengen. Programmerere kaller denne prosessen variabel substitusjon eller interpolasjon.

Merk: Perl tolker ikke variabler som inneholder strenger med anførselstegn.

PERL OPERATØR

Mens Perls data og variabeltyper er ganske forskjellige fra C, bør Perls operatorer og uttrykk føles mye mer kjente. Alle C-operatorer er til stede i Perl bortsett fra type-operatoren, *ptr contents-operatoren og var.member eller var->member-operatoren. I tillegg introduserer Perl mange nye operatører for bruk i operasjoner som strengsammenligning og strengmanipulering.

ARITMETISK OPERATØR

Aritmetiske operatorer opererer på numeriske verdier og resultatet deres er et tall. Hvis et uttrykk inkluderer strengoperander, konverterer Perl strengverdiene til numeriske verdier før uttrykket evalueres. Perl konverterer strenger til tall på en lignende måte som funksjonen C atof() i kjøretidsbibliotekene. Perl støtter for øyeblikket følgende aritmetiske operatorer:
- + tillegg
- - subtraksjon eller endring av fortegn
- * multiplikasjon
- / divisjon (kun for flytende kommatall)
- % modulo (bare for heltallsverdier)

La oss se på følgende eksempler aritmetiske operasjoner Perl-språk:

$x = 2,5; $y = 3; print ($x + 2*$y); # vil skrive ut 8.5-utskrift (7 / $y); # vil skrive ut 2.3333333 print int (7 / $y); # vil skrive ut 2 utskrifter (7 % $y); # vil skrive ut 1 utskrift (7,5 % $y); # vil skrive ut 1

Merk: I Perl resulterer divisjonsoperatoren alltid i et flyttall, og resultatet av å ta ett tall modulo et annet er et heltall, og begge operandene konverteres først til en heltallstype.

Tenk på følgende modulo-operasjon:

Print (7,9 % 3,6); # vil gi ut 1 samme (7 % 3) = 1

Perl støtter også inkrement- og dekrementoperatorer:
- ++ reduksjon i prefiks- eller postfiksform
- - økning i prefiks- eller postfiksform. La oss se på eksempler på inkrement- og dekrementeringsoperasjoner:

$x = 4; +$x; skriv ut $x; # vil skrive ut 5 $y = $x-; # vil redusere x etter å ha tildelt y verdien av x print "$y $x" # print 5 4

Til slutt gir Perl en aritmetisk operator for eksponentiering (**). Tenk på følgende eksempler på bruk av eksponentieringsoperasjonen:

$x = 2 ** 3; # resultat 8 $x = 2 ** 0,5; # Kvadratrot fra 2 $x = -2 ** -3; # 1/(-2 terninger), resultat -1/8 (-0,125)

TISE OPERATORER

Bitvise operatorer opererer på den binære representasjonen av heltall og har et heltallsresultat. Hvis operanden er en streng eller en brøk, konverterer Perl den først til et heltall og behandler operanden ved å bruke 32-bits representasjonen. Alle C bitvise operatorer er representert i Perl:
- | bitvis ELLER
- & bitvis OG
- ^ bitvis eksklusiv ELLER
- ~ bit inversjon
- << сдвиг влево
- >> skift til høyre

Tenk på følgende eksempler på bitvise operasjoner:

$x = 5; #101 i binær $y = 3; #011 i binær utskrift $x | $y; # 7 (111) print $x & $y; # 1 (001) print $x ^ $y # 6 (110) print $x & ~1; # 4 (100) utskrift $x<< 2 # 20 (10100) print $x >> 1 # 2 (10)

Som i C avhenger oppførselen til høyreskiftoperatorer av språkimplementeringen når operanden er negativ.

SAMMENLIGNING OPERATØRER

Sammenligningsoperatorer sammenligner verdiene til to operander. Akkurat som når du jobber med aritmetiske operatorer, Perl konverterer strengoperander til numeriske operander før sammenligningen utføres. For å tillate et skript å sammenligne strenger som ikke er tall, har Perl flere strengsammenligningsoperatorer. Disse operatorene sammenligner strenger ved å bruke ASCII-verdier. Hvis en numerisk verdi er gitt som operanden til en strengsammenligning, konverteres den først til en streng. Tabell 12.1 viser sammenligningsoperatorer:

Tallstreng Verdi = = eq lik!= nе ikke lik > gt større enn< it меньше чем >= gе større enn eller lik<= lе меньше или равно <=>cmp ikke lik (signert resultat)

Bord 12.1. Perl-sammenligningsoperatører.

Resultatet av en sammenligningsoperasjon er ett hvis sammenligningen er sann og null ellers. Men den siste operasjonen (<=>eller cmp) kan returnere verdiene -1, 0 eller 1 avhengig av om verdien til den første operanden er mindre enn, lik eller større enn den andre.

Merk: Perls cmp-operator oppfører seg på samme måte som C-runtime-bibliotekets Strcmp()-funksjon.

Tenk på følgende sammenligningseksempel:

$x = 5; # x er lik 5 print ($x< 4); # если false, то выведет 0

LOGISKE OPERATORER

Logiske operatorer analyserer boolske uttrykk og returnerer verdier<истинно>eller<ложно>som et resultat. Perl behandler operandene til logiske operasjoner som boolske verdier, dvs. som sant eller usant.

Perls logiske operatorer inkluderer følgende:

Perl behandler alltid boolske uttrykk fra venstre til høyre. I tillegg. Perl slutter alltid å evaluere hvis den allerede utførte evalueringen er tilstrekkelig til å bestemme verdien av resultatet. I tillegg til de generelle logiske operatorene, støtter Perl følgende ekstra logiske operatorer:

Den logiske negasjonsoperatoren (!) erstatter verdien av en boolsk verdi med dens motsatte verdi. Akkurat som i C, har Perl en betinget operator (
-:) bruker tre operander. Et uttrykk som bruker en betinget operator har følgende form:

Betingelse
- sant-resultat: usant-resultat

På samme måte bruker følgende uttrykk en betinget operatør for å gi Bob full tilgang og alle andre begrenset tilgang:

$access = ($user eq "Bob"
- "Full" : "Begrenset");

Sekvensiell operatør<,>(også kjent som kommaoperatoren) er ikke en helt logisk operator fordi den ikke undersøker sannheten til operandene. Perl evaluerer operandene til den sekvensielle operatoren fra venstre til høyre og returnerer verdien til operanden lengst til høyre. Følgende eksempel illustrerer bruken av kommaoperatoren i en for-løkke.

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

STRING OPERATØRER

Siden Perl er et tekstbehandlingsspråk, er det ikke overraskende at det inkluderer ekstra operatører for å manipulere strenger. Følgende er strengbehandlingsoperatorene:
-. strengsammenkobling
- x replikering
- =~ variabel mønstertilpasning
- !~ den samme som den forrige, men med den ekstra negasjonen av resultatet

De to første påstandene illustreres enkelt med et eksempel:

Skriv ut "b". "en" x 2. "en"; # vil skrive ut "banan"

Som vist bruker dette uttrykket strengsammenkobling og replikeringsoperatoren for å skrive ut strengen .De to siste operatorene brukes til å teste om en strengoperand inkluderer et gitt mønster. Denne problemstillingen diskuteres i detalj i avsnittet<Регулярные выражения>. Følgende eksempel illustrerer bruken av dem:

$var = "banan"; print ($var =~ /ana/)
- SANN: USANT;

I dette tilfellet ble testoperatoren for mønsterstrengforekomst (=~) brukt for å sjekke om mønsteret ana er i $var-variabelen. I i dette tilfellet uttrykket får verdien<истинно>.

OPPDRAG OPERATØR

Hvis du er kjent med programmeringsspråket C, bør formene til Perls oppdragsoperatører være ganske kjent for deg. Akkurat som i C, tvinger disse operatørene Perl til å utføre spesielle operasjoner på verdiene som vises på høyre side av operatøren og deretter utføre en oppgave:

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

LVERDI I Perl, som i C, er en lverdi navnet på det som vises på venstre side av tildelingsoperatoren. Dermed representerer en lverdi en enhet som kan tildeles en verdi, for eksempel kan en lverdi være en variabel. Et Perl-skript kan for eksempel ikke tilordne en verdi til en streng med tegn, for eksempel uttrykket = 32 fordi er ikke en lverdi. Skriptet kan imidlertid tilordne en verdi til $Bob, for eksempel $Bob = 32, siden $Bob er en lverdi. I Perl er vanligvis enhver enhet som kan brukes som en lverdi. For eksempel pakker og pakker det følgende uttrykket ut en liste med verdier, med listen over variabler i det første tilfellet og tre skalarer i det andre er lverdier:

@farge = ($r, $g, $b); # fargepakke ($r, $g, $b) = @color; # farge unboxing

Når du jobber med lister i Perl, gjelder ikke nødvendigvis oppdragsoperatøren for hele listen. Skriptet kan tilordne verdier til individuelle listeelementer, som vist nedenfor:

@elementer = (100 200 300);

I dette tilfellet tildeler operatøren en verdi til tre elementer i listen. På samme måte pakker følgende uttrykk ut elementene i en liste, og tildeler verdiene til de to første elementene til to skalarvariabler, og resten av matrisen til en listevariabel:

($arg1,$arg2,@rest) = @ARGV; # du kan blande skalarer og matriser

OPERASJONER FOR ARBEID MED LISTER

Operasjoner for å jobbe med lister inkluderer følgende:

Listekonstruktør - .. omfangsoperator - x replikeringsoperator

Du har allerede brukt listekonstruktøren til å initialisere arrays og lage en liste over variabler som brukes som lverdier. Områdeoperatoren returnerer som sin verdi en sekvens av heltall som starter fra venstre operand og fortsetter til og med høyre operand. Skript bruker ofte omfangsoperatoren i forbindelse med en listekonstruktør for å lage lister. For eksempel bruker følgende uttrykk scope-operatoren til å lage en liste kalt @digits som inneholder tallene null til ni:

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

På samme måte kan dette uttrykket bruke omfangsoperatoren til å lage et omfang av endringer i matriseindekser Anta at listen @days inneholder ukedagene (starter med søndag). Følgende uttrykk tildeler @weekdays listeverdier fra mandag til fredag:

@helg = @dager;

Til slutt bruker følgende uttrykk to områdeoperatorer for å lage en liste over heksadesimale sifre:

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

Replikeringsoperatoren lager ganske enkelt kopier av en gitt oper og det angitte antallet ganger. For eksempel gjentar følgende uttrykk listen over verdier 1, 2, 3 tre ganger:

OPERATØRER FOR ARBEID MED FILER

Perl inneholder en omfattende liste over operatører for arbeid med filer. Det er minst 27 operatører som returnerer spesifikk informasjon om en fil uten engang å åpne den. Mange Perl-utsagn er rettet mot UNIX-systemer, men følgende utsagn fungerer på alle systemer:

D ser etter katalogeksistens
--e bestemmer tilstedeværelsen av en fil
--s spesifiserer filstørrelse
--w bestemmer om den gitte filen kan skrives til

De neste to filoperatorene returnerer en boolsk verdi.Den tredje operatoren returnerer filstørrelsen i byte. Følgende tekst illustrerer bruken av disse operatørene:

If (-e,"perl.exe") ( skriv ut "Filstørrelse er:" -s "perl.exe"; ) else ( skriv ut "kan\" ikke finne perl.exe\n"; ) (-w "SomeFile ") || die "Kan ikke skrive til SomeFile\n";

OPERATORENS UTFØRELSESPRIORITETER

Som et hvilket som helst programmeringsspråk, bestemmer Perl utførelsesprioritetene til operatører, ved hjelp av hvilken rekkefølgen av deres utførelse er bestilt. Tabell 12.2 viser operatørprioritetene fra høyeste til laveste:

Bord 12.2. Perl-operatørprioritet fra høyeste til laveste

I skriptet ditt kan du endre rekkefølgen setningene utføres i ved hjelp av parenteser.

PERL KONSTRUKTER

Perl støtter alle C-uttrykk ved å bruke et nesten identisk format. Kontroll konstruerer for eksempel hvis, mens, gjør det. for og goto brukes i samme form på begge språk. Som du vil se senere, har fortsett-setningen en litt annen betydning i Perl. Dens tidligere verdi kalles nå neste, og bruddsetningen kalles nå sist. Perl implementerer ikke en switch-setning. I tillegg kan noen C-språkuttrykk finnes i Perl i andre formater, og mange nye uttrykk er lagt til.

ENKLE OG KOMPOSITT OPERATORER

Et enkelt uttrykk er en hvilken som helst gyldig kombinasjon av operatorer og operander. I Perl er en operator et uttrykk som slutter med semikolon. Som i programmeringsspråket C, slutter alle utsagn med semikolon. Når du sender ut programtekst til feilsøkeren, kan du utelate semikolon fordi feilsøkeren vil levere det for deg. Følgende tekst illustrerer en enkel oppdragsoperatør i Perl:

$Title = "Webprogrammering"; !}

Akkurat som C-programmering, kan Perl-skript inneholde setningsblokker, eller sammensatte setninger, som er plassert inne i krøllete klammeparenteser (()), som vist nedenfor:

(#Operatorer#En annen operatørblokk)

Skriptene dine vil gjøre omfattende bruk av instruksjonsblokker sammen med mer komplekse utsagn. Som i C, kan Perl-skript bruke blokker med setninger for å definere omfanget av lokale variabler. Definisjonen av lokale variabler i en blokk er imidlertid ikke automatisk. Skriptet må bruke det lokale nøkkelordet for å deklarere dem. Vi skal se nærmere på omfanget av variabler senere i dette kapittelet.

BETINGEDE OPERATØRER

Mange av de tidligere eksemplene brukte if-setningen. I Perl er if-setningen nesten identisk med if-setningen i C. Forskjellen er imidlertid at i C kan if-setningen bruke en enkel setning uten krøllete klammeparenteser, mens i Perl må utsagn omsluttes av krøllete klammeparenteser, danner en blokk.

If (uttr.) uttalelse; // akseptabelt for C, men ikke for Perl if (expr) ( setning; # dette er hvordan du bør gjøre det i Perl)

På samme måte fungerer Perls else-utsagn litt annerledes enn tilsvarende utsagn i C. I Perl må utsagn også være omsluttet av krøllete klammeparenteser og danne en blokk:

// Eksempel i C er ikke akseptabelt i Perl hvis (uttr1) statament1; annet hvis (uttr2) setning2; annet ststement3;

Følgende viser at Perl lar deg bruke elsif-konstruksjonen:

If (uttr1) ( statament1; ) elsif (uttr2) ( statement2; ) else ( ststement3; )

OPERATØR MED MINDRE

I programmeringsspråket C bruker programmerere logisk negasjon (!) for å reversere en boolsk verdi, som vist nedenfor:

Hvis (!(uttr)) // Negasjon i C ( setning; )

Sammen med bruken av logisk negasjon inneholder Perl-skript ofte en unless-setning, som gjør det samme som C-koden ovenfor.

Med mindre (uttr.) ( setning; )

Merk: I motsetning til C, inneholder ikke Perl en switch-setning.

GJØR OPERATØR

Et spesielt tilfelle av blokkoperatorer er do-operatoren, som lar en blokk med utsagn returnere verdier. Verdien som do-setningen returnerer er verdien av det siste uttrykket som ble evaluert i blokken. Følgende do-setning sammenligner for eksempel strengvariabelen $Month med månedene i året og setter variabelen $DayCount til antall dager i måneden:

$DayCount = do ( if ($Month eq "September" || $Month eq "April" || $Month eq "Juni" || $Month eq "November") ( 30; ) elsif ($Month eq "February" ) ($Year & 3
- 28:29; # Sjekk for skuddår ) else ( 31; ) );

Merk at Perl krever et semikolon på slutten av do-blokken. Ikke forveksle do-blokken med do while-setningen, som vil bli diskutert senere i dette kapittelet.

SYKLER OG GRENER

Perl støtter for, while og do loop-setninger med mindre forskjeller fra implementeringen i C. Den vesentlige forskjellen er at Perl krever at setninger brukes i blokker omsluttet av krøllete klammeparenteser. Som du vil se, utvider Perl også løkkekonstruksjonen for å gi noen nye former. I de følgende eksemplene fungerer for-, while- og do-løkkene på samme måte i C og Perl:

For($i = 0; $i< 100;$i++) { printf("%d\n", $i) ; } while ($i >0) ( printf("%d\n", $i-); ) gjør ( printf("%d\n", $i++); ) mens ($i< 0);

Utformingen av loops i C er også forskjellig fra den i Perl ved at Perl ikke inneholder en break-setning, og continu-setningen utfører en helt annen funksjon. Heldigvis gir Perlo noen nye, mer fleksible og mer intuitive konstruksjoner:

For å forstå løkkekonstruksjoner i Perl, må du forstå bruken av fortsettelsesblokken. Tenk på følgende while-løkke, som inneholder en fortsettelsesblokk:

$i = 100; mens ($i > 0) ( skriv ut $i; ) fortsett ($i-)

Du kan tenke på en fortsettelsesblokk som det tredje uttrykket i en for-løkke som utføres hver iterasjon. På samme måte utfører Perl en fortsettelsesblokk på slutten av hver iterasjon. Men som du vil lære senere, gir Fortsett-blokken skriptet mer kontroll over prosessen enn en for-løkke gir. Når en Perl-sløyfe bruker en neste setning, kjøres den kontinuerlige blokken fortsatt hvis den eksisterer. Men hvis løkken bruker en redo-setning, kjøres ikke fortsett-blokken.

TAGGER

I et Perl-skript betyr etiketter ganske enkelt et navn som tilsvarer en posisjon i skriptet. Etikettnavn slutter med kolon (for eksempel ytterløkke:). Ved å bruke goto-setningen kan skriptet hoppe til en etikett. I tillegg kan de siste, neste og redo-operatorene brukes til å hoppe til en etikett. Følgende kode illustrerer bruken av den siste operatoren for å hoppe til en etikett:

Outerloop: while ($i > 0) ( while ($j > 0) ( #Noen annen prosess her if ($needToAboutLoop) ( siste outerloop; ) ) )

I dette tilfellet inneholder instruksjonen en siste gren for å hoppe til yttersløyfen og avslutte sløyfen.

TIL LOOP

En annen sløyfekonstruksjon i Perl er inntil-løkken, som er det motsatte av while-løkken. Husk, i en while-løkke, utføres setninger så lenge den angitte betingelsen er oppfylt. I en inntil-løkke, derimot, blir instruksjoner utført til en betingelse er oppfylt. Tenk for eksempel på en while-løkke som den som vises på neste side.

Mens (!(uttr)) ( setning; )

Ved å bruke en inntil-løkke kan du lage en identisk løkke vist nedenfor:

Inntil (uttr.) ( uttalelse; )

På samme måte bruker følgende do while-setning den logiske negasjonsoperatoren til å løkke til et gitt boolsk uttrykk evalueres til sant:

Gjør ( setning; ) mens (!(uttr));

Ved å bruke gjør til-konstruksjonen kan du danne en identisk sløyfe uten å bruke logisk negasjon:

Gjør ( setning; ) til (uttr);

FOR OG FORHVER SYKLER

Perl støtter løkker på en veldig lik måte som C:

For (påstand1; uttrykk; utsagn2) (utsagn3; )

For eksempel bruker følgende kode en for-løkke for å skrive ut verdiene til tall fra 0 til 100:

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

I tillegg inkluderer Perl en foreach loop-konstruksjon som lar et skript iterere over lister og arrays. La oss se på et eksempel:

@list = ("a","b","c"); foreach $arg (@list) ( skriv ut "Listeelement: $arg\n"; ) foreach $i (1..10) ( skriv ut "iterasjon $i\n" )

I det første tilfellet itererte foreach-løkken gjennom verdiene til @list-variabelen. I det andre eksemplet itererer foreach-løkken over tall i området fra 1 til 10. Foreach-løkken kan inneholde en liste over bokstaver eller en matrise, som illustrert i forrige eksempel. Etter én iterasjon av løkken, tar en spesiell skalarvariabel ($arg i det første tilfellet og $i i det andre tilfellet) en verdi fra den gitte listen over elementer. Omfanget av denne skalarvariabelen i en foreach loop er begrenset til sløyfens kropp. Derfor vil en skalar løkkevariabel, foreach, ikke komme i konflikt med et identisk variabelnavn definert utenfor løkken. Følgende kode bruker en variabel kalt $i innenfor og utenfor en foreach loop:

$i = 1001; foreach $i (1..9) ( skriv ut "$i\n"; # loop vil skrive ut 123456789 ) skriv ut "$i\n";

Som du kan se fra dette eksemplet, er ikke $i-variabelen som brukes til å organisere loop-iterasjonene i konflikt med $i-variabelen definert utenfor loopen. En funksjon ved foreach-løkken som skriptene dine kan dra nytte av, er muligheten til å endre matriseelementer. (Vær forsiktig når du implementerer denne funksjonen!) Tenk på følgende foreach-løkke, som legger til verdien 10 til hvert matriseelement:

@liste = 1..5; foreach $i (@list) ( $i += 10; ) $, = " "; skriv ut @liste; # vil gi ut 11 12 13 14 15

La oss gjøre noen siste notater om foreach loop. Perl behandler navnene både for og for som synonymer. Derfor kan du bruke disse navnene om hverandre i skript. Perl vil på sin side bestemme typen løkke basert på konteksten.

UBEtinget JOBB-FØRER GÅ TIL

Perl støtter goto-operatoren, som er identisk med C-programmeringsspråkoperatoren. Nedenfor er et eksempel på bruk av goto-operatoren for å skrive ut tall fra 1 til 10:

$i = 1; loop: print $i++, " "; hvis ($i<=10) { goto loop; }

OPERATØRMODIFIKASJONER

Perl bruker spesielle former for if, unless, while og til-konstruksjonene for å kontrollere fremdriften av beregninger. I visse tilfeller kan disse spesielle konstruksjonene gjøre koden din klarere og lettere å lese. For å gjøre koden lettere å lese og dens betydning mer åpenbar, er det tilrådelig å velge et passende format for opptak. Tenk på et watch-uttrykk som bruker die-funksjonen for å avslutte skriptet hvis verdien av $count-variabelen er mindre enn 10:

Hvis ($count< 10) { die; }

Ved å plassere terningsfunksjonen foran if-setningen, som vist nedenfor, vil antall kodelinjer reduseres:

Dø hvis ($count< 10);

På samme måte kan det samme uttrykket skrives som følger:

($count >= 10) || dø;

I dette tilfellet, hvis $count-variabelen er større enn eller lik 10, stopper Perl videre evaluering på den linjen og die-funksjonen blir ikke utført. Ellers, hvis $count-variabelen er mindre enn 10, etter å ha evaluert den første delen av uttrykket kjører koden die-funksjonen og avslutter dermed utførelsen av skriptet. Til slutt, i følgende eksempel, reduserer bruk av unless-konstruksjonen også antall linjer til én:

Dø med mindre ($count >= 10);

På samme måte er følgende while-løkker identiske:

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

Som du kan se, ved å bruke en modifikasjon av designet, lar skriptet deg redusere antall linjer i løkkeinngangen til én. På samme måte er følgende inntil-løkker likeverdige:

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

Merk: I alle fire tilfeller, selv om uttrykket som skal evalueres kommer etter setningen som skal utføres, evaluerer Perl først betingelsen og bare deretter utfører setningen.

GENERER DYNAMISKE UTTRYKK VED HJELP AV EVAL-FUNKSJONEN

Fordi Perl er et tolket språk, kan skriptene dine bruke Perl til å generere kode<налету>, det vil si dynamisk under kjøring av skript. Dette er nøyaktig hvordan Perl-feilsøkeren (som i seg selv er et Perl-program kalt Perldb.PL) fungerer. Når du designer skript, kan du bruke slik dynamisk kode for å lage dynamiske variabler eller til og med bygge spesielle rutiner. Perl evaluerer dynamiske uttrykk ved å bruke evalfunksjonen. Følgende eksempel oppretter en dynamisk instruksjon ved å tilordne verdien av en variabel til tekst, som faktisk inneholder den nødvendige Perl-instruksjonen. Ytterligere instruksjoner bruker eval-funksjonen for å utføre denne instruksjonen:

$perl_statement = "skriv ut "Hei verden\n";"; eval $perl_statement; # vil skrive ut Hei, verden $i = 1001; $varname = "$i"; print eval $varname; # vil skrive ut verdien av $i

Merk: Det er farer ved å bruke eval-funksjonen i et skript, spesielt hvis skriptet sender brukerlevert data til eval-funksjonen. Ved å bruke eval-funksjonen kan et skript utføre en vilkårlig Perl-kommando, inkludert systemkommandoer. Dette gir brukeren kontroll over programmet, som kan være spesielt risikabelt på Internett og web.

SUBRUTINER

Som alle strukturerte programmeringsspråk, støtter Perl rutiner. En subrutine kan defineres ved å bruke undernøkkelordet som vist nedenfor:

Sub demo_sub ( skriv ut "demo_sub kalt\n"; ) &demo_sub; # subrutineanrop

I dette tilfellet danner instruksjonene en subrutine kalt demo_sub. For å kalle en subrutine, plasserer skriptet et og-tegn (&) foran subrutinenavnet. Når du kaller en subrutine i Perl, kan parentesene utelates. Du kan plassere en rutine hvor som helst i et skripts kildekode fordi Perl vil analysere all kildekoden før skriptet kjøres. Du kan deklarere en subrutine i kildekoden umiddelbart etter første gangs bruk av subrutinen (forward reference). Subrutiner kan ha argumenter og returverdier. Følgende kodebit inneholder en rutine kalt show_value som skriver ut verdien mottatt av rutinen som en parameter:

Sub show_value ( skriv ut "Verdien id ", $_; ) &show_value(1001);

Formelt erklærer ikke en Perl-rutine variabler for å lagre argumenter. I stedet sendes en matrisevariabel kalt @_ til rutinen, som inneholder parameterverdiene. I sin tur får rutinen tilgang til verdiene til argumentene ved å bruke følgende notasjon for matriseelementer: $_, $_, etc. Denne metoden for å sende parametere kan imidlertid svekke lesbarheten til koden, og derfor bruker de fleste rutiner kopiering av argumenter til lokale variabler. I likhet med forrige eksempel, viser følgende show_fwo_values-rutine verdiene til to parametere:

Sub show_two_values ​​(skriv ut "Første parameter ", $_, "\n"; skriv ut "Andre parameter", $_, "\n"; ) &show_two_values(1001, 2002);

Til slutt, den neste funksjonen, show_all_values, skriver ut verdiene til alle parameterne den mottar. Funksjonen bruker en matrise for å definere et tall som en parameter:

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

Som nevnt kan Perl-rutiner returnere verdier. Til dette brukes returoppgaven. I motsetning til C-språket, krever ikke Perl bruk av en returerklæring. Hvis rutinen ikke inneholder en retursetning, vil det siste evaluerte uttrykket bli tatt som returverdi. Følgende eksempel legger til to parametere og returnerer resultatet:

Sub add_values​( return $_ + $_; ) print "Resultatet er: ", &add_values(1001,2002);

BIBLIOTEK AV SUBRUTINER

I motsetning til C, støtter ikke Perl faktisk konseptet med et bibliotek. Den har imidlertid en mekanisme som lar skript bruke kildekode fra en annen fil. Anta for eksempel at du lagrer add_valuesl-rutinen i en fil som heter addvalue.pl. Ved å bruke require-setningen kan et annet Perl-skript få tilgang til den rutinen, som vist nedenfor:

Krev "addvalue.pl"; skriv ut &add_values(10,11);

Du kan tenke på require-setningen som analog med C-preprosessorens #include-setning. For å finne en kildefil, ser Perl først i standardkatalogen for Perl-biblioteket (se installasjonsinstruksjonene for detaljer), og deretter i gjeldende katalog. Du kan også bruke en absolutt eller relativ bane vedlagt filnavnet. Perl husker hvilke filer som ble forespurt av require-setningen og laster dem bare én gang, selv om disse filene åpnes flere ganger. Det er mange standardbiblioteker som utvider mulighetene til Perl-språket. Nå er et godt tidspunkt å vandre gjennom katalogen der Perl-biblioteksfilene er lagret for å få en ide om mulighetene de tilbyr.

BRUKE PAKKER FOR Å ISOLERE SUBRUTINER

Hvis du har mange rutiner, spesielt rutiner som du lagrer i forskjellige filer, kan variabelnavnkollisjoner oppstå når samme variabelnavn brukes til forskjellige formål. Perl hjelper til med å unngå dette med pakker. Som du vet, ved å deklarere lokale variabler for subrutiner, kan du unngå navnekollisjoner. Men hvis flere rutiner deler spesifikke data, kan disse dataene kreve et globalt omfang, noe som kan føre til navnekollisjoner. Ved å bruke pakker kan du gruppere globale data i private navnerom, utenfor de hvis globale variabler ikke er synlige, dvs. ukjente. . Tenk på det enkle eksemplet nedenfor, der to rutiner (plassert i forskjellige filer) bruker private, individuelle navnerom.

# Kode i fil one.pl sub sub_one ( pakke demo_one; $some_data = 10; ) # * * * * * * * * # Kode i fil two.pl sub sub_one ( pakke demo_two; $some_data = 20; )

Som du kan se, bruker den første rutinen pakkenavnet demo_one, den andre rutinen bruker pakkenavnet demo_two. Begge rutinene kan angi og bruke $some_data-variabelen uten å forårsake en navnekollisjon mellom en global variabel og den andre. Manus<знает>navnet på pakken som variabelen ligger innenfor og organiserer tilgangen til den, bruker pakkenavnet som et prefiks til variabelnavnet. Følgende eksempel legger til pakkenavnet pakke_en eller pakke_to som et prefiks til variabelnavnet noen_data:

&sub_one; &sub_two; skriv ut "Variabel 1 $package_one"noen_data\n" skriv ut "Variabel 2 $pakke_to"noen_data\n"

Når du bruker Perl-pakker, kan du opprette et unikt navneområde i gjeldende kildefil ved å plassere en pakkesetning i begynnelsen av filen, som vist nedenfor:

Pakke some_package_name $some_data = 1; sub some_sub ( returner $some_data; )

I dette tilfellet eksisterer $some_data-variabelen bare i pakken og er derfor beskyttet mot feil tilgang. Å bruke en pakke gir altså dataene samme omfang som i programmeringsspråket C, hvor globale variabler har sitt omfang i kildekodefilen de er deklarert. Når du kaller en rutine fra en annen skriptfil, må du bruke pakkenavnet:

Krev "some_package.pl"; skriv ut &some_package_name"some_sub;

RADBEHANDLING

I de forrige eksemplene lærte du hvordan du konstruerer strengliteraler ved hjelp av variabel interpolasjon. Du har også lært hvordan du kan sette sammen strengliteraler og strengvariabler. I denne delen ser du at Perl har et stort sett med funksjoner som skript kan bruke til å manipulere strenger.

CHOPPEFUNKSJON

Chop-funksjonen fjerner det siste tegnet i en streng. Den har følgende format:

$character = hogge(Str);

Chop-funksjonen returnerer det fjernede tegnet. Perl-skript bruker utstrakt bruk av chop for å fjerne nylinje- og linjeslutttegn.

INDEKSFUNKSJON

Indeksfunksjonen søker etter en gitt delstreng i en streng. Den har følgende format:

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

Indeksfunksjonen returnerer indeksen for den første forekomsten av en delstreng (SubStr) i en streng (Str). En forskyvning kan eventuelt spesifiseres, hvoretter søket begynner. Hvis delstrengen blir funnet, returneres verdien -1. I det følgende eksempelet søker indeksfunksjonen etter forekomster av understrengen "na" etter det tredje tegnet i strengen "banana":

Skriv ut indeks("banan","na",3); # Utskrifter 4.

Rindex-funksjonen ser etter den siste forekomsten lengst til høyre av en delstreng i en streng og returnerer posisjonsverdien til det første tegnet i delstrengen. Funksjonen har følgende format:

$location = rindex(Str, SubStr);

Denne funksjonen ligner på indeksfunksjonen, bortsett fra at den returnerer den siste forekomsten i stedet for den første. For eksempel bruker følgende eksempel funksjonen rindex for å bestemme siste forekomst av delstrengen "na" i strengen "banana":

Skriv ut rindex("banan","na"); # Utskrifter 4

LENGDEFUNKSJON

Lengdefunksjonen returnerer antall tegn i en streng. Den har følgende format:

$len = lengde(Str);

Følgende eksempel bruker lengdefunksjonen til å skrive ut antall tegn i en streng:

Utskriftslengde("banan"); # Utskrifter 6

SUBSTR FUNKSJON

Substr-funksjonen brukes til å fjerne en del av en streng. Den har følgende format:

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

Funksjonen returnerer en delstreng, det vil si en del av en streng hvis lengde ikke overskrider verdien spesifisert av den valgfrie Len-parameteren. Den returnerte delstrengen til str begynner ved tegnet på posisjonen spesifisert av Offset. Hvis Len-parameteren utelates, inneholder den returnerte strengen tegn til og med slutten av linjen. Hvis Offset-parameteren er negativ, beregnes offset fra slutten av linjen. Til slutt kan skriptet bruke substr som en lverdi for å utføre en tildelingsoperasjon. Følgende kodebit illustrerer bruken av substr-funksjonen.

Skriv ut substr("oransje",3); #Outputs "nge" print substr("oransje",-2); # Skriver ut "ge" print substr("orange",2,2); # Skriver ut "an" $str = "eple"; substr($str,-3) = "rikot"; skriv ut $str; # Trykker "aprikos"

Merk: Å bruke Perl-operatorer for regulære uttrykk er ofte mer effektivt enn å bruke substr-funksjoner. Regelmessige uttrykk diskuteres senere i dette kapittelet.

BLI MED FUNKSJON

Sammenføyningsfunksjonen slår sammen en liste over elementer i en streng, og skiller hvert element med et gitt tegn. Den har følgende format:

$ny_streng = join(Str,Liste);

Sammenføyningsfunksjonen konverterer hvert element i en liste til en streng og kobler sammen strengene. Følgende kodebit illustrerer bruken av join-funksjonen:

$str = join(",", 0..4,10,20); # Listen vil være "0,1,2,3,4,10,20" $strn = join ("\t", $a, $b, $c);# Blander listene

SPLIT FUNKSJON

Splitt-funksjonen deler innholdet i en streng i en liste med elementer. Den har følgende format:

Split(Delimeter, Str[,Limit]);

Delimeter-argumentet spesifiserer tegnet som skal deles med, for eksempel mellomrom, ord, tabulator osv. e. Den valgfrie grenseparameteren spesifiserer det maksimale antallet elementer listen kan inneholde. Følgende eksempel illustrerer bruken av split-funksjonen.

FUNKSJONER FOR BEHANDLING AV LISTER

I eksemplene diskutert tidligere i dette kapittelet lærte vi hvordan du lager en liste, lagrer den som verdien av en variabel, itererer gjennom alle elementene i listen og får tilgang til et enkelt element i listen. I denne delen lærer du noen flere funksjoner som utvider listene dine.

REVERS FUNKSJON

Reversfunksjonen reverserer elementene i en liste. Den har følgende format:

@ny_liste = reverse(@Liste);

Reverseringsfunksjonen reverserer en liste og returnerer en ny resulterende liste. Følgende eksempel illustrerer bruken av omvendt funksjon:

@liste = reverse(1..5); # Resultat 5,4,3,2,1 @liste = reverse(@liste); # Resultat 1,2,3,4,5

SORTERINGSFUNKSJON

Sorteringsfunksjonen sorterer elementene i en liste. Den har følgende format:

@ny_liste = sort(@Liste);

@ny_liste = sorter(Underrutine @Liste);

@new_list = sort(BlockStatement @Liste);

Sorteringsfunksjonen plasserer elementer i en liste, og sorterer dem i henhold til ordenstegnstallene i ASCII-tabellen. Som den omvendte funksjonen, returnerer sorteringsfunksjonen en ny liste som sin verdi og påvirker ikke den opprinnelige listen. Følgende eksempel illustrerer bruken av sorteringsfunksjonen:

@liste = sorter(1,5,2,3,4); # Resultat 1,2,3,4,5 @liste = sort(1,2,10); # 1,10,2 sortering i ASCII

I en subrutine eller blokk kan du endre rekkefølgen sorteringen utføres i. Følgende eksempel illustrerer bruken av sorteringsfunksjonen.

@list = sort(($a<=>$b) (2,1,10)); # @liste 1,2,10 @liste = sort(($b<=>$a)) (2,1,10); # @list 10,2,1 sub mycomp ( $b<=>$a) @list = sort(mycomp (2,1,10)); # @liste 10,2,1

FUNKSJONER FOR ARBEID MED ARRAYS

Som du vet, er en matrise en datastruktur som inneholder en eller flere verdier av samme type, for eksempel 100 studentnavn. Perl inneholder flere innebygde funksjoner som hjelper deg å jobbe med array-elementer. De følgende delene dekker flere grunnleggende array-behandlingsfunksjoner.

PUSH OG POP-FUNKSJONER

Perl-skript bruker push- og pop-fiksjoner for å legge til og fjerne elementer fra slutten av en matrise. Med andre ord, push- og pop-funksjonene lar skript utføre stablede operasjoner på sist-inn, først-ut-basis. Push-funksjonen har følgende format:

Push(@ARRAY, LIST);

Følgende utdrag illustrerer bruken av push-funksjonen:

@liste = (); push(@liste,10,20); # @list er nå (10,20) push(@list,1..3); # @list er nå (10,20,1,2,3)

I motsetning til dette fjerner pop-funksjonen elementet som sist ble skjøvet inn i stabelen og returnerer verdien til det elementet. Pop-funksjonen har følgende format:

$verdi = pop(@ARRAY);

Følgende programfragment illustrerer bruken av pop-funksjonen:

# La oss ta @list fra forrige eksempel print pop(@list); # Skriv ut 3 print pop(@list); # Utskrifter 2 # Nå @liste (10,20)

SHIFT-FUNKSJON

Skiftfunksjonen fjerner og returnerer et element fra begynnelsen av en matrise. Denne funksjonen ligner pop-funksjonen med den eneste forskjellen at den fungerer fra begynnelsen av matrisen i henhold til FIFO-prinsippet (<первым вошел, первым вышел>). Skiftfunksjonen har følgende format:

$verdi = shift(@ARRAY);

Følgende programfragment illustrerer bruken av shift-funksjonen:

# La oss ta @list fra forrige eksempel

Skriv ut shift(@list); # Skriv ut 10 print shift(@list); # Skriver ut 20 # Nå @list()

UNSHIFT FUNKSJON

Unshift-funksjonen legger til ett eller flere elementer i begynnelsen av en matrise. Den har følgende kode:

Unshift(@Array, List);

Følgende programfragment illustrerer bruken av unshift-funksjonen:

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

SPLICEFUNKSJON

Perl-skript bruker spleisefunksjonen til å fjerne elementer fra en liste, og erstatte dem med elementer fra en annen liste. Den har følgende format:

Splice(@Array, Offset[, Count[, List]]);

Spleisefunksjonen fjerner det spesifiserte antallet elementer (Count) fra en matrise (@Array), og starter med elementet pekt på av offsetverdien (Offset), og erstatter elementene med elementer fra en annen liste (List). Hvis funksjonskallet ikke spesifiserer en Count-parameter, henter funksjonen elementer helt til slutten av matrisen. Hvis funksjonskallet ikke spesifiserer en liste hvis elementer erstatter de originale elementene, legger ikke funksjonen til noen elementer til den opprinnelige listen. Følgende uttrykk illustrerer bruken av skjøtefunksjonen:

@liste = 1..10; skjøte(@liste,1,8,5,6); # @liste = (1,5,6,10)

SKALAR FUNKSJON

Skalarfunksjonen bestemmer antall elementer i en liste. Den har følgende format:

Rsult = skalar(Liste);

Vanligvis trenger ikke Perl-skript å bruke skalarfunksjonen med matriser, fordi når et skript får tilgang til en matrise ved å skrive den i en skalarkontekst, returnerer det antall matriseelementer. Skript kan imidlertid bruke skalarfunksjonen i tilfeller der konteksten er tvetydig eller hvis listen ikke er en matrise. Følgende uttrykk illustrerer bruken av skalarfunksjonen.

@liste = 1..10; print scalar(@list); # Skriver ut størrelsen på @liste

GREP-FUNKSJON

grep-funksjonen filtrerer listeelementer som et gitt uttrykk evalueres til<ложно>. Den har følgende format:

@list = grep(Uttrykk, Liste);

grep-funksjonen itererer gjennom elementene i en liste, og erstatter dem som argumenter i et gitt uttrykk. grep-funksjonen tilordner gjeldende uttrykk for et listeelement til variabelen $_ og evaluerer det gitte uttrykket. Hvis det resulterende uttrykket er sant, legger grep-funksjonen det elementet til den resulterende listen. Følgende programfragment illustrerer bruken av grep-funksjonen:

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

Merk: Hvis uttrykk, endrer en variabel. $_, vil den opprinnelige listen også bli endret.

FUNKSJONER FOR BEHANDLING AV ASSOSIATIVE ARRAYS

Som kjent er assosiative arrays de arrays der indeksen ikke er en numerisk verdi, men for eksempel et navn. Perl har flere innebygde funksjoner som gjør det lettere for skript å håndtere assosiative arrays.

TASTER FUNKSJON

Tastefunksjonen returnerer nøkkelverdiene som tilsvarer en assosiativ matrise. Den har følgende format:

@key_list = keys(%Array);

Tastefunksjonen returnerer en rekke nøkler som en vanlig liste. Følgende programfragment illustrerer bruken av tastefunksjonen:

$ages("Bob") = 25; $ages("Mary") = 30; $ages("Zack") = 15; @list = keys(%ages); # @list vil være "Zack", "Bob", "Mary" @list = sorteringsnøkler %ages # @ list "Bob", "Mary", "Zack" for $key (sorteringsnøkler %ages) (skriv ut "$ nøkkelen er $ages($key)\n" )

VERDIER FUNKSJON

Verdifunksjonen returnerer en vanlig matrise som består av verdiene til en assosiativ matrise. Den har følgende format:

@value_list = verdier(%Array)

Verdifunksjonen returnerer en rekke assosiative matriseverdier som en vanlig liste. Følgende programfragment illustrerer bruken av verdifunksjonen:

# Bruk verdiene fra forrige eksempel %ages = ("Bob", 25, "Mary", 30, "Zack", 15); @list = sorteringsverdier %ages; # @liste (15, 25, 30) @liste = %aldre; # @list("Zack", 15, "Bob", 25, "Mary", 30)

HVER FUNKSJON

Hver funksjon itererer gjennom elementene i en assosiativ matrise. Den har følgende format:

@key_values ​​= hver(%Array);

Når skriptet kaller hver funksjon, returnerer det en liste over to komponenter som inneholder et nøkkelverdi-par. Når funksjonen når slutten av listen, returnerer den en tom liste. Neste gang funksjonen kalles opp, starter iterasjonsprosessen på nytt. Følgende programfragment illustrerer bruken av hver funksjon:

# Bruk verdiene fra forrige eksempel %ages = ("Bob", 25, "Mary", 30, "Zack", 15); while (($name, $age) = hver %ages) ( # Print ages print "$key is $ages($key)\n"; )

SLETTEFUNKSJON

Slettefunksjonen fjerner elementer i en assosiativ matrise. Den har følgende format:

Slett $Array(Key)

Følgende setning bruker delete-funksjonen til å fjerne elementet som tilsvarer nøkkelen Bob fra $Employees assosiative array:

Slett $Employees("Bob")

KOMMANDOLINJEARGUMENT

Perl-skript kan enkelt få tilgang til kommandolinjeargumenter. Når et skript kjøres, plasserer Perl skriptets kommandolinjeargumenter i @ARGV listevariabelen. Følgende programfragment brukes til å skrive ut kommandolinjeargumenter til skjermen:

Mens ($arg = shift @ARGV) ( skriv ut "$arg\n"; )

TILGANG TIL MILJØVARIABLER

Tilgang til miljøvariabler i Perl-skript er også veldig enkelt. Hver gang et skript kjøres, plasserer Perl kopier av miljøvariablene i en assosiativ matrise kalt %ENV. Følgende setning bruker %ENV-matrisen for å vise gjeldende katalog:

Skriv ut "$ENV(PATH)\n"; # Skriv ut gjeldende katalog

I tillegg til å hente verdier fra %ENV-matrisen, kan skript også endre matriseelementer. Slike endringer i %ENV-matrisen vil endre miljøvariabelinnstillingen for alle underordnede prosesser opprettet av skriptet. For eksempel, neste instruksjon bruker %ENV-matrisen for å endre gjeldende bane:

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

Merk: Endringer skriptet gjør i %ENV-matrisen vil ikke påvirke de originale miljøvariablene. Med andre ord, etter at skriptet er ferdig å kjøre, endres ikke systemmiljøvariablene.

FILINNGANG OG UTGANG

Perl ble spesielt utviklet for å være et adekvat verktøy for å lese og skrive tekstfiler. Men som du vil lære senere, utfører Perl tilfeldig tilgang og binære fil I/O-funksjoner. 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: STDIN, STDOUT, STDERR. Disse tre standardpekerne tilsvarer standardstrømmene STDIN, STDOUT, STDERR i programmeringsspråket C. I tillegg kan Perl-skriptet åpne flere pekere til andre spesifikke filer.

ÅPNING AV FILER OG ANDRE STRØMMER

For at et skript skal bruke en fil, må det kalle opp funksjonen. Det ser slik ut:

Åpne (Filhåndtak[, Filnavn])

I motsetning til C runtime library open-funksjonen, inneholder ikke Perls åpne-funksjon en modusparameter i funksjonskallet. Perl bestemmer modusen for å åpne en fil basert på filnavnet. Tabell 12.3 illustrerer forholdet mellom filåpningsmodus og filnavn.

Bord 12.3. Perl-filnavnekonvensjoner og tilgangsmoduser

Hvis et filnavn er utelatt fra det åpne funksjonskallet, antar Perl at filnavnet er inneholdt i strengvariabelen $FileHandle. Når skriptet er ferdig med å bruke filen, lukkes det ved å bruke lukkefunksjonen som vist nedenfor:

Lukk(Filhåndtak);

Et programfragment illustrerer bruken av åpne- og lukkefunksjonene:

Åpne(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 fullføring # test.dat close(InFile); close(OutFile); lukk(Aux);

Merk at filpekere ikke har de vanlige enkelttegnsprefiksene. Som du vil lære senere, kan Perl-skript lagre pekernavn som skalære variabelstrenger og sende pekeren til en hvilken som helst funksjon som kan behandle dem. Perl utfører verdikonvertering om nødvendig.

På MS-DOS støtter Perl en tilleggsfunksjon kalt hinmode som lar filinndata/utdata bytte mellom tekst- og binærmodus. I de fleste systemer spiller ikke skillet mellom tekst og binære modus noen rolle. 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 må den tilsvarende pekeren åpnes. Binmode-funksjonen har følgende format:

Binmode(Filhåndtak);

LINJE-LINE LESE OG SKRIVE DATA

Den enkleste måten for et skript å lese en linje fra en fil er å bruke operatoren . I Perl blir en filpeker omgitt av trekantparenteser input-symbolet. For eksempel illustrerer følgende programfragment bruken av inndatategnet for å lese og vise innholdet i Test.dat-filen.

Åpne(InFile, "Test.dat") || dø; while ($line = ) ( print $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 utførelsen av while-løkken. Det er et spesielt (tomt) inndatategn merket med<>, som har en veldig spesialisert, men nyttig applikasjon. Første gang et skript bruker et tomt inndatategn<>, analyserer den kommandolinjeargumentene. Hvis strengen @ARGV er tom, så inndatategnet<>leser fra STDIN. Hvis i stedet @ARGV ikke er tom, åpner Perl den første av filene spesifisert i @ARGV-variabelen 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, vises symbolet<>returnerer usant. 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:

@linjer = ;

Å skrive data til en fil er også ganske enkelt. Faktisk gjorde du dette hver gang du brukte utskriftsfunksjonen. Fullformatet til utskriftsfunksjonen er som følger:

Skriv ut liste;

Hvis utskriftsfunksjonen ikke mottar en filpeker som argument, sender den utdata til STDOUT. Følgende programfragment illustrerer bruken av utskriftsfunksjonen for å legge til data til en utdatafil:

Åpne(LogFile, ">>logfile.dat") || dø; ############## ($m, $d, $y) = (lokaltid(tid)) ; skriv ut loggfilen "kapteinens logg, stjernedato ++m$/$d/$y\n"; close(LogFile);

Merk: Filpekeren og utdatalisten er ikke atskilt med komma.

LESE OG SKRIVE DATABLOKKER

Programmerere behandler ofte tekstfiler som tekststrømmer rett og slett fordi ett tegn følger etter et annet til slutten av filen. Hvis skriptet må fungere med en fil som er blokkorientert i stedet for trådorientert, kan skriptet bruke sysread- og syswrite-funksjonene til å behandle faste datablokker. Sysread- og syswrite-funksjonene har følgende formater:

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

Hvis et funksjonskall spesifiserer en offset fra begynnelsen av filen (Offset), vil funksjonene søke etter stedet hvorfra de vil starte I/O-operasjoner. Sysread- og syswrite-funksjonene sender begge data ved hjelp av en skalarstrengvariabel. Fordi funksjoner behandler faste minneblokker, kan dataene inneholde binære verdier, inkludert nuller og slutt-på-fil-markører. Hvis funksjonskallet spesifiserer en offset fra begynnelsen av filen (Offset), så søker funksjonen etter plasseringen i filen som den begynner å utføre I/O-operasjoner fra. Hvis du jobber med datablokker, kan skript også bruke følgende I/O-funksjoner:

$result = seek(Filhåndtak, Posisjon, Base); $result = tell(Filhåndtak); $result = eof(Filhåndtak);

Seek-funksjonen fungerer nøyaktig som C runtime library-funksjonen fseek. Posisjonsparameteren spesifiserer posisjonen i forhold til origo, som igjen spesifiseres av Base-parameteren som følger:

Perls tell-funksjon fungerer nøyaktig som C runtime-bibliotekets ftell-funksjon. Denne funksjonen returnerer gjeldende posisjon i filen som en lese- eller skriveoperasjon utføres fra. Til slutt returnerer eof-funksjonen, som C-språkfunksjonen feof, verdien<истинно>eller<ложино>, som skriptet kan bruke til å bestemme når slutten av filen er nådd.

BINÆR DATABEHANDLING

Selv om Perl først og fremst fokuserer på tekstbehandling, kan den også behandle 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 å oppnå noe<полезное>med data tvinges skriptet til å konvertere dataene til sine egne<родные>skalære formater.

LAGRING AV BINÆR DATA

Når et Perl-skript leser en blokk med binære data ved å bruke sysread-funksjonen, plasserer det de binære dataene i en skalarstrengvariabel. Perl bryr seg ikke om disse er gitt, om de inneholder nullverdier eller ikke-ASCII-verdier. Innenfor en tegnstreng godtar Perl byte som byte. I motsetning til C, bruker ikke Perl nullterminerte strenger. Hvis dataene er ASCII, kan skriptet behandle det som hvilken som helst tekst. Men hvis dataene er binære, må skriptet dekomprimere dem før Perl kan behandle dataene.

UTPAKKING AV BINÆRE DATATRENGER TIL PERL-VARIABLER

For at skriptet skal få tilgang til binære data, må det pakkes ut i sitt eget skalarformat. Perl-skript pakker ut data ved å bruke utpakkingsfunksjonen, som har følgende format:

$result = unpack(Template, Expression);

Expression er en regulær strengvariabel som inneholder binære data lest av sysread-funksjonen, men kan også være et uttrykk som må tolkes som en streng. Template er en tegnmalstreng som beskriver hvordan du tolker verdiene i Expression-operanden. Følgende programfragment illustrerer bruken av unpack-funksjonen:

($r, $g, $b) = unpack("C3", $color);# vil pakkes ut i 3 tegn
- @longwords = unpack("L*", $data); # pakker ut i en liste med lange # ord @stuff = unpack("S2L", $bin); # pakkes ut i 2 shorts og lange

Hvert mønstertegn kan følges av et tall som indikerer hvor mange ganger det tegnet skal brukes. Hvis det er en stjerne (*) i stedet for et tall, vil operasjonen bli utført på alle gjenværende data i raden. Hvis nummeret ikke er oppgitt, utføres det én gang. Skriptet kan legge inn et hvilket som helst antall mønstertegn i malstrengen. Tabell 12.4 viser symbolene som inngår i strengparameter Mal sammen med en beskrivelse av hvordan hver påvirker utførelsen av utpakkingsfunksjonen.

Bord 12.4. Mønstersymboler

PAKKE DATA I BINÆRE STRENGER

For å sende ut binære data, må skriptet pakke skalarverdier inn i binære tegnstrenger. For å gjøre dette, bruk pakkefunksjonen, hvis format er gitt nedenfor:

$result = pack(mal, liste);

Følgende programfragment illustrerer bruken av pakkefunksjonen:

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

Pakkefunksjonen bruker de samme mønstertegnene som utpakkefunksjonen, bortsett fra a-tegnene. A, u, x, x, @.

JOBBER MED KATALOGER

Perl tilbyr ikke bare et bredt spekter av filbehandlingsfunksjoner, men også noen veldig praktiske funksjoner for å skanne kataloger. I de følgende avsnittene vil vi se på noen av hovedfunksjonene for å jobbe med kataloger i detalj.

ÅPNING, LESE OG LUKKE KATALOGER

Perl-skript lar deg åpne og lese innholdet i filer. På samme måte åpner disse skriptene kataloger og leser navnene på filene de inneholder. For å åpne en katalog bruker skript opendir-funksjonen, og sender katalogpekeren og banen til den. For lesing filliste som finnes i katalogen, bruker skriptet readdir-funksjonen. Til slutt brukes closedir-funksjonen for å lukke katalogen. Følgende programfragment 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 $INC-variabelen for å få tilgang til gjeldende katalog. Ved å endre $INC til $ARGV, viser skriptet en liste over filer i katalogen du spesifiserte på kommandolinjen.

I tillegg til katalogfunksjonene diskutert ovenfor, tilbyr Perl et sett med funksjoner som lar deg plassere gjeldende indeks i en katalogoppføring:

$result = rewinddir(DirHandle); $result = telldir(DirHandle); $result = seekdir(DirHandle, Posisjon);

FORMATERT UTGANG

I dette kapittelet lærte du flere måter å formatere skriptutdata ved å bruke utskriftsfunksjonen. I likhet med C, støtter Perl også funksjonene printf og sprintf. I tillegg støtter Perl også generering av kolonnebaserte rapporter ved hjelp av skjemamaler.

BRUKE UTSKRIFTSFUNKSJONEN

Skriptene i dette kapittelet gjorde mye bruk av utskriftsfunksjonen. I tillegg gir Perl spesielle variabler som påvirker driften av utskriftsfunksjonen. Tabell 12.5 karakteriserer kort disse spesialvariablene.

Bord 12.5. Spesielle variabler som styrer utskriftsfunksjonen

For å bruke disse spesialvariablene tildeler du dem de verdiene du ønsker. For eksempel bruker følgende programfragment $-variabelen for å spesifisere en skilletegn mellom utskriftselementer:

Det viser seg at $-variabelen faktisk påvirker alle linjer, ikke bare de som skrives ut. Imidlertid vil du oftest bruke den til å endre verdien som skrives ut av utskriftsfunksjonen.

FORMATERT DATAUTGANG VED UTSKRIFTSFUNKSJON

Som standard sender printf-funksjonen formatert utdata til STDIO, og sprintf-funksjonen returnerer en formatert streng. I begge tilfeller er strengformatet nesten identisk med C-språkfunksjonene, bortsett fra at Perl-språkfunksjonene ikke støtter lengdespesifikasjonen (*). Følgende programfragment 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 gi ut 3.14

RINGE EKSTERNE PROGRAMMER FRA ET SCRIPT I PERL

På en måte en erstatning for shell-skript, gir Perl støtte systeminteraksjon, inkludert samtale eksterne programmer. De følgende avsnittene diskuterer flere måter å ringe eksterne programmer fra Perl-skript. Vær imidlertid oppmerksom på at ved å tillate skript å utføre systemkommandoer, åpner du opp sikkerhetshull i verten din. Hold deg til det generell regel ikke utfør eksterne kommandoer fra et Perl-skript. Men hvis du blir tvunget til å utføre eksterne kommandoer fra et skript, kan du bruke de innebygde kommandoene til disse formålene. systemfunksjoner, exec eller gaffel.

VANLIG UTTRYKK

Gjennom dette kapittelet har du sett eksempler på strengbehandlingsfunksjoner. Mange av dem er basert på begrepet regulære uttrykk. Som du kan se fra de følgende avsnittene, bruker Perl-skript utstrakt bruk av regulære uttrykk for tekstbehandling. Hvis regulære uttrykk er nytt for deg, så ikke bekymre deg. Etter kort tid, etter at du har gått gjennom noen deler av dette kapittelet, vil regulære uttrykk bli enkle å forstå.

VANLIGE UTTRYKK OVERSIKT

Regelmessige uttrykk er et fancy begrep som har sin opprinnelse i informatikk for å referere til et mønster av tegn. Perl-skript bruker tegnmønstre ganske enkelt for å analysere inndataene, og bryte dem ned i biter. Ofte kan et skript analysere inndata basert på mellomrom, kommaer, tabulatorer og andre skilletegn. Men når inndataene har et vilkårlig format, så takler regulære uttrykk denne oppgaven best.

VANLIG UTTRYKKS SYNTAKS

For å redusere størrelsen på regulære uttrykk bruker Perl spesialtegn. Tabell 12.6 viser noen av symbolene som brukes av Perl-skript i vanlig uttrykk X.

Bord 12.6. Symboler som brukes i regulære uttrykk

Perl plasserer regulære uttrykk (mønstre) i skråstreker, dvs. i skråstreker, for eksempel i formen /pattern/. Følgende programfragment illustrerer Perl regulære uttrykk:

# følgende regulære uttrykk er sanne hvis: /ig/ # streng inneholder "ig" /(b|d|f)ig/ # streng inneholder "big", "dig" eller "fig" /+/ # streng inneholder et tall /*/ # streng inneholder en identifikator

Hvis disse uttrykkene ikke gir mening for deg, ikke bekymre deg. I dette kapittelet skal vi se på flere regulære uttrykk. For nå, bare husk at Perl setter regulære uttrykk mellom to skråstreker, som vist ovenfor.

BRUKE VANLIGE UTTRYKK FOR Å SØKE SØKEORD

Perl-skript bruker regulære uttrykk for å gjøre strengsammenlikninger enklere. For å sjekke om en streng inneholder et gitt mønster, kan skriptet bruke regulære uttrykk som dette:

Hvis ($str =~ /pattern/)

I dette tilfellet tar regulære uttrykk verdien<истинно>hvis mønsteret er funnet i streng ($str). Hvis strengen inneholder mønsteret, returnerer uttrykket verdien<ложно>. Følgende uttrykk tester for eksempel om strengen inneholder teksten WebProgramming:

If ($str =~ /Nettprogrammering/)

For å se etter et eksakt samsvar, må uttrykket binde sammenligningen til begynnelsen og slutten av strengen. For eksempel har følgende uttrykk verdien<истинно>, hvis og bare hvis $str-variabelen har en av tre verdier: , ) :

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

På samme måte er følgende uttrykk sant hvis og bare hvis $str inneholder ordet og er ikke en del av et annet ord som f.eks .

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

BRUKE VANLIGE UTTRYKK FOR AT ANALYSE INNGANGSDATA

Ettersom Perl-skriptene dine blir mer komplekse, vil det være mange tilfeller der du vil vite mer enn bare å sjekke om et mønster samsvarer med en streng eller ikke. For eksempel vil du kanskje at et skript skal trekke ut en bestemt strengverdi. Ved å bruke gruppering av tegn () i et regulært uttrykk, kan skriptet trekke ut samsvarende verdier fra en streng og danne en liste over dem. For eksempel bruker følgende programfragment 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))/;

Perl støtter også en annen form for mønstertilpasning, ved å bruke (=~)-operatoren, som legger til negasjonen av resultatet: (!~). Denne operatoren tilsvarer uttrykket!($str=~/pattern/).

VANLIGE UTTRYKK FOR SØKE OG ERSTATTE STRENG

Så langt har du brukt operatorer som samsvarer med mønster. Det viser seg at Perl støtter to andre regulære uttrykk som endrer strengvariabelen som testes. I setningen nedenfor erstatter Perl den delen av strengen som matcher mønsteret med gitt streng:

$str =~ s/pattern/replacement/;

For eksempel vil følgende instruksjon erstatte ordet på :

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

En liten modifikasjon lar deg erstatte alle ord på :

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

I dette tilfellet forteller g-en på slutten av uttrykket Perl at global substitusjon er nødvendig.

Ved å bruke i-suffikset kan du angi at søket skal skille mellom store og små bokstaver. I motsetning til bare å se etter et mønster, 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

Tenk på følgende eksempel for deg selv:

$letters = "abcde"; print "$letters\n" # Skriv ut abcde $letters =~ tr/a-z/A-Z/; skriv ut "$letters\n" # Skriv ut ABCDE

SAMMENDRAG

Dette kapittelet gir en introduksjon til Perl-programmering. Ved å bruke konseptene som er diskutert her, kan du skrive komplekse CGI-skript i Perl. Det neste kapittelet vil hjelpe deg å få ferdighetene til å lage CGI-skript i Perl som du kan kjøre på din egen server. Før du fortsetter, 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 Internett og Internett.

Perls konstruksjoner ligner på C i mange henseender, men Perl tilbyr mange tilleggsfunksjoner, 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 Internett og Internett, først og fremst på grunn av fleksibiliteten, kompakt stil og høy sikkerhet.

VIKTIGSTE NETTSIDER FOR INFORMASJON OM PERL

Følgende nettsteder vil hjelpe deg med å finne informasjon om detaljer du er interessert i angående Pcrl-språket, dets skript og spesifikk informasjon om Perl 5-språkressurser og dets biblioteker. Bruk disse nettstedene som et utgangspunkt for søket.

SAMMENDRAG

I dette kapittelet lærte du hvordan du bruker Perl til å skrive ganske komplekse CGI-skript. Ved å bruke teknologien du har blitt kjent med, kan du tilby programmeringstjenester på profesjonelt nivå til kundene dine som ønsker at virksomheten deres skal være representert på nettet. Kapittel 14 introduserer deg til Java-språket. Som du vil se Java-språk godt egnet til å lage nettsteder som inneholder animasjon og multimedia. I tillegg introduserer kapittel 14 et annet språk for å skrive JavaScript-skript. Men før du går videre til kapittel 14, sørg for at du forstår følgende nøkkelbegreper:
- Perl er et allsidig og fleksibelt programmeringsspråk som kan brukes til å utvikle CGI-skript for nettet så vel som tradisjonelle programmer for daglig bruk.

• Perl egner seg godt for tekstbehandling, databasetilgang, den er portabel og gir sikkerhet ved arbeid i nettverk. Alle disse egenskapene er viktige for webprogrammering.
• Perl-skript bruker mye regulære uttrykk for tekstbehandling.
• De fleste skript på nettet er nå skrevet i Perl. Språk som JavaScript og VBScript kan imidlertid gjøre inngrep i Perls monopol.