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

De skriver til os:

Du er ved at tage på en rejse ind i Perl-programmeringens verden. Din rejse bliver så meget desto mere behagelig på grund af tilstedeværelsen af ​​et stort antal eksempler, der vil blive mødt undervejs. Begyndelsen på vores rejse dækker sprogets grundlæggende begreber. Efterhånden vil du lære nok om Perl til at lave små programmer. Ved slutningen af ​​vores rejse vil du allerede have den nødvendige viden til at kunne skabe fuldgyldige applikationer.

Taler du andre programmeringssprog? Hvis ja, så vil det være en fornøjelse for dig at lære Perl. Hvis ikke, så skynd dig ikke, prøv alle de foreslåede øvelser og eksempler og vær ikke bange for at eksperimentere!

Oprindelse

Perl var resultatet af én mands indsats, og efter hans egen indrømmelse resultatet af hans dovenskab. Dette er et unikt sprog, hvis essens ikke kan formidles ved en simpel beskrivelse af tekniske detaljer. Perl er en sindstilstand.

Et af sprogets særheder er dets navn. Det har flere definitioner. Perl stod oprindeligt for Practical Extraction Report Language. Imidlertid kalder programmører det meget ofte Phatologically Eclectic Rubbish Lister eller endog Praktisk alt virkelig sympatisk.

Lad os bruge et par minutter på at forstå, hvad Perl er, og hvilke opgaver den blev tildelt på tidspunktet for dens oprettelse. Tilbage i 1986 arbejdede Larry Wall på problemet med at generere rapporter fra et stort antal tekstfiler, der overlappede hinanden. Da han var Unix-programmør, og fordi opgaven involverede at manipulere indholdet af tekstfiler, prøvede han først at bruge Awk. Men det stod hurtigt klart, at Awk ikke var egnet til jobbet, og da der ikke var andre kandidater til at løse problemet, var det eneste, der var tilbage, at opfinde sit eget værktøj, der kunne bruges i fremtiden.

I stedet for at spilde tid opfandt Larry simpelthen et nyt programmeringssprog og skrev en tolk til det. Dette virker som et paradoks, men det er ikke helt sandt - det, du gør, er altid en masse arbejde, men hvis du gør det korrekt, så vil dette arbejde helt sikkert betale sig.

Larry tilbød snart sin skabelse til Usenet-nyhedslæserfællesskabet. Brugere med adgang til Usenet gav Perls skaber effektiv feedback og spurgte, hvordan man gør dette, det og det andet. Larry havde ikke engang til hensigt at skabe mange af disse problemer for sit lille nye programmeringssprog.

Det nye programmeringssprog havde en vægt på systemkontrol og tekstbehandling. Efter flere revisioner kunne den allerede bruge regulære udtryk, signaler og netværkssockets. Det blev kendt som Perl og blev hurtigt populært blandt Unix-programmører, og snart resten af ​​os.

Larry vedligeholder ikke længere Perl alene, men beholder sin eksklusive titel som hovedudvikler.

Perl-programmer ligner meget C-programmer, måske fordi Perl blev skrevet i C, og måske fordi Larry fandt nogle C-konstruktioner nyttige. Men Perl er mindre pedantisk og meget mere kortfattet end C.

Perl er designet til at hjælpe programmøren med at udføre rutineopgaver, der er for vanskelige eller dårligt bærbare til skallen, og for abstrude eller svære at kode til C (eller et hvilket som helst andet sprog).

Når du har mestret Perl, kan du opleve, at du bruger mærkbart mindre tid på at citere forskellige shell-parametre korrekt (eller udføre C-deklarationer korrekt) og mere tid på at læse Usenet-nyheder og stå på ski ned ad bjerget. For Perl er et vidunderligt værktøj til at hjælpe dig med at blive en programmør. "Nogle af de gamle" sagde: "Du bør ikke lære et programmeringssprog, der ikke radikalt ændrer din forståelse af programmering." Vær sikker på, når du først har lært Perl, vil du se på programmering fra et helt andet perspektiv.

De kraftfulde konstruktioner af dette sprog giver dig mulighed for at skabe meget effektive løsninger og universelle værktøjer med minimal indsats. Disse værktøjer kan fortsat bruges, fordi programmer skrevet i Perl er meget bærbare og klar til brug. Som et resultat vil du have endnu mere tid til at læse Usenet-nyheder og gå på barer med venner.

Perl er meget god til at håndtere opgaver på lavt niveau, især siden den femte version af sproget blev udgivet.

Omkostninger og licens

Perl er gratis. For at være mere præcis distribueres Perl under GNU Public License. Den komplette kildekode og dokumentation er helt gratis at kopiere, kompilere og udskrive. Alle de programmer, du skriver i Perl, er dine, og du kan gøre, hvad du vil med dem.

Udover UNIX-computere findes Perl også til andre platforme - Windows, DOS, Atari, Amiga osv.

Har du Perl installeret?

Det er meget nemt at finde ud af, om du har Perl. Bare udfør følgende kommando på kommandolinjen:

Hvis du modtager en fejlmeddelelse, eller du har version 4 af Perl, skal du kontakte din systemadministrator eller installere Perl selv.

Dit første Perl-program

Dit første Perl-program illustrerer udskrivning af en tekstlinje til skærmen. For at begynde skal du oprette en simpel tekstfil, der vil indeholde dit Perl-program. Derefter vil du køre din programfil.

Et Perl-program er en almindelig tekstfil, der indeholder flere sprogkonstruktioner. Sidstnævnte ligner normalt en blanding af C, Unix shell script og engelsk. Generelt er det præcis sådan, det virkelig er.

Perl-kode kan være ret forskelligartet. Her er nogle grundlæggende regler:

Indledende mellemrum i linjen ignoreres. Du kan placere sprogsætningen, hvor som helst du vil: i begyndelsen af ​​linjen, indrykket (anbefalet) eller endda justeret til højre (men i dette tilfælde vil det være ekstremt svært at læse programteksten og forstå noget som helst);

En sprogkonstruktion skal slutte med et semikolon, medmindre det er den sidste konstruktion i en blok eller fil, eller er en eval-sætning;

Mellemrum, tabulatorer, tomme linjer er irrelevante - et mellemrum er så godt som hundrede mellemrum. Dette betyder, at du kan bryde sprogkonstruktionen op i flere linjer for klarhed. En streng er normalt en række tegn omgivet af anførselstegn. Kapitel 2, "Number and String Literals," indeholder en mere detaljeret beskrivelse af strenge;

Alt efter tegnet "#" ignoreres, medmindre det er inden for en linje. Brug denne funktion til at give nyttige kommentarer til din kode. Det skal bemærkes, at der ikke er flere linjers kommentarer (for eksempel som i C-sproget) i Perl.

I lighed med et shell-script består et Perl-program af alle de Perl-sætninger, der er til stede i en fil, betragtet sammen som ét stort program, der skal udføres. Der er intet begreb om en hovedfunktion, som i C, i Perl.

Datatyper bruges i programmer, når variabler deklareres. Kort sagt definerer en datatype det sæt af værdier, som en variabel kan tage, såvel som det sæt af operationer, som et program kan udføre på den. I Perl kan data være et tal eller en streng af tegn.

En værdi kaldes en skalær mængde eller blot en skalar. Følgende er eksempler på skalarværdier, der bruges i Perl:
- Decimal: 127 eller 127,0 eller 1,27E2
- Hexadecimal: Ox7F eller 0x7f
- Oktal: 0177 (første 0 angiver, at oktal er brugt)
- Streng: "Hello World\n" eller "Hello World"

For eksempel bruger følgende kommando Perl-debuggeren til at udskrive det oktale tal 0177, som svarer til decimaltallet 127:

D.B.<4>r 0177 127

Perl oversætter dataene til dets interne format. Når Perl udskriver oktale eller hexadecimale værdier, konverterer den først dem til decimalformat, som vist.

Bemærk: Som du vil lære, giver Perl-script dig mulighed for at bruge printf-funktionen til at udskrive værdier i et kaldbart format, såsom oktal eller hexadecimal.

Dobbelt præcision flydende komma-format bruges som den interne repræsentation af alle tal. Med andre ord er der intet heltal blandt de interne formater. Men i de fleste tilfælde kan du ignorere dette, og Perl vil gøre alt rigtigt. For eksempel, hvis du bruger mængder i en kontekst, hvor kun heltalsværdier giver mening, vil Perl automatisk afkorte selve tallet.

Bemærk: Hvis du programmerer i C og har brugt heltalsdivision med heltalsafkortning automatisk, så skal du ved programmering i Perl huske at udføre trunkeringen manuelt ved hjælp af int()-funktionen.

Følgende kommando illustrerer, hvordan Perl håndterer heltal og flydende decimaltal:

Udskriv 6&3; # vil udskrive 2 print 6.9 & 3.1 # print 7 / 2 # vil udskrive 2.3333 ikke et heltal print int(7/3) # vil udskrive 2

På samme måde som Perl konverterer flydende kommatal til heltal: Når et script bruger heltalsværdier, konverterer det også tal til strenge og omvendt, når en sådan konvertering giver mening. For eksempel, hvis scriptet bruger tal i en kontekst, hvor kun strenge giver mening, f.eks. ved sammenkædning af strenge, konverterer det tallene til strenge. Ligeledes, hvis du vil bruge strenge, hvor kun tal giver mening, konverterer Perl dem til tal. Når du arbejder med Perl-scripts, behøver du normalt ikke bekymre dig om den interne repræsentation af skalære værdier.

Perl understøtter også begrebet booleske værdier, men har ikke en særlig type til at beskrive dem. Som i C betragtes en numerisk værdi som sand, hvis den ikke er nul. Derudover behandles en strengværdi som sand, hvis den ikke er lig med "" eller "0". Nogle boolske operatorer som f.eks<>> (større end), returner en som værdi<истинно>og nul - som<ложно>.

Således skal dit script simpelthen behandle ikke-nul værdier af både streng og numeriske typer som booleske værdier<истинно>. Perl-scripts kan gruppere skalære værdier sammen og oprette en liste. Hvis et script gemmer en liste i en variabel, bliver denne variabel en matrix.

VARIABLER

Perl understøtter tre typer variabler: skalarer, arrays og associative arrays. Som i C skrives variabelnavne med en skelnen mellem små og store bogstaver. Således beskriver navnene VAR, Var og var forskellige variable. Et script kan have en skalarvariabel kaldet var og en matrixvariabel også kaldet var. De vil adskille sig i Perl alt efter konteksten.

Bemærk: Perl-variabler er utypede, som de er i C. For eksempel kan en skalarvariabel indeholde enhver type skalar, og typecasting er automatisk. Som du måske allerede har bemærket, skal variabler i Perl ikke nødvendigvis deklareres. Hvis en variabel ikke er deklareret, behandler Perl den som global. Nedenfor lærer du om deklarationen af ​​variabler og deres omfang.

SKALARE VARIABLER

Som nævnt kan en skalarvariabel indeholde en enkelt værdi. I Perl begynder skalarvariablenavne altid med en ($). Følgende udtryk tildeler skalarvariablen $age værdien 35 og variablen $name strengværdien . Printfunktionen bruges derefter til at udskrive værdien af ​​hver variabel:

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

Hvis du gemmer disse udtryk i en fil kaldet SCALAR.PL, kan du køre programmet sådan:

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

MATERIALER

Som nævnt ovenfor er arrays variable, der tager en liste over skalarværdier som en værdi. Følgende Perl-programtekst illustrerer erklæringen af ​​arrayvariabler og deres initialisering:

@days = ("søn","man","tir","on","tor","fre","lør"); print(@dage); # vil udskrive "SønMandTirOnsTuFriSat" print($dage); # vil udskrive "torsdag" @weekdays = @days; # værdi ("man","tir","on","tor","fre") @emptylist = (); # venteliste

Reference til typevariabler<массив>begynder normalt med et (@)-tegn og efterfølges af værdier i firkantede parenteser (). Som i C-programmering er array-indekser for scripts altid heltalsvariable, som normalt starter med en nulværdi. Du vil se undtagelser fra disse to regler i eksemplerne, der vil blive forklaret i dette kapitel.Det tredje udtryk ($days) er et eksempel på en matrix, der refererer til en skalarværdi. Da den kun indeholder ét element, er den resulterende værdi en skalar.

Hvis du bruger tegnet ($) i stedet for tegnet (@), vil scriptet referere til en skalarværdi. Denne note er meget vigtig. Firkantede parenteser angiver, at scriptet refererer til et array. $-tegnet angiver igen en reference til en skalarværdi. Initialisering af @weekdays-arrayet udføres ved at vælge en del af @days-arrayet. I det foregående eksempel blev @days-arrayet brugt uden et indeks. Når indekset er udeladt, refererer Perl til hele arrayet. På samme måde blev @days-arrayet i det foregående eksempel initialiseret med en liste over bogstaver.

Ud over at tildele literaler som værdier til et array, kan scriptet også tildele værdierne af variabler eller endda andre arrays til arrays, som vist nedenfor:

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

Følgende eksempel bruger dele af arrays:

@weekend = @dage ; # resultat ("søn","lør") print (@dage); # vil udsende "manTuOnsTuFriSunSat"

Hvis et script bruger en matrixvariabel i sammenhæng med en skalar, så er værdien antallet af matrixelementer. En skalær kontekst er en, hvor kun skalære værdier er meningsfulde. For eksempel bruger det følgende udtryk den skalære kontekst for stuff-arrayet til at bestemme antallet af elementer indeholdt i arrayet. Hvis antallet af elementer er større end eller lig med 2, viser scriptet en besked og afslutter eksekveringen:

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

Die-funktionen instruerer Perl til at afslutte eksekveringen og udstede en specificeret besked. Hvis beskeden ikke er indeholdt, afslutter funktionen blot scriptet.

Perl understøtter også en speciel $# variabel konstruktion, der returnerer den sidste indeksværdi i et array. For eksempel bruger det følgende for udtryk $[ til at bestemme startindeksværdien for en matrix og $# til at bestemme det sidste element i matrixen. I dette tilfælde, ved at bruge for udtryk, vises værdierne for hvert af elementerne:

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

Sløjfen skrevet for kan erstattes med følgende ækvivalente udtryk:

Udskriv @ting;

KONTEKSTROLE FOR SKALARE OG VEKTORTYPEVARIABLER

Bemærk, at listekonstruktionsoperatoren (,) ser nøjagtigt ud som den sekventielle evalueringsoperator (,). Hvilken operator der bruges afhænger af konteksten den optræder i, især om variablen er en skalar eller en matrix. Perl bruger listekonstruktion i sammenhæng med arrays og sekventiel evaluering for skalarer. Overvej følgende udtryk:

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

Det første udtryk initialiserer arrayet, mens det andet udtryk sætter skalarvariablen $a_scalar til 5, hvilket kasserer de første fire værdier. Overvej følgende to udtryk:

Udskriv $assoc(1,2); print @assoc(1,2);

Det første tilfælde vil udskrive en værdi af et associativt array med to nøgler, mens det andet vil udskrive to værdier af et associativt array med en nøgle. Af de følgende to udtryk kopierer det første en liste, mens det andet tildeler en skalarværdi svarende til størrelsen af ​​matrixen:

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

ASSOCIATIVE ARRAYS

Associative arrays ligner almindelige arrays ved, at de er en liste over skalarvariabler. Forskellen er, at et array skal bruge heltalsværdier som indeks ved udvælgelse af arrayelementer, hvorimod et associativt array kan bruge værdier af enhver type til at vælge array elementer. Indeksværdierne for et associativt array kaldes nøgler. Overvej følgende eksempler:

$ages("Bob") = 35; $ages("Mary") = 25; $, = " "; # skift output-separator for printoperatør print @ages("Bob","Mary"); # vil udskrive "25 35" printtaster(%ages); # vil udskrive "Bob Mary" for $name (keys(%ages)) (print "$name is $ages($keys)\n"; )

Som du kan se, tildeler programmet værdier til variablen "$," (en skalarvariabel, hvis navn er et komma). Scriptet bruger dette udtryk, så når print-sætningen bruges senere, smelter outputdataene ikke sammen med hinanden. Særlige variabler såsom "$," diskuteres senere i dette kapitel. Associative arrays identificeres ved hjælp af krøllede seler. Som med arrays bruges indekser ikke, når der refereres til en hel associativ array. For eksempel bruger link@ages("Bob", "Mary") indekser i parentes, hvilket peger på et associativt array. @-præfikset angiver, at vi taler om et array. På samme måde angiver brug af et dollartegn foran et array, at der bruges en skalær mængde.

Bemærk: Hvis der er angivet to nøgler, så indikerer dette sammen med @-tegnet, at vi taler om en del af et associativt array, og resultatet skal være i form af en liste. Dette udtryk svarer til #ages(" Bob"), #ages("Mary"). som har værdien (35, 25).

Udtrykket print keys(%ages) kalder nøgleoperatoren, som returnerer hele listen over nøgler i det associative array. En %ages reference med et procenttegn som præfiks betyder, at referencen refererer til hele det associative array. Bemærk, at for-løkken refererer til variabler i dobbelte anførselstegn. Endelig bruger det sidst diskuterede eksempel også nøgleoperatoren og introducerer en for-løkke til at udskrive alle kombinationerne af det associative array. For-løkken refererer til variabler omsluttet af dobbelte anførselstegn. Perl vil til gengæld erstatte de værdier, der refereres til af variablerne, mens den analyserer strengen. Programmører kalder denne proces variabel substitution eller interpolation.

Bemærk: Perl fortolker ikke variabler, der indeholder strenge med anførselstegn.

PERL OPERATØRER

Mens Perls data og variabeltyper er ret forskellige fra dem i C, burde Perls operatorer og udtryk føles meget mere velkendte. Alle C-operatorer er til stede i Perl undtagen type-operatoren, *ptr contents-operatoren og var.member eller var->member-operatoren. Derudover introducerer Perl mange nye operatører til brug i operationer såsom strengsammenligning og strengmanipulation.

ARITMETISKE OPERATØRER

Aritmetiske operatorer opererer på numeriske værdier, og deres resultat er et tal. Hvis et udtryk inkluderer strengoperander, konverterer Perl strengværdierne til numeriske værdier, før udtrykket evalueres. Perl konverterer strenge til tal på samme måde som C atof()-funktionen i runtime-bibliotekerne. Perl understøtter i øjeblikket følgende aritmetiske operatorer:
- + tilføjelse
- - subtraktion eller ændring af fortegn
- * multiplikation
- / division (kun for flydende kommatal)
- % modulo (kun for heltalsværdier)

Lad os se på følgende eksempler aritmetiske operationer Perl sprog:

$x = 2,5; $y = 3; print ($x + 2*$y); # vil udskrive 8.5 print (7 / $y); # vil udskrive 2.3333333 print int (7 / $y); # vil udskrive 2 print (7 % $y); # vil udskrive 1 print (7,5 % $y); # vil udskrive 1

Bemærk: I Perl resulterer divisionsoperatoren altid i et flydende kommatal, og resultatet af at tage et tal modulo et andet er et heltal, og begge operander konverteres først til en heltalstype.

Overvej følgende modulo-operation:

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

Perl understøtter også inkrement- og dekrementoperatorer:
- ++ reduktion i præfiks eller postfix form
- - stigning i præfiks- eller postfiksform. Lad os se på eksempler på stignings- og reduktionsoperationer:

$x = 4; +$x; print $x; # vil udskrive 5 $y = $x-; # vil formindske x efter at have tildelt y værdien af ​​x print "$y $x" # print 5 4

Endelig giver Perl en aritmetisk operator til eksponentiering (**). Overvej følgende eksempler på brug af eksponentieringsoperationen:

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

TÆVEOPERATORER

Bitvise operatorer opererer på den binære repræsentation af heltal og har et heltalsresultat. Hvis operanden er en streng eller en brøk, konverterer Perl den først til et heltal og behandler operanden ved hjælp af 32-bit repræsentationen. Alle C bitvise operatorer er repræsenteret i Perl:
- | bitvis ELLER
- & bitvis OG
- ^ bitvis eksklusiv ELLER
- ~ bit inversion
- << сдвиг влево
- >> skift til højre

Overvej følgende eksempler på bitvise operationer:

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

Som i C afhænger opførselen af ​​højreskiftoperatorer af sprogimplementeringen, når operanden er negativ.

SAMMENLIGNING OPERATØRER

Sammenligningsoperatorer sammenligner værdierne af to operander. Ligesom når man arbejder med aritmetiske operatorer, Perl konverterer strengoperander til numeriske operander før sammenligningen udføres. For at tillade et script at sammenligne strenge, der ikke er tal, har Perl yderligere strengsammenligningsoperatorer. Disse operatorer sammenligner strenge ved hjælp af ASCII-værdier. Hvis en numerisk værdi er angivet som operanden af ​​en strengsammenligning, konverteres den først til en streng. Tabel 12.1 viser sammenligningsoperatorer:

Talstreng Værdi = = lign. lig!= nе ikke lig > gt større end< it меньше чем >= gе større end eller lig med<= lе меньше или равно <=>cmp ikke ens (signeret resultat)

Bord 12.1. Perl-sammenligningsoperatører.

Resultatet af en sammenligningsoperation er ét, hvis sammenligningen er sand og nul ellers. Men den sidste operation (<=>eller cmp) kan returnere værdierne -1, 0 eller 1 afhængigt af om værdien af ​​den første operand er mindre end, lig med eller større end den anden.

Bemærk: Perls cmp-operator opfører sig på samme måde som C runtime-bibliotekets Strcmp()-funktion.

Overvej følgende sammenligningseksempel:

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

LOGISKE OPERATØRER

Logiske operatorer analyserer booleske udtryk og returnerer værdier<истинно>eller<ложно>som resultat. Perl behandler operanderne af logiske operationer som boolske værdier, dvs. som sand eller falsk.

Perls logiske operatorer inkluderer følgende:

Perl behandler altid booleske udtryk fra venstre mod højre. Udover. Perl stopper altid med at evaluere, hvis den allerede udførte evaluering er tilstrækkelig til at bestemme værdien af ​​resultatet. Ud over de generelle logiske operatorer understøtter Perl følgende yderligere logiske operatorer:

Den logiske negationsoperator (!) erstatter værdien af ​​en boolsk værdi med dens modsatte værdi. Ligesom i C har Perl en betinget operator (
-:) bruger tre operander. Et udtryk, der bruger en betinget operator, har følgende form:

Tilstand
- sandt-resultat: falsk-resultat

På samme måde bruger følgende udtryk en betinget operator til at give Bob fuld adgang og alle andre begrænset adgang:

$access = ($user eq "Bob"
- "Fuld" : "Begrænset");

Sekventiel operatør<,>(også kendt som kommaoperatoren) er ikke en fuldstændig logisk operator, fordi den ikke undersøger sandheden af ​​dens operander. Perl evaluerer operanderne af den sekventielle operator fra venstre mod højre og returnerer værdien af ​​operanden længst til højre. Følgende eksempel illustrerer brugen af ​​kommaoperatoren i en for-løkke.

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

STRING OPERATØRER

Da Perl er et tekstbehandlingssprog, er det ikke overraskende, at det inkluderer yderligere operatorer til at manipulere strenge. Følgende er strengbehandlingsoperatorerne:
-. strengsammenkædning
- x replikering
- =~ variabel mønstertilpasning
- !~ den samme som den forrige, men med tilføjet negation af resultatet

De to første udsagn er let illustreret med et eksempel:

Udskriv "b". "en" x 2. "en"; # vil udskrive "banan"

Som vist bruger dette udtryk strengsammenkædning og replikeringsoperatoren til at udskrive strengen .De sidste to operatorer bruges til at teste om en strengoperand indeholder et givet mønster. Dette spørgsmål diskuteres detaljeret i afsnittet<Регулярные выражения>. Følgende eksempel illustrerer deres brug:

$var = "banan"; print ($var =~ /ana/)
- SANDT FALSK;

I dette tilfælde blev mønsterstreng-forekomsttestoperatoren (=~) brugt til at kontrollere, om mønsteret ana er i $var-variablen. I I dette tilfælde udtrykket får værdien<истинно>.

OPGAVE OPERATØRER

Hvis du er bekendt med programmeringssproget C, så burde formerne for Perls opgaveoperatører være ret bekendte for dig. Ligesom i C tvinger disse operatører Perl til at udføre specielle operationer på de værdier, der vises på højre side af operatøren og derefter udføre en tildeling:

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

LVALUES I Perl, som i C, er en lvalue navnet på det, der vises i venstre side af tildelingsoperatoren. En lværdi repræsenterer således en enhed, der kan tildeles en værdi, for eksempel kan en lværdi være en variabel. For eksempel kan et Perl-script ikke tildele en værdi til en streng af tegn, såsom udtrykket = 32 fordi er ikke en lværdi. Dog kunne scriptet tildele en værdi til $Bob, såsom $Bob = 32, da $Bob er en lværdi. I Perl er enhver enhed, der kan bruges som en lværdi, normalt. For eksempel pakker og udpakker følgende udtryk en liste over værdier, hvor listen over variabler i det første tilfælde og tre skalarer i det andet er lværdier:

@farve = ($r, $g, $b); # farvepakke ($r, $g, $b) = @color; # farve unboxing

Når du arbejder med lister i Perl, gælder opgaveoperatøren ikke nødvendigvis for hele listen. Scriptet kan tildele værdier til individuelle listeelementer, som vist nedenfor:

@items = (100.200.300);

I dette tilfælde tildeler operatøren en værdi til tre elementer på listen. På samme måde udpakker det følgende udtryk elementerne i en liste, og tildeler værdierne af de to første elementer til to skalarvariabler, og resten af ​​arrayet til en listevariabel:

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

OPERATIONER TIL ARBEJDE MED LISTER

Operationer for at arbejde med lister omfatter følgende:

Listekonstruktør - .. omfangsoperator - x replikeringsoperator

Du har allerede brugt listekonstruktøren til at initialisere arrays og oprette en liste over variabler, der bruges som lværdier. Områdeoperatoren returnerer som sin værdi en sekvens af heltal, der starter fra venstre operand og fortsætter til og med højre operand. Scripts bruger ofte scope-operatoren sammen med en listekonstruktør til at oprette lister. For eksempel bruger følgende udtryk scope-operatoren til at oprette en liste kaldet @digits, der indeholder tallene nul til ni:

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

På samme måde kan dette udtryk bruge scope-operatoren til at skabe et omfang af ændringer til matrixindekser Antag, at listen @days indeholder ugedagene (startende med søndag). Følgende udtryk tildeler @weekdays listeværdierne fra mandag til fredag:

@weekend = @dage;

Til sidst bruger følgende udtryk to områdeoperatorer til at oprette en liste over hexadecimale cifre:

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

Replikeringsoperatoren opretter simpelthen kopier af en given operand det angivne antal gange. For eksempel gentager følgende udtryk listen over værdier 1, 2, 3 tre gange:

OPERATØRER TIL ARBEJDE MED FILER

Perl indeholder en omfattende liste over operatører til at arbejde med filer. Der er mindst 27 operatører, der returnerer specifikke oplysninger om en fil uden selv at åbne den. Mange Perl-udsagn er rettet mod UNIX-systemer, men følgende udsagn virker på alle systemer:

D kontrollerer tilstedeværelse i kataloget
--e bestemmer tilstedeværelsen af ​​en fil
--s angiver filstørrelse
--w bestemmer om den givne fil kan skrives til

De næste to filoperatorer returnerer en boolesk værdi. Den tredje operator returnerer filstørrelsen i bytes. Følgende tekst illustrerer brugen af ​​disse operatorer:

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

OPERATØRENS UDFØRELSESPRIORITETER

Som ethvert programmeringssprog bestemmer Perl udførelsesprioriteterne for operatører, ved hjælp af hvilken rækkefølgen af ​​deres udførelse er bestilt. Tabel 12.2 viser operatørprioriteterne fra højeste til laveste:

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

I dit script kan du ændre rækkefølgen, som udsagn udføres i ved hjælp af parenteser.

PERL KONSTRUKTER

Perl understøtter alle C-udtryk ved hjælp af et næsten identisk format. For eksempel konstruerer kontrol, hvis, mens, gør. for og goto bruges i samme form på begge sprog. Som du vil se senere, har fortsæt-sætningen en lidt anden betydning i Perl. Dens tidligere værdi kaldes nu næste, og pausesætningen kaldes nu sidst. Perl implementerer ikke en switch-erklæring. Derudover kan nogle C-sprogsudtryk findes i Perl i andre formater, og mange nye udtryk er tilføjet.

ENKLE OG KOMPOSIT OPERATORER

Et simpelt udtryk er enhver gyldig kombination af operatorer og operander. I Perl er en operator et udtryk, der ender med et semikolon. Som i programmeringssproget C slutter alle udsagn med semikolon. Når du udsender programtekst til debuggeren, kan du udelade semikolon, fordi debuggeren vil levere det til dig. Følgende tekst illustrerer en simpel opgaveoperatør i Perl:

$Title = "Webprogrammering"; !}

Ligesom C-programmering kan Perl-scripts indeholde sætningsblokke eller sammensatte sætninger, som er placeret inde i krøllede parenteser (()), som vist nedenfor:

(#Operators#Endnu en operatorblok)

Dine scripts vil gøre omfattende brug af instruktionsblokke sammen med mere komplekse udsagn. Som i C kan Perl-scripts bruge sætningsblokke til at definere omfanget af lokale variabler. Definitionen af ​​lokale variable i en blok er dog ikke automatisk. Scriptet skal bruge det lokale nøgleord til at erklære dem. Vi vil se nærmere på omfanget af variabler senere i dette kapitel.

BETINGEDE OPERATØRER

Mange af de foregående eksempler brugte if-sætningen. I Perl er if-sætningen næsten identisk med if-sætningen i C. Forskellen er dog, at i C kan if-sætningen bruge en simpel sætning uden krøllede klammeparenteser, hvorimod udsagn i Perl skal være omsluttet af krøllede klammeparenteser. danner en blok.

Hvis (udtr.) erklæring; // acceptabelt for C, men ikke for Perl if (udtr.) (sætning; # sådan skal du gøre det i Perl)

På samme måde fungerer Perls else-udsagn lidt anderledes end den tilsvarende udsagn i C. I Perl skal udsagn også være omsluttet af krøllede parenteser og danne en blok:

// Eksempel i C er ikke acceptabelt i Perl, hvis (udtr1) statament1; else if (udtr2) statement2; andet ststement3;

Det følgende viser, at Perl giver dig mulighed for at bruge elsif-konstruktionen:

If (udtr1) ( udtr.1; ) elsif (udtr2) ( udsagn2; ) andet ( ststement3; )

OPERATØR MEDMINDRE

I programmeringssproget C bruger programmører logisk negation (!) til at vende en boolsk værdi, som vist nedenfor:

Hvis (!(udtr.)) // Negation i C ( sætning; )

Sammen med brugen af ​​logisk negation indeholder Perl-scripts ofte en unless-sætning, som gør det samme som C-koden ovenfor.

Medmindre (udtr.) ( statement; )

Bemærk: I modsætning til C indeholder Perl ikke en switch-sætning.

GØR OPERATØR

Et særligt tilfælde af blokoperatorer er do-operatoren, som tillader en blok af udsagn at returnere værdier. Værdien, som do-sætningen returnerer, er værdien af ​​det sidste udtryk, der blev evalueret i blokken. For eksempel sammenligner følgende do-sætning strengvariablen $Month med årets måneder og indstiller variablen $DayCount til antallet af dage i måneden:

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

Bemærk, at Perl kræver et semikolon i slutningen af ​​do-blokken. Forveksle ikke do-blokken med do while-sætningen, som vil blive diskuteret senere i dette kapitel.

CYKLER OG GRENE

Perl understøtter for, while og do loop-sætninger med små forskelle fra deres implementering i C. Den væsentlige forskel er, at Perl kræver, at sætninger bruges i blokke omsluttet af krøllede parenteser. Som du vil se, udvider Perl også loop-konstruktionen for at give nogle nye former. I de følgende eksempler fungerer for-, while- og do-løkkerne på samme måde i C og Perl:

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

Designet af loops i C er også anderledes end i Perl, idet Perl ikke indeholder en break-sætning, og continu-sætningen udfører en helt anden funktion. Heldigvis giver Perlo nogle nye, mere fleksible og mere intuitive konstruktioner:

For at forstå loop-konstruktioner i Perl skal du forstå brugen af ​​fortsæt-blokken. Overvej følgende while-løkke, som indeholder en fortsæt-blok:

$i = 100; mens ($i > 0) ( print $i; ) fortsæt ($i-)

Du kan tænke på en fortsæt-blok som det tredje udtryk i en for-løkke, der udføres hver iteration. På samme måde udfører Perl en fortsæt-blok i slutningen af ​​hver iteration. Men som du vil lære senere, giver fortsæt-blokken scriptet mere kontrol over processen, end en for-løkke giver. Når en Perl-løkke bruger en næste sætning, udføres kontinueringsblokken stadig, hvis den eksisterer. Men hvis løkken bruger en redo-sætning, udføres fortsæt-blokken ikke.

TAGS

I et Perl-script betyder etiketter blot et navn, der svarer til en position i scriptet. Etiketnavne slutter med et kolon (f.eks. outerloop:). Ved hjælp af goto-sætningen kan scriptet hoppe til en etiket. Derudover kan de sidste, næste og redo-operatorer bruges til at springe til en etiket. Følgende kode illustrerer brugen af ​​den sidste operator til at hoppe til en etiket:

Outerloop: while ($i > 0) ( while ($j > 0) ( #Nogle anden proces her if ($needToAboutLoop) ( last outerloop; ) ) )

I dette tilfælde indeholder instruktionen en sidste gren til at hoppe til den ydre løkke og afslutte løkken.

INDTIL LOOP

En anden loop-konstruktion i Perl er indtil-løkken, som er det modsatte af while-løkken. Husk, i en while-løkke, udføres sætninger, så længe den angivne betingelse er opfyldt. I en indtil-løkke, på den anden side, udføres instruktioner, indtil en betingelse er opfyldt. Overvej for eksempel en while-løkke som den, der vises på næste side.

Mens (!(udtr.)) ( sætning; )

Ved at bruge en indtil-løkke kan du oprette en identisk løkke vist nedenfor:

Indtil (udtr.) ( erklæring; )

På samme måde bruger følgende do while-sætning den logiske negationsoperator til at loope, indtil et givet boolsk udtryk evalueres til sandt:

Do ( statement; ) while (!(udtr.));

Ved at bruge gør indtil-konstruktionen kan du danne en identisk løkke uden at bruge logisk negation:

Gør ( statement; ) indtil (udtr);

FOR OG FORHVER CYKLER

Perl understøtter loops på en meget lignende måde som C:

For (udsagn1; udtryk; udsagn2) (udsagn3; )

For eksempel bruger følgende kode en for-løkke til at udskrive værdierne af tal fra 0 til 100:

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

Derudover inkluderer Perl en foreach loop-konstruktion, der tillader et script at iterere over lister og arrays. Lad os se på et eksempel:

@liste = ("a","b","c"); foreach $arg (@list) ( udskriv "Listeelement: $arg\n"; ) foreach $i (1..10) ( udskriv "iteration $i\n" )

I det første tilfælde itererede foreach loop gennem værdierne af @list-variablen. I det andet eksempel itererer foreach-løkken over tal i området fra 1 til 10. Foreach-løkken kan indeholde en liste over bogstaver eller en matrix, som illustreret i det foregående eksempel. Efter én iteration af løkken tager en speciel skalarvariabel ($arg i det første tilfælde og $i i det andet tilfælde) en værdi fra den givne liste af elementer. Omfanget af denne skalarvariabel i en foreach loop er begrænset til loopens krop. Derfor vil en skalær løkkevariabel, foreach, ikke være i konflikt med et identisk variabelnavn defineret uden for løkken. Følgende kode bruger en variabel ved navn $i i og uden for en foreach loop:

$i = 1001; foreach $i (1..9) ( print "$i\n"; # loop vil udskrive 123456789 ) print "$i\n";

Som du kan se fra dette eksempel, er $i-variablen, der bruges til at organisere loop-iterationerne, ikke i konflikt med $i-variablen, der er defineret uden for loopen. En funktion ved foreach-løkken, som dine scripts kan drage fordel af, er evnen til at ændre array-elementer. (Vær forsigtig, når du implementerer denne funktion!) Overvej følgende foreach-løkke, som tilføjer værdien 10 til hvert array-element:

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

Lad os lave et par sidste bemærkninger om foreach loop. Perl behandler navnene både for og for som synonymer. Derfor kan du bruge disse navne i flæng i scripts. Perl vil til gengæld bestemme typen af ​​sløjfe baseret på dens kontekst.

UBETINGET JOBFØRER GÅ TIL

Perl understøtter goto-operatoren, som er identisk med C-programmeringssprog-operatoren. Nedenfor er et eksempel på brug af goto-operatoren til at udskrive tal fra 1 til 10:

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

OPERATØR MODIFIKATIONER

Perl bruger specielle former for if, unless, while og indtil-konstruktionerne til at kontrollere beregningernes fremskridt. I visse tilfælde kan disse specielle konstruktioner gøre din kode klarere og lettere at læse. For at gøre koden lettere at læse og dens betydning mere indlysende, er det tilrådeligt at vælge et passende format til optagelse. Overvej et watch-udtryk, der bruger die-funktionen til at afslutte scriptet, hvis værdien af ​​$count-variablen er mindre end 10:

Hvis ($tæller< 10) { die; }

Ved at placere terningsfunktionen før if-sætningen, som vist nedenfor, vil antallet af kodelinjer blive reduceret:

Dø hvis ($count< 10);

På samme måde kan det samme udtryk skrives som følger:

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

I dette tilfælde, hvis $count-variablen er større end eller lig med 10, stopper Perl yderligere evaluering på den linje, og die-funktionen udføres ikke. Ellers, hvis $count-variablen er mindre end 10, efter at have evalueret den første del af udtrykket, koden kører die-funktionen og afslutter derved udførelsen af ​​scriptet. Til sidst, i det følgende eksempel, reducerer brug af unless-konstruktionen også antallet af linjer til én:

Dø medmindre ($count >= 10);

På samme måde er følgende mens-løkker identiske:

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

Som du kan se, ved hjælp af en ændring af designet, giver scriptet dig mulighed for at reducere antallet af linjer i løkkeindgangen til én. På samme måde er følgende indtil-løkker ækvivalente:

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

Bemærk: I alle fire tilfælde, selvom udtrykket, der skal evalueres, kommer efter den sætning, der skal udføres, evaluerer Perl først betingelsen og udfører først derefter sætningen.

GENERERING AF DYNAMISKE UDTRYK VED BRUG AF EVAL-FUNKTIONEN

Fordi Perl er et fortolket sprog, kan dine scripts bruge Perl til at generere kode<налету>, det vil sige dynamisk under scriptudførelse. Det er præcis sådan, Perl-debuggeren (som i sig selv er et Perl-program ved navn Perldb.PL) fungerer. Når du designer scripts, kan du bruge sådan dynamisk kode til at skabe dynamiske variabler eller endda bygge specielle rutiner. Perl evaluerer dynamiske udtryk ved hjælp af eval-funktionen. Følgende eksempel opretter en dynamisk instruktion ved at tildele værdien af ​​en variabel til tekst, som faktisk indeholder den nødvendige Perl-instruktion. Yderligere instruktioner bruger eval-funktionen til at udføre denne instruktion:

$perl_statement = "udskriv "Hej verden\n";"; eval $perl_statement; # vil udskrive Hej, verden $i = 1001; $varname = "$i"; print eval $varname; # vil udskrive værdien af ​​$i

Bemærk: Der er farer ved at bruge eval-funktionen i et script, især hvis scriptet videregiver brugerleverede data til eval-funktionen. Ved at bruge eval-funktionen kan et script udføre en vilkårlig Perl-kommando, herunder endda systemkommandoer. Dette giver brugeren kontrol over programmet, hvilket kan være særligt risikabelt på internettet og nettet.

SUBRUTINER

Som alle strukturerede programmeringssprog understøtter Perl rutiner. En underrutine kan defineres ved at bruge undernøgleordet som vist nedenfor:

Sub demo_sub ( udskriv "demo_sub kaldet\n"; ) &demo_sub; # subrutineopkald

I dette tilfælde danner instruktionerne en underrutine kaldet demo_sub. For at kalde en underrutine placerer scriptet et og-tegn (&) foran underrutinenavnet. Når du kalder en underrutine i Perl, kan parenteserne udelades. Du kan placere en rutine hvor som helst i et scripts kildekode, fordi Perl vil parse al kildekoden, før scriptet udføres. Du kan erklære en subrutine i kildekoden umiddelbart efter den første brug af subrutinen (fremadrettet reference). Underrutiner kan have argumenter og returværdier. Følgende kodestykke indeholder en rutine kaldet show_value, der udskriver værdien modtaget af rutinen som en parameter:

Sub show_value ( udskriv "Værdien id ", $_; ) &show_value(1001);

Formelt erklærer en Perl-rutine ikke variabler til lagring af argumenter. I stedet sendes en matrixvariabel ved navn @_ til rutinen, som indeholder parameterværdierne. Til gengæld får rutinen adgang til værdierne af argumenterne ved hjælp af følgende notation for array-elementer: $_, $_ osv. Denne metode til at sende parametre kan dog forringe kodens læsbarhed, og derfor bruger de fleste rutiner kopiering af argumenter til lokale variabler. I lighed med det foregående eksempel viser følgende show_fwo_values-rutine værdierne af to parametre:

Sub show_two_values ​​​​( udskriv "Første parameter ", $_, "\n"; udskriv "Anden parameter", $_, "\n"; ) &show_two_values(1001, 2002);

Til sidst udskriver den næste funktion, show_all_values, værdierne for alle de parametre, den modtager. Funktionen bruger et array til at definere et tal 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 nævnt kan Perl-rutiner returnere værdier. Til dette bruges returopgørelsen. I modsætning til C-sproget kræver Perl ikke brug af en returerklæring. Hvis rutinen ikke indeholder en return-sætning, vil det sidst evaluerede udtryk blive taget som returværdi. Følgende eksempel tilføjer to parametre og returnerer resultatet:

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

BIBLIOTEK AF UNDERRUTINER

I modsætning til C understøtter Perl faktisk ikke konceptet om et bibliotek. Det har dog en mekanisme, der tillader scripts at bruge kildekode fra en anden fil. Antag for eksempel, at du gemmer add_valuesl rutinen i en fil kaldet addvalue.pl. Ved at bruge require-sætningen kan et andet Perl-script få adgang til denne rutine, som vist nedenfor:

Kræv "addvalue.pl"; print &add_values(10,11);

Du kan tænke på require-sætningen som analog med C-præprocessorens #include-sætning. For at finde en kildefil, kigger Perl først i standardmappen for Perl-biblioteket (se installationsinstruktionerne for detaljer), og derefter i den aktuelle mappe. Du kan også bruge en absolut eller relativ sti, der er tilføjet filnavnet. Perl husker, hvilke filer der blev anmodet om af require-sætningen og indlæser dem kun én gang, selvom disse filer tilgås flere gange. Der er mange standardbiblioteker, der udvider Perl-sprogets muligheder. Nu er det et godt tidspunkt at vandre gennem biblioteket, hvor Perl-biblioteksfilerne er gemt for at få en idé om de muligheder, de tilbyder.

BRUG AF PAKKER TIL AT ISOLERE SUBRUTINER

Hvis du har mange rutiner, især rutiner, som du gemmer i forskellige filer, kan der opstå kollisioner med variabelnavne, når det samme variabelnavn bruges til forskellige formål. Perl hjælper med at undgå dette med pakker. Som du ved, kan du undgå navnekollisioner ved at deklarere lokale variabler for subrutiner. Men hvis flere rutiner deler specifikke data, kan disse data kræve et globalt omfang, hvilket kan føre til navnekollisioner. Ved hjælp af pakker kan du gruppere globale data i private navneområder, uden for hvis globale variabler ikke er synlige, dvs. ukendte . Overvej det enkle eksempel nedenfor, hvor to rutiner (placeret i forskellige filer) bruger private, individuelle navnerum.

# 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, bruger den første rutine pakkenavnet demo_one, den anden rutine bruger pakkenavnet demo_two. Begge rutiner kan indstille og bruge $some_data-variablen uden at forårsage en navnekollision mellem en global variabel og den anden. Manuskript<знает>navnet på den pakke, hvori variablen ligger og organiserer adgangen til den, bruger pakkenavnet som et præfiks til variabelnavnet. Følgende eksempel tilføjer pakkenavnet pakke_en eller pakke_to som et præfiks til variabelnavnet nogle_data:

&sub_one; &sub_two; print "Variabel 1 $package_one"nogle_data\n" print "Variabel 2 $pakke_to"nogle_data\n"

Når du bruger Perl-pakker, kan du oprette et unikt navneområde i den aktuelle kildefil ved at placere en pakkesætning i begyndelsen af ​​filen, som vist nedenfor:

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

I dette tilfælde eksisterer variablen $some_data kun i pakken og er derfor beskyttet mod forkert adgang. Brug af en pakke giver således dataene samme omfang som i programmeringssproget C, hvor globale variabler har deres omfang i kildekodefilen, hvori de er deklareret. Når du kalder en rutine fra en anden scriptfil, skal du bruge pakkenavnet:

Kræv "some_package.pl"; udskriv &some_package_name"some_sub;

RÆKKEBEHANDLING

I de foregående eksempler lærte du, hvordan man konstruerer strengliteraler ved hjælp af variabel interpolation. Du lærte også, hvordan man sammenkæder strengliteraler og strengvariabler. I dette afsnit kan du se, at Perl giver et stort sæt funktioner, som scripts kan bruge til at manipulere strenge.

CHOP FUNKTION

Chop-funktionen fjerner det sidste tegn i en streng. Det har følgende format:

$character = chop(Str);

Chop-funktionen returnerer det fjernede tegn. Perl-scripts gør udstrakt brug af chop til at fjerne newline- og end-of-line-tegn.

INDEKSFUNKTION

Indeksfunktionen søger efter en given understreng i en streng. Det har følgende format:

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

Indeksfunktionen returnerer indekset for den første forekomst af en understreng (SubStr) i en streng (Str). En Offset kan eventuelt angives, hvorefter søgningen begynder. Hvis understrengen findes, returneres værdien -1. I det følgende eksempel søger indeksfunktionen efter forekomster af understrengen "na" efter det tredje tegn i strengen "banana":

Udskriv index("banan","na",3); # Udskrifter 4.

Funktionen rindex leder efter den sidste forekomst længst til højre af en understreng i en streng og returnerer positionsværdien af ​​det første tegn i understrengen. Funktionen har følgende format:

$placering = rindex(Str, SubStr);

Denne funktion ligner indeksfunktionen, bortset fra at den returnerer den sidste forekomst i stedet for den første. For eksempel bruger følgende eksempel rindex-funktionen til at bestemme den sidste forekomst af understrengen "na" i strengen "banana":

Udskriv rindex("banan","na"); # Udskrifter 4

LÆNGDE FUNKTION

Længdefunktionen returnerer antallet af tegn i en streng. Det har følgende format:

$len = længde(Str);

Følgende eksempel bruger længdefunktionen til at udskrive antallet af tegn i en streng:

Udskriftslængde("banan"); # Udskrifter 6

SUBSTR FUNKTION

Substr-funktionen bruges til at fjerne en del af en streng. Det har følgende format:

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

Funktionen returnerer en understreng, det vil sige en del af en streng, hvis længde ikke overstiger værdien angivet af den valgfrie Len-parameter. Den returnerede understreng af str begynder ved tegnet på den position, der er angivet af Offset. Hvis Len-parameteren udelades, så indeholder den returnerede streng tegn til og med slutningen af ​​linjen.Hvis Offset-parameteren er negativ, så beregnes offset fra slutningen af ​​linjen. Endelig kan scriptet bruge substr som en lværdi til at udføre en tildelingsoperation. Følgende kodestykke illustrerer brugen af ​​substr-funktionen.

Print substr("orange",3); #Output "nge" print substr("orange", -2); # Udskriver "ge" print substr("orange",2,2); # Udskriver "an" $str = "æble"; substr($str,-3) = "rikot"; print $str; # Udskriver "abrikos"

Bemærk: Brug af Perl regulære udtryksoperatorer er ofte mere effektivt end at bruge substr-funktioner. Regulære udtryk diskuteres senere i dette kapitel.

JOIN FUNKTION

Sammenføjningsfunktionen forbinder en liste af elementer i en streng, der adskiller hvert element med et givet tegn. Det har følgende format:

$ny_streng = join(Str,Liste);

Sammenkædningsfunktionen konverterer hvert element i en liste til en streng og forbinder strengene. Følgende kodestykke illustrerer brugen af ​​joinfunktionen:

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

SPLIT FUNKTION

Split-funktionen opdeler indholdet af en streng i en liste af elementer. Det har følgende format:

Split(Delimeter, Str[,Grænse]);

Argumentet Delimeter angiver det tegn, som skal opdeles med, såsom mellemrum, ord, tabulator osv. e. Den valgfrie grænse parameter angiver det maksimale antal elementer, listen kan indeholde. Følgende eksempel illustrerer brugen af ​​splitfunktionen.

FUNKTIONER TIL BEHANDLING AF LISTER

I eksemplerne diskuteret tidligere i dette kapitel lærte vi, hvordan man opretter en liste, gemmer den som værdien af ​​en variabel, gentager alle listens elementer og får adgang til et individuelt element i listen. I dette afsnit lærer du nogle flere funktioner, der udvider dine listearbejdsevner.

BAGE FUNKTION

Den omvendte funktion vender elementerne i en liste. Det har følgende format:

@ny_liste = omvendt(@Liste);

Den omvendte funktion vender en liste og returnerer en ny resulterende liste. Følgende eksempel illustrerer brugen af ​​den omvendte funktion:

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

SORTERINGSFUNKTION

Sorteringsfunktionen sorterer elementerne i en liste. Det har følgende format:

@ny_liste = sort(@Liste);

@ny_liste = sort(Underrutine @Liste);

@ny_liste = sort(Blokudsagn @Liste);

Sorteringsfunktionen placerer elementer i en liste og sorterer dem i henhold til ordenstegnsnumrene i ASCII-tabellen. Ligesom den omvendte funktion returnerer sorteringsfunktionen en ny liste som dens værdi og påvirker ikke den oprindelige liste. Følgende eksempel illustrerer brugen af ​​sorteringsfunktionen:

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

I en underrutine eller blok kan du ændre rækkefølgen, som sorteringen udføres i. Følgende eksempel illustrerer brugen af ​​sorteringsfunktionen.

@liste = 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

FUNKTIONER TIL ARBEJDE MED ARRAYS

Som du ved, er et array en datastruktur, der indeholder en eller flere værdier af samme type, for eksempel 100 elevnavne. Perl indeholder flere indbyggede funktioner, der hjælper dig med at arbejde med array-elementer. De følgende afsnit dækker flere grundlæggende array-behandlingsfunktioner.

PUSH OG POP FUNKTIONER

Perl-scripts bruger push- og pop-fiktioner til at tilføje og fjerne elementer fra slutningen af ​​et array. Med andre ord giver push- og pop-funktionerne scripts mulighed for at udføre stablede operationer på sidst-ind, først-ud-basis. Push-funktionen har følgende format:

Push(@ARRAY, LIST);

Følgende uddrag illustrerer brugen af ​​push-funktionen:

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

I modsætning hertil fjerner pop-funktionen det element, der sidst blev skubbet ind på stakken, og returnerer værdien af ​​dette element. Pop-funktionen har følgende format:

$værdi = pop(@ARRAY);

Følgende programfragment illustrerer brugen af ​​pop-funktionen:

# Lad os tage @list fra det forrige eksempel print pop(@list); # Udskriv 3 print pop(@list); # Udskriver 2 # Nu @liste (10,20)

SHIFT FUNKTION

Skiftfunktionen fjerner og returnerer et element fra begyndelsen af ​​et array. Denne funktion ligner pop-funktionen med den eneste forskel, at den fungerer fra begyndelsen af ​​arrayet efter FIFO-princippet (<первым вошел, первым вышел>). Skiftfunktionen har følgende format:

$værdi = skift(@ARRAY);

Følgende programfragment illustrerer brugen af ​​shift-funktionen:

# Lad os tage @list fra det forrige eksempel

Udskriv shift(@list); # Udskriv 10 print shift(@list); # Udskriver 20 # Nu @list()

FJERN SKIFT FUNKTION

Unshift-funktionen tilføjer et eller flere elementer til begyndelsen af ​​et array. Den har følgende kode:

Unshift(@Array, List);

Følgende programfragment illustrerer brugen af ​​unshift-funktionen:

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

SPLICE FUNKTION

Perl-scripts bruger splejsningsfunktionen til at fjerne elementer fra en liste, og erstatte dem med elementer fra en anden liste. Det har følgende format:

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

Splejsefunktionen fjerner det angivne antal elementer (Count) fra et array (@Array), startende med det element, der peges på af offsetværdien (Offset), og erstatter elementerne med elementer fra en anden liste (List). Hvis funktionskaldet ikke angiver en Count-parameter, henter funktionen elementer helt til slutningen af ​​arrayet. Hvis funktionskaldet ikke angiver en liste, hvis elementer erstatter de originale elementer, tilføjer funktionen ingen elementer til den originale liste. Følgende udtryk illustrerer brugen af ​​splejsningsfunktionen:

@liste = 1..10; splice(@liste,1,8,5,6); # @liste = (1,5,6,10)

SKALAR FUNKTION

Den skalære funktion bestemmer antallet af elementer på en liste. Det har følgende format:

Rsult = scalar(Liste);

Typisk behøver Perl-scripts ikke at bruge den skalære funktion med arrays, for når et script får adgang til et array ved at skrive det i en skalar kontekst, returnerer det antallet af array-elementer. Scripts kan dog bruge den skalære funktion i tilfælde, hvor konteksten er tvetydig, eller hvis listen ikke er en matrix. Følgende udtryk illustrerer brugen af ​​skalarfunktionen.

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

GREP FUNKTION

grep-funktionen filtrerer listeelementer, som et givet udtryk evaluerer til<ложно>. Det har følgende format:

@list = grep(Udtryk, Liste);

grep-funktionen itererer gennem elementerne i en liste og erstatter dem som argumenter i et givet udtryk. grep-funktionen tildeler det aktuelle udtryk for et listeelement til variablen $_ og evaluerer det givne udtryk. Hvis det resulterende udtryk er sandt, tilføjer grep-funktionen det element til den resulterende liste. Følgende programfragment illustrerer brugen af ​​grep-funktionen:

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

Bemærk: Hvis udtryk, ændrer en variabel. $_, så vil den originale liste også blive ændret.

FUNKTIONER TIL BEHANDLING AF ASSOCIATIVE ARRAYS

Som det er kendt, er associative arrays de arrays, hvor indekset ikke er en numerisk værdi, men for eksempel et navn. Perl har flere indbyggede funktioner, der gør det nemmere for scripts at håndtere associative arrays.

TASTER FUNKTION

Nøglefunktionen returnerer de nøgleværdier, der svarer til en associativ matrix. Det har følgende format:

@key_list = nøgler(%Array);

Tasterfunktionen returnerer et array af nøgler som en almindelig liste. Følgende programfragment illustrerer brugen af ​​nøglefunktionen:

$ages("Bob") = 25; $ages("Mary") = 30; $ages("Zack") = 15; @list = nøgler(%aldre); # @list vil være "Zack", "Bob", "Mary" @list = sorteringsnøgler %ages # @ list "Bob", "Mary", "Zack" for $key (sorteringsnøgler %ages) (udskriv "$ nøglen er $ages($key)\n" )

VÆRDIER FUNKTION

Værdifunktionen returnerer et regulært array, der består af værdierne af et associativt array. Det har følgende format:

@value_list = værdier(%Array)

Værdifunktionen returnerer en matrix af associative matrixværdier som en almindelig liste. Følgende programfragment illustrerer brugen af ​​værdifunktionen:

# Brug værdierne fra det foregående eksempel %ages = ("Bob", 25, "Mary", 30, "Zack", 15); @list = sorteringsværdier %ages; # @liste (15, 25, 30) @liste = %aldre; # @list("Zack", 15, "Bob", 25, "Mary", 30)

HVER FUNKTION

Hver funktion itererer gennem elementerne i et associativt array. Det har følgende format:

@key_values ​​= hver(%Array);

Når scriptet kalder hver funktion, returnerer det en liste over to komponenter, der indeholder et nøgle-værdi-par. Når funktionen når slutningen af ​​listen, returnerer den en tom liste. Næste gang funktionen kaldes, starter iterationsprocessen forfra. Følgende programfragment illustrerer brugen af ​​hver funktion:

# Brug værdierne fra det foregående eksempel %ages = ("Bob", 25, "Mary", 30, "Zack", 15); mens (($name, $age) = hver %ages) ( # Print ages print "$key is $ages($key)\n"; )

SLET FUNKTION

Sletfunktionen fjerner elementer i en associativ matrix. Det har følgende format:

Slet $Array(Key)

Følgende sætning bruger delete-funktionen til at fjerne elementet, der svarer til nøglen Bob fra $Employees associative array:

Slet $Employees("Bob")

KOMMANDO LINJE ARGUMENTER

Perl-scripts kan nemt få adgang til kommandolinjeargumenter. Når et script køres, placerer Perl scriptets kommandolinjeargumenter i @ARGV listevariablen. Følgende programfragment bruges til at udskrive kommandolinjeargumenter til skærmen:

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

ADGANG TIL MILJØVARIABLER

Adgang til miljøvariabler i Perl-scripts er også meget let. Når et script køres, placerer Perl kopier af miljøvariablerne i et associativt array kaldet %ENV. Følgende sætning bruger %ENV-arrayet til at vise den aktuelle mappe:

Udskriv "$ENV(PATH)\n"; # Udskriv den aktuelle mappe

Ud over at hente værdier fra %ENV-arrayet, kan scripts også ændre array-elementer. Sådanne ændringer af %ENV-arrayet vil ændre indstillingen af ​​miljøvariablen for enhver underordnet proces, der er oprettet af scriptet. For eksempel, næste instruktion bruger %ENV-arrayet til at ændre den aktuelle sti:

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

Bemærk: Ændringer, som scriptet foretager i %ENV-arrayet, vil ikke påvirke de originale miljøvariabler. Med andre ord, efter at scriptet er færdigt med at køre, ændres systemmiljøvariablerne ikke.

FILINDGANG OG OUTPUT

Perl er specielt designet til at være et passende værktøj til at læse og skrive tekstfiler. Men som du vil lære senere, udfører Perl random access og binære fil I/O-funktioner. Filhandlinger kræver et filhåndtag, som er en variabel, der svarer til en specifik fil. Som standard har hvert Perl-script tre standardpointere, som Perl automatisk åbner, når scriptet kører: STDIN, STDOUT, STDERR. Disse tre standardpointere svarer til standardstrømmene STDIN, STDOUT, STDERR i programmeringssproget C. Derudover kan Perl-scriptet åbne yderligere pointere til andre specifikke filer.

ÅBNING AF FILER OG ANDRE STREAMS

For at et script kan bruge en fil, skal det kalde den åbne funktion. Det ser sådan ud:

Åbn (Filhåndtag[, Filnavn])

I modsætning til C runtime library open-funktionen, indeholder Perls åbne funktion ikke en tilstandsparameter i funktionskaldet. Perl bestemmer tilstanden til at åbne en fil baseret på filnavnet. Tabel 12.3 illustrerer forholdet mellem filåbningstilstand og filnavn.

Bord 12.3. Perl filnavngivningskonventioner og adgangstilstande

Hvis et filnavn udelades fra det åbne funktionskald, antager Perl, at filnavnet er indeholdt i strengvariablen $FileHandle. Når scriptet er færdig med at bruge filen, lukkes det ved at bruge lukkefunktionen som vist nedenfor:

Luk (Filhåndtag);

Et programfragment illustrerer brugen af ​​åbne og lukke funktionerne:

Åbn(InFile, "test.dat") || dø; # åben til læsning # test.dat åben(OutFile, ">test.dat") || dø; # create test.dat $AuxFile = ">>test.dat"; åben(Aux, $AuxFile) || dø; # åbner for færdiggørelse # test.dat close(InFile); close(OutFile); luk(Aux);

Bemærk, at filmarkører ikke har de sædvanlige enkelttegnspræfikser. Som du vil lære senere, kan Perl-scripts gemme pointernavne som skalære variable strenge og videregive markøren til enhver funktion, der kan behandle dem. Perl udfører værdikonvertering om nødvendigt.

På MS-DOS understøtter Perl en ekstra funktion kaldet hinmode, der tillader filinput/output at skifte mellem tekst og binære tilstande. I de fleste systemer er skelnen mellem tekst og binære tilstande ligegyldig. For MS-DOS-operativsystemet er det nye linjetegn dog en sekvens af to tegn (CR+LF). Da de fleste programmer ikke forventer at støde på to tegn i slutningen af ​​en linje, skal I/O-systemet udføre konverteringen. For at bruge binmode-funktionen skal den tilsvarende markør åbnes. Binmode-funktionen har følgende format:

Binmode(Filhåndtag);

LINJE-LINE LÆSE OG SKRIVE DATA

Den enkleste måde for et script at læse en linje fra en fil på er at bruge operatoren . I Perl bliver en filmarkør omgivet af trekantede parenteser til input-symbolet. For eksempel illustrerer det følgende programfragment brugen af ​​inputtegnet til at læse og vise indholdet af filen Test.dat.

Åbn(InFile, "Test.dat") || dø; mens ($line = ) ( print $line; # Udskriver en linje fra en fil ) close(InFile);

Når inputtegnet når slutningen af ​​filen, returnerer det false, hvilket i dette tilfælde afslutter udførelsen af ​​while-løkken. Der er et særligt (tomt) inputtegn, der er angivet med<>, som har en meget specialiseret, men nyttig applikation. Første gang et script bruger et tomt inputtegn<>, parser den kommandolinjeargumenterne. Hvis strengen @ARGV er tom, så inputtegnet<>lyder fra STDIN. Hvis i stedet @ARGV ikke er tom, åbner Perl den første af de filer, der er angivet i @ARGV-variablen og læser indholdet af filen. Når Perl er færdig med at behandle en fil, går den videre til den næste. Når scriptet har læst alle filerne, vises symbolet<>returnerer falsk. Perl-scripts kan også bruge inputtegnet til at læse hele indholdet af en fil i et array, så hver linje i filen bliver et element i arrayet. For eksempel læser følgende sætning fra STDIN-filen ind i @lines-arrayet:

@linjer = ;

At skrive data til en fil er også ret simpelt. Faktisk gjorde du dette hver gang du brugte printfunktionen. Det fulde format af printfunktionen er som følger:

Udskriv Liste;

Hvis printfunktionen ikke modtager en filmarkør som argument, sender den outputtet til STDOUT. Følgende programfragment illustrerer brugen af ​​printfunktionen til at tilføje data til en outputfil:

Open(LogFile, ">>logfile.dat") || dø; ############## ($m, $d, $y) = (lokaltid(tid)) ; print LogFile "Captain"s log, Stardate ++m$/$d/$y\n"; close(LogFile);

Bemærk: Filmarkøren og outputlisten er ikke adskilt af et komma.

LÆSE OG SKRIVE DATABLOKKE

Programmører behandler ofte tekstfiler som tekststrømme, simpelthen fordi et tegn følger efter et andet indtil slutningen af ​​filen. Hvis scriptet skal arbejde med en fil, der er blokorienteret i stedet for trådorienteret, så kan scriptet bruge sysread og syswrite funktionerne til at behandle faste datablokke. Funktionerne sysread og syswrite har følgende formater:

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

Hvis et funktionskald specificerer en offset fra begyndelsen af ​​filen (Offset), så vil funktionerne søge efter det sted, hvorfra de vil begynde I/O-operationer. Sysread- og syswrite-funktionerne sender begge data ved hjælp af en skalær strengvariabel. Fordi funktioner behandler faste hukommelsesblokke, kan data indeholde binære værdier, herunder nuller og slutningen af ​​filen. Hvis funktionskaldet angiver en offset fra begyndelsen af ​​filen (Offset), så søger funktionen efter den placering i filen, hvorfra den begynder at udføre I/O-operationer. Hvis du arbejder med datablokke, kan scripts også bruge følgende I/O-funktioner:

$result = seek(FileHandle, Position, Base); $result = tell(FileHandle); $result = eof(FileHandle);

Seek-funktionen fungerer nøjagtigt som C runtime library-funktionen fseek. Position-parameteren angiver positionen i forhold til oprindelsen, som igen er specificeret af Base-parameteren som følger:

Perls tell-funktion fungerer præcis som C runtime-bibliotekets ftell-funktion. Denne funktion returnerer den aktuelle position i filen, hvorfra en læse- eller skriveoperation udføres. Endelig returnerer eof-funktionen ligesom C-sprogfunktionen feof værdien<истинно>eller<ложино>, som scriptet kan bruge til at bestemme, hvornår slutningen af ​​filen er nået.

BINÆR DATABEHANDLING

Selvom Perl primært er fokuseret på tekstbehandling, kan den også behandle binære data. Scripts kan flytte binære data i bidder ved hjælp af strengvariabler og udføre byte I/O-operationer ved hjælp af sysread- og syswrite-funktionerne. Dog for at udrette noget<полезное>med data tvinges scriptet til at konvertere dataene til sine egne<родные>skalære formater.

BINÆR DATALAGRING

Når et Perl-script læser en blok af binære data ved hjælp af sysread-funktionen, placerer det disse binære data i en skalær strengvariabel. Perl er ligeglad med, om disse er givet, om de indeholder nuller eller ikke-ASCII-værdier. Inden for en tegnstreng accepterer Perl bytes som bytes. I modsætning til C bruger Perl ikke null-terminerede strenge. Hvis dataene er ASCII, kan scriptet behandle det som enhver tekst. Men hvis dataene er binære, skal scriptet dekomprimere det, før Perl kan behandle dataene.

UDPAKNING AF BINÆRE DATATRENGE I PERL-VARIABLER

For at scriptet kan få adgang til binære data, skal det pakke det ud i sit eget skalære format. Perl-scripts pakker data ud ved hjælp af unpack-funktionen, som har følgende format:

$result = unpack(Skabelon, Udtryk);

Udtryk er en regulær strengvariabel, der indeholder binære data læst af sysread-funktionen, men kan også være et udtryk, der skal fortolkes som en streng. Skabelon er en tegnskabelonstreng, der beskriver, hvordan man fortolker værdierne i Expression-operanden. Følgende programfragment illustrerer brugen af ​​unpack-funktionen:

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

Hvert mønstertegn kan efterfølges af et tal, der angiver, hvor mange gange det pågældende tegn skal bruges. Hvis der er en stjerne (*) i stedet for et tal, udføres handlingen på alle resterende data i rækken. Hvis nummeret ikke er angivet, udføres det én gang. Scriptet kan indsætte et vilkårligt antal mønstertegn i skabelonstrengen. Tabel 12.4 viser de symboler, der indgår i streng parameter Skabelon sammen med en beskrivelse af, hvordan hver enkelt påvirker udførelsen af ​​udpakningsfunktionen.

Bord 12.4. Mønster symboler

PAKKE DATA I BINÆRE STRINGE

For at udlæse binære data skal scriptet pakke skalære værdier ind i binære tegnstrenge. For at gøre dette skal du bruge pakkefunktionen, hvis format er angivet nedenfor:

$result = pack(Skabelon, Liste);

Følgende programfragment illustrerer brugen af ​​pakkefunktionen:

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

Pakkefunktionen bruger de samme mønstertegn som udpakningsfunktionen, bortset fra a-tegnene. A, u, x, x, @.

ARBEJDER MED KATALOGER

Perl giver ikke kun en bred vifte af filbehandlingsfunktioner, men også nogle meget praktiske funktioner at scanne mapper. I de følgende afsnit vil vi se på nogle af hovedfunktionerne til at arbejde med mapper i detaljer.

ÅBNING, LÆSNING OG LUKNING AF MOBILER

Perl-scripts giver dig mulighed for at åbne og læse indholdet af filer. På samme måde åbner disse scripts mapper og læser navnene på de filer, de indeholder. For at åbne en mappe bruger scripts funktionen opendir, der sender mappemarkøren og stien til den. Til læsning filliste indeholdt i mappen, bruger scriptet funktionen readdir. Til sidst bruges closedir-funktionen til at lukke mappen. Følgende programfragment illustrerer brugen af ​​readdir-funktionen til at vise en liste over filer i den aktuelle mappe:

Opendir(Dir, $INC) || dø; while ($file = readdir(Dir)) ( print "$file \n" ) closedir(Dir);

Dette uddrag bruger $INC-variablen til at få adgang til den aktuelle mappe. Ved at ændre $INC til $ARGV, viser scriptet en liste over filer indeholdt i den mappe, du har angivet på kommandolinjen.

Ud over de katalogfunktioner, der er diskuteret ovenfor, tilbyder Perl et sæt funktioner, der giver dig mulighed for at placere det aktuelle indeks i en katalogliste:

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

FORMATERT OUTPUT

I dette kapitel lærte du flere måder at formatere scriptoutput ved hjælp af printfunktionen. I lighed med C understøtter Perl også funktionerne printf og sprintf. Derudover understøtter Perl også generering af kolonnebaserede rapporter ved hjælp af formularskabeloner.

BRUG AF UDSKRIVNINGSFUNKTIONEN

Scripterne i dette kapitel gjorde udstrakt brug af printfunktionen. Derudover giver Perl specielle variabler, der påvirker driften af ​​printfunktionen. Tabel 12.5 karakteriserer kort disse særlige variable.

Bord 12.5. Særlige variabler, der styrer udskrivningsfunktionen

For at bruge disse specielle variabler, tildeler du dem blot de værdier, du ønsker. For eksempel bruger følgende programfragment $-variablen til at angive en separator mellem printelementer:

Det viser sig, at $-variablen faktisk påvirker alle linjer, ikke kun dem, der udskrives. Men oftest vil du bruge det til at ændre værdien, som udskrives af printfunktionen.

FORMATERT DATAOUTPUT VED UDSKRIVNINGSFUNKTION

Som standard sender printf-funktionen formateret output til STDIO, og sprintf-funktionen returnerer en formateret streng. I begge tilfælde er strengformatet næsten identisk med C-sprogfunktionerne, bortset fra at Perl-sprogfunktionerne ikke understøtter længdeangivelsen (*). Følgende programfragment illustrerer brugen af ​​funktionerne printf og sprintf.

$præcision = 2; $pi = 3,1415; printf("%.2f\n", $pi); # vil udskrive 3.14 printf("%.$(præcision)f", $pi); # vil udsende 3.14

KALD TIL EKSTERNE PROGRAMMER FRA ET SCRIPT I PERL

I en vis forstand er Perl en erstatning for shell-scripts systeminteraktion, herunder opkald eksterne programmer. De følgende afsnit diskuterer flere måder at kalde eksterne programmer fra Perl scripts. Vær dog opmærksom på, at ved at tillade scripts at udføre systemkommandoer, åbner du sikkerhedshuller i din vært. Bliv ved med det almindelig regel udfør ikke eksterne kommandoer fra et Perl-script. Men hvis du er tvunget til at udføre eksterne kommandoer fra et script, kan du bruge de indbyggede kommandoer til disse formål. systemfunktioner, exec eller gaffel.

REGELMÆSSIGE UDTRYK

Igennem dette kapitel har du set eksempler på strengbehandlingsfunktioner. Mange af dem er baseret på begrebet regulære udtryk. Som du kan se i de følgende afsnit, gør Perl-scripts udstrakt brug af regulære udtryk til tekstbehandling. Hvis regulære udtryk er nyt for dig, så fortvivl ikke. Efter kort tid, efter at du har været igennem et par afsnit af dette kapitel, vil regulære udtryk blive nemme at forstå.

REGELMÆSSIGE UDTRYK OVERSIGT

Regulære udtryk er et fancy udtryk, der stammer fra datalogi for at henvise til et mønster af tegn. Perl-scripts bruger tegnmønstre blot til at parse inputdataene og opdele dem i stykker. Ofte kan et script parse input baseret på mellemrum, kommaer, tabulatorer og andre skilletegn. Men når inputdata har et vilkårligt format, så klarer regulære udtryk denne opgave bedst.

REGELMÆSSIG UDTRYKS SYNTAX

For at reducere størrelsen af ​​regulære udtryk bruger Perl specialtegn. Tabel 12.6 viser nogle af de symboler, der bruges af Perl-scripts i regulære udtryk X.

Bord 12.6. Symboler brugt i regulære udtryk

Perl placerer regulære udtryk (mønstre) i skråstreger, dvs. i skråstreger, for eksempel i formen /mønster/. Følgende programfragment illustrerer Perl regulære udtryk:

# følgende regulære udtryk er sande, hvis: /ig/ # streng indeholder "ig" /(b|d|f)ig/ # streng indeholder "big", "dig" eller "fig" /+/ # streng indeholder et tal /*/ # streng indeholder en identifikator

Hvis disse udtryk ikke giver mening for dig, så fortvivl ikke. I dette kapitel skal vi se på flere regulære udtryk. Indtil videre skal du bare huske, at Perl sætter regulære udtryk mellem to skråstreger, som vist ovenfor.

BRUG AF REGELMÆSSIGE UDTRYK TIL SØGNING AF SØGEORD

Perl-scripts bruger regulære udtryk for at gøre strengsammenligninger nemmere. For at kontrollere, om en streng indeholder et givet mønster, kan scriptet bruge regulære udtryk som dette:

Hvis ($str =~ /mønster/)

I dette tilfælde tager regulære udtryk værdien<истинно>hvis mønsteret findes i streng ($str). Hvis strengen by indeholder mønsteret, returnerer udtrykket værdien<ложно>. For eksempel tester følgende udtryk, om strengen indeholder teksten WebProgramming:

Hvis ($str =~ /Web Programmering/)

For at kontrollere, om der er et nøjagtigt match, skal udtrykket binde sammenligningen til begyndelsen og slutningen af ​​strengen. For eksempel har følgende udtryk værdien<истинно>, hvis og kun hvis $str-variablen tager en af ​​tre værdier: , ) :

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

På samme måde er det følgende udtryk sandt, hvis og kun hvis $str indeholder ordet og er ikke en del af et andet ord som f.eks .

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

BRUG AF REGELMÆSSIGE UDTRYK TIL AT ANALYSE INPUT DATA

Efterhånden som dine Perl-scripts bliver mere komplekse, vil der være mange tilfælde, hvor du vil vide mere end blot at tjekke, om et mønster matcher en streng eller ej. For eksempel vil du måske have et script til at udtrække en bestemt strengværdi. Ved at bruge gruppering af tegn () i et regulært udtryk, kan scriptet udtrække matchende værdier fra en streng og danne en liste over dem. For eksempel bruger følgende programfragment regulære udtryk til at udtrække måneder, dage og år fra en liste:

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

Perl understøtter også en anden form for mønstermatchning ved at bruge (=~) operatoren, som tilføjer negationen af ​​resultatet: (!~). Denne operator svarer til udtrykket!($str=~/pattern/).

REGELMÆSSIGE UDTRYK TIL SØG OG UDSKIFTNING AF STRENGE

Indtil videre har du brugt mønstermatchende operatorer. Det viser sig, at Perl understøtter to andre regulære udtryk, der ændrer den strengvariabel, der testes. I sætningen nedenfor erstatter Perl den del af strengen, der matcher mønsteret med givet streng:

$str =~ s/mønster/erstatning/;

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

$str =~ s/\bfarve\b/farve/;

En lille ændring giver dig mulighed for at erstatte alle ord på :

$str =~ s/\bfarve\b/farve/g;

I dette tilfælde fortæller g i slutningen af ​​udtrykket Perl, at global substitution er påkrævet.

Ved at bruge i-suffikset kan du angive, at søgningen skelner mellem store og små bogstaver. I modsætning til blot at tjekke for et mønster, udfører følgende udtryk også erstatning:

$str =~ tr/SearchList/ReplacementList/;

For eksempel kan udskiftning af alle små bogstaver med de samme store bogstaver gøres sådan:

$str =~ tr/a-z/A-Z/; # skifter store og små bogstaver fra nedre til øvre

Overvej selv følgende eksempel:

$letters = "abcde"; print "$letters\n" # Udskriv abcde $letters =~ tr/a-z/A-Z/; udskriv "$letters\n" # Udskriv ABCDE

RESUMÉ

Dette kapitel giver en introduktion til Perl-programmering. Ved at bruge de begreber, der er diskuteret her, kan du skrive komplekse CGI-scripts i Perl. Det næste kapitel hjælper dig med at få færdighederne til at oprette CGI-scripts i Perl, som du kan køre på din egen server. Før du går videre, skal du sørge for at forstå følgende nøglebegreber:

Perl er et fortolket programmeringssprog, der bruges af programmører til at skrive scripts til internettet og internettet.

Perls konstruktioner ligner dem i C i mange henseender, men Perl tilbyder mange ekstra funktioner, især til håndtering af strenge og filer, der er svære at finde i C.

Perl er det primære sprog til at skrive CGI-programmer til internettet og internettet, primært på grund af dets fleksibilitet, kompakte stil og høje sikkerhed.

VÆSENTLIGE WEBSITES FOR INFORMATION OM PERL

Følgende websteder hjælper dig med at finde information om detaljer, du er interesseret i vedrørende Pcrl-sproget, dets scripts og specifik information om Perl 5-sprogressourcer og dets biblioteker. Brug disse websteder som udgangspunkt for din søgning.

RESUMÉ

I dette kapitel lærte du, hvordan du bruger Perl til at skrive ret komplekse CGI-scripts. Ved at bruge den teknologi, du er blevet fortrolig med, kan du levere programmeringstjenester på professionelt niveau til dine kunder, som gerne vil have deres virksomhed repræsenteret på nettet. Kapitel 14 introducerer dig til Java-sproget. Som du vil se Java sprog velegnet til at skabe websteder indeholdende animation og multimedie. Derudover introducerer kapitel 14 et andet sprog til at skrive JavaScript-scripts. Før du går videre til kapitel 14, skal du dog sikre dig, at du forstår følgende nøglebegreber:
- Perl er et alsidigt og fleksibelt programmeringssprog, der kan bruges til at udvikle CGI-scripts til nettet såvel som traditionelle programmer til hverdagsbrug.

• Perl er velegnet til tekstbehandling, databaseadgang, den er bærbar og giver sikkerhed ved arbejde på netværk. Alle disse egenskaber er vigtige for webprogrammering.
• Perl-scripts bruger i vid udstrækning regulære udtryk til tekstbehandling.
• De fleste scripts på nettet er nu skrevet i Perl. Sprog som JavaScript og VBScript kan dog gribe ind i Perls monopol.