Spara filen på disk.

Steg 2 - Skapa ett skript

Skriptet nedan tar indata, sparar det i en fil och visar ett meddelande som innehåller en länk till filen med det sparade namnet. Skriv in programmets text i editorn och spara den i filen testform.pl i cgi-bin-katalogen på din webbserver. Se till att den första raden i programmet innehåller rätt sökväg till tolkprogrammet (på UNIX använder du kommandot which perl för att hitta programmet; i Windows, sök efter perl.exe). Se också till att sökvägen till utdatafilen är den korrekta sökvägen till webbserverns dokumentlagringsområde. Till sist, fixa URL:en till serverns adress.

Steg 3 — Testa skriptet

Efter att ha kontrollerat skriptet visuellt för fel - frånvaron av ";" i slutet av rader, närvaron av oparade parenteser och citattecken, etc., kör skriptet för att kontrollera direkt från kommandoraden, efter att ha gått till cgi-bin-katalogen. Här är några exempel på hur detta går till:

Om skriptet innehåller fel kommer du att se ett meddelande som

I det här fallet kontrollerar du texten nära den angivna raden. Kom ihåg att orsaken till felet kan vara flera, ibland ganska många rader högre. Spara det korrigerade skriptet och testa så här tills det ger rätt utdata:

Steg 4 — Testa formulärskriptet

Om skriptet fungerar av sig självt kan du testa det med ett formulär:

1. Se till att webbservern är igång.
2. Starta din webbläsare.
3. Skriv in webbadressen där ditt formulär finns (observera att raden måste börja med http://, inte file://.
4. Ange ditt namn i formulärfältet och klicka på knappen "Registrera".
5. Du bör se ett meddelande så här:

Tack för att du fyllde i formuläret
Klick här för att se din input.

Det här är sidan som genereras av skriptet i farten. Om du får ett serverfel, kontrollera att skriptet är på rätt plats och att värdet på handlingsparametern i formtaggen är korrekt.

1. Om du ser en korrekt genererad sida, klicka på länken. Du bör se en ny sida skapad av skriptet som ser ut ungefär så här:

Namn: Novikov

Om du inte ser det, kontrollera den korrekta sökvägen i variabeln $targetfile och den korrekta URL:en på näst sista raden i skriptet. Annars fungerar formuläret och skriptet korrekt tillsammans. Du har skapat din första webbapplikation.

Diskussion: Att sätta upp manuset

Som redan nämnts innehåller den första delen av skriptet inställningar som innehåller flera element. Den första raden definierar sökvägen till tolkprogrammet:
#!/usr/local/bin/perl för UNIX
eller
\Program Files\Perl5\perl.exe för Win32

Även i början av skriptet kan du för enkelhetens skull lägga en kommentar om vad det här skriptet är avsett för.

Kommentarer kan läggas var som helst i programmet och börja med #-symbolen:
# Det här är en kommentar eller
open(NAMEFILE, ">$testfile"); #Öppna fil för att skriva...

Det är också god praxis att definiera alla konstanter och globala variabler i början av skriptet. (Jag råder dig att skriva alla sökvägar som variabler, särskilt om programmet innehåller mer än 50 rader, för att göra det lättare att ändra platsen för filer). Till exempel:
$homepage = "http://servernamn/hem/index.html";

Alla vanliga variabler i Perl börjar med $-symbolen. Det finns många andra typer av variabler som arrayer och så vidare.

Alla rader i programmet utom den första och kommentarer måste sluta med ";".

Diskussion: Läsa data från ett formulär

Nu måste vi "läsa" användarens input i Perl-variabler. Efter att användaren klickat på knappen Skicka i formuläret skickar webbläsaren namnet på skriptet och data som hämtats från formuläret till servern. Data skickas till skriptet på standardinmatning.

Anta att formuläret innehåller följande fält:

I det här fallet kommer data att skickas till skriptet i följande format:
user_name=Andy+Novikov&co_name=TeleSputnik&phone=(812)+123-45-67

Perl-skriptet bör analysera denna rad i delar och lagra den i variabler för vidare bearbetning. Raderna som utför dessa åtgärder är ganska standard:
read(STDIN, $buffer, $ENV("CONTENT_LENGTH"));

Den här raden läser data från standardindata och placerar den i variabeln $buffer. Längden på strängen skickas till skriptet via miljövariabeln CONTENT_LENGTH.

När data väl har placerats i $buffervariabeln kan du dela upp den i separata variabler med motsvarande värden:
@par = split(/&/, $buffert);

Vi har nu en @pairs-array med följande strängvariabler:
user_name=Andy+Novikov
co_name=TeleSputnik
telefon=(812)+123-45-67

Nu måste vi dela upp dessa rader i parameter-värdepar:
foreach $pair (@pairs) (($name, $value) = split(/=/, $pair); $value =~ tr/+/ /; # ersätt plus med blanksteg $value =~ s/%() /pack("C", hex($1))/t.ex; $värde =~ s///g; $input($namn) = $värde; )

Sålunda får du en uppsättning variabler, indexet i vilket är värdet på namnparametern i formulärfältet, och värdet är data som anges i motsvarande fält.

Diskussion: Vad ska man göra med datan?

Nästa steg är databehandling. Men hur? Allt beror på vad du vill göra med datan. I vårt exempel skapar vi ett nytt HTML-dokument baserat på mottagna data. Nedan ska vi titta på några enkla exempel på vad som kan göras med den mottagna datan. Observera att vi inte försöker validera innehållet i fälten. Även om detta i riktiga manus är en önskvärd och ibland nödvändig åtgärd.

Diskussion: Skriva till filer

En av sakerna du kan göra med data är att skriva den till en fil. Perl tillhandahåller en uppsättning funktioner för att öppna, bearbeta och stänga filer. På så sätt kan du skapa ett nytt HTML-dokument, lägga till data i ett befintligt HTML-dokument eller spara data i en textfil för vidare bearbetning.

Filöppningsfunktionen ser ut så här:
open(HANDLE, "namn"); # Öppna fil för läsning öppen(HANDLE, ">namn"); # Öppna fil för att skriva öppen(HANDLE, ">>namn"); # Öppna filen för att lägga till till slutet

HANDLE är ett temporärt namn som du kommer att använda som filidentifierare när du utför operationer. När filen är öppen kan du skriva till den med utskriftsfunktionen:
print HANDLE "Denna text kommer att placeras i filen som den är.\n"; print HANDLE "I detta fall kommer variabeln ",$variable," att placeras i texten."; print HANDLE "Variabeln $variable kan placeras i texten och så.\n"; print HANDTAG "Citationstecken och andra specialtecken \; måste \"klippa\".\n";

När du har slutfört operationer med filen måste du stänga den:
close(HANDLE);

Efter det kommer all inspelad data att sparas på disken.

Innan du skriver till en fil måste du se till att webbservern har tillgång till katalogen där filen finns och har behörighet att skriva till den filen.

Observera att stängningsfunktionen ska placeras så nära den sista skrivfunktionen till filen som möjligt. Detta beror på att webbservern körs i en fleranvändarmiljö, och skriptet kan köras samtidigt av flera användare. När en fil öppnas för skrivning blockeras den (filen) och andra instanser av skriptet kommer inte att kunna öppna den, vilket kommer att orsaka en fördröjning i utförandet av begäran.

Exempel: Skapa en ny HTML-sida

Följande exempel kan verka komplicerat vid första anblicken, men allt det gör är att skriva lite information till en fil.

På grund av att vi skapar en webbsida innehåller filen HTML-taggar tillsammans med vanlig text. Kom ihåg att \n helt enkelt infogar en ny rad i texten för att underlätta senare visning av den genererade filen.

All indata från formuläret finns i variablerna $input(field_name). När de skrivs ut måste sådana variabler omges av citattecken och avgränsas med kommatecken.

Exempel: Lägga till i slutet av en fil

Det är enkelt att skriva till en befintlig fil när du vill lägga till ny information i slutet av filen. Till exempel, för att lägga till data om en ny användare till filen som skapats ovan, behöver du följande skript:

Exempel: Lägga till i mitten av en befintlig fil

En svårare uppgift är att infoga ny data i mitten av filen. Observera att i det första exemplet infogade vi en kommentarsrad i filen som ser ut så här:

Den här kommentaren kommer att fungera som en etikett för platsen där vi behöver infoga ny data. Det här exemplet innehåller inte riktigt en elegant lösning, men det är lätt att implementera och förstå. Den använder en temporär fil, även om du kan klara dig utan den:

Exempel: Skicka data via e-post

Ibland kanske du vill att uppgifterna i ett formulär ska skickas till en specifik e-postadress.

För att göra detta behöver du ett program för att skicka e-post med ett kommandoradsgränssnitt. Under UNIX kan detta vara sendmail eller post. I detta exempel data skickas med sendmail-programmet. Istället för att skriva till en fil använder vi att skriva till ett speciellt öppnat rör (pipe):

Diskussion: Skapa webbsidor i farten

Den sista viktiga delen av ett Perl-skript är att skicka tillbaka resultatet till användaren. Detta uppnås med samma utskrift, men utan fil- eller röridentifierare. Allt som skrivs ut till standardutdata bildar det aktuella dokumentet i webbläsarfönstret. Till exempel:

Var uppmärksam på den första raden. Denna sträng innehåller information om vilken typ av data som returneras. En dubbel överföring av lager krävs. Denna sida kommer att returneras till användaren nästan omedelbart efter att de klickat på knappen Skicka.

Observera att detta bara är ett av många exempel på vad en sida kan vara i farten. I princip kan du skapa ett HTML-dokument oavsett form och innehåll.

1. Använd färdiga skript

Om du redan har skrivit CGI-skript bör du göra det innan du kopierar dem till servern följande åtgärder:

• Se till att rätt sökväg till tolken anges i skripten:

perl: /usr/bin/perl
Pytonorm: /usr/local/bin/python

• Om ditt skript behöver åtkomst till MySQL-databasen, måste du ange åtkomstparametrarna (se artikel )
• I avsnitt Webserverhantering aktivera CGI-modulen.

Nu kan du kopiera dina skript till servern.
Filer måste laddas upp till katalogen din_domän/cgi. Filer från denna katalog kommer att finnas tillgängliga på http://din_domän/cgi-bin/filnamn. För att CGI-skript ska köras från webbplatsens rotkatalog din_domän/dokument måste du skapa en .htaccess-fil i den med följande innehåll:

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

Skript måste vara inställda behörigheter 755 eller -rwxr-xr-x.
Åtkomsträttigheter kan ändras med hjälp av kontrollpanelen.

2. Att skriva ett enkelt CGI-skript

Överväg att skriva ett enkelt CGI-skript i Perl.
Om du kör Windows måste du använda en specialiserad textredigerare, som Notepad++, för att arbeta med skriptkoden. Standard för Windows-program Anteckningsblock bör inte användas. För att visa hur CGI-skriptet fungerar måste du skapa två filer. Den första filen är ett html-dokument med en textinmatningsform:

Den andra filen är ett CGI-skript

#!/usr/bin/perl
använd CGI;
print "Innehållstyp: text/html\n\n";
$my_cgi = ny CGI;
$ditt_namn = $my_cgi->param("namn");
print "Hej $ditt_namn!!!";

Du kan placera den första filen i katalogen din_domän/dokument. Den andra filen måste placeras i katalogen din_domän/cgi. Se till att kontrollera behörigheterna på ditt CGI-skript. De måste ställas in på -rwxr-xr-x eller 755 .

3. Se installerade PERL-moduler

För att kontrollera installerade PERL-moduler, utför följande steg i följd:

• och kör kommandot:

Detta skapar filen modules.pl

• Nu måste du redigera det, för detta trycker vi på Infoga, vi skriver följande:

#!/usr/bin/perl -w

använd ExtUtils::Installed;

$installed = ExtUtils::Installed->new();
foreach $modul ($installed->modules())(
printf "Modul: %s\t\tVersion: %s\n", $modul, $installed->version($module);
}

För att avsluta redigeraren och spara texten du precis skrev, tryck på Esc och sedan: wq

• Vi kan se de installerade modulerna:

perl ./modules.pl

4. Installera ytterligare PERL-moduler

Du kan installera ytterligare PERL-moduler på hosting från källkoder. Innan installationen påbörjas, anslut senaste versionen PHP i avsnitt Webserverhantering→PHP-modulhantering värdkontrollpanel, kommer detta att ansluta en uppdaterad uppsättning programvara, som kan innehålla Perl-modulen du behöver.
Innan installationen måste du ställa in miljövariabler så att de installerade modulerna är tillgängliga för tolken.

• För att göra detta, skapa en .bashrc-fil i din hemkatalog med kommandot:

katt >> ~/.bashrc<< "EOF"
PERL5LIB=$HOME/PERL/lib:$HOME/PERL/lib/perl5
exportera PERL5LIB

MANPATH=$HEM/PERL/andel/man
exportera MANPATH
EOF

• För att ändringarna ska träda i kraft, kör kommandot:

källa ~/.bashrc

För att installera den valda modulen för PERL måste du utföra följande kommandosekvens:

• på sidan http://search.cpan.org/ hitta önskad modul, till exempel, Net::SMPP och kopiera länken för att ladda ner arkivet med modulens källkoder,
• anslut till webbhotellet via SSH och gå till katalogen för temporära filer

• ladda upp arkivet till webbhotellet med hjälp av den hittade länken med wget

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

• packa upp arkivet och gå till modulens källkatalog

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

Installation måste göras i en separat katalog, t.ex. /home/login/PERL, var logga in- värdtjänstidentifierare, som anger variabeln INSTALL_BASE.

• Makefile.PL använd kommandon:

perl Makefile.PL INSTALL_BASE=$HOME/PERL
göra
göra installera

• För att installera en modul med hjälp av en fil Build.PL använd kommandon:

perl Build.PL
./Bygg --install_base $HOME/PERL
./Bygg installera --install_base $HOME/PERL

För att använda de installerade modulerna i ett perl-skript måste du inkludera dem genom att lägga till följande rader i skriptfilen:

använd lib "/home/login/PERL/lib";
använd lib "/home/login/PERL/lib/perl5";
använd Net::SMPP;

För att Apache-webbservern ska fungera med ytterligare moduler måste du aktivera modulen i värdkontrollpanelen env_modul och lägg till följande rader i filen .htaccess i webbplatsens rotkatalog eller i katalogen med CGI-skript:

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

där inloggning är värdtjänstens ID.

5. Möjliga fel

Fel 403

Om du ser ett 403-fel när du kommer åt ett skript betyder det att skriptet har felaktiga behörigheter. CGI-skript måste ha attributet execute set (behörigheter 755 eller -rwxr-xr-x). Attribut kan ändras med hjälp av kontrollpanelens filhanterare.

Fel 500

Om du ser ett 500-felmeddelande när du kör ditt skript betyder det att det finns ett fel i skriptet på grund av vilket Perl-översättaren "a inte kan slutföra sitt arbete. Felet kan vara lika syntaktisk (till exempel glömde du någonstans då stäng citatet eller klammerparentesen), och logiskt, till exempel, som ett resultat av någon av dina handlingar, sker en division med noll. För att förstå orsaken till felet måste du titta på webbserverns loggfiler som lagras i /var-katalogen /log/.

Datatyper används i program när variabler deklareras. Kort sagt, en datatyp definierar uppsättningen värden som en variabel kan ta, såväl som uppsättningen av operationer som ett program kan utföra på den. I Perl data kan vara ett nummer eller en teckensträng.

Ett enskilt värde kallas ett skalärt värde, eller helt enkelt ett skalärt. Följande är exempel på skalära värden som används i Perl-språket:
- Decimal: 127 eller 127,0 eller 1,27E2
- Hexadecimal: 0x7F eller 0x7f
- Oktal: 0177 (den första nollan anger att ett oktalt tal används)
- Sträng: "Hello World\n" eller "Hello World"

Till exempel använder följande kommando Perl debugger för att visa talet 0177 i oktal, vilket motsvarar talet 127 i decimal:

D.B.<4>s 0177 127

Perl översätter data till sitt interna format. När Perl skriver ut oktala eller hexadecimala värden konverterar den först dem till decimalformat, som visas.

Notera: Som du kommer att lära dig låter Perl-skriptet dig använda printf-funktionen för att skriva ut värden i ett anropsbart format, såsom oktalt eller hexadecimalt.

Den interna representationen av alla tal är flyttalsformatet med dubbel precision. Det finns med andra ord inget heltal bland de interna formaten. Men i de flesta fall kan du ignorera detta och Perl kommer att göra rätt för dig. Till exempel, om du använder värden i ett sammanhang där endast heltalsvärden är vettiga, kommer Perl automatiskt att trunkera själva talet.

Obs: Om du programmerar i C och har använt heltalsdivision med heltalsstympning automatiskt, då måste du när du programmerar i Perl komma ihåg att utföra manuell trunkering med int()-funktionen.

Följande kommando illustrerar hur Perl hanterar heltal och flyttal:

Skriv ut 6 & 3; # kommer att skriva ut 2 print 6.9 & 3.1 # print 7 / 2 # kommer att skriva ut 2.3333 inte ett heltals print int(7/3) # kommer att skriva ut 2

På samma sätt som Perl konverterar flyttal till heltal: när ett skript använder heltalsvärden konverterar det också tal till strängar och vice versa när en sådan omvandling är vettig. Till exempel, om ett skript använder siffror i ett sammanhang där bara strängar är meningsfulla, som att sammanfoga strängar, kommer det att konvertera siffrorna till strängar. På samma sätt, om du vill använda strängar där endast siffror är vettiga, konverterar Perl dem till siffror. När du arbetar med Perl-skript behöver du vanligtvis inte oroa dig för den interna representationen av skalärer.

Perl stöder också begreppet booleska värden, men har ingen speciell typ för att beskriva dem. Som i C anses ett numeriskt värde vara sant om det inte är noll. Dessutom anses ett strängvärde vara sant om det inte är lika med "" eller "0". Vissa booleska operatorer som t.ex<>> (större än), returnera ett som värde<истинно>och noll som<ложно>.

Därför bör ditt skript helt enkelt betrakta värden som inte är noll, både strängar och numeriska, som ett booleskt värde.<истинно>. Perl-skript kan gruppera skalärer och skapa en lista. Om skriptet lagrar listan i någon variabel, blir denna variabel en array (array).

VARIABLER

Perl stöder tre typer av variabler: skalärer, arrayer och associativa arrayer. Liksom i C skrivs variabelnamn med en distinktion mellan små och stora bokstäver. Namnen VAR, Var och var beskriver alltså olika variabler. Ett skript kan ha en skalär variabel som kallas var och en arrayvariabel som även kallas var. De kommer att skilja sig åt i Perl-språket beroende på sammanhanget.

Obs: Perl-variabler är otypade, vilket är fallet i C. Till exempel kan en skalär variabel innehålla vilken typ av skalär som helst, och typcasting görs automatiskt. Dessutom, som du kanske har märkt, behöver Perl-variabler inte deklareras. Om en variabel inte deklareras, behandlar Perl den som global. Nedan kommer du att bekanta dig med deklarationen av variabler och deras omfattning.

SKALÄRA VARIABLER

Som nämnts kan en skalär variabel innehålla ett enda värde. I Perl börjar skalära variabelnamn alltid med ett ($) tecken. Följande uttryck ställer in den skalära variabeln $age till 35 och variabeln $name till strängvärdet . Utskriftsfunktionen används sedan för att skriva ut värdet för var och en av variablerna:

$ålder = 35; $name = "Bob"; print($namn,"är",$ålder);

Om du sparar dessa uttryck i en fil som heter SCALAR.PL kan du köra programmet så här:

C:\PERL> Perl SCALAR.PL Bob är 35

ARRASER

Som nämnts ovan är arrayer variabler som tar en lista med skalära värden som ett värde. Följande Perl-kod illustrerar deklarationen av arrayvariabler och deras initiering:

@days = ("sön","mån","tis","ons","tor","fre","lör"); print(@dagar); # utskrifter "Sön Måndag OnsTuFriLör" utskrift($dagar); # skriver ut "tors" @veckodagar = @dagar; # värde ("mån","tis","ons","tor","fre") @emptylist = (); # väntelista

Referens till typvariabler<массив>börjar vanligtvis med ett vid-tecken (@) och följs av värden inom hakparenteser (). Liksom i C-programmering är arrayindex för skript alltid heltalsvariabler, som vanligtvis börjar på noll. Du kommer att se undantag från dessa två regler i exemplen som kommer att förklaras i det här kapitlet Det tredje uttrycket ($days) är ett exempel på en array som refererar till ett skalärt värde. Eftersom det bara innehåller ett element är det resulterande värdet en skalär.

Om du använder tecknet ($) istället för (@-tecknet), kommer skriptet att referera till ett skalärt värde. Denna kommentar är mycket viktig. Hakparenteserna indikerar att skriptet refererar till en array. $-tecknet i sin tur anger en referens till ett skalärt värde. Arrayen @weekdays initieras genom att en del av @days-matrisen hämtas. I föregående exempel användes arrayen @days utan ett index. När indexet utelämnas hänvisar Perl till hela arrayen. På liknande sätt, i det föregående exemplet, initierades @days-matrisen med en lista med bokstaver.

Förutom att kunna tilldela bokstaver som värden till en array, kan ett skript också tilldela variabler eller till och med andra arrayer till arrayer, som visas nedan:

@stuff = ($ålder, $namn) @FriendsOfMine = ("Joe","Mary", @FriendsOfYours);

Följande exempel använder delar av arrayer:

@helg = @dagar ; # resultat ("sön","lör") utskrift (@dagar); # utskrifter "måntisdag tors fresön lör"

Om skriptet använder en arrayvariabel i sammanhanget av en skalär är värdet antalet arrayelement. Ett skalärt sammanhang är ett där endast skalära värden är vettiga. Till exempel använder följande uttryck det skalära sammanhanget för stuff-arrayen för att bestämma antalet element som finns i arrayen. Om antalet element är större än eller lika med 2, skickar skriptet ett meddelande och avslutar körningen:

(@stuff >= 2) || dö "För mycket saker!\n";

Tärningsfunktionen dirigerar Perl att avsluta exekveringen och utfärda det angivna meddelandet. Om meddelandet inte finns, avslutar funktionen helt enkelt skriptet.

Perl stöder också variabelkonstruktionen $#, som returnerar det sista indexvärdet i en array. Till exempel använder följande för sats $[ för att bestämma startvärdet för arrayindexet och $# för att bestämma det sista elementet i arrayen. I det här fallet, med hjälp av for expression, visas värdena för vart och ett av elementen:

För ($i =$[; $i<= $#stuff; $i++) { print $stuff[$i]; }

Spelade in för slinga kan ersättas med följande ekvivalenta uttryck:

Skriv ut @stuff;

KONTEXTS ROLL FÖR SKALÄR OCH VEKTORTYP VARIABLER

Observera att listkonstruktionsoperatorn (,) ser exakt likadan ut som sekventiell utvärderingsoperator (,). Vilken operator som används beror på i vilket sammanhang den förekommer, i synnerhet om variabeln är en skalär eller en array. Perl använder listkonstruktion i samband med arrayer och sekventiell utvärdering för skalärer. Tänk på följande uttryck:

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

Det första uttrycket initierar arrayen, medan det andra uttrycket ställer in värdet på den skalära variabeln $a_scalar till 5, vilket förkastar de första fyra värdena. Tänk på följande två uttryck:

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

Det första fallet kommer att skriva ut ett associativt arrayvärde med två nycklar, medan det andra kommer att skriva ut två associativa arrayvärden med en nyckel. Av följande två uttryck kopierar det första listan, medan det andra ställer in det skalära värdet till storleken på matrisen:

@x = @lista; $x = @lista;

ASSOCIATIV ARRASER

Associativa arrayer liknar vanliga arrayer genom att de är en lista med skalära variabler. Skillnaden är att en array måste använda heltalsvärden som index när man väljer arrayelement, medan en associativ array kan använda vilken typ av värde som helst för att välja arrayelement . Indexvärden för en associativ array kallas nycklar. Tänk på följande exempel:

$ages("Bob") = 35; $ages("Mary") = 25; $, = " "; # ändra utdataseparator för utskriftsoperatör print @ages("Bob","Mary"); # skriver ut "25 35" utskriftsnycklar (%åldrar); # kommer att skriva ut "Bob Mary" för $name (keys(%ages)) (skriv ut "$name is $ages($keys)\n"; )

Som du kan se tilldelar programmet värden till variabeln "$," (en skalär variabel vars namn är ett kommatecken). Skriptet använder detta uttryck för att säkerställa att utdata inte smälter samman med varandra när du använder utskriftssatsen . Längre fram i det här kapitlet diskuteras speciella variabler som "$". Associativa arrayer identifieras med lockiga hängslen. Som med arrayer används inte index när man refererar till en hel associativ array. Till exempel använder länken @ages("Bob", "Mary") index inom parentes för att peka på en associativ array. Prefixet @ indikerar att det är en array. Liknande användning av ett dollartecken före en array indikerar att ett skalärt värde används.

Notera: Om två nycklar anges, tillsammans med @-tecknet, indikerar detta att detta är en del av en associativ array och resultatet bör vara i form av en lista. Detta uttryck motsvarar #ages(" Bob"), #ages("Mary"). som har värdet (35, 25) som sitt värde.

Print keys(%ages)-satsen anropar keys-satsen, som returnerar hela listan med nycklar i den associativa arrayen. En %ages-referens med ett procenttecken som prefix betyder att referensen refererar till hela den associativa arrayen. Notera att for-loopen hänvisar till variabler omslutna av dubbla citattecken. Slutligen, det sista exemplet vi tittade på använder också keys-satsen och introducerar en for-loop för att skriva ut alla kombinationer av en associativ array. For-loopen hänvisar till variabler omslutna av dubbla citattecken. Perl kommer i sin tur att ersätta värdena som refereras till av variablerna när den analyserar strängen. Programmerare kallar denna process variabel substitution eller interpolation.

Obs: Perl tolkar inte variabler som innehåller strängar med citattecken.

PERL OPERATÖRER

Medan Perls data och variabeltyper skiljer sig ganska mycket från motsvarande C-typer, borde Perls operatorer och uttryck verka mycket mer bekanta för dig. Alla C-operatorer finns i Perl, med undantag för cast-operatorn (typ), operatorn för att komma åt innehållet i pekaren *ptr, och operatorn för att välja en medlem av en struct var.member eller var->member. Dessutom tillhandahåller Perl många nya operatörer för användning i operationer som jämförelse och strängmanipulation.

ARITMETISKA OPERATORER

Aritmetiska operatorer agerar på numeriska värden och resulterar i ett tal. Om uttrycket innehåller strängoperander, konverterar Perl strängvärdena till numeriska värden innan uttrycket utvärderas. Perl konverterar strängar till tal på samma sätt som C:s atof()-funktion gör i runtime-bibliotek. Perl stöder för närvarande följande aritmetiska operatorer:
- + tillägg
- - subtrahera eller ändra tecken
- * multiplikation
- / division (endast för flyttal)
- % modulo (endast för heltalsvärden)

Betrakta exempel på följande Perl aritmetiska operationer:

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

Notera: I Perl resulterar divisionsoperatorn alltid i ett flyttal, och att ta ett tal modulo ett annat resulterar i ett heltal, och båda operanderna konverteras först till en heltalstyp.

Tänk på följande modulo-operation:

Skriv ut (7,9 % 3,6); # skriver ut 1 samma (7 % 3) = 1

Perl stöder även inkrement- och dekrementoperatorer:
- ++ minskning i prefix- eller postfixform
- - inkrement i prefix- eller postfix-form Låt oss överväga exempel på inkrement- och dekrementeringsoperationer:

$x = 4; ++$x; skriv ut $x; # utskrifter 5 $y = $x-; # minska x efter att ha tilldelats y värdet för x skriv ut "$y $x" # utskrifter 5 4

Slutligen tillhandahåller Perl en aritmetisk operator för exponentiering (**). Betrakta följande exempel på användning av exponentieringsoperationen:

$x = 2 ** 3; # resultat 8 $x = 2 ** 0,5; # kvadratroten av 2 $x = -2 ** -3; # 1/(-2 kuber), resultat -1/8 (-0,125)

BITwise OPERATÖRER

Bitvisa operatorer agerar på den binära representationen av heltal och har ett heltalsresultat. Om operanden är en sträng eller ett bråktal, konverterar Perl det först till ett heltal och bearbetar operanden med hjälp av 32-bitars representationen. Alla bitvisa C-operatorer finns i Perl:
- | bitvis ELLER
-& bitvis OCH
- ^ bitvis XOR
- ~ bitvis inversion
- << сдвиг влево
->växling åt höger

Betrakta följande exempel på bitvisa operationer:

$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) print $x<< 2 # 20 (10100) print $x >> 1 # 2 (10)

Liksom i C beror beteendet hos de högra skiftoperatorerna på språkimplementeringen när operanden är negativ.

JÄMFÖRELSE OPERATÖRER

Jämförelseoperatorer jämför värdena för två operander. Precis som med aritmetiska operatorer konverterar Perl strängoperander till numeriska operander innan jämförelser utförs. För att tillåta ett skript att jämföra strängar som inte är siffror, har Perl ytterligare strängjämförelseoperatorer. Dessa operatorer jämför strängar med ASCII-värden. Om ett numeriskt värde ges som en operand i en strängjämförelse, konverteras det först till en sträng. Tabell 12.1 listar jämförelseoperatorerna:

Talsträng Betydelse = = ekv är lika!= ne är inte lika > gt är större än< it меньше чем >= ge större än eller lika<= lе меньше или равно <=>cmp är inte lika (signerat resultat)

Flik. 12.1. Perl jämförelseoperatörer.

Resultatet av jämförelseoperationen är ett om jämförelsen är sann och noll annars. Men den sista operationen<=>eller cmp) kan returnera -1, 0 eller 1 beroende på om värdet på den första operanden är mindre än, lika med eller större än den andra.

Obs: Perls cmp-operator fungerar som Strcmp()-funktionen i C runtime-biblioteket.

Överväga nästa exempel jämförelser:

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

LOGISKA OPERATÖRER

Booleska operatorer analyserar booleska uttryck och returnerar värden<истинно>eller<ложно>som ett resultat. Perl behandlar logiska operationers operander som booleaner, dvs. som sant eller falskt värde.

Perls logiska operatorer inkluderar följande:

Perl bearbetar alltid booleska uttryck från vänster till höger. Förutom. Perl slutar alltid utvärdera om den utvärdering som redan utförts är tillräcklig för att fastställa värdet på resultatet. Utöver de allmänna logiska operatorerna stöder Perl följande ytterligare logiska operatorer:

Den logiska negationsoperatorn (!) ersätter värdet på ett booleskt värde med dess motsats. Precis som i C, i Perl den villkorliga operatorn (
-:) använder tre operander. Ett uttryck som använder en villkorlig operator har följande form:

Skick
- sant-resultat: falskt-resultat

På liknande sätt använder följande uttalande en villkorad operatör för att ge Bob full åtkomst och begränsad åtkomst för alla andra:

$access = ($user eq "Bob"
- "Full" : "Begränsad");

Sekventiell exekveringsförklaring<,>(även känd som kommaoperatorn) är inte en helt logisk operator eftersom den inte analyserar sanningen i dess operander. Perl exekverar operanderna för en sekventiell exekveringsoperator från vänster till höger och returnerar värdet för operanden längst till höger. Följande exempel illustrerar användningen av kommaoperatorn i en for-loop.

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

STRING OPERATÖRER

Eftersom Perl är ett textbearbetningsspråk är det inte förvånande att det inkluderar ytterligare operatorer för att arbeta med strängar. Strängbearbetningsoperatorerna listas nedan:
-. strängsammansättning
- x replikering
- =~ variabel mönstermatchning
- !~ samma som den föregående, men med tillägget negation av resultatet

De två första påståendena illustreras lätt med ett exempel:

Skriv ut "b". "en" x 2 . "a"; # utskrifter "banan"

Som visas använder detta uttryck strängsammansättning och en replikeringsoperator för att skriva ut strängen .De två sista operatorerna används för att kontrollera om strängoperanden innehåller det givna mönstret. Denna fråga diskuteras i detalj i avsnittet<Регулярные выражения>. Följande exempel illustrerar deras användning:

$var = "banan"; skriv ut ($var =~ /ana/)
- SANT FALSKT;

I det här fallet användes mönstersträngens förekomsttestoperator (=~) för att testa om mönstret ana finns i variabeln $var. I det här fallet uttryck tar ett värde<истинно>.

UPPDRAG OPERATÖRER

Om du är bekant med programmeringsspråket C, bör formerna för Perls uppdragsangivelser vara väl bekanta för dig. Precis som i C, får dessa operatorer Perl att utföra speciella operationer på värdena som visas på höger sida om operatorn och sedan utföra en uppgift:

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

LVÄRDEN I Perl, som i C, är ett lvärde namnet på det som finns på vänster sida av en tilldelningssats. Ett lvärde är alltså en enhet som kan tilldelas ett värde, till exempel kan ett lvärde vara en variabel. Till exempel kan ett Perl-skript inte tilldela ett värde till en teckensträng som uttrycket = 32 eftersom är inte ett lvärde. Skriptet kan dock tilldela ett värde till variabeln $Bob, som $Bob = 32, eftersom variabeln $Bob är ett lvärde. I Perl är varje enhet som kan användas som ett lvärde vanligtvis en. Till exempel, följande uttryck packar (packar) och packar upp (packar upp) en lista med värden, med listan med variabler i det första fallet och de tre skalärerna i det andra är lvalues:

@färg = ($r, $g, $b); # färgpaket ($r, $g, $b) = @color; # färg uppackning

När du arbetar med listor i Perl gäller inte nödvändigtvis uppdragssatsen för hela listan. Skriptet kan tilldela värden till individuella listobjekt, som visas nedan:

@items = (100 200 300);

I det här fallet tilldelar operatören ett värde till tre element i listan. På liknande sätt packar följande uttryck upp elementen i en lista genom att tilldela värdena för de två första elementen till två skalära variabler och resten av arrayen till en listvariabel:

($arg1,$arg2,@rest) = @ARGV; # du kan blanda skalärer och arrayer

OPERATIONER FÖR ATT ARBETA MED LISTER

Listoperationer inkluderar följande:

Listkonstruktor - .. scope operator - x replikeringsoperator

Du har redan använt listkonstruktorn för att initiera arrayer och skapa en lista med variabler som används som lvärden. Omfattningsoperatorn returnerar som sitt värde en sekvens av heltal som börjar från den vänstra operanden och fortsätter till och med den högra operanden. Skript använder ofta scope-operatorn i kombination med listkonstruktorn för att skapa listor. Till exempel använder följande uttryck scope-operatorn för att skapa en lista med namnet @digits som innehåller siffrorna noll till nio:

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

På liknande sätt kan det här uttrycket använda scope-operatorn för att skapa en rad arrayindex. Antag att @days-listan innehåller veckodagarna (som börjar med söndag). Följande uttryck tilldelar @weekdays listvärden från måndag till fredag:

@helg = @dagar;

Slutligen använder följande uttryck två områdesoperatorer för att skapa en lista med hexadecimala siffror:

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

Replikeringsoperatorn skapar helt enkelt kopior av den givna operand det angivna antalet gånger. Till exempel, i följande uttryck upprepas listan med värden 1, 2, 3 tre gånger:

OPERATÖRER FÖR ATT ARBETA MED FIL

Perl har en omfattande lista över filoperatörer. Det finns minst 27 operatörer som returnerar specifik information om en fil utan att ens öppna den. Många av Perl-språksatserna är UNIX-orienterade, men följande satser fungerar på alla system:

D kontrollerar att katalogen finns
--e avgör om filen finns
--s anger filstorlek
--w bestämmer om den givna filen kan skrivas till

De följande två filsatserna returnerar ett booleskt värde. Den tredje satsen returnerar storleken på filen i byte. Följande text illustrerar användningen av dessa operatorer:

If (-e,"perl.exe") (skriv ut "Filstorleken är:" -s "perl.exe"; ) else (skriv ut "kan\" inte hitta perl.exe\n"; ) (-w "SomeFile ") || die "Kan inte skriva till SomeFile\n";

UTFÖRANDEPRIORITERINGAR FÖR OPERATORER

Liksom alla programmeringsspråk, prioriterar Perl exekveringen av satser som sekvensen av deras exekvering är ordnad efter. Tabell 12.2 listar operatörsprioritet från högsta till lägsta:

Flik. 12.2. Perl-operatörsföreträde från högsta till lägsta

I ditt skript kan du ändra i vilken ordning satserna körs med hjälp av parenteser.

PERL KONSTRUKTIONER

Perl stöder alla C-språkuttryck med ett nästan identiskt format. Till exempel, kontrollstrukturer om, medan, gör det. for och goto används i samma form på båda språken. Som du kommer att se senare har fortsätt-satsen en något annan innebörd i Perl. Dess tidigare värde kallas nu nästa, och break-satsen kallas nu sist. Perl implementerar inte byta uttalande. Dessutom finns vissa C-uttryck i Perl i andra format, och många nya uttryck har lagts till.

ENKLA OCH KOMPOSITA OPERATÖRER

Ett enkelt uttryck är vilken giltig kombination av operatorer och operander som helst. I Perl är en operator ett uttryck som slutar med semikolon. Som i programmeringsspråket C slutar alla påståenden med semikolon. När du matar ut programtext till felsökaren kan du utelämna semikolon, eftersom felsökaren tillhandahåller det åt dig. Följande text illustrerar en enkel Perl-uppgiftssats:

$Title = "(!LANG:Webbprogrammering"; !}

Precis som i C-programmering kan Perl-skript innehålla satsblock, eller sammansatta satser, som är inneslutna i klammerparenteser (()), som visas nedan:

(# Statements # Another block of statements )

Dina skript kommer att göra omfattande användning av satsblock tillsammans med mer komplexa satser. Liksom C kan Perl-skript använda satsblock för att definiera omfattningen av lokala variabler. Definitionen av lokala variabler i ett block är dock inte automatisk. För att deklarera dem måste skriptet använda det lokala nyckelordet. Senare i det här kapitlet kommer vi att titta på variabel omfattning i detalj.

VILLKORLIGA OPERATÖRER

Många av de tidigare exemplen använde en if-sats. I Perl är if-satsen nästan identisk med if-satsen i C. Skillnaden är dock att i C kan if-satsen använda en enkel sats utan klammerparenteser, medan i Perl måste satser inneslutas i tandställning, bildar ett block.

If (expr) uttalande; // acceptabelt i C men inte i Perl if (expr) ( uttalande; # så här gör du i Perl )

På liknande sätt fungerar Perls else-sats lite annorlunda än motsvarande C-sats. I Perl måste satser också vara inneslutna i hängslen och bilda ett block:

// Ett exempel i C är inte acceptabelt i Perl om (expr1) statament1; annat om (uttr2) uttalande2; annat stsment3;

Följande visar att Perl tillåter användningen av elsif-konstruktionen:

If (uttr1) ( uttalande1; ) elsif (uttr2) ( uttalande2; ) annat ( ststeg3; )

OM INTE OPERATÖR

I programmeringsspråket C använder programmerare logisk negation (!) för att vända ett booleskt värde, som visas nedan:

Om (!(uttr.)) // Negativ i C ( uttalande; )

Tillsammans med användningen av logisk negation innehåller Perl-skript ofta en unless-sats som uppnår samma sak som ovanstående C-kod.

Om inte (expr) ( uttalande; )

Obs: Till skillnad från C innehåller Perl ingen switch-sats.

GÖR OPERATÖR

Ett specialfall av blocksatser är do-satsen, som tillåter ett block av satser att returnera värden. Värdet som do-satsen returnerar är värdet av det senaste uttrycket som utvärderades inom blocket. Till exempel jämför följande do-sats strängvariabeln $Month med årets månader och ställer in $DayCount-variabeln till antalet dagar i månaden:

$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; # Kontrollera efter ett skottår ) else ( 31; ) );

Observera att Perl kräver ett semikolon i slutet av do-blocket. Blanda inte ihop do-blocket med do while-satsen, som kommer att diskuteras senare i det här kapitlet.

CYKLAR OCH GRENAR

Perl stöder loop-satserna for, while och do med mindre skillnader från deras C-implementering. Den stora skillnaden är att Perl kräver att satser används i block inneslutna i hängslen. Dessutom, som du kommer att se härnäst, utökar Perl slingkonstruktionen för att tillhandahålla några nya former för den. I följande exempel fungerar for-, while- och do-looparna på liknande sätt i C och Perl:

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

Slingkonstruktionen i C skiljer sig från den i Perl genom att Perl inte innehåller en break-sats, medan continu-satsen fyller en helt annan funktion. Lyckligtvis ger Perl några nya, mer flexibla och mer intuitiva konstruktioner:

För att förstå Perls looping-konstruktioner är det nödvändigt att förstå användningen av fortsätt-blocket. Tänk på följande while-loop, som innehåller ett fortsättningsblock:

$i = 100; medan ($i > 0) ( skriv ut $i; ) fortsätt ($i-)

Du kan tänka på continue-blocket som den tredje satsen i for-loopen, som exekveras vid varje iteration. På liknande sätt kör Perl fortsättningsblocket i slutet av varje iteration. Men som du kommer att lära dig senare, förser fortsätt-blocket skriptet med mer full kontrollöver processen, som tillhandahålls av for-slingan. När en Perl-loop använder nästa programsats exekveras fortsättningsblocket fortfarande om det finns. Men om loopen använder en redo-sats exekveras inte continu-blocket.

ETIKETTER

I ett Perl-skript betyder etiketter helt enkelt ett namn som motsvarar någon position i skriptet. Etikettnamn slutar med ett kolon (till exempel ytterslinga:). Med hjälp av goto-satsen kan skriptet hoppa till en etikett. Dessutom kan de sista, nästa och redo-operatorerna användas för att hoppa till en etikett. Följande kod illustrerar användningen av den sista operatorn för att hoppa till en etikett:

Outerloop: while ($i > 0) ( while ($j > 0) ( #Någon annan process här if ($needToAboutLoop) ( sista yttre loop; ) ) )

I det här fallet innehåller instruktionen en sista gren för att hoppa till konturerna av den yttre slingan och avsluta slingan.

TILL LOOP

En annan loopkonstruktion i Perl är tills-loopen, som är motsatsen till while-loopen. Som du minns, i en while-loop, exekveras satserna så länge det angivna villkoret är sant. I en till-loop, å andra sidan, exekveras satserna tills villkoret är uppfyllt. Tänk till exempel på en while-loop som den som visas på nästa sida.

Medan (!(expr)) ( uttalande; )

Genom att använda till-slingan kan du skapa den identiska slingan som visas nedan:

tills (expr) ( uttalande; )

På liknande sätt använder följande do while-konstruktion den logiska negationsoperatorn för att loopa tills det givna booleska uttrycket utvärderas till sant:

Gör ( statement; ) while (!(expr));

Genom att använda konstruktionen gör tills kan du bilda en identisk slinga utan att använda logisk negation:

Gör ( uttalande; ) tills (expr);

FÖR OCH FOREACH SLÖGAR

Perl stöder for-loopen på exakt samma sätt som C:

För (påstående1; uttryck; påstående2) (påstående3;)

Till exempel använder följande kod en for-loop för att skriva ut värdena för siffror från 0 till 100:

För ($digit = 0; $digit<=100; $digit++) { print $digit, " "; }

Dessutom tillhandahåller Perl en foreach loop-konstruktion som gör att ett skript kan iterera över listor och arrayer. Tänk på ett exempel:

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

I det första fallet itererade foreach loop över värdena för listvariabeln @list. I det andra exemplet itererar foreach loop över siffror i intervallet från 1 till 10. Foreach loop kan innehålla en lista med bokstaver eller en array, som illustreras i föregående exempel. Efter en iteration av loopen tar en speciell skalär variabel ($arg i det första fallet och $i i det andra fallet) ett värde från den givna listan med element. Omfattningen av denna skalära variabel i en foreach loop är begränsad till slingans kropp. Därför kommer en skalär loopvariabel, foreach, inte i konflikt med ett identiskt variabelnamn definierat utanför loopen. Följande kod använder en variabel som heter $i inuti och utanför foreach loop:

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

Som du kan se från det här exemplet kommer $i-variabeln som används för att iterera loopen inte i konflikt med $i-variabeln som definieras utanför loopen. En funktion hos foreach-loopen som dina skript kan använda är möjligheten att modifiera array-element. (Var försiktig när du implementerar denna förmåga!) Tänk på följande foreach-loop, som lägger till värdet 10 till varje array-element:

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

Låt oss göra några sista kommentarer om foreach loop. I Perl behandlas namnen foreach och for som synonymer. Därför kan skript använda dessa namn omväxlande. Perl kommer i sin tur att bestämma looptypen baserat på dess sammanhang.

OVILLKORLIG GÅ TILL OPERATÖR

Perl stöder goto-operatorn, som är identisk med programmeringsspråksoperatorn C. Följande är ett exempel på hur man använder goto-operatorn för att visa siffror från 1 till 10:

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

OPERATÖR MODIFIERARE

Perl använder speciella former av if, unless, while och till-konstruktionerna för att styra beräkningsflödet. I vissa fall kan dessa speciella konstruktioner göra din kod tydligare och lättare att läsa. För att göra koden lättare att läsa och dess betydelse mer uppenbar, är det lämpligt att välja ett lämpligt format för inspelning. Tänk på följande uttryck, som använder tärningsfunktionen för att avsluta skriptet om värdet på $count-variabeln är mindre än 10:

Om ($count< 10) { die; }

Att sätta tärningsfunktionen före if-satsen, som visas nedan, minskar antalet rader kod:

Dö om ($count< 10);

På liknande sätt kan samma uttryck skrivas på följande sätt:

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

I det här fallet, om $count-variabeln är större än eller lika med 10, stoppar Perl ytterligare utvärdering på den här raden och tärningsfunktionen exekveras inte. Annars, om $count-variabeln är mindre än 10, efter att ha utvärderat den första delen av expression, kör koden tärningsfunktionen och avslutar därmed skriptexekveringen . Slutligen, i följande exempel, minskar användningen av unless-konstruktionen också antalet rader till en:

Dö om inte ($count >= 10);

På liknande sätt är följande while-loopar identiska:

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

Som du kan se, med hjälp av konstruktionsändringen, låter skriptet dig minska antalet rader i loopposten till en. På liknande sätt är följande tills loopar likvärdiga:

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

Notera: I alla fyra fallen, även om uttrycket som ska utvärderas är efter exekveringssatsen, utvärderar Perl först villkoret innan satsen exekveras.

DYNAMISK EXPRESSION GENERATION MED EVAL-FUNKTIONEN

Eftersom Perl är ett tolkat språk kan dina skript använda Perl för att generera kod.<налету>, d.v.s. dynamiskt under skriptkörning. Det är exakt hur Perl-felsökaren (som i sig är ett Perl-program som heter Perldb.PL) fungerar. När du designar skript kan du använda sådan dynamisk kod för att skapa dynamiska variabelnamn eller till och med bygga anpassade subrutiner. Perl utvärderar dynamiska uttryck med hjälp av eval-funktionen. Följande exempel skapar dynamisk instruktion genom att tilldela textvärdet till variabeln, som faktiskt innehåller den nödvändiga instruktionen för Perl-språket. Vidare instruktioner använd eval-funktionen för att utföra denna instruktion:

$perl_statement = "skriv ut "Hej världen\n";"; eval $perl_statement; # print Hej, världen $i = 1001; $varname = "$i"; print eval $varname; # skriver ut värdet på $i

Obs: Användningen av eval-funktionen av ett skript är behäftad med fara, särskilt om skriptet överför data som tas emot från användaren till eval-funktionen. Genom att använda eval-funktionen kan ett skript köra ett godtyckligt Perl-kommando, inklusive systemkommandon. Detta gör att användaren kan kontrollera programmet, vilket kan vara särskilt riskabelt på Internet och webben.

DELPROGRAM

Liksom alla strukturerade programmeringsspråk stöder Perl subrutiner. En subrutin kan definieras med nyckelord sub som nedan:

Sub demo_sub ( skriv ut "demo_sub anropad\n"; ) &demo_sub; # subrutinsamtal

I det här fallet bildar instruktionerna en subrutin som kallas demo_sub. För att anropa en subrutin placerar skriptet ett och-tecken (&) framför subrutinnamnet. När du anropar en subrutin i Perl kan parenteser utelämnas. Du kan placera subrutinen var som helst inom skriptets källkod, eftersom Perl kommer att analysera all källkod innan skriptet körs. Det är möjligt att deklarera en subrutin i källkoden direkt efter den första användningen av subrutinen (framåtriktad referens). Subrutiner kan ta argument och returnera värden. Följande kodavsnitt innehåller en subrutin med namnet show_value som visar värdet som subrutinen fick som en parameter:

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

Formellt deklarerar en Perl-subrutin inte variabler för att lagra argument. Istället skickas en arrayvariabel med namnet @_ till subrutinen, som innehåller parametervärdena. Subrutinen får i sin tur åtkomst till argumentvärdena med hjälp av följande notation för arrayelement: $_, $_ osv. Detta sätt att skicka parametrar kan dock försämra läsbarheten av koden, och därför använder de flesta subrutiner kopiering av argument till lokala variabler. I likhet med föregående exempel visar följande subrutin show_fwo_values ​​värdena för två parametrar:

Sub show_two_values ​​(skriv ut "Första parametern", $_, "\n"; skriv ut "Andra parametern", $_, "\n"; ) &show_two_values(1001, 2002);

Slutligen skriver följande show_all_values-funktion ut värdena för alla parametrar som den tar emot. Funktionen använder en array för att definiera ett tal som en parameter:

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

Som nämnts kan Perl-subrutiner returnera värden. För detta används returuppgiften. Till skillnad från C kräver inte Perl användning av ett returmeddelande. Om subrutinen inte innehåller en retursats, kommer det senast utvärderade uttrycket att tas som returvärde. Följande exempel lägger till två parametrar och returnerar resultatet:

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

BIBLIOTEK MED DELPROGRAM

Till skillnad från C stöder Perl faktiskt inte konceptet med ett bibliotek. Det tillhandahåller dock en mekanism för att tillåta skript att använda källkod från en annan fil. Anta till exempel att du lagrar add_valuesl-rutinen i en fil som heter addvalue.pl. Genom att använda require-satsen kan ett annat Perl-skript komma åt den subrutinen, som visas nedan:

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

Du kan tänka dig en require-sats som analog med #include-satsen för C-förprocessorn. För att hitta en källfil letar Perl först i standardkatalogen för Perl-språkbiblioteket (se installationsinstruktionerna för detaljer) och sedan i aktuell katalog. Du kan också använda en absolut eller relativ sökväg som har filnamnet tillagt. Perl kommer ihåg vilka filer som begärdes av require-satsen och laddar dem bara en gång, även om dessa filer är åtkomliga flera gånger. Det finns många standardbibliotek som utökar kapaciteten för Perl-språket. Nu är det ett bra tillfälle att vandra genom katalogen där Perl-språkbiblioteksfilerna lagras för att få en uppfattning om de möjligheter de erbjuder.

ANVÄNDA PAKET FÖR ATT ISOLERA DELPROGRAM

Om du har många subrutiner, speciellt subrutiner som du lagrar i olika filer, kan variabelnamnkollisioner uppstå när samma variabelnamn används för olika ändamål. Perl hjälper till att undvika detta med paket. Som du vet kan du undvika namnkollisioner genom att deklarera lokala variabler för subrutiner. Men om flera rutiner delar vissa specifika data, kan dessa data kräva ett globalt omfattning, vilket kan leda till namnkollisioner. Med hjälp av paket kan du gruppera globala data i privata namnutrymmen (namnutrymmen), utanför vilka globala variabler finns inte synlig, dvs okänt. Betrakta följande enkla exempel, där två rutiner (i olika filer) använder privata, separata namnområden.

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

Som du kan se använder den första subrutinen paketnamnet demo_one, den andra subrutinen använder paketnamnet demo_two. Båda subrutinerna kan ställa in och använda variabeln $some_data utan att orsaka en namnkollision mellan en global variabel och den andra. Manus<знает>namnet på paketet som variabeln finns i, och det organiserar åtkomst till det, använder paketnamnet som ett prefix till variabelnamnet. Följande exempel lägger till paketnamnet package_one eller package_two som ett prefix till variabelnamnet some_data:

&sub_one; &sub_two; print "Variabel 1 $package_one"some_data\n" print "Variabel 2 $package_two"some_data\n"

När du använder Perl-språkpaket kan du skapa ett unikt namnutrymme i den aktuella källfilen genom att placera en paketsats i början av filen, som visas nedan:

Paket some_package_name $some_data = 1; sub some_sub ( returnera $some_data; )

I det här fallet finns variabeln $some_data endast i paketet och är därför skyddad från felaktig åtkomst. Att använda ett paket ger alltså data med samma omfattning som i programmeringsspråket C, där globala variabler omfångas till källfilen där de deklareras. När du anropar en subrutin från en annan skriptfil måste du använda paketnamnet:

Kräv "some_package.pl"; skriv ut &some_package_name"some_sub;

RADBEHANDLING

I de tidigare exemplen har du lärt dig hur man konstruerar strängliteraler med hjälp av variabel interpolation. Du lärde dig också hur man sammanfogar strängliteraler och strängvariabler. I det här avsnittet ser du att Perl tillhandahåller en stor uppsättning funktioner som skript kan använda för att manipulera strängar.

CHOP FUNKTION

Chop-funktionen tar bort det sista tecknet i en sträng. Den har följande format:

$character = chop(Str);

Chop-funktionen returnerar det borttagna tecknet. Perl-skript använder chop i stor utsträckning för att ta bort tecknet för nyrad och radslut.

INDEXFUNKTION

Indexfunktionen söker efter en given delsträng i en sträng. Den har följande format:

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

Indexfunktionen returnerar indexet för den första förekomsten av delsträngen(SubStr) i strängen(Str). Valfritt kan en offset från början (Offset) anges, varefter sökningen börjar. Om delsträngen inte hittas returneras -1. I följande exempel letar indexfunktionen efter förekomster av delsträngen "pa" efter det tredje tecknet i strängen "banana":

Skriv ut index("banan","na",3); # Utgångar 4.

Funktionen rindex letar efter den sista förekomsten längst till höger av en delsträng i en sträng och returnerar positionen för det första tecknet i delsträngen. Funktionen har följande format:

$plats = rindex(Str, SubStr);

Denna funktion liknar indexfunktionen, förutom att den returnerar den sista förekomsten, inte den första. Till exempel använder följande exempel funktionen rindex för att bestämma den senaste förekomsten av delsträngen "na" i strängen "banana":

Skriv ut rindex("banan","na"); # Utgångar 4

LÄNGD FUNKTION

Längdfunktionen returnerar antalet tecken i en sträng. Den har följande format:

$len = längd(Str);

Följande exempel använder längdfunktionen för att skriva ut antalet tecken i en sträng:

print length("banan"); # Utgångar 6

SUBSTR FUNKTION

Substr-funktionen används för att ta bort en del av en sträng. Den har följande format:

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

Funktionen returnerar en delsträng, det vill säga en del av strängen, vars längd inte överstiger värdet som anges av den valfria Len-parametern. Den returnerade delsträngen av str börjar vid tecknet på den position som anges av Offset. Om Len-parametern utelämnas, innehåller den returnerade strängen tecken till och med slutet av strängen. Om parametern Offset är negativ, beräknas offset från slutet av strängen. Slutligen kan skriptet använda substr som ett lvärde för att utföra tilldelningsoperationen. Följande kodsnutt illustrerar användningen av substr-funktionen.

Print substr("orange",3); #Prints "nge" print substr("orange",-2); # Skriv ut "ge" print substr("orange",2,2); # Skriver ut "an" $str = "äpple"; substr($str,-3) = "rikot"; skriv ut $str; # Skriv ut "aprikos"

Obs: Ofta är det mer effektivt att använda Perl-språkoperatorerna för reguljära uttryck än substr-funktionerna. Reguljära uttryck diskuteras senare i detta kapitel.

JOIN-FUNKTION

Funktionen join sammanfogar en lista med element till en sträng, och separerar varje element med ett givet tecken. Den har följande format:

$new_string = join(Str,List);

Join-funktionen konverterar varje element i listan till en sträng och sammanfogar strängarna. Följande kodavsnitt illustrerar användningen av join-funktionen:

$str = join(",", 0..4,10,20); # Listan kommer att vara "0,1,2,3,4,10,20" $strn = join ("\t", $a, $b, $c);# Mixlistor

SPLIT FUNKTION

Splitfunktionen delar upp innehållet i en sträng i en lista med element. Den har följande format:

Split(Delimeter, Str[,Limit]);

Argumentet Delimeter anger vilket tecken som ska delas upp, såsom mellanslag, ord, tabb, etc. e. Den valfria parametern Limit anger det maximala antalet element som listan kan innehålla. Följande exempel illustrerar användningen av splitfunktionen.

FUNKTIONER FÖR BEHANDLING AV LISTER

I exemplen tidigare i det här kapitlet såg vi hur man skapar en lista, lagrar den som värdet på en variabel, itererar genom alla element i listan och får åtkomst till ett enskilt listelement. I det här avsnittet kommer du att lära dig några fler funktioner som utökar utbudet av möjligheter att arbeta med listor.

REVERSE FUNKTION

Den omvända funktionen vänder på elementen i en lista. Den har följande format:

@ny_lista = omvänd(@lista);

Den omvända funktionen vänder listan och returnerar en ny resulterande lista. Följande exempel illustrerar användningen av den omvända funktionen:

@list = omvänd(1..5); # Resultat 5,4,3,2,1 @list = reverse(@list); # Resultat 1,2,3,4,5

SORTERINGSFUNKTION

Sorteringsfunktionen sorterar elementen i en lista. Den har följande format:

@ny_lista = sort(@lista);

@new_list = sort(Subrutin @List);

@new_list = sort(BlockStatement @List);

Sorteringsfunktionen ordnar elementen i en lista genom att ordna dem enligt tecknets ordinal i ASCII-kodtabellen. Precis som den omvända funktionen returnerar sorteringsfunktionen en ny lista som dess värde och påverkar inte den ursprungliga listan. Följande exempel illustrerar användningen av sorteringsfunktionen:

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

I en subrutin eller block kan du ändra ordningen efter vilken sorteringen utförs. Följande exempel illustrerar användningen av sorteringsfunktionen.

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

ARRAY FUNKTIONER

Som du vet är en array en datastruktur som innehåller ett eller flera värden av samma typ, till exempel 100 studentnamn. Perl har flera inbyggda funktioner som hjälper dig att arbeta med arrayelement. Följande avsnitt täcker några grundläggande arraybehandlingsfunktioner.

PUSH OCH POP-FUNKTIONER

Perl-skript använder push- och pop-fiktioner för att lägga till och ta bort element från slutet av en array. Med andra ord, push- och pop-funktionerna tillåter skript att utföra stackoperationer på sist-in-först-ut-basis. Push-funktionen har följande format:

Push(@ARRAY, LIST);

Följande utdrag illustrerar användningen av push-funktionen:

@lista=(); push(@lista,10,20); # @list är nu (10,20) push(@list,1..3); # @lista är nu (10,20,1,2,3)

Däremot tar pop-funktionen bort elementet som senast trycktes på stacken och returnerar värdet för det elementet. Popfunktionen har följande format:

$värde = pop(@ARRAY);

Följande programfragment illustrerar användningen av popfunktionen:

# Ta @list från föregående exempel print pop(@list); # Skriv ut 3 print pop(@list); # Utgångar 2 # Nu @lista (10,20)

SKIFTFUNKTION

Skiftfunktionen tar bort och returnerar ett element från början av en array. Denna funktion liknar pop-funktionen, med den enda skillnaden att den fungerar från början av arrayen enligt FIFO-principen (<первым вошел, первым вышел>). Skiftfunktionen har följande format:

$värde = shift(@ARRAY);

Följande programfragment illustrerar användningen skiftfunktioner:

# Ta @list från föregående exempel

Printshift(@list); # Skriv ut 10 print shift(@list); # Output 20 # Nu @list()

AVSKIFTSFUNKTION

Unshift-funktionen lägger till ett eller flera element i början av en array. Den har följande kod:

Unshift(@Array, List);

Följande programfragment illustrerar användningen av unshift-funktionen:

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

SPLICE FUNKTION

Perl-skript använder skarvfunktionen för att extrahera element från en lista och ersätta dem med element från en annan lista. Den har följande format:

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

Splitsfunktionen extraherar det angivna antalet element (Count) från arrayen (@Array), med början på det element som pekas på av offsetvärdet (Offset), och ersätter elementen med element från en annan lista (List). Om parametern Count inte anges i funktionsanropet, extraherar funktionen element fram till slutet av arrayen. Om funktionsanropet inte anger en lista vars element ersätter de ursprungliga elementen, så lägger funktionen inte till några element till den ursprungliga listan. Följande uttryck illustrerar användningen av skarvfunktionen:

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

SKALÄR FUNKTION

Den skalära funktionen bestämmer antalet element i en lista. Den har följande format:

Rsult = scalar(List);

Normalt behöver Perl-skript inte använda den skalära funktionen med arrayer, för när ett skript kommer åt en array och skriver den i skalär kontext, får det antalet arrayelement som ett returvärde. Skript kan dock använda den skalära funktionen i fall där sammanhanget är tvetydigt eller om listan inte är en array. Följande uttryck illustrerar användningen av den skalära funktionen.

@lista = 1..10; print scaler(@list); # Visa storleken på @lista

GREP-FUNKTION

grep-funktionen filtrerar elementen i en lista för vilka det givna uttrycket utvärderas till ett värde<ложно>. Den har följande format:

@list = grep(Uttryck, Lista);

grep-funktionen itererar genom elementen i en lista och ersätter dem som ett argument i ett givet uttryck. grep-funktionen tilldelar det aktuella listobjektuttrycket till $_ och utvärderar det givna uttrycket. Om det resulterande uttrycket är sant, lägger grep-funktionen till det elementet till den resulterande listan. Följande programfragment illustrerar användningen av grep-funktionen:

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

Obs: Om ett uttryck, ändrar variabeln. $_, då kommer den ursprungliga listan också att ändras.

ASSOCIATIV ARRAY-FUNKTIONER

Som ni vet är associativa arrayer arrayer vars index inte är ett numeriskt värde, utan till exempel ett namn. Perl har flera inbyggda funktioner som gör det lättare för skript att hantera associativa arrayer.

FUNKTIONSTANGENTER

Nyckelfunktionen returnerar värdena för nycklarna som motsvarar den associativa arrayen. Den har följande format:

@key_list = nycklar(%Array);

Nycklarfunktionen returnerar en uppsättning nycklar som en vanlig lista. Följande programfragment illustrerar användningen av tangentfunktionen:

$ages("Bob") = 25; $ages("Mary") = 30; $ages("Zack") = 15; @list = nycklar(%åldrar); # @list skulle vara "Zack", "Bob", "Mary" @list = sorteringsnycklar %ages # @ lista "Bob", "Mary", "Zack" för $key (sorteringsnycklar %ages) (skriv ut "$ nyckeln är $ages($key)\n" )

VÄRDEN FUNKTION

Funktionen värden returnerar en vanlig array som består av värdena för den associativa arrayen. Den har följande format:

@value_list = värden(%Array)

Funktionen värden returnerar en array av associativa arrayvärden som en vanlig lista. Följande programfragment illustrerar användningen av värdefunktionen:

# Använd värdena från föregående exempel %ages = ("Bob", 25, "Mary", 30, "Zack", 15); @list = sorteringsvärden %ages; # @list (15, 25, 30) @list = %åldrar; # @list("Zack", 15, "Bob", 25, "Mary", 30)

VARJE FUNKTION

Varje funktion itererar över elementen i en associativ array. Den har följande format:

@key_values ​​= varje(%Array);

Närhelst skriptet anropar varje funktion returnerar det en lista med två komponenter som innehåller ett nyckel-värdepar. När funktionen når slutet av listan återvänder den tom lista. Nästa gång funktionen anropas kommer iterationsprocessen att starta från början. Följande programfragment illustrerar användningen av varje funktion:

# Använd värdena från föregående exempel %ages = ("Bob", 25, "Mary", 30, "Zack", 15); while (($name, $age) = varje %ages) ( # Output ages print "$key is $ages($key)\n"; )

DELETE-FUNKTION

Raderingsfunktionen tar bort elementen i en associativ array. Den har följande format:

Ta bort $Array(Key)

Följande sats använder delete-funktionen för att ta bort elementet som motsvarar nyckeln Bob från den associativa arrayen $Employees:

Ta bort $Employees("Bob")

KOMMANDORAGUMENT

Det är lätt för Perl-skript att komma åt kommandoradsargument. Närhelst ett skript körs placerar Perl skriptets kommandoradsargument i listvariabeln @ARGV. Följande programfragment används för att skriva ut kommandoradsargument till displayen:

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

TILLGÅNG TILL MILJÖVARIABLER

Det är också mycket enkelt att komma åt miljövariabler i Perl-skript. Närhelst ett skript körs, lägger Perl kopior av miljövariablerna i en associativ array som heter %ENV. Följande sats använder %ENV-matrisen för att visa den aktuella katalogen:

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

Förutom att få värden från %ENV-matrisen, kan skript också modifiera matriselement. Sådana ändringar av %ENV-matrisen kommer att ändra inställningen av miljövariabler för alla underordnade processer som skapas av skriptet. Till exempel använder följande sats arrayen %ENV för att ändra den aktuella sökvägen:

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

Obs: Ändringar som skriptet gör i %ENV-matrisen kommer inte att påverka de ursprungliga miljövariablerna. Med andra ord, efter att skriptet avslutas kommer systemmiljövariablerna inte att ändras.

FIL INPUT OCH OUTPUT

Perl utformades specifikt för att vara ett lämpligt sätt att läsa och skriva textfiler. Men som du kommer att lära dig senare, utför Perl slumpmässig åtkomst och I/O-funktioner på binära filer. Filoperationer kräver ett filhandtag, vilket är en variabel som motsvarar en viss fil. Som standard har varje Perl-skript tre standardpekare som Perl automatiskt öppnar när skriptet körs: STDIN,STDOUT, STDERR. Dessa tre standardpekare motsvarar standardströmmarna STDIN, STDOUT, STDERR i programmeringsspråket C. Dessutom kan ett Perl-skript öppna ytterligare pekare till andra specifika filer.

ÖPPNING AV FILER OCH ANDRA STRÖMAR

För att ett skript ska kunna använda en fil måste det anropa den öppna funktionen. Det ser ut så här:

Öppna (FileHandle[, Filnamn])

Till skillnad från C runtime-bibliotekets öppna funktion, inkluderar Perls öppna funktion inte en lägesparameter i funktionsanropet. Perl bestämmer läget för att öppna en fil baserat på filnamnet. Tabell 12.3 illustrerar förhållandet mellan filöppningsläge och filnamn.

Flik. 12.3. Perl filnamn och åtkomstkonventioner

Om ett filnamn utelämnas från anropet att öppna, antar Perl att filnamnet finns i strängvariabeln $FileHandle. När skriptet har slutat använda filen stänger det den med stängningsfunktionen, som visas nedan:

Close(FileHandle);

Programfragmentet illustrerar användningen av öppna och stäng-funktionerna:

Öppna(InFile, "test.dat") || dö; # öppen för läsning # test.dat open(OutFile, ">test.dat") || dö; # create test.dat $AuxFile = ">>test.dat"; öppna(Aux, $AuxFile) || dö; # öppnas för slutförande # test.dat close(InFile); close(OutFile); close(Aux);

Observera att filpekare inte har de vanliga enteckenprefixen. Som du kommer att lära dig senare kan Perl-skript lagra pekarnamn som strängar av skalära variabler och skicka pekaren till valfri funktion som kan bearbeta dem. Perl utför värdekonvertering efter behov.

På MS-DOS stöder Perl en extra funktion som kallas hinmode som gör att fil-I/O kan växla mellan text- och binärläge. På de flesta system är dock skillnaden mellan text och binära lägen irrelevant. Men för operativ system MS-DOS nyradstecken är en sekvens av två tecken (CR+LF). Eftersom de flesta program inte förväntar sig att se två tecken i slutet av en sträng måste I/O-systemet göra omvandlingen. För att kunna använda binmode-funktionen kan motsvarande pekare öppnas. Binmode-funktionen har följande format:

Binmode(FileHandle);

LÄSA OCH SKRIVA DATA

Det enklaste sättet för ett skript att läsa en rad från en fil är att använda operatorn . I Perl blir en filpekare omgiven av triangelparenteser en inmatningssymbol (ingångssymbol). Till exempel illustrerar följande programfragment användningen av enter-tecknet för att läsa och visa innehållet i filen Test.dat.

Öppna(InFile, "Test.dat") || dö; while ($line = ) ( print $line; # Skriv ut en rad från filen ) close(InFile);

När inmatningstecknet når slutet av filen, returnerar det false, vilket avslutar while-loopen i detta fall. Det finns ett speciellt (tomt) inmatningstecken, betecknat<>, som har en mycket speciell men användbar applikation. Första gången ett skript använder ett tomt inmatningstecken<>, den analyserar kommandoradsargument. Om @ARGV-strängen är tom, då inmatningstecknet<>lyder från STDIN. Om istället @ARGV inte är tomt, öppnar Perl den första av de filer som anges av @ARGV och läser innehållet i filen. När Perl är klar med att bearbeta en fil, går den vidare till nästa. Efter att skriptet har läst alla filer, visas tecknet<>returnerar falskt. Perl-skript kan också använda enter-tecknet för att läsa hela innehållet i en fil i en array, så att varje rad i filen blir ett element i arrayen. Till exempel läser följande instruktion från STDIN-filen till @lines-arrayen:

@linjer= ;

Att skriva data till en fil är också ganska enkelt. Faktum är att du gjorde detta varje gång du använde utskriftsfunktionen. Det fullständiga formatet för utskriftsfunktionen är som följer:

skriva ut lista;

Om utskriftsfunktionen inte tar emot en filpekare som ett argument, skickar den utdata till STDOUT. Följande programfragment illustrerar användningen av utskriftsfunktionen för att lägga till data till en utdatafil:

Öppna(LogFile, ">>loggfil.dat") || dö; ############## ($m, $d, $y) = (lokal tid(tid)) ; skriv ut loggfilen "Captain's log, Stardate ++m$/$d/$y\n"; close(LogFile);

Obs: Filpekaren och utdatalistan är inte åtskilda med kommatecken.

LÄSA OCH SKRIVA DATABLOCK

Programmerare tänker ofta på textfiler som textströmmar helt enkelt för att ett tecken följer efter ett annat fram till slutet av filen. Om skriptet behöver arbeta på en fil som är blockorienterad snarare än strömorienterad, kan skriptet använda sysread- och syswrite-funktionerna för att bearbeta fasta datablock. Funktionerna sysread och syswrite har följande format:

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

Om offset från början av filen (Offset) anges i funktionsanropet, kommer funktionerna att söka efter den plats från vilken de kommer att starta I/O-operationerna. Sysread- och syswrite-funktionerna skickar båda data med hjälp av en skalär strängvariabel. Eftersom funktioner fungerar på fasta minnesblock, kan data innehålla binära värden, inklusive nollor och markörer för filslut. Om funktionsanropet anger en offset från början av filen (Offset), så söker funktionen efter en plats i filen från vilken den börjar utföra I/O-operationer. Om du arbetar med datablock kan skript också använda följande I/O-funktioner:

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

Seek-funktionen fungerar precis som fseek, C runtime library-funktionen. Position-parametern anger en position i förhållande till ursprunget, som i sin tur specificeras av Base-parametern enligt följande:

Perls tell-funktion fungerar på exakt samma sätt som C runtime-bibliotekets fiktiva ftell. Denna funktion returnerar den aktuella positionen i filen från vilken en läs- eller skrivoperation utförs. Slutligen returnerar eof-funktionen, liksom C-språkets feof-funktion, värdet<истинно>eller<ложино>, som skriptet kan använda för att avgöra om slutet av filen har nåtts.

BINÄR DATABEHANDLING

Även om Perl främst är inriktat på textbehandling, kan den också bearbeta binär data. Skript kan flytta binära data i bitar med hjälp av strängvariabler och utföra byte I/O-operationer med sysread och syswrite-funktionerna. Men för att göra något<полезное>med datan tvingas skriptet konvertera datan till sin egen<родные>skalära format.

LAGRING AV BINÄRDATA

När ett Perl-skript läser ett block med binär data med hjälp av sysread-funktionen, placerar det binära data i en skalär strängvariabel. Perl bryr sig inte om de ges värden, om de innehåller nollvärden eller icke-ASCII-värden. inom det symboliska Perl strängar accepterar byte som byte. Till skillnad från C använder Perl inte nollterminerade strängar. Om data matchar ASCII-kodtabellen kan skriptet bearbeta det som vilken text som helst, men om data är ett binärt värde måste skriptet dekomprimera det innan Perl kan bearbeta data.

UPPACKNING AV BINÄRA DATASTRÄNGAR TILL PERL-SPRÅKVARIABLER

För att skriptet ska få tillgång till binär data måste det dekomprimera det genom att konvertera till dess skalära format. Perl-skript packar upp data med hjälp av uppackningsfunktionen, som har följande format:

$result = packa upp(Mall, uttryck);

Expression är en vanlig strängvariabel som innehåller binära data som läses av sysread-funktionen, men kan också vara ett uttryck som måste tolkas som en sträng. Mall är en mall-teckensträng som beskriver hur man tolkar värdena i Expression-operanden. Följande kodsnutt illustrerar användningen av uppackningsfunktionen:

($r, $g, $b) = packa upp("C3", $color);# packas upp i 3 tecken
- @longwords = packa upp("L*", $data); # packar upp i en lista med # långa ord @stuff = unpack("S2L", $bin); # kommer att packas upp i 2 shorts och långa

Varje mönstertecken kan följas av en siffra som anger hur många gånger det tecken ska användas. Om det finns en asterisk (*) istället för ett nummer, kommer operationen att utföras för alla återstående data på raden. Om numret inte är inställt, utförs det en gång. Skriptet kan lägga valfritt antal malltecken i mallsträngen. Tabell 12.4 listar tecknen som utgör strängparametern Template, tillsammans med en beskrivning av hur varje tecken påverkar exekveringen av uppackningsfunktionen.

Flik. 12.4. Mallsymboler

FÖRPACKNING DATA TILL BINÄRA STRÄNGAR

För att mata ut binär data måste skriptet packa de skalära värdena i binära teckensträngar. För att göra detta, använd packfunktionen, vars format visas nedan:

$result = pack(mall, lista);

Följande programfragment illustrerar användningen av packfunktionen:

$färg = pack("C3", $r, $g, $b); $data = pack("L*", @longword); $bin = pack("S2L", @prylar);

Packfunktionen använder samma jokertecken som uppackningsfunktionen, förutom a-tecken. A, u, x, x, @.

ARBETA MED KATALOGER

Perl tillhandahåller inte bara ett brett utbud av funktioner för att hantera filer, utan också några mycket praktiska funktioner för att skanna kataloger. I de följande avsnitten kommer vi att titta på några av huvudfunktionerna för att arbeta med kataloger i detalj.

ÖPPNA, LÄSA OCH STÄNG KATALOGER

Perl-skript låter dig öppna och läsa innehållet i filer. På samma sätt öppnar dessa skript kataloger och läser namnen på filerna de innehåller. För att öppna en katalog använder skript funktionen opendir och skickar katalogpekaren och sökvägen till den. För läsning fil-lista som finns i katalogen använder skriptet funktionen readdir. Slutligen används closedir-funktionen för att stänga katalogen. Följande programfragment illustrerar användningen av readdir-funktionen för att visa en lista med filer i den aktuella katalogen:

Opendir(Dir, $INC) || dö; while ($file = readdir(Dir)) (skriv ut "$file \n" ) closedir(Dir);

Det här utdraget använder variabeln $INC för att komma åt den aktuella katalogen. Genom att ändra $INC till $ARGV visar skriptet en lista över filer som finns i katalogen du angav på kommandoraden.

Utöver katalogfunktionerna som diskuterats ovan, tillhandahåller Perl en uppsättning funktioner som låter dig placera den aktuella pekaren i en kataloglista:

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

FORMATERAD UTGÅNG

I det här kapitlet har du sett flera sätt att formatera skriptutdata med utskriftsfunktionen. I likhet med C stöder Perl även funktionerna printf och sprintf. Dessutom stöder Perl även generering av rapporter i kolumnform med hjälp av formulärmallar.

ANVÄNDA UTSKRIFTSFUNKTIONEN

Skripten i det här kapitlet har i stor utsträckning använt utskriftsfunktionen. Dessutom tillhandahåller Perl speciella variabler som påverkar hur utskriftsfunktionen fungerar. Tabell 12.5 karakteriserar i korthet dessa specialvariabler.

Flik. 12.5. Särskilda variabler som styr utskriftsfunktionen

För att använda dessa speciella variabler, tilldela dem helt enkelt de värden du vill ha. Till exempel använder följande kodfragment variabeln $ för att ställa in avgränsaren mellan utskriftsobjekt:

Det visar sig att variabeln $ faktiskt påverkar alla rader, inte bara de som skrivs ut. Oftast kommer du dock att använda den för att ändra värdet som skrivs ut av utskriftsfunktionen.

FORMATERAD UTGÅNG AV PRINTF-FUNKTIONEN

Som standard skickar printf-funktionen formaterad utdata till STDIO, och sprintf-funktionen returnerar en formaterad sträng. I båda fallen är strängformatet nästan identiskt med C-funktioner, förutom att Perl-funktioner inte stöder längdspecifikationen (*). Följande programfragment illustrerar användningen av funktionerna printf och sprintf.

$precision = 2; $pi = 3,1415; printf("%.2f\n", $pi); # utskrifter 3.14 printf("%.$(precision)f", $pi); # utskrifter 3.14

RINGA EXTERNA PROGRAM FRÅN ETT PERL-SKRIPT

På sätt och vis, en ersättning för skalskript, ger Perl stöd för systeminteraktion, inklusive anrop av externa program. Följande avsnitt diskuterar flera sätt att anropa externa program från Perl-skript. Var dock medveten om att om du tillåter skript att köra systemkommandon öppnas säkerhetshål i din värd. Följ den allmänna regeln att inte köra externa kommandon från ett Perl-skript. Däremot om man tvingas externa kommandon från ett skript kan du använda system-, exec- eller fork-funktionerna för detta ändamål.

VANLIGA UTTRYCK

Under hela det här kapitlet har du blivit introducerad till exempelfunktioner för hantering av strängar. Många av dem bygger på begreppet reguljära uttryck. Som du kan se i följande avsnitt använder Perl-skript i stor utsträckning reguljära uttryck för textbehandling. Om reguljära uttryck är nytt för dig, oroa dig inte. Inom en kort tid efter att du har gått igenom några avsnitt i detta kapitel kommer reguljära uttryck att vara lätta att förstå för dig.

ÖVERSIKT ÖVER VANLIGA UTTRYCK

Reguljära uttryck är en fancy term som har sitt ursprung i datavetenskap för att referera till ett mönster av tecken. Perl-skript använder teckenmönster helt enkelt för att analysera indata genom att dela upp den i bitar. Ofta kan ett skript analysera indata baserat på mellanslag, kommatecken, tabbar och andra avgränsare. Men när indata är i ett godtyckligt format, gör reguljära uttryck jobbet bäst.

VANLIGT UTTRYCKSSYNTAX

För att förkorta längden på reguljära uttryck använder Perl specialtecken. Tabell 12.6 listar några av de symboler som används av Perl-skript i vanliga uttryck X.

Flik. 12.6. Symboler som används i reguljära uttryck

Perl sätter reguljära uttryck (mönster, mönster) i snedstreck, det vill säga i snedstreck, till exempel i formen /mönster/. Följande programfragment illustrerar Perls reguljära uttryck:

# följande reguljära uttryck är sanna om: /ig/ # sträng innehåller "ig" /(b|d|f)ig/ # sträng innehåller "big", "dig" eller "fig" /+/ # sträng innehåller ett nummer /*/ # sträng innehåller en identifierare

Om dessa uttryck verkar meningslösa för dig, oroa dig inte. I det här kapitlet ska vi titta på flera reguljära uttryck. För nu, kom bara ihåg att Perl placerar reguljära uttryck mellan två snedstreck, som visas ovan.

ANVÄNDA VANLIGA UTTRYCK FÖR ATT SÖKA MED SÖKORD

Perl-skript använder reguljära uttryck för att göra det enkelt att jämföra strängar. För att kontrollera om en sträng innehåller ett givet mönster, kan ett skript använda reguljära uttryck så här:

Om ($str =~ /mönster/)

I det här fallet tar reguljära uttryck värdet<истинно>om mönstret finns i strängen ($str). Om strängen av innehåller ett mönster, returnerar uttrycket ett värde<ложно>. Till exempel testar följande uttryck om en sträng innehåller texten WebProgramming:

If ($str =~ /Webbprogrammering/)

För att testa för en exakt matchning måste uttrycket binda jämförelsen till början och slutet av strängen. Till exempel utvärderas följande uttryck till värdet<истинно>, om och bara om $str tar ett av tre värden: , ) :

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

På samma sätt är följande uttryck sant om och endast om $str innehåller ordet och är inte en del av ett annat ord som t.ex .

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

ANVÄNDA VANLIGA UTTRYCK FÖR ATT ANALYSE INMATNINGSDATA

När dina Perl-skript blir mer komplexa kommer det att finnas många fall där du vill veta mer än att bara kontrollera om ett mönster matchar en sträng eller inte. Till exempel kanske du vill att ett skript ska extrahera ett specifikt värde från en sträng. Genom att använda grupperingstecknen () i ett reguljärt uttryck kan ett skript extrahera matchande värden från en sträng och bilda en lista över dem. Till exempel använder följande programfragment reguljära uttryck för att extrahera månader, dagar och år från en lista:

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

Perl stöder också en annan form av mönstermatchning, med operatorn (=~), som lägger till en negation av resultatet: (!~). Denna operator motsvarar uttrycket!($str=~/pattern/).

VANLIGA UTTRYCK FÖR SÖKNING OCH BYTE AV STRÄNGAR

Hittills har du använt mönstermatchande operatorer. Det visar sig att Perl stöder två andra reguljära uttryck som modifierar strängvariabeln som testas. I följande uttalande ersätter Perl den del av strängen som matchar mönstret med den givna strängen:

$str =~ s/mönster/ersättning/;

Till exempel skulle följande påstående ersätta ordet på :

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

En liten modifiering gör att du kan ersätta alla ord på :

$str =~ s/\bfärg\b/färg/g;

I det här fallet säger g i slutet av uttrycket Perl att använda global substitution.

Med i-suffixet kan du ange att sökningen är skiftlägeskänslig. I motsats till en enkel mönstermatchning utför följande uttryck också en substitution:

$str =~ tr/SearchList/ReplacementList/;

Till exempel, att ersätta alla gemener med samma versaler kan göras så här:

$str =~tr/a-z/A-Z/; # ändrar skiftläge från nedre till övre

Tänk på följande exempel för dig själv:

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

SAMMANFATTNING

Det här kapitlet ger en introduktion till Perl-programmering. Med de begrepp som diskuteras här kan du skriva komplexa CGI-skript i Perl. Nästa kapitel hjälper dig att få färdigheter i att skapa Perl CGI-skript som du kan köra på din egen server. Innan du fortsätter, se till att du förstår följande nyckelbegrepp:

Perl är ett tolkat programmeringsspråk som används av programmerare för att skriva skript för webben och internet.

Perls språkkonstruktioner liknar i många avseenden de i C, men Perl erbjuder många ytterligare funktioner, särskilt för att hantera strängar och filer som är svåra att hitta i C.

Perl är det primära språket för att skriva CGI-program för webben och internet, främst på grund av dess flexibilitet, kompakta stil och höga säkerhet.

BÄSTA PERL-WEBBAR

Följande webbplatser hjälper dig att hitta information om detaljer av intresse för dig angående Pcrl-språket, dess skript och specifik information om Perl 5-språkresurser och bibliotek. Använd dessa webbplatser som utgångspunkt för din sökning.

SAMMANFATTNING

I det här kapitlet lärde du dig hur du använder Perl för att skriva ganska komplexa CGI-skript. Med hjälp av de tekniker du har lärt dig kan du tillhandahålla professionella programmeringstjänster till dina kunder som vill att deras verksamhet ska finnas på webben. Kapitel 14 introducerar dig till Java-språket. Som du kommer att se Java språk väl lämpad för att skapa webbplatser som innehåller animationer och multimedia. Dessutom introducerar kapitel 14 ett annat språk för att skriva JavaScript-skript. Men innan du går vidare till kapitel 14, kontrollera att du förstår följande nyckelbegrepp:
– Perl är ett mångsidigt och flexibelt programmeringsspråk med vilket du kan utveckla CGI-skript för webben, såväl som traditionella program för dagligt bruk.

• Perl lämpar sig väl för ordbehandling, databasåtkomst, den är portabel och ger säkerhet för nätverk. Alla dessa egenskaper är viktiga för webbprogrammering.
• Perl-skript använder i stor utsträckning reguljära uttryck för textbehandling.
• De flesta skript på webben är för närvarande skrivna i Perl. Men språk som JavaScript och VBScript kan utmana Perls monopol.