Perl programmeringsspråk. Grunderna i Perl - strängar, siffror, matriser, hash
Perlspråket skapades 1987 av en amerikansk programmerare med en språklig utbildning - Larry Wall. Ett år efter skapandet, 1988, hade språket stöd för reguljära uttryck och 1989 - bearbetning av en dataflöde som presenterades i binär form. Arbetet med Perl-språket fortsätter. Nya versioner av Perl har lagt till stöd för komplexa datatyper och en objektmodell.
Funktioner i Perl-språket.
Perls struktur liknar C-språket. Några av funktionerna i Perl-språket är lånade från UNIX-skalspråken.
Ett utmärkande inslag i språket är förmågan att skriva program från en rad. De används direkt i skalinropsraden.
Fördelar.
Perl språk fördelar:
- inbyggda verktyg för att arbeta med komplexa strukturer;
- gratis syntax (ett och samma problem kan lösas på olika sätt);
- många färdiga bibliotek - moduler;
- stöd för att arbeta med reguljära uttryck;
- enkel behandling av stora mängder data;
- förmågan att programmera i en objektorienterad eller "funktionell" stil;
- plattform.
Nackdelar.
För vissa uppgifter blir några av fördelarna med Perl-språket till nackdelar. Ett stort antal moduler gör det svårt att hitta dem, vilket inte är trevligt för programmerare, som av hela sorten bara behöver ett par specifika.
Språket behåller de tidigare populära men nu föråldrade tillvägagångssätten. Ändå kan vissa av dem vara väl lämpade för specifika programvaruuppgifter.
Virtuell värd för webbplatser för populära CMS:
Vad används det till?
Systemstöd för Windows och UNIX.
Perl är populär bland systemadministratörer UNIX och Windows. Dess funktioner gör det möjligt att inte involvera andra programverktyg för att lösa administrativa uppgifter. Perl används för att styra datorer från kommandorad, styrning av ett program över ett annat och andra funktioner.
E-post.
Perl är rätt verktyg för bearbetning av automatisering E-post... Med sin hjälp konfigurerar de filtrering av meddelanden efter angivna parametrar, organiserar utskick och löser många andra problem.
CGU - skript.
Användningen av CGU-skript beror på behovet av att bearbeta de data som användaren har angett på html-sidan. Ett speciellt program startas på servern som genererar ett svar till användaren efter att ha angett data. Perl-språket har blivit utbrett inom detta område på grund av att det är enkelt att implementera de nödvändiga funktionerna.
Webbplatsstöd.
Webbplatsen är ett arkiv textinformation i formatet för html-sidor. Perl-språket är utformat med tanke på behovet av att bearbeta stora mängder textdata, därför används det i stor utsträckning inom detta område.
Det dök upp 1987.
Detta programmeringsspråk är rikt på möjligheter att arbeta med text, vilket avgör huvudområdet för dess tillämpning - speciellt manipulation med text.
Den här artikeln guidar dig genom stegen för att ställa in Perl-körtiden, välja utvecklingsverktyg och skapa ditt första program. I slutet av den här guiden hittar du en lista med resurser som hjälper dig att komma igång med grunderna i Perl och också lära dig mer om språket.
Perl är det enda språket som ser samma ut före och efter RSA-kryptering.
När detta skrivs aktuell version tolk är 5.22.0. Perl 6 är planerad att släppas 2015 men är ännu inte väldokumenterad.
Programmeringsspråket Perl är mycket avskräckt att ta det som ett språk för bekantskap med programmeringen. Om du är en absolut nybörjare är det bättre att börja med något mindre skadligt för ditt omogna medvetande. Seriöst, här är vad Jon Ribbens sa om språket:
PHP är en liten ondska skapad av inkompetenta nybörjare, medan Perl är en stor och smygande ondska skapad av skickliga men perversa proffs.
Förresten bör du inte heller börja med PHP. Låt oss nu komma till saken.
Runtime-miljö
Perl stöds för närvarande officiellt av tre stora plattformar: Mac OS X, Unix och Windows. På de två första av dem är Perl-körtiden förinstallerad och dess version kan hittas via kommandot perl -v (den senaste versionen kan laddas ner) och för operativsystem Windows-familjen Perl-tolk finns tillgänglig för nedladdning på denna sida. Det rekommenderas att välja ActivePerl (distribution från ActiveState) som den vanligaste.
Integrerad utvecklingsmiljö (IDE)
Perl är tyvärr inte särskilt populär bland IDE-utvecklare, så det finns bara en handfull specialiserade verktyg att välja mellan.
Padre, Perl IDE
En lättviktsutvecklingsmiljö med flera plattformar designad speciellt för Perl och bekväm för nybörjare. Förutom traditionell syntaxmarkering och autofullförande har den också inbyggda refactoring-verktyg. Förresten är Padre själv skrivet i Perl 5.
Textredigerare
Som med alla programmeringsspråk har du naturligtvis ett stort utbud av textredigerare med flera plattformar att välja mellan: från förinstallerade bärbara datorer till mer praktiska redigeringsverktyg för källkod med syntaxmarkering, autofullföring och mer. Var särskilt uppmärksam på:
- KomodoEdit - en avskalad version av den kommersiella utvecklingsmiljön Komodo IDE, utvecklad av ActiveState (den som stöder ActivePerl-distributionen), har automatisk komplettering, syntaxmarkering, flera markörer och dokumentationstips;
- Vim - textredigerare vars gränssnitt kan visa sig vara ovanligt för en Windows-användare; stöder syntaxmarkering;
- Sublime Text är ett av de mest redigeringsverktygen för källkoder med syntaxmarkering, autoslutförande etc. vars funktionalitet utökas med många befintliga plugins;
- Notepad ++ - lätt textredigerare med den mest korrekta syntaxmarkeringen efter KomodoEdit; funktionaliteten kan utökas med plugins, men det finns en hel del speciellt för Perl.
CodeGround
Dessutom, om du bara vill prova programmering i Perl och inte vill installera ytterligare programvara på din dator, kan du använda CodeGround-tjänsten, som ger tillgång till utvecklingsmiljöer online med grundläggande funktionalitet för de flesta programmeringsspråk, inklusive Perl.
Den första "Hej världen!" i Perl
Traditionellt föreslår vi att du börjar bekanta dig med ett nytt språk med ett välkänt program:
Skriv ut "Hello World \ n";
Spara den här raden i hello.pl-filen och kör programmet du just skapade med kommandot:
Perl hej.pl
Men se först till att det körbara filer Perl är bland dina miljövariabler (miljövariabler) och även genom att du anropar perl från mappen med källfilen hello.pl. Om det lyckas ser du det förväntade "Hej världen!"
Grattis, du har börjat skriva i Perl!
Och sedan - på väg ...
En utmärkt engelskspråkig guide till Perl-programmeringsspråket för en snabb start finns på tutorialspoint.com. Dessutom finns det en officiell utbildningsresurs -
Datatyper används i program när variabler deklareras. Kort sagt bestämmer en datatyp uppsättningen värden som en variabel kan ta, liksom den uppsättning operationer som ett program kan utföra på den. I Perl kan data vara ett antal eller en rad tecken.
Ett värde kallas en skalar eller bara en skalar. Följande är exempel på skalära värden som används i Perl-språket:
- Decimal: 127 eller 127.0 eller 1.27Е2
- Hexadecimal: Ox7F eller 0x7f
- Oktal: 0177 (den första 0 indikerar att ett oktalt tal används)
- Sträng: "Hello World \ n" eller "Hello World"
Till exempel, nästa kommando använder Perl-felsökaren för att skriva ut numret 0177 oktalt system motsvarande 127 decimaler:
DB<4>s 0177
Perl översätter data till sitt interna format. När Perl skriver ut oktala eller hexadecimala värden, konverterar den först till decimal, som visas.
Obs! Som du ser tillåter Perl-skript dig att använda funktionen printf för att skriva ut värden i ett anropsbart format som oktalt eller hexadecimalt.
Alla siffror representeras internt i flytande punktformat med dubbel precision. Med andra ord finns det inget heltal bland de interna formaten. För det mesta kan du dock ignorera det och Perl kommer att göra det rätt. Om du till exempel använder värden i ett sammanhang där endast helvärden är meningsfulla, kommer Perl att automatiskt avkorta själva numret.
Obs! Om du är en C-programmerare och har använt heltalsdelning med heltalsavkortning automatiskt, kom ihåg att programmera i Perl att göra avkortningen manuellt med funktionen int ().
Följande kommando illustrerar hur Perl hanterar heltal och flyttal:
Skriv ut 6 & 3; # utskrifter 2 utskrift 6.9 & 3.1 # utskrift 7/2 # utskrifter 2.3333 inte ett heltal utskrift int (7/3) # utskrifter 2
Precis som Perl omvandlar flyttal till heltal: när ett skript använder heltal, konverterar det också tal till strängar och vice versa när en sådan konvertering är vettig. Till exempel, om ett skript använder siffror i ett sammanhang där endast strängar är meningsfulla, som att sammanfoga strängar, omvandlar det 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 skalar.
Perl stöder också begreppet booléer, 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 operatörer som<>> (större än), returnera en som ett värde<истинно>och noll - som<ложно>.
Således ska ditt skript helt enkelt behandla icke-nollvärden av både sträng och numerisk typ som ett booleskt värde.<истинно>... Perl-skript kan gruppera skalar tillsammans och skapa en lista. Om skriptet lagrar listan i någon variabel blir variabeln en matris.
VARIABLER
Perl stöder tre typer av variabler: skalar, matriser och associerande matriser. Som i C-språket skrivs variabla namn med en skillnad mellan gemener och stora bokstäver... Således beskriver namnen VAR, Var och var olika variabler. Ett skript kan ha en skalarvariabel med namnet var och en matrisvariabel som också heter var. De skiljer sig åt i Perl beroende på sammanhanget.
Obs! Perl-variabler är otypade, vilket görs i C. Till exempel kan en skalarvariabel innehålla vilken typ av skalär som helst och typprognosen är automatisk. Som du kanske har märkt behöver Perl-variabler inte deklareras. Om en variabel inte deklareras behandlar Perl den som global. Nedan lär du dig om variabla deklarationer och deras omfattning.
SKALARVARIER
Som nämnts kan en skalarvariabel innehålla ett enda värde. I Perl börjar skalära variabelnamn alltid med ett ($) tecken. I följande uttryck tilldelas den skalära variabeln $ age värdet 35 och variabeln $ är strängvärdet
$ ålder = 35; $ name = "Bob"; skriva ut ($ namn, "är", $ ålder);
Om du sparar dessa uttryck i en fil som heter SCALAR.PL kan du köra programmet enligt följande:
C: \ PERL> Perl SCALAR.PL
ARRAYS
Som nämnts ovan är matriser variabler som tar en lista över skalar som sitt värde. Följande Perl-kod illustrerar deklarationen av arrayvariabler och deras initialisering:
@days = ("Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"); skriva ut (@dagar); # kommer att skriva ut "SunMonTueWedThuFriSat" -tryck ($ dagar); # kommer att skriva ut "tors" @ veckodagar = @dagar; # värde ("Mån", "Tis", "Ons", "Tor", "Fre") @emptylist = (); # väntelista
Hänvisar till typvariabler<массив>börjar vanligtvis med ett @ -tecken och följs av värden inom hakparenteser (). Som i C-programmering är arrayindex för skript alltid heltalsvariabler, som vanligtvis börjar med noll. Du kommer att se undantag från dessa två regler i exemplen som kommer att förklaras i detta kapitel. Det tredje uttrycket ($ dagar) är ett exempel på en matris 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 hänvisar manuset till en skalar. Denna anmärkning är mycket viktig. De hakparenteserna indikerar att skriptet hänvisar till en matris. $ -Tecknet anger i sin tur en skalärreferens. @Weekdays-arrayen initialiseras genom att hämta en del av @days-arrayen. I föregående exempel användes matrisen @days utan index. När index utelämnas hänvisar Perl till hela matrisen. På samma sätt initialiserades @days-arrayen i föregående exempel med en lista med bokstäver.
Förutom det faktum att en matris kan tilldelas bokstäver som värden, kan ett skript också tilldela variabler eller till och med andra matriser till matriser, som visas nedan:
@stuff = ($ age, $ name) @FriendsOfMine = ("Joe", "Mary", @FriendsOfYours);
I följande exempel används delar av matriser:
@helg = @dagar; # resultat ("Sun", "Sat") tryck (@days); # kommer att skriva ut "MonTueWedThuFriSunSat"
Om manuset använder variabel av typ array i en skalär sammanhang, då är värdet antalet element i arrayen. En skalär kontext är en där endast skalära värden är vettiga. Till exempel använder följande uttryck den skalära kontexten för grejer för att bestämma antalet element som finns i matrisen. 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 grejer! \ n";
Die-funktionen leder Perl att avsluta körningen och skriva ut det angivna meddelandet. Om meddelandet inte finns, avslutar funktionen helt enkelt skriptkörningen.
Perl stöder också den speciella konstruktionen $ # variabel, som returnerar det sista indexvärdet i en matris. Exempelvis använder följande för uttryck $ [för att bestämma det ursprungliga värdet för array-indexet och $ # för att bestämma det sista av array-elementen. I det här fallet, med hjälp av for-uttrycket, visas värdena för vart och ett av elementen:
För ($ i = $ [; $ i<= $#stuff; $i++) { print $stuff[$i]; }
Den inspelade för loop kan ersättas med följande motsvarande uttryck:
Skriv ut @stuff;
KONTEXTENS ROLL FÖR VARIABLER AV SKALÄR OCH VEKTORTYP
Observera att listbyggnadsoperatören (,) ser exakt ut som den sekventiella utvärderingsoperatören (,). Vilken operatör som används beror på i vilket sammanhang den visas, särskilt om variabeln är en skalär eller en matris. Perl använder listkonstruktion inom ramen för matriser och sekventiell utvärdering för skalar. Tänk på följande uttryck:
@an_array = (1,2,3,4,5); $ a_scalar = (1,2,3,4,5);
Det första uttrycket initialiserar en matris, medan det andra uttrycket ställer in skalar $ a_scalar till 5 och förkastar de fyra första värdena. Tänk på följande två uttryck:
Skriv ut $ assoc (1,2); skriv ut @assoc (1,2);
I det första fallet kommer ett värde i en associerande matris med två nycklar att skrivas ut, medan i det andra fallet kommer två värden i en associerande matris med en nyckel att skrivas ut. Av följande två uttryck kopierar den första listan, medan den andra tilldelar ett skalärt värde lika med storleken på matrisen:
@x = @lista; $ x = @lista;
ASSOCIATIVA ARRAYS
Associerande matriser liknar vanliga matriser genom att de är en lista över skalära variabler. Skillnaden är att en matris måste använda heltal som index när man väljer matriselement, medan en associerande matris kan använda vilken typ av värde som helst för att välja matriselement . Indexvärden för en associerande matris kallas nycklar. Tänk på följande exempel:
$ åldrar ("Bob") = 35; $ åldrar ("Mary") = 25; $, = ""; # ändra utmatningsavgränsare för utskriftsoperatörens utskrift @ages ("Bob", "Mary"); # kommer att skriva ut "25 35" utskriftsknappar (% åldrar); # kommer att skriva ut "Bob Mary" för $ name (tangenter (% åldrar)) (skriva ut "$ name är $ ages ($ keys) \ n";)
Som du kan se tilldelar programmet värden till variabeln "$" (en skalarvariabel vars namn är ett kommatecken). Skriptet använder detta uttryck så att utdata inte slås samman när utskriftssatsen används. med varandra. Resten av detta kapitel diskuterar speciella variabler som "$". Associerande matriser identifieras med hjälp av lockiga hängslen. Som med matriser används inte index när man refererar till en associativ array helt. Exempelvis använder @ ages ("Bob", "Mary") index inom parentes för att indikera en associerande matris. Prefixet @ anger en matris. En liknande användning av ett dollartecken framför en matris indikerar att en skalär används.
Obs: Om två nycklar är specificerade, indikerar detta tillsammans med @ -tecknet att vi pratar om en del av en associerande matris och resultatet bör vara i form av en lista. Detta uttryck motsvarar #ages ("Bob"), #ages ("Mary"). som har värdet (35, 25).
Uttrycket för utskriftsnycklar (% åldrar) anropar nyckeluttrycket, som returnerar hela listan med nycklar i den associerande matrisen. En% åldersreferens med ett procenttecken som ett prefix betyder att referensen hänvisar till hela associerande matrisen. Observera att for-loop hänvisar till variabler som är bifogade i dubbla citat. Slutligen använder det sista exemplet vi tittade på också tangentuttrycket och introducerar en for loop för att skriva ut alla kombinationer av den associerande matrisen. For-loop hänvisar till variabler i dubbla citat. Perl kommer i sin tur att ersätta de värden som refereras till av variablerna när den analyserar strängen. Programmerare kallar denna process för variabel ersättning eller interpolation.
Obs! Perl tolkar inte variabler som innehåller enstaka citerade strängar.
PERLOPERATÖRER
Medan Perls data och variabeltyper skiljer sig mycket från motsvarande C-typer, bör Perls operatörer och uttryck verka mycket mer bekanta för dig. Alla C-operatörer finns i Perl, med undantag för typgjutningsoperatören, * ptr-pekareinnehållsoperatören och var.member- eller var-> medlemsstrukturen för medlemsval. Dessutom har Perl många nya operatörer för användning i operationer som strängjämförelser och bearbetning.
ARITMETISKA OPERATÖRER
Aritmetiska operatörer arbetar 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 siffror på liknande sätt som C atof () -funktionen i runtime-bibliotek. Perl stöder för närvarande följande aritmetiska operatörer:
- + tillägg
- - subtraktion eller teckenändring
- * multiplikation
- / division (endast för flytande nummer)
-% modulo (endast för heltal)
Tänk på exempel på följande Perl-aritmetiska operationer:
$ x = 2,5; $ y = 3; skriva ut ($ x + 2 * $ y); # utskrifter 8,5 utskrift (7 / $ y); # kommer att skriva ut 2.3333333 print int (7 / $ y); # kommer att skriva ut 2 tryck (7% $ y); # skriver ut 1 utskrift (7,5% $ y); # kommer att mata ut 1
Obs: I Perl resulterar delningsoperatören alltid i ett flytpunktsnummer, och resultatet av att ta ett nummer till modulen för ett annat är ett heltal och båda operanderna omvandlas först till en heltalstyp.
Tänk på följande moduloperation:
Utskrift (7,9% 3,6); # matar ut 1 samma (7% 3) = 1
Perl stöder också operatörerna för ökning och minskning:
- ++ minskning i prefix- eller postfixform
- - inkrement i prefix- eller postfixform Tänk på exempel på steg för steg och minskning:
$ x = 4; ++ $ x; skriva ut $ x; # kommer att skriva ut 5 $ y = $ x-; # minskningar x efter att ha tilldelat y till x-utskrift "$ y $ x" # utskrifter 5 4
Slutligen tillhandahåller Perl den aritmetiska operatören för exponentiering (**). Tänk på följande exempel på exponentieringsåtgärden:
$ x = 2 ** 3; # resultat är 8 $ x = 2 ** 0,5; # kvadratrot av 2 $ x = -2 ** -3; # 1 / (- 2 kubad), resultat -1/8 (-0,125)
BIT-OPERATÖRER
Bitvis operatörer agerar på den binära representationen av heltal och har ett heltalresultat. Om operand är en sträng eller ett bråknummer, konverterar Perl det till ett heltal, bearbetar operand med en 32-bitarsrepresentation. Alla C-bitvisa operatorer representeras på Perl-språk:
- | bitvis ELLER
- & bitvis OCH
- ^ bitvis exklusivt ELLER
- ~ bitvis inversion
- << сдвиг влево
- >> flytta åt höger
Tänk på följande exempel på bitvisa operationer:
$ x = 5; # 101 i binär $ y = 3; # 011 i binärt tryck $ x | $ y; # 7 (111) skriv ut $ x & $ y; # 1 (001) skriv ut $ x ^ $ y # 6 (110) skriv ut $ x & ~ 1; # 4 (100) skriv ut $ x<< 2 # 20 (10100) print $x >> 1 # 2 (10)
Som i C beror beteendet hos rätt skiftoperatörer på språkets implementering när operanden är negativ.
JÄMFÖRELSE
Jämförelseoperatörer jämför värdena för två operander. Som med aritmetiska operatorer konverterar Perl strängoperander till numeriska innan de utför jämförelsen. För att tillåta skriptet att jämföra strängar som inte är siffror har Perl ytterligare strängjämförelseoperatörer. Dessa operatörer jämför strängar med ASCII-värden. Om ett numeriskt värde anges som en operand för en strängjämförelse konverteras det först till en sträng. Tabell 12.1 visar jämförelseoperatörerna:
Antal strängvärde = = ekv lika! = Ne inte lika> gt större än< it меньше чем >= gе är större än eller lika<= lе меньше или равно <=>cmp 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. Den sista operationen (<=>eller cmp) kan returnera -1, 0 eller 1 beroende på om den första operanden är mindre än, lika med eller större än den andra.
Obs! Perl cmp-operatören beter sig på samma sätt som Strcmp () -funktionen i C-runtime-biblioteket.
Överväga nästa exempel jämförelser:
$ x = 5; # x är lika med 5 utskrifter ($ x< 4); # если false, то выведет 0
LOGISKA OPERATÖRER
Booleska operatörer analyserar booleska uttryck och returvärden<истинно>eller<ложно>som ett resultat. Perl behandlar booleska operander som booléer, dvs. som ett sant eller falskt värde.
Perl logiska operatörer inkluderar följande:
- || logisk ELLER
- && logisk OCH
Perl bearbetar alltid logiska uttryck från vänster till höger. Dessutom. Perl slutar alltid utvärdera om den redan utförda utvärderingen är tillräcklig för att bestämma resultatet av resultatet. Förutom vanliga logiska operatörer stöder Perl följande ytterligare logiska operatörer:
-! logisk negation ()
-
-: villkorlig drift
-, sekventiell körning
Den logiska negationsoperatören (!) Ersätter ett booleskt värde med motsatsen. Som i C är den villkorliga operatören i Perl (
- :) använder tre operander. Ett uttryck med en villkorlig operatör har följande form:
Tillstånd
- sant resultat: falskt resultat
På samma sätt använder följande uttryck en villkorlig operatör för att ge Bob full kontroll och begränsa alla andra:
$ access = ($ användarekv. "Bob"
- "Full": "Begränsad");
Sekventiell utförandeoperatör<,>(även känd som kommaoperatören) är inte en helt logisk operatör eftersom den inte analyserar sanningen i sina operander. Perl kör operanderna för en sekventiell operatör från vänster till höger och returnerar värdet för den högsta operand. Följande exempel illustrerar användningen av kommaoperatören i en for-loop.
För ($ i = 0, $ j = 10; $ i<10; $i++, $j-) { print i$," ",$j }
LINJEOPERATÖRER
Eftersom Perl är ett textbehandlingsspråk bör det inte bli någon överraskning att det innehåller ytterligare strängoperatörer. Följande är operatörer av strängbearbetning:
-. strängsammankoppling
- x replikering
- = ~ matcha variabel till mönster
-! samma som ovan, men med förstärkt resultat
De två första operatörerna illustreras enkelt med ett exempel:
Skriv ut "b". "an" x 2. "a"; # kommer att skriva ut "banan"
Som visat använder detta uttryck strängkompatering och replikeringsoperatören för att skriva ut strängen
$ var = "banan"; skriva ut ($ var = ~ / ana /)
- SANT FALSKT;
I det här fallet användes testoperatören för förekomst av mönstersträngar (= ~) för att kontrollera om mönstret ana är i $ var. I det här fallet uttrycket tar på sig värdet<истинно>.
OPERATIONSOPERATÖRER
Om du är bekant med C-programmeringsspråket, bör formuläret för Perl-tilldelningsuttalanden vara helt bekant för dig. Precis som i C tvingar dessa uttalanden Perl att utföra speciella operationer på de värden som visas på höger sida av uttalandet och sedan utföra uppdraget:
= += -= *= /= %= |= &= ^= ~= <<= >> = ** =. = x =
LVALUES I Perl, som i C, är en lvalue namnet på den till vänster i ett uppdragsuttalande. Således representerar en lvalue en integritet som kan tilldelas ett värde, till exempel kan en lvalue vara en variabel. Exempelvis kan ett Perl-skript inte tilldela ett värde till en teckensträng, som uttrycket
@färg = ($ r, $ g, $ b); # färgpaket ($ r, $ g, $ b) = @färg; # uppackningsfärg
När du arbetar med listor i Perl gäller tilldelningsoperatören inte nödvändigtvis för hela listan. Skriptet kan tilldela värden till enskilda listobjekt enligt nedan:
@items = (100,200,300);
I detta fall tilldelar operatören ett värde till tre element i listan. På samma sätt packar följande uttryck upp elementen i en lista, tilldelar värdena för de två första elementen till två skalära variabler och resten av matrisen till en listvariabel:
($ arg1, $ arg2, @ rest) = @ARGV; # du kan blanda skalar och matriser
FUNKTIONER FÖR ATT ARBETA MED LISTER
Funktionerna för att arbeta med listor inkluderar följande:
Listkonstruktör - .. scope-operatör - x replikeringsoperator
Du har redan använt listkonstruktören för att initiera matriser och skapa en lista över variabler som används som värden. Omfattningsoperatören returnerar en sekvens av heltal som ett värde som börjar vid vänster operand och fortsätter till och med höger operand. Skript använder ofta omfångsoperatören i kombination med listkonstruktören för att skapa listor. Följande uttryck använder till exempel omfångsoperatören för att skapa en lista med namnet @ siffror som innehåller siffror från noll till nio:
@ siffror = 0..9; #lista (1,2,3,4,5,6,7,8,9)
På samma sätt kan detta uttryck använda omfångsoperatören för att skapa omfånget för matrisindexen. Antag att listan @days innehåller veckodagarna (börjar på söndag). Följande uttryck tilldelar listan @weekdays till värden från måndag till fredag:
@helg = @dagar;
Slutligen använder följande uttryck två omfångsoperatorer för att skapa en lista med hexadecimala siffror:
@hex_digits = (0..9, a..f);
Replikeringsoperatören gör helt enkelt kopior av den givna operan och det angivna antalet gånger. Till exempel, i följande uttryck upprepas listan över värden 1, 2, 3 tre gånger:
FUNKTIONER FÖR ATT ARBETA MED FILER
Perl innehåller en omfattande lista över filoperatörer. Det finns minst 27 uttalanden som returnerar specifik information om en fil utan att ens öppna den. Många Perl-operatörer riktar sig till UNIX-system, men följande operatörer arbetar på vilket system som helst:
D kontrollerar om det finns en katalog
--e upptäcker närvaron av en fil
--s anger filstorleken
--w avgör om den givna filen kan skrivas
De två följande filoperatorerna returnerar ett booleskt värde. Den tredje operatören returnerar filstorleken i byte. Följande text illustrerar användningen av dessa operatörer:
Om (-e, "perl.exe") (skriv ut "Filstorlek är:" -s "perl.exe";) annat (skriv ut "kan inte hitta perl.exe \ n";) (-w "SomeFile ") || die" Kan inte skriva till SomeFile \ n ";
PRIORITERINGAR FÖR GENOMFÖRANDE AV OPERATÖREN
Precis som alla programmeringsspråk definierar Perl företräde för utförande av uttalanden, med hjälp av vilken sekvens för deras körning beställs. Tabell 12.2 visar operatörens företräde från högsta till lägsta:
- ++
-! ~ unary minus
- **
- =~ !~
- * /% x
- +
- <<>>
- -d -e -s -w (och andra filoperatörer)
- <> <= >= Det gt le ge
- = = != < =>ekv ne cmp
- &
- |^
- &&
- ||
- ..
-
- : = += -= *=
Flik. 12.2. Perl-operatörens prioriteringar högsta till lägsta
I ditt skript kan du ändra sekvensen för exekvering av uttalanden med parenteser.
PERL SPRÅKONSTRUKTIONER
Perl stöder alla C-uttryck med nästan identiskt format. Till exempel kontrollstrukturer om, medan, gör. for och goto används på båda språken i samma form. Som du kommer att se senare har fortsättningsuttalandet en något annan betydelse i Perl. Dess tidigare värde kallas nu nästa och pausuttrycket kallas nu sist. Perl implementerar inte ett switch-uttalande. Dessutom finns vissa C-uttryck i Perl i olika format och många nya uttryck har lagts till.
ENKELA OCH KOMPOSITA OPERATÖRER
Varje giltig kombination av operatorer och operander kallas ett enkelt uttryck. I Perl är en operator ett uttryck som slutar med semikolon. Som i programmeringsspråket C slutar alla uttalanden med semikolon. Du kan utelämna semikolon när du går in i programmet i felsökaren, eftersom felsökaren levererar det åt dig. Följande text illustrerar en enkel Perl-uppdragsoperatör:
$ Title = "(! LANG: Webbprogrammering"; !}
Som med C-programmering kan Perl-skript innehålla uttalande block eller sammansatta påståenden, som är inneslutna i lockiga hakparenteser (()), som visas nedan:
(# Operatörer # Ett annat block av operatörer)
Dina skript kommer att använda omfattande uttalande block tillsammans med mer komplexa uttalanden. Som i C kan Perl-skript använda uttalande block för att definiera omfattningen av lokala variabler. Definitionen av lokala variabler i ett block är dock inte automatisk. Skriptet måste använda det lokala nyckelordet för att deklarera dem, och vi kommer att titta på variabelt omfång i detalj senare i detta kapitel.
FÖRHÅLLANDE FÖRETAGARE
Många av de tidigare exemplen har använt ett if-uttalande. I Perl är if-uttalandet nästan identiskt med if-uttalandet i C. Skillnaden är dock att i C kan if-uttalandet använda ett enkelt uttalande utan lockiga hakparenteser, medan i Perl måste uttalandena omslutas i lockiga hakparenteser för att bilda ett block ...
Om (expr) uttalande; // acceptabelt för C men inte för Perl om (expr) (uttalande; # så ska du göra det i Perl)
På samma sätt fungerar Perl else-påståendet något annorlunda än motsvarande C. I Perl måste uttalanden också vara inneslutna i lockiga hakparenteser och bilda ett block:
// Exempel i C är inte acceptabelt i Perl om (expr1) statament1; annars om (expr2) uttalande2; annat ststement3;
Följande visar att Perl tillåter användning av elsif-konstruktionen:
Om (expr1) (statament1;) elsif (expr2) (statement2;) else (ststement3;)
ANVÄNDARE UNDAN
På programmeringsspråket C använder programmerare logisk negation (!) För att vända om ett booleskt värde, som visas nedan:
If (! (Expr)) // Negation in C (statement;)
Tillsammans med användningen av logisk negation innehåller Perl-skript ofta ett såväl uttalande som ger samma som C-koden ovan.
Om inte (expr) (uttalande;)
Obs! Till skillnad från C innehåller Perl inte ett switch-uttalande.
OPERATÖR GÖR
Ett av de speciella fallen för blockoperatörer är do-operatören, som gör det möjligt för ett block med uttalanden att returnera värden. Värdet som do-uttalandet returnerar är värdet för det senaste uttrycket som utvärderats i blocket. Till exempel jämför följande do-uttalande strängvariabeln $ Month med årets månader och ställer variabeln $ DayCount till antalet dagar i månaden:
$ DayCount = do (if ($ Month eq "September" || $ Month ekw "April" || $ Month eq "June" || $ Month ekv "November") (30;) elsif ($ Month ekv "Februry" ) ($ År och 3
- 28: 29; # Kontrollera om det bärande året) annars (31;));
Observera att Perl kräver ett semikolon i slutet av do-blocket. Blanda inte do-blocket med do while-uttalandet, som kommer att diskuteras senare i detta kapitel.
Cykler och grenar
Perl stöder for, while och do loop-uttalanden med mindre skillnader från C.-implementeringen. Den signifikanta skillnaden är att Perl kräver att uttalanden används i block som är inneslutna i lockiga hakparenteser. Dessutom, som du kommer att lära dig senare, utvidgar Perl loopkonstruktionen för att ge några nya former. I följande exempel fungerar loopar för, medan och fungerar på samma sätt i C och Perl:
För ($ 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);
Konstruktionen av öglor i C skiljer sig från konstruktionen i Perl också genom att Perl inte innehåller ett brytuttalande, och fortsättningsuttalandet utför en helt annan funktion. Lyckligtvis ger Perl några nya, mer flexibla och mer intuitiva konstruktioner:
- sista utgången från slingan (som ett C-break-uttalande)
- nästa starta en ny iteration (som ett C continue-uttalande)
- gör om den aktuella iterationen
För att förstå loopkonstruktionerna i Perl måste du förstå användningen av fortsättningsblocket. Tänk på följande medan slinga som innehåller ett fortsättningsblock:
$ i = 100; medan ($ i> 0) (skriv ut $ i;) fortsätt ($ i-)
Du kan tänka på fortsättningsblocket som det tredje uttrycket i for-slingan som körs vid varje iteration. På samma sätt utför Perl ett fortsättningsblock i slutet av varje iteration. Men som du kommer att lära dig senare ger fortsättningsblocket skriptet mer kontroll över processen än för loop gör. När en Perl-loop använder nästa uttalande körs fortsättningsblocket fortfarande om det finns. Men om slingan använder ett redo-uttalande körs fortsättningsblocket inte.
ETIKETTER
I ett Perl-skript betyder etiketter helt enkelt ett namn som motsvarar en plats i skriptet. Etikettnamn slutar med ett kolon (till exempel yttre loop :). Med hjälp av goto-uttalandet kan manuset hoppa till etiketten. Dessutom kan operatörerna Last, Next och Redo användas för att hoppa till en etikett. Följande kod illustrerar användningen av den senaste operatören för att hoppa till en etikett:
Outerloop: while ($ i> 0) (while ($ j> 0) (# Någon annan process här om ($ needToAboutLoop) (sista yttre loop;)))
I det här fallet innehåller uttalandet en sista gren för att förgrena sig till den yttre slingan och avsluta slingan.
Cykel fram till
En annan slingkonstruktion i Perl är till-slingan, som är motsatsen till while-slingan. Kom ihåg att uttalanden exekveras under en viss tid så länge det angivna villkoret är uppfyllt. Däremot utför en till-loop instruktioner tills ett villkor är uppfyllt. Tänk till exempel på en stundslinga som den som visas på nästa sida.
While (! (Expr)) (uttalande;)
Med till-slingan kan du skapa en identisk slinga som visas nedan:
Fram till (expr) (uttalande;)
På samma sätt använder följande under konstruktion den logiska negationsoperatören för att slinga igenom tills ett givet booleskt uttryck utvärderas till sant:
Gör (uttalande;) medan (! (Uttr.));
Med hjälp av do till-konstruktionen kan du skapa en identisk slinga utan att använda boolesk negation:
Gör (uttalande;) tills (expr);
FÖR OCH FOREACH-CYKLER
Perl stöder en for loop på exakt samma sätt som C:
För (uttalande1; uttryck; uttalande2) (uttalande3;)
Följande kod använder till exempel en for-loop för att skriva ut värdena för siffror från 0 till 100:
För ($ siffra = 0; $ siffra<=100; $digit++) { print $digit, " "; }
Dessutom innehåller Perl en foreach-loopkonstruktion som gör att skriptet kan iterera över listor och matriser. Låt oss överväga 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 iterades foreach-slingan över värdena för @list-listvariabeln. I det andra exemplet itererar foreach-slingan över siffror i intervallet 1 till 10. Foreach-slingan kan innehålla en lista med bokstäver eller en matris, såsom illustreras i föregående exempel. Efter att ha utfört en iteration av slingan tar en speciell skalarvariabel ($ arg i det första fallet och $ i i det andra fallet) ett värde från den angivna listan med element. Omfattningen av denna skalära variabel i en foreach-loop är begränsad till loopens kropp. Därför kommer en skalar loop-variabel, foreach, inte att strida mot ett identiskt variabelnamn definierat utanför loop. Följande kod använder en variabel med namnet $ i inom och utanför foreach-slingan:
$ i = 1001; för varje $ i (1..9) (skriv ut "$ i \ n"; # slingan kommer att skriva ut 123456789) skriva ut "$ i \ n";
Som du kan se från detta exempel kommer $ i-variabeln som används för att iterera genom slingan inte i konflikt med $ i-variabeln som definieras utanför slingan. En funktion av foreach-slingan som dina skript kan använda är möjligheten att modifiera arrayelement. (Var försiktig när du implementerar detta!) Tänk på följande foreach-loop, vilket lägger till ett värde på 10 för varje arrayelement:
@list = 1..5; för varje $ i (@lista) ($ i + = 10;) $, = ""; skriv ut @lista; # skrivs ut 11 12 13 14 15
Låt oss göra några sista kommentarer om foreach-slingan. Perl behandlar namnen för alla och för som synonymer. Därför kan du i skript använda dessa namn omväxlande. Perl bestämmer i sin tur typen av slinga baserat på dess sammanhang.
Ovillkorlig övergångsoperatör GOTO
Perl stöder en ovillkorlig goto-operatör, som är identisk med samma operatör i programmeringsspråket C. Nedan följer ett exempel på hur man använder goto-operatören för att skriva ut siffror från 1 till 10:
$ i = 1; loop: skriv ut $ i ++, ""; if ($ i<=10) { goto loop; }
FÖRÄNDRARE
Perl använder speciella former av om, om inte, medan och tills 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 skrivning. Tänk på följande uttryck som använder die-funktionen för att avsluta skriptkörningen om värdet på $ count är mindre än 10:
Om ($ räkna< 10) { die; }
Att sätta formfunktionen före if-uttalandet, som visas nedan, minskar antalet kodrader:
Dö om ($ räkna< 10);
På samma sätt kan samma uttryck skrivas på följande sätt:
($ count> = 10) || dö;
I det här fallet, om den variabla $ räkningen är större än eller lika med 10, stoppar Perl ytterligare beräkning i den här raden och matrisfunktionen utförs inte. Om inte variabeln $ räknas är mindre än 10, efter att den första delen uttrycket, koden startar dörfunktionen och avslutar därmed skriptkörningen ... Slutligen, i följande exempel, med användning av kan också minska antalet rader till en:
Dör såvida inte ($ count> = 10);
På samma sätt är följande medan slingor är identiska:
$ i = 0; medan ($ i< 10) { $i++; } $i = 0; $i++ while ($i < 10);
Som du kan se, med hjälp av en designmodifiering, tillåter skriptet dig att minska antalet rader i slingposten till en. Likaså följande tills slingor är ekvivalenta:
$ i = 10; tills ($ i> = 10) ($ i ++;); $ i = 10; $ i ++ tills ($ i> = 10);
Obs: I alla fyra fall, även om uttrycket som ska utvärderas efter exekveringsuttalandet, analyserar Perl först villkoret och först sedan utförs uttalandet.
GENERERA DYNAMISKA UTTRYCKAR MED ANVÄNDNING AV EVAL FUNKTION
Eftersom Perl är ett tolkat språk kan dina skript använda Perl för att generera kod.<налету>, det vill säga dynamiskt under körning av skript. Så här fungerar Perl-felsökaren (som i sig är ett Perl-program med namnet Perldb.PL). När du utformar skript kan du använda den här dynamiska koden för att skapa dynamiska variabelnamn eller till och med skapa anpassade rutiner. Perl utvärderar dynamiska uttryck med eval-funktionen. I följande exempel skapas en dynamisk instruktion genom att tilldela en variabel som ett värde till text som faktiskt innehåller den önskade Perl-instruktionen. Ytterligare instruktioner använder eval-funktionen för att utföra denna instruktion:
$ perl_statement = "skriv ut" Hej världen \ n ";"; eval $ perl_statement; # utskrifter Hello, world $ i = 1001; $ varname = "$ i"; skriv eval $ varname; # skriver ut värdet på $ i
Obs: Att använda eval-funktionen i ett skript är farligt, särskilt om manuset skickar data som tas emot från användaren till eval-funktionen. Med eval-funktionen kan ett skript utföra godtyckliga Perl-kommandon, inklusive även systemkommandon... Detta gör det möjligt för användaren att styra programmet, vilket kan vara särskilt riskabelt på Internet och på nätet.
DELPROGRAM
Precis som alla strukturerade programmeringsspråk stöder Perl underrutiner. En underrutin kan specificeras med hjälp av undernyckelordet, som visas nedan:
Under demo_sub (skriv ut "demo_sub kallas \ n";) & demo_sub; # subrutinanrop
I det här fallet bildar instruktionerna en underrutin som heter demo_sub. För att anropa en underrutin placerar manuset ett tecken (&) framför underrutinens namn. När du anropar en Perl-underrutin kan parenteserna utelämnas. Du kan placera underrutinen var som helst inom skriptets källkod eftersom Perl analyserar all källkod innan man startar skriptet. Du kan deklarera en subrutin i källkoden omedelbart efter första användningen av subrutinen (framåtreferens). Underrutiner kan ha argument och returnera värden. Följande kodavsnitt innehåller en underrutin med namnet show_value som matar ut det värde som mottagits av underrutinen som en parameter:
Under show_value (skriv ut "The value id", $ _;) & show_value (1001);
Formellt förklarar en Perl-subrutin inte variabler som innehåller argument. Istället skickas en matrisvariabel med namnet @_ till underrutinen och innehåller parametervärdena. I sin tur får subrutinen åtkomst till värdena för argumenten med hjälp av följande notation för arrayelement: $ _, $ _, etc. Men att skicka parametrar på detta sätt kan försämra kodens läsbarhet och därför använder de flesta underrutiner kopiering argument till lokala variabler. I likhet med föregående exempel visar följande underrutin show_fwo_values värdena för två parametrar:
Under show_two_values (skriv ut "Första parameter", $ _, "\ n"; skriv ut "Andra parameter", $ _, "\ n";) & show_two_values (1001, 2002);
Slutligen visar följande funktion show_all_values värdena för alla parametrar den får. Funktionen använder en matris för att definiera numret som en parameter:
Under show_all_values (för ($ i = 0; $ i< @_; $i++) { print "Parametr ", $i, " is ", $_[$i], "\n"; } } & show_all_values(1001,2002,3003,4004);
Som sagt kan Perl-rutiner returnera värden. Avkastningsuttalandet används för detta. Till skillnad från C kräver Perl inte att använda en returret. Om underrutinen inte innehåller ett returuttal, kommer det senaste utvärderade uttrycket att tas som returvärdet. Följande exempel lägger till två parametrar och returnerar resultatet:
Sub add_values (return $ _ + $ _;) skriv ut "Resultatet är:", & add_values (1001,2002);
BIBLIOTEK AV DELPROGRAM
Till skillnad från C stöder inte Perl faktiskt konceptet med ett bibliotek. Den har dock en mekanism för att tillåta skript att använda källkod från en annan fil, till exempel antar att du lagrar subrutinen add_valuesl i en fil som heter addvalue.pl. Med hjälp av kravet kan ett annat Perl-skript komma åt den underrutinen enligt nedan:
Kräva "addvalue.pl"; skriv ut & lägg till värden (10,11);
Du kan tänka på kravuttrycket som analogt med #include-uttalandet för preprocessorn C. För att hitta en källfil letar Perl först i standardkatalogen för Perl-biblioteket (se installationsinstruktionerna för detaljer) och sedan i den aktuella katalogen . Du kan också använda en absolut eller relativ sökväg som filnamnet läggs till. Perl kommer ihåg vilka filer som begärts av begäran, och laddar dem bara en gång, även om dessa filer nås flera gånger. Det finns många standardbibliotek som utökar Perls språk. Nu är det dags att vandra runt i katalogen där Perl-bibliotekets filer 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 underrutiner, särskilt underrutiner som du lagrar i olika filer, kan kollisioner med variabelt namn inträffa när samma variabelnamn används för olika ändamål. Perl hjälper dig att undvika detta genom att använda paket. Som du vet kan namnkollisioner undvikas genom att deklarera lokala variabler för underrutiner. Men om flera rutiner delar vissa specifika data kan dessa data kräva ett globalt omfång, vilket kan leda till en namnkollision. Med hjälp av paket kan du gruppera globala data i privata namnutrymmen, utanför vilka globala variabler inte syns. , dvs okänd. Tänk på följande enkla exempel där två underrutiner (placerade i olika filer) använder privata, distinkta namnområden.
# Kod i en.pl-fil underenhet (paketet demo_on; $ some_data = 10;) # * * * * * * * * # Kod i fil two.pl underenhet (paket demo_two; $ some_data = 20;)
Som du ser använder den första rutinen paketnamnet demo_one, den andra rutinen använder paketnamnet demo_two. Båda rutinerna 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 inom vilket variabeln finns, och den organiserar åtkomst till den, använder paketnamnet som ett prefix till variabelns namn. I följande exempel har paketnamnet package_one eller package_two prefix till namnet på variabeln some_data:
& sub_one; & sub_two; skriv ut "Variabel 1 $ paket_en" vissa_data \ n "skriv ut" Variabel 2 $ paket_två "vissa_data \ n"
När du använder Perl-paket kan du skapa ett unikt namnområde inom den aktuella källfilen genom att placera ett paketuttalande 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 fel åtkomst. Att använda ett paket ger således samma omfattning för data som i C-programmeringsspråket, där globala variabler omfattas av den källfil där de deklareras. När du ringer till en underrutin från en annan skriptfil måste du använda paketnamnet:
Kräva "some_package.pl"; skriva ut & some_package_name "some_sub;
BEARBETNINGSLINJE
I de föregående exemplen lärde du dig hur man konstruerar stränglitteraler med variabel interpolering. Du lärde dig också att sammanfoga stränglitteraler och strängvariabler. I det här avsnittet kan du se att Perl tillhandahåller en stor uppsättning funktioner som skript kan använda för att manipulera strängar.
HOPPA FUNKTION
Chop-funktionen tar bort det sista tecknet från strängen. Den har följande format:
$ tecken = hugga (Str);
Hackfunktionen returnerar det raderade tecknet. Perl-skript använder huggning för att ta bort de nya raden och slutet på raden.
INDEXFUNKTION
Indexfunktionen söker efter en given sträng i en sträng. Den har följande format:
$ location = index (Str, SubStr [, Offset]);
Indexfunktionen returnerar index för den första förekomsten av en substring (SubStr) i en sträng (Str). Valfritt kan en förskjutning anges från början (Offset), varefter sökningen börjar. Om en substring hittas returneras -1. I följande exempel söker indexfunktionen efter förekomster av understrängen "na" efter det tredje tecknet i strängen "banan":
Utskriftsindex ("banan", "na", 3); # Kommer ut 4.
RINDEX-FUNKTIONRindex-funktionen söker efter den sista, längst uppe förekomsten av en substring i en sträng och returnerar positionen för den första karaktären i substringen. Funktionen har följande format:
$ plats = rindex (Str, SubStr);
Den här funktionen liknar indexfunktionen, förutom att den returnerar den senaste förekomsten, inte den första. Till exempel använder följande exempel rindex-funktionen för att bestämma den sista förekomsten av understrängen "na" i strängen "banan":
Skriv ut rindex ("banan", "na"); # Kommer ut 4
LÄNGDSFUNKTION
Längdfunktionen returnerar antalet tecken i en sträng. Den har följande format:
$ len = längd (Str);
I följande exempel används längdfunktionen för att visa antalet tecken i en sträng:
Utskriftslängd ("banan"); # Kommer ut 6
SUBSTR-FUNKTION
Substratfunktionen 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 en sträng som inte överskrider den längd som anges av den valfria parametern Len. Den returnerade strä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 offsetparametern är negativ beräknas offset från slutet av strängen. Slutligen kan manuset använda substr som ett värde för att utföra tilldelningsoperationen. Följande kodavsnitt illustrerar användningen av substrfunktionen.
Utskriftssubstrat ("orange", 3); # Skriver ut "nge" utskriftssubstrat ("orange", - 2); # Skriver ut "ge" utskriftssubstrat ("orange", 2,2); # Skriver ut "an" $ str = "apple"; substr ($ str, -3) = "ricot"; skriva ut $ str; # Skriver ut "aprikos"
Obs! Ofta är det effektivare att använda Perl-operatorer för reguljära uttryck än substrfunktioner. Regelbundna uttryck diskuteras senare i detta kapitel.
GÅ MED FUNKTION
Sammanfogningsfunktionen sammanfogar en lista med element i en sträng och separerar varje element med det angivna tecknet. Den har följande format:
$ new_string = gå med (Str, List);
Föreningsfunktionen konverterar varje objekt i listan till en sträng och sammanfogar strängarna. Följande kodavsnitt illustrerar användningen av anslutningsfunktionen:
$ str = join (",", 0..4,10,20); # Listan kommer att vara "0,1,2,3,4,10,20" $ strn = gå med ("\ t", $ a, $ b, $ c); # Mixlistor
SPLITFUNKTION
Delningsfunktionen delar upp innehållet i en sträng i en lista med element. Den har följande format:
Split (Delimeter, Str [, Limit]);
Delimeter-argumentet anger tecknet som ska avgränsas, till exempel mellanslag, ord, tabbtecken, etc. e. Den valfria parametern Limit anger det maximala antalet element som listan kan innehålla. Följande exempel illustrerar användningen av delningsfunktionen.
FUNKTIONER FÖR BEHANDLING AV LISTER
I exemplen vi såg tidigare i detta kapitel såg vi hur man skapar en lista, lagrar den som ett variabelt värde, itererar över alla listobjekt och får åtkomst till ett enskilt listobjekt. I det här avsnittet lär du dig några fler funktioner som utökar utbudet av möjligheter att arbeta med listor.
OMVÄNDNINGSFUNKTION
Den omvända funktionen reverserar elementen i en lista. Den har följande format:
@new_list = omvänd (@List);
Omvänd funktion vänder listan och returnerar en ny resulterande lista. Följande exempel illustrerar användningen av omvänd funktion:
@list = omvänd (1..5); # Resultat 5,4,3,2,1 @list = omvänd (@list); # Resultat 1,2,3,4,5
SORTFUNKTION
Sorteringsfunktionen sorterar elementen i listan. Den har följande format:
@new_list = sortera (@List);
@new_list = sort (Subrutin @ Lista);
@new_list = sortera (BlockStatement @List);
Sorteringsfunktionen placerar objekten i en lista genom att ordna dem enligt tecknen i ASCII-tabellen. Liksom omvänd returnerar sortering en ny lista som ett 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 sortering i ASCII
I en underrutin eller ett block kan du ändra ordningen enligt vilken sorteringen utförs. Följande exempel illustrerar användningen av sorteringsfunktionen.
@list = sort (($ a<=>$ b) (2,1,10)); # @list 1,2,10 @list = sort (($ b<=>$ a)) (2,1,10); # @list 10,2,1 sub mycomp ($ b<=>$ a) @list = sort (mycomp (2,1,10)); # @list 10,2,1
ARRAYFUNKTIONER
Som du vet är en matris en datastruktur som innehåller en eller flera värden av samma typ, till exempel 100 studentnamn. Perl innehåller flera inbyggda funktioner som hjälper dig att arbeta med arrayelement. I följande avsnitt diskuteras några grundläggande funktioner för bearbetning av matriser.
PUSH- OCH POP-FUNKTIONER
Perl-skript använder push- och pop-fiktionerna för att lägga till och ta bort element från slutet av en matris. Med andra ord tillåter push- och pop-funktionerna att skript kan utföra stackoperationer på en sista in-först-ut-basis. Push-funktionen har följande format:
Tryck (@ARRAY, LIST);
Följande utdrag illustrerar användningen av push-funktionen:
@list = (); tryck (@ lista, 10,20); # @list är nu (10,20) push (@ list, 1..3); # @lista är nu (10,20,1,2,3)
Däremot tar popfunktionen bort det sista elementet som tryckts på stacken och returnerar värdet för det elementet. Popfunktionen har följande format:
$ värde = pop (@ARRAY);
Följande kodavsnitt illustrerar användningen av pop-funktionen:
# Ta @lista från föregående exempel print pop (@list); # Skriver ut 3 tryck pop (@lista); # Kommer att mata ut 2 # Nu @list (10,20)
SKIFTFUNKTION
Skiftfunktionen tar bort och returnerar ett element från början av en matris. Denna funktion liknar popfunktionen med den enda skillnaden att den fungerar från början av arrayen enligt FIFO (<первым вошел, первым вышел>). Skiftfunktionen har följande format:
$ värde = skift (@ARRAY);
Följande kodavsnitt illustrerar användningen av skiftfunktionen:
# Ta @lista från föregående exempel
Skriv ut skift (@lista); # Skriver ut 10 skift (@list); # Kommer att mata ut 20 # Nu @list ()
UNSHIFT-FUNKTION
Unshift-funktionen lägger till ett eller flera element i början av en matris. Den har följande kod:
Avaktivera (@Array, List);
Följande kodavsnitt illustrerar användningen av unshift-funktionen:
# @list = () unShift (@ list, 5,10,20); # @list (5,10,20) unshift (@list, 1..3); # @list (1,2,3,5,10,20)
SPLICEFUNKTION
Perl-skript använder splitsningsfunktionen för att extrahera objekt från en lista och ersätta dem med objekt från en annan lista. Den har följande format:
Splice (@Array, Offset [, Count [, List]]);
Skarvfunktionen extraherar ett specificerat antal element (Count) från en array (@Array), med början vid det element som pekas av Offset-värdet och ersätter elementen med elementen i en annan lista. Om parametern Count inte anges i funktionsanropet hämtar funktionen elementen till slutet av matrisen. Om funktionsanropet inte anger en lista vars element ersätter de ursprungliga elementen lägger funktionen inte till några element i originallistan. Följande uttryck illustrerar användningen av skarvfunktionen:
@list = 1..10; skarv (@ list, 1,8,5,6); # @list = (1,5,6,10)
SKALARFUNKTION
Skalarfunktionen bestämmer antalet objekt i listan. Den har följande format:
Rsult = skalär (Lista);
Vanligtvis behöver inte Perl-skript använda skalar på matriser, för när ett skript kommer åt en matris och skriver det i ett skalärt sammanhang får det antalet element i matrisen som sitt returvärde. Skript kan dock använda skalarfunktionen när sammanhanget är tvetydigt eller om listan inte är en matris. Följande uttryck illustrerar användningen av skalarfunktionen.
@list = 1..10; skriva ut skalar (@list); # Skriv ut storleken på @listan
GREP FUNKTION
Grep-funktionen filtrerar listobjekten som det angivna uttrycket utvärderas till<ложно>... Den har följande format:
@list = grep (uttryck, lista);
Grep-funktionen skannar igenom elementen i listan och ersätter dem som ett argument i det angivna uttrycket. Grep-funktionen tilldelar det aktuella uttrycket för listobjektet till $ _ och utvärderar det angivna uttrycket. Om det returnerade uttrycket är sant lägger grep-funktionen till det elementet i den resulterande listan. Följande programavsnitt 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 ($ _ ekv "", @list); # @list ("a", "b")
Obs: Om uttrycket ändras variabeln. $ _, då ändras också originallistan.
ASSOCIATIVA ARRAYBEHANDLINGSFUNKTIONER
Som känt, associerande matriser- det här är sådana matriser, för vilka indexet 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 associerande matriser.
FUNKTIONSTANGENTER
Nyckelfunktionen returnerar värdena för nycklar som motsvarar en associerande matris. Den har följande format:
@key_list = tangenter (% Array);
Nyckelfunktionen returnerar en uppsättning nycklar som en vanlig lista. Följande kodavsnitt illustrerar användningen av tangentfunktionen:
$ åldrar ("Bob") = 25; $ åldrar ("Mary") = 30; $ åldrar ("Zack") = 15; @list = tangenter (% åldrar); # @list kommer att vara "Zack", "Bob", "Mary" @list = sorteringstangenter% åldrar # @ lista "Bob", "Mary", "Zack" för $ -tangent (sorteringstangenter% åldrar) (skriv ut "$ nyckeln är $ ages ($ key) \ n ")
VÄRDESFUNKTION
Funktionen värden returnerar en vanlig matris med värden från en associerad matris. Den har följande format:
@value_list = värden (% Array)
Funktionen värden returnerar en matris av värdena i en associerad matris som en vanlig lista. Följande kodavsnitt illustrerar användningen av värderingsfunktionen:
# Använda värdena från föregående exempel% ages = ("Bob", 25, "Mary", 30, "Zack", 15); @list = sortera värden% åldrar; # @list (15, 25, 30) @list =% åldrar; # @list ("Zack", 15, "Bob", 25, "Mary", 30)
VARJE FUNKTION
Varje funktion itererar över elementen i en associerande matris. Den har följande format:
@key_values = varje (% Array);
När 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 returnerar den en tom lista. Nästa gång funktionen anropas startar iterationsprocessen från början. Följande kodavsnitt illustrerar användningen av varje funktion:
# Använda värdena från föregående exempel% ages = ("Bob", 25, "Mary", 30, "Zack", 15); medan (($ name, $ age) = each% ages) (# Output age print "$ key is $ ages ($ key) \ n";)
RADERA FUNKTION
Radera-funktionen tar bort elementen i en associerande matris. Den har följande format:
Ta bort $ Array (Key)
Följande uttalande använder borttagningsfunktionen för att ta bort objektet som motsvarar nyckeln Bob från den associerande matrisen $ Anställda:
Ta bort $ anställda ("Bob")
KOMMANDO RADSARGUMENT
Perl-skript har lätt åtkomst till kommandoradsargument. När ett skript körs lägger Perl skriptets kommandoradsargument i @ARGV-listvariabeln. Följande kodavsnitt används för att visa argument i kommandoraden:
Medan ($ arg = shift @ARGV) (skriv ut "$ arg \ n";)
TILLGÅNG TILL MILJÖVARIER
Åtkomst till miljövariabler i Perl-skript är också väldigt enkelt. När skriptet körs lägger Perl kopior av miljövariablerna i en associerande matris med% ENV-namn. Följande uttalande använder% ENV-matrisen för att lista den aktuella katalogen:
Skriv ut "$ ENV (PATH) \ n"; # Skriv ut aktuell katalog
Förutom att hämta värden från% ENV-matrisen kan skript också ändra arrayelement. Om du ändrar% ENV-matrisen så här ändras inställningen för miljövariabler för alla underprocesser som skapas av skriptet. Följande uttalande använder till exempel% ENV-matrisen för att ändra den aktuella sökvägen:
$ ENV (PATH) = "c: \\ myexec;". $ ENV (PATH);
Obs! Ändringar som skriptet gör i% ENV-matrisen påverkar inte de ursprungliga miljövariablerna. Med andra ord, efter att skriptet är klart, ändras inte systemmiljövariablerna.
FILINGÅNG OCH UTGÅNG
Perl var särskilt utformad för att vara ett adekvat sätt att läsa och skriva textfiler. Men som du kommer att lära dig senare, gör Perl random access och binära I / O-funktioner. Filhantering kräver ett filhandtag, vilket är en variabel som motsvarar en specifik fil. Som standard har varje Perl-skript tre standardpekare som Perl automatiskt öppnar när manuset körs: STDIN, STDOUT, STDERR. Dessa tre standardpekare motsvarar standardströmmarna STDIN, STDOUT, STDERR för programmeringsspråket C. Dessutom kan Perl-skriptet öppna ytterligare pekare för andra specifika filer.
ÖPPNA FILER OCH ANDRA STRÖMMAR
För att skriptet ska kunna använda filen måste det anropa den öppna funktionen. Det ser ut så här:
Öppna (FileHandle [, FileName])
Till skillnad från den öppna funktionen i C-körtidsbiblioteket inkluderar Perls öppna funktion inte en lägesparameter i funktionsanropet. Perl bestämmer läget (läge) för att öppna en fil baserat på filnamnet. Tabell 12.3 illustrerar förhållandet mellan filöppningsläget och filnamnet.
Flik. 12.3. Namngivningskonventioner och åtkomstlägen för Perl-filer
-Obs! Rörströmsläget kanske inte finns i alla system.
Om ett filnamn utelämnas i ett samtal för att öppna, antar Perl att filnamnet finns i $ FileHandle-strängvariabeln. När skriptet har använt filen stängs det med hjälp av stängningsfunktionen, som visas nedan:
Stäng (FileHandle);
Utdraget illustrerar användningen av öppna och stänga funktioner:
Öppna (InFile, "test.dat") || dö; # öppen för läsning # test.dat öppen (OutFile, "> test.dat") || dö; # skapa test.dat $ AuxFile = ">> test.dat"; öppen (Aux, $ AuxFile) || dö; # öppnas för addon # test.dat stänga (InFile); stäng (OutFile); stäng (Aux);
Observera att filpekare inte har de vanliga prefixen med ett tecken. Som du kommer att lära dig senare kan Perl-skript lagra pekarnamn som skalära strängar och skicka en pekare till vilken funktion som helst som kan hantera dem. Perl konverterar värdena efter behov.
I MS-DOS-operativsystemet stöder Perl en ytterligare funktion som kallas hinmode, som gör att fil I / O kan växla mellan text- och binärlägen. I de flesta system är skillnaden mellan text och binärläge irrelevant. Men för operativ system MS-DOS newline-karaktär är en sekvens av två tecken (CR + LF). Eftersom de flesta program inte förväntar sig att få två tecken i slutet av en rad måste I / O-systemet utföra konverteringen. För att använda binmode-funktionen kan motsvarande pekare öppnas. Binmode-funktionen har följande format:
Binmode (FileHandle);
LÄNG OCH SKRIV DATA FÖR RAD
Det enklaste sättet för ett skript att läsa en rad från en fil är att använda operatören
Öppna (InFile, "Test.dat") || dö; medan ($ rad =
När inmatningstecknet når slutet av filen returneras det falskt, vilket i det här fallet slutar while-slingan. Det finns ett speciellt (tomt) ingångstecken betecknat<>som har en mycket speciell men användbar applikation. Första gången manuset använder ett tomt inmatningstecken<>, det analyserar kommandoradsargument. Om @ARGV-strängen är tom kommer inmatningstecknet<>läser från STDIN. Om @ARGV inte är tom istället öppnar Perl den första av filerna som anges i @ARGV och läser innehållet i filen. När Perl har bearbetat en fil, går den vidare till nästa, efter att manusen har läst alla filerna, symbolen<>returnerar falskt. Perl-skript kan också använda ett inmatningstecken 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. Följande uttalande läser till exempel från STDIN-filen i @lines-arrayen:
@lines =
Att skriva data till en fil är också ganska enkelt. Faktum är att du gjorde det när du använde utskriftsfunktionen. Fullständigt format utskriftsfunktioner ser ut så här:
Skriv ut lista;
Om utskriftsfunktionen inte tar emot en filpekare som ett argument skickar den utdata till STDOUT. Följande kodavsnitt illustrerar användningen av utskriftsfunktionen för att lägga till data i en utdatafil:
Öppna (LogFile, ">> logfile.dat") || dö; ############### ($ m, $ d, $ y) = (lokaltid (tid)); skriv ut LogFile "Captain's log, Stardate ++ m $ / $ d / $ y \ n"; stäng (LogFile);
Obs! Filpekaren och utmatningslistan är inte kommaseparerade.
LÄS OCH SKRIV DATABLOCKAR
Programmerare tänker ofta på textfiler som textströmmar helt enkelt för att ett tecken följer ett annat fram till slutet av filmarkören. Om skriptet behöver arbeta med en fil som är blockorienterad snarare än trådorienterad kan skriptet använda sysread- och syswrite-funktionerna för att bearbeta fasta datablock. Sysread- och syswrite-funktionerna har följande format:
$ result = sysread (FileHandle, $ Var, Length [, Offset]); $ result = syswrite (FileHandle, $ Var, Length [, Offset]);
Om en förskjutning från början av filen (Offset) anges i funktionsanropet, söker funktionerna efter den plats där de startar I / O-operationer. Sysread- och syswrite-funktionerna skickar båda data med hjälp av en skalarsträngvariabel. Eftersom funktioner bearbetar fasta minnesblock kan data innehålla binära värden, inklusive nollor och filändare. Om funktionsanropet anger en förskjutning från början av filen (Offset), söker funktionen efter den plats i filen från vilken I / O-operationer ska börja. Om du arbetar med datablock kan skript också använda följande I / O-funktioner:
$ resultat = sök (FileHandle, Position, Base); $ resultat = berätta (FileHandle); $ resultat = eof (FileHandle);
Seek fungerar på exakt samma sätt som fseek, en runtime-biblioteksfunktion C. Positionsparametern anger positionen relativt ursprunget, som i sin tur specificeras av basparametern enligt följande:
- 0 Sök från början av filer
- 1 Sök från aktuell position
- 2 Sök från slutet av filen
Perls tell-funktion fungerar precis som ftell ftell i runtime-biblioteket C. Den här funktionen returnerar den aktuella positionen i filen från vilken läs- eller skrivoperationer utförs. Slutligen returnerar eof-funktionen, precis som C-funktionsfeof, värdet<истинно>eller<ложино>som manuset kan använda för att fastställa att slutet på filen har nåtts.
BINÄR DATABEHANDLING
Även om Perl främst är inriktad på textbehandling kan den också behandla binär data. Skript kan flytta binär 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 åstadkomma någonting<полезное>med data tvingas manuset att konvertera data till sina egna<родные>skalära format.
LAGRING AV BINÄRA DATA
När ett Perl-skript läser ett block med binär data med hjälp av sysread-funktionen sätts det binära data i en skalarsträngvariabel. Perl bryr sig inte om vad dessa ges, om de innehåller nollor eller icke-ASCII-värden. Inom en teckensträng accepterar Perl byte som byte. Till skillnad från C använder Perl inte nollavslutade strängar. Om data överensstämmer med ASCII-kodtabellen kan skriptet behandlas som vilken text som helst, men om data är binära värden måste skriptet packas upp innan Perl kan bearbeta data.
UPPACKNING AV BINÄRA DATASTRÄNGAR I PERLVARIER
För att skriptet ska få åtkomst till binär data måste det packas upp i dess skalära format. Perl-skript packar upp data med hjälp av unpack-funktionen, som har följande format:
$ resultat = packa upp (mall, uttryck);
Uttryck är en vanlig strängvariabel som innehåller binära data som läst av sysread, men kan också vara ett uttryck som ska tolkas som en sträng. Mall är en teckensträngmall som beskriver hur man tolkar värdena i Expression-operanden. Följande kodavsnitt illustrerar användningen av uppackningsfunktionen:
($ r, $ g, $ b) = packa upp ("C3", $ färg); # packa upp i 3 tecken
- @longwords = packa upp ("L *", $ data); # packar upp i en lista med långa # ord @stuff = packar upp ("S2L", $ bin); # packa upp i två shorts och långa
Varje tecken i mönstret kan följas av ett tal som anger hur många tecken som ska användas. Om det finns en asterisk (*) istället för ett nummer kommer operationen att utföras på alla återstående data i raden. Om inget nummer anges, körs det en gång. Skriptet kan placera valfritt antal malltecken i mallsträngen. Tabell 12.4 listar symbolerna som ingår i mallsträngparametern, tillsammans med en beskrivning av hur var och en påverkar utförandet av uppackningsfunktionen.
Flik. 12.4. Mall symboler
| Mönster symbol | Beskrivning |
| a | |
| MEN | ASCII-sträng utan noll tecken |
| b | Bitsträng (minst betydande bit först) |
| I | Bitsträng (viktigast bit först) |
| från | Signerad en-byte karaktär |
| FRÅN | Osignerad karaktär med en byte |
| d | Dubbel precision flytande punktvärde |
| f | Flytpunkt, enkelprecisionsmönster |
| h | Hexadecimal sträng (minst betydande bitar först) |
| H | Hexadecimal sträng (viktigaste bitar först) |
| i | Signerat heltal |
| Jag | Osignerat heltal |
| l | Signerat heltal av typen lång |
| L | Samma, bara utan tecken |
| n | Kort heltal |
| N | Långt heltal |
| sid | Pekare till sträng |
| s | Signerat kort heltal |
| S | Osignerat kort heltal |
| u | Avkoda en sträng |
| v | Kort heltal |
| V | Långt heltal |
| x | Hoppa fram en byte |
| X | Hoppa tillbaka en byte |
| @ | Flytta till en angiven position på en rad |
PACKNINGSDATA I BINÄRA STRÄNDER
För att mata ut binär data måste skriptet packa skalära värden i strängar med binära tecken. För att göra detta, använd förpackningsfunktionen, vars format visas nedan:
$ resultat = pack (mall, lista);
Följande kodavsnitt illustrerar användningen av förpackningsfunktionen:
$ color = pack ("C3", $ r, $ g, $ b); $ data = pack ("L *", @longword); $ bin = pack ("S2L", @stuff);
Pack-funktionen använder samma jokertecken som unpack-funktionen, med undantag för a-tecknen. A, u, x, X, @.
ARBETAR MED KATALOGER
Perl tillhandahåller inte bara ett brett spektrum av funktioner för bearbetning av filer utan också några mycket praktiska funktioner för skanning av kataloger. I följande avsnitt kommer vi att titta på några av de grundläggande funktionerna för att arbeta med kataloger i detalj.
ÖPPNINGS-, LÄS- OCH STÄNNINGSKORT
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 in en katalogpekare och sökväg till den. Skriptet använder readdir-funktionen för att läsa listan över filer som finns i en katalog. Slutligen används closedir-funktionen för att stänga katalogen. Följande kodavsnitt illustrerar användningen av readdir-funktionen för att visa en lista med filer i den aktuella katalogen:
Opendir (Dir, $ INC) || dö; medan ($ file = readdir (Dir)) (skriv ut "$ file \ n") closedir (Dir);
Detta kodavsnitt använder $ INC-variabeln för att komma åt den aktuella katalogen. Genom att ändra $ INC till $ ARGV visar skriptet en lista över filerna i katalogen som du angav på kommandoraden.
Förutom de katalogfunktioner som diskuterats ovan erbjuder Perl en uppsättning funktioner som låter dig placera den aktuella pekaren i en kataloglista:
$ resultat = spola tillbaka (DirHandle); $ resultat = telldir (DirHandle); $ resultat = seekdir (DirHandle, Position);
FORMERAD UTGÅNG
I detta kapitel lärde du dig om flera sätt att formatera utdata från ett skript med hjälp av utskriftsfunktionen. Precis som C stöder Perl också printf och sprintf. Dessutom stöder Perl också att generera kolumnformaterade rapporter med formulärmallar.
ANVÄNDA UTSKRIFTSFUNKTIONEN
I detta kapitel har manus använt utskriftsfunktionen i stor utsträckning. Dessutom tillhandahåller Perl speciella variabler som påverkar hur utskriftsfunktionen fungerar. Tabell 12.5 sammanfattar dessa speciella variabler.
Flik. 12.5. Särskilda variabler som styr utskriftsfunktionen
För att använda dessa speciella variabler behöver du bara tilldela dem de värden du vill ha. Följande kodavsnitt använder till exempel variabeln $ för att ställa in avgränsaren mellan utskriftsobjekt:
$, = "*"; @list = 1..10; skriv ut @lista; # Kommer att mata ut 1 * 2 * 3 * 4 * 5 * 6 * 7 * 8 * 9 * 10Det visar sig att variabeln $ faktiskt påverkar alla rader, inte bara de som skrivs ut. För det mesta använder du dock den för att ändra det värde som skrivs ut med utskriftsfunktionen.
FORMATERAD DATAUTGÅNG MED UTSKRIFT
Perl har printf- och sprintf-funktioner som liknar motsvarande C-körtidsbiblioteksfunktioner.De har följande format: $ result = printf (Format, List); $ resultat = sprintf (Format, Lista);Som standard skickar printf-funktionen formaterad utdata till STDIO-standardutgången, och sprintf-funktionen returnerar den formaterade strängen. I båda fallen är strängformaten nästan identiska med funktionerna i C-språket, förutom bristen på stöd för Perl-språkfunktionerna för längdspecifikatorn (*). Följande kodavsnitt illustrerar användningen av funktionerna printf och sprintf.
$ precision = 2; $ pi = 3,1415; printf ("%. 2f \ n", $ pi); # skriver ut 3.14 printf ("%. $ (precision) f", $ pi); # matar ut 3.14
RINGAR EXTERNA PROGRAM FRÅN ETT SKRIFT PÅ PERLSPRÅK
På sätt och vis ersätter Perl support för systemkommunikation, inklusive samtal externa program... I följande avsnitt diskuteras flera sätt att ringa externa program från Perl-skript. Tänk dock på att genom att tillåta skript att köra systemkommandon öppnar du säkerhetshål på din webbplats. Följ den allmänna regeln om att inte köra externa kommandon från ett Perl-skript. Men om du tvingas göra det externa team från ett skript kan du använda det inbyggda system-, exec- eller gaffelfunktionerna för detta ändamål.
VANLIGA UTTRYCK
Under hela detta kapitel har du sett exempel på strängbearbetningsfunktioner. Många av dem bygger på begreppet reguljära uttryck. Som du kan se i följande avsnitt använder Perl-skript omfattande reguljära uttryck för att bearbeta text. Om reguljära uttryck är nya för dig, oroa dig inte. Efter en kort stund efter att du har läst några avsnitt i detta kapitel kommer reguljära uttryck att vara enkla och enkla för dig.
ÖVERSIKT ÖVER REGELBARA UTTRYCK
Regulära uttryck är en snygg term som har sitt ursprung i datavetenskap och tjänar till att beteckna ett mönster som består av symboler. Perl-skript använder symboliska mönster helt enkelt för att analysera ingångsdata genom att dela upp dem. Ofta kan ett skript analysera ingången baserat på mellanslag, komma, flikar och andra avgränsare. Men när ingångsdata är i ett godtyckligt format, är reguljära uttryck bäst lämpade för denna uppgift.
SYNTAX AV REGELBARA UTTRYCK
Perl använder specialtecken för att minska storleken på reguljära uttryck. Tabell 12.6 visar några av de tecken som används av Perl-skript i reguljära uttryck.
Flik. 12.6. Symboler som används i reguljära uttryck
| Symbol | Beskrivning |
| . | Matchar alla karaktärer (exklusive newline-karaktär) |
| (..) | Grupperar en sekvens av element |
| + | Uppfyller det föregående mönstret en eller flera gånger |
- |
Uppfyller mönstret noll eller en gång |
| * | Matchar mönster en eller noll gånger |
| [...] | Matchar en karaktär från en viss uppsättning |
| [^...] | Matchar en karaktär från uppsättningen som erhållits genom negation |
| (...|...|...) | Matchar ett av alternativen |
| ^ | Matchar början på en rad |
| $ | Matchar mönstret i slutet av raden |
| (n, m) | Matchar mönster n till m gånger |
| (n) | Matchar mönstret exakt n gånger |
| (n,) | Matchar provet minst n gånger |
| \ n \ t etc. | Matchar en nylinjetecken, flikkaraktär och så vidare. |
| \ b | Matchar vid ordgränser |
| \ B | Matchar inom ordgränser |
| \ d | Motsvarar figuren |
| \ D | Motsvarar inte en siffra |
| \ s | Matchar ett mellanslag |
| \ S | Matchar inte ett mellanslag |
| \ w | Matchar en bokstav eller ett nummer |
| \ W | Matchar ett tecken som varken är en bokstav eller ett tal |
Perl lägger regelbundna uttryck (mönster, mönster) i snedstreck, det vill säga i sneda streck, till exempel i form / mönster /. Följande kodavsnitt illustrerar Perl-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 "stor", "gräva" eller "fig" / + / # sträng innehåller ett tal / * / # sträng innehåller en identifierare
Oroa dig inte om dessa uttryck verkar meningslösa. I det här kapitlet ska vi titta på flera reguljära uttryck. För närvarande, kom bara ihåg att Perl sätter regelbundna uttryck mellan de två snedstrecken, som visas ovan.
ANVÄNDNING AV REGELBARA UTtryck FÖR SÖKNING MED NYCKELORD
Perl-skript använder reguljära uttryck för att göra strängjämförelser enklare. För att kontrollera om en sträng innehåller ett visst 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äng ($ str). Om strängen innehåller ett mönster returnerar uttrycket värdet<ложно>... Exempelvis testar följande uttryck om strängen innehåller texten WebProgramming:
Om ($ str = ~ / webbprogrammering /)
För att söka efter en fullständig matchning måste uttrycket binda jämförelsen till början och slutet av strängen. Till exempel har följande uttryck värdet<истинно>om och endast om $ str-variabeln tar ett av tre värden:
($ str = ~ / ^ ba (na) (2,4) $ /)
På samma sätt gäller följande uttryck om och endast om $ str-variabeln innehåller ordet
($ str = ~ / \ bthe \ b /)
ANVÄNDA REGLERADE UTTRYCK FÖR ATT ANALYSERA INGÅNGSDATA
När dina Perl-skript blir mer komplexa, kommer det att finnas många fall där du vill veta mer än bara att kontrollera om ett mönster matchar en sträng eller inte. Du kanske till exempel vill att ett skript ska hämta ett visst strängvärde. Genom att använda grupperingstecken () inom ett vanligt uttryck kan skriptet extrahera värden från strängen som matchar mönstret och skapa en lista från dem. Följande kodavsnitt använder till exempel 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)) /;
- Hoppa över det första speciell karaktär;
- skriv alla icke-specialtecken till variabeln $ m
- (variabel för att ange månader);
- hoppa över ett specialtecken;
- placera alla siffror i variabeln $ d (en variabel för inspelningsdagar);
- hoppa över alla tecken som inte är siffror;
- skriv fyra siffror till variabeln $ y (en variabel som anger år).
Perl stöder också en annan form av mönstermatchning, med operatören (= ~), som tillför negationen till resultatet: (! ~). Denna operatör motsvarar! ($ Str = ~ / mönster /).
REGELBARA UTTRYCK FÖR SÖKNING OCH BYTTNING AV STRINGAR
Hittills har du använt mönster för matchning av mönster. Det visar sig att Perl stöder två andra reguljära uttryck som ändrar strängvariabeln som testas. I följande uttalande ersätter Perl den del av strängen som matchar mönstret med en viss sträng:
$ str = ~ s / mönster / ersättning /;
Till exempel kommer följande uttalande att ersätta ordet
$ str = ~ s / \ bcolour \ b / color /;
En liten ändring gör att du kan ersätta alla ord
$ str = ~ s / \ bfärg \ b / färg / g;
I det här fallet säger g i slutet av uttrycket Perl att global substitution krävs.
Genom att använda i-suffixet kan du göra sökningen skiftlägeskänslig. Till skillnad från enkel mönstermatchning utför följande uttryck också substitution:
$ str = ~ tr / Söklista / Ersättningslista /;
Att till exempel 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
Analysera följande exempel själv:
$ bokstäver = "abcde"; skriv ut "$ bokstäver \ n" # Skriver ut abcde $ bokstäver = ~ tr / a-z / A-Z /; skriv ut $ $ \ n "# Skriver ut ABCDE
SAMMANFATTNING
Detta kapitel ger en introduktion till programmering på Perl-språket. Med hjälp av de begrepp som diskuteras här kan du skriva komplex CGI-skript på Perl-språk. Nästa kapitel hjälper dig att få tag på 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 Internet och Internet.
Perls konstruktioner liknar C på många sätt, men Perl erbjuder många ytterligare funktioner, särskilt för hantering av 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.
VIKTIG PERL INFORMATION WEBBPLATSER
Följande webbplatser hjälper dig att hitta information om intressanta detaljer om Pcrl-språket, skript i det och specifik information om Perl 5-resurser 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 man använder Perl för att skriva ganska komplexa CGI-skript. Med de tekniker som du känner till kan du tillhandahålla professionella programmeringstjänster till dina kunder som vill att deras verksamhet ska presenteras 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 animering och multimedia. Dessutom introducerar kapitel 14 ett annat språk för att skriva JavaScript. Innan du går vidare till kapitel 14, kontrollera dock om 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, liksom traditionella program för daglig användning.
- Perl är väl lämpad för ordbehandling, databasåtkomst, bärbart språk och nätverkssäkerhet. Alla dessa egenskaper är viktiga för webbprogrammering.
- Perl-skript använder omfattande reguljära uttryck för att bearbeta text.
- De flesta skript på webben idag är skrivna i Perl. Men språk som JavaScript och VBScript kan bryta mot Perls monopol.
Idag inbjuder vi dig att bekanta dig med en av Technosphere-kurserna, som ägnas åt programmering i Perl. Kursen är öppen - varje student eller doktorand vid Moskva State University kan anmäla sig till den. Lomonosov. Det finns också flera fler i teknosfären; den 1 september öppnas inspelningen på dem. Denna termin väntar på dig trevligt tillägg: de kommer att stödjas av metodologiskt material som kommer att innehålla tillräckligt med information så att du kan komma ihåg materialet från varje föreläsning och, om nödvändigt, studera det djupare.
Målet med Perl-programmeringskursen är att lära sig språkkunskaperna (dess styrkor och svaga sidor), lär dig att skriva programvaruprodukter på detta språk, lär dig att snabbt navigera i någon annans kod. Alla föreläsningar i videoformat och en kort beskrivning för dem finns under klippningen.
Föreläsning 1. Inledning
Historien om skapandet av Perl-språket. Prestandajämförelse. Exempel på projekt. Dokumentation (perldoc). Ställa in miljön. Körande skript (perlrun). Deparse-modul. Data :: Dumper-modul. DDP-modul. Felsökning av perl-skript (perldebug).
Föreläsning 2. Syntax och data
Grundläggande syntax (villkor, slingor, kontrollfunktioner, postfix-notation). Variabler (bastyper, referenser, interpolation). Funktioner (deklaration, argument, sammanhang, prototyper, inbyggda funktioner, grep / karta / sortering, eval). Operatörer (order för utförande, specialoperatörer, nummer och strängar).
Föreläsning 3. Modularitet och återanvändning
Omfatta. Fasblock. Paket. Exportera. Versioner. Pragmatiska moduler. Nej. Symblobord. CPAN.
Föreläsning 4. Regeluttryck och unicode
Unicode-stöd (definitioner, strängar och oktetter, konverteringar, UTF8-flagga, I / O). Regulära uttryck (matcha, hitta och ersätt, translitterering, karaktärsklasser, modifierare, grupper, uppslag, fångster, kvantifierare, arbeta med unicode, felsökning)
Föreläsning 5. Kommunikation med omvärlden
Arbeta med filer. Perl IO-backend. Interaktion mellan processer. Arbeta med uttag. Serialisering (konvertering av data till binär, JSON, CBOR, MSGPACK, lagringsbar, XML). Analysera ingångsparametrarna.
Föreläsning 6. OOP
Metoder. Exempel. Arv. Metodupplösningsordning. Detaljer. Älgliknande.
Föreläsning 7. Arbeta med databaser
SQL. DBI. Ansluta. SQL-injektion. Förbered, utför. Fetchrow. Fetchall_arrayref. Fetchall_hashref. Selectrow. Välj alla. Fel. Transaktioner. Last_insert_id. DBIx :: Klass. Filer. Resultat, resultat. Sök. Hitta, singel. Räkna. Relationer. Ansluta sig. Förhämtning. Uppdatera, ta bort. Många_till_många. Lagring. DBIx :: Klass :: Schema :: Loader. SQL :: Översättare. Memcached.
Föreläsning 8. Webbapplikationer från insidan
HTTP-protokoll. CGI, mod_perl, FastCGI, PSGI. Webbramar. Säkerhetsmekanismer i applikationer.
Föreläsning 9. Programmering av asynkron händelse
Operativsystemets drift (parallellitet och pseudoparallellism, processläge och kontextväxling, grad av multitasking, systemanrop, blockering av I / O-operationer). Bearbetar N parallella anslutningar (acceptera + gaffel, C10k, icke-blockerande I / O-operationer, händelseslinga). AnyEvent (stängningar, uppskjutna funktioner, AnyEvent-gränssnitt, Guard). Coro.
Föreläsning 10. Påskynda pärlan. Expanderar "C"
Generering av XS-moduler. Makroprocessor. Datatyper inifrån. Arbetar med stacken. Typkartor. Bädda in Perl (perlembed).
Föreläsning 11-12. Testning. Prestationsanalys
Funktionell testning. Prestandatester. Stresstestning. Användbarhetstestning. Test av användargränssnitt. Säkerhetstestning. Lokaliseringstestning. Kompatibilitetstest. Profilering. Jämförelser. Hitta läckor i Pure Perl. Hitta läckor i XS.
Prenumerera på vår youtube-kanal Technostream Mail.Ru! Där hittar du alla föreläsningar, mästarkurser och sändningar av våra utbildningsprojekt.
Perl- ett tolkat språk anpassat för att behandla godtyckliga textfiler, extrahera nödvändig information från dem och utfärda meddelanden. Det är också praktiskt för att skriva olika systemprogram. Detta språk är enkelt att använda, effektivt, men det är svårt att säga om det att det är elegant och kompakt.
Perl skapades 1986 som ett verktyg för att administrera och konfigurera systemresurser på ett nätverk av Unix-datorer. Den kombinerar de bästa funktionerna i C, skal, sed och awk, så att lära sig Perl är lätt för dem som är bekanta med dem. Syntaxen för Perl-uttryck ligger nära syntaxen för C. Till skillnad från de flesta OS-verktyg lägger UNIXPerl inte begränsningar på mängden data som behandlas, och om det finns tillräckligt med resurser behandlas hela filen som en rad. Rekursion kan vara av godtyckligt djup. Även om Perl är lämplig för skanning av textfiler kan den också bearbeta binär data och skapa .dbm-filer, som liknar associerande matriser. Perl låter dig använda reguljära uttryck, skapa objekt, infoga bitar av Perl-kod i ett C- eller C ++ - program och låter dig också komma åt databaser.
Perl-språket skapades för att effektivisera behandlingen av textdokument. Det är fokuserat på hantering av strängar. Numera har språket blivit utbrett som ett verktyg för att skapa körbara WWW-servermoduler. Befintliga plugin-paket ger åtkomst till SQL-servrar direkt från ett Perl-program. Detta gör att den kan användas för att lösa alla problem som uppstår när WWW-åtkomst till databaser tillhandahålls. Perl är också effektivt för behandling av godtyckliga datastrukturer: befintliga rapporter, listor, elektroniska kort.
Även om CGI-applikationer kan skrivas på nästan vilket språk som helst har Perl- och CGI-programmering blivit synonymt för många programmerare. Som Hassan Shroeder, Suns första webbansvarige, sa: “Perl är Internetens artär.” Perl är det mest använda språket för CGI-programmering, och det finns många goda skäl till detta:
Perl är lätt att lära sig: dess syntax liknar andra språk (som C) eftersom det är "förlåtande mycket", vilket ger ett detaljerat felmeddelande som hjälper dig att snabbt lokalisera problemet.
Perl underlättar snabb utveckling eftersom det är ett tolkat språk; källkoden behöver inte kompileras innan den körs.
Perl finns på många plattformar med minimala förändringar.
Perl innehåller mycket kraftfulla funktioner för att bearbeta strängar med inbyggt språkstöd för sökning och ersätt med reguljära uttryck.
Perl behandlar binär data lika enkelt som den bearbetar text.
Perl kräver ingen tydlig uppdelning i typer: siffror, strängar och booleska uttryck är vanliga skalärer.
Perl interagerar mycket enkelt med externa applikationer och tillhandahåller sina egna funktioner för att arbeta med filsystem.
Det finns många fritt tillgängliga moduler för Perl, från CPAN, från moduler för att skapa dynamisk grafik till gränssnitt med internetservrar och databashanteringssystem. För information om CPAN, se bilaga B.
Perl är verkligen väldigt snabb: när den läser en källfil kompilerar den omedelbart till lågnivåkod som den sedan kör. Vanligtvis ses inte kompilering och exekvering i Perl som separata steg eftersom de utförs tillsammans: Perl startar upp, läser källfilen, kompilerar den, startar den och avslutar sedan. Denna process upprepas varje gång Perl-skriptet körs, inklusive CGI-skript. Eftersom Perl är så effektiv är denna process snabb nog för att hantera alla förfrågningar på mindre upptagna servrar. Observera dock att på Windows-system är detta mycket mindre effektivt på grund av behovet av att skapa nya processer.
PHP uppfanns av Rasmus Lerdorf i slutet av 1994. Den första versionen släpptes 1995 under namnet "Personal Home Pages Toolkit", sedan designades den om och kallades PHP / FI Version 2 (FI - databehandlingsmodul för formulär). Stöd för mSQL-databaser har också lagts till. Från det ögonblicket började volontärer att delta i utvecklingen.
PHP-användningsstatistik är ungefärlig, men enligt en studie av Netcraft användes PHP i början av 2001 på mer än 5 300 000 webbplatser över hela världen. Som jämförelse: vid denna tid var antalet IIS-servrar ungefär detsamma (5 miljoner). Utvecklingen av PHP-tolk har tagit formen av en organiserad kommandoprocess, där tolkens kärna har utvecklats av Zend.com. Samtidigt distribueras PHP fritt: dess senaste version kan laddas ner från PHP.net-webbplatsen. PHP-moduler levereras med Apache-servern i kit med Linux-system.
Ursprungligen förkortning PHP menade Förprocessor av Hem Sidor - hemsida förprocessor... Det är språket för skript som är inbäddade i HTML-sidor och körs på servern. För det mesta lånas syntaxen från språk som C, Perl, Java, samtidigt som man lägger till många funktioner som dessa språk saknar. Enkelt uttryckt är PHP: s syntax ett förnuftigt alternativ till både C-stränghet och Perls "oändlighet".
PHP är utrustad med nästan hela uppsättningen funktionalitet som (före PHP) bara kunde drömma om en webbprogrammerare. Hans mål- låter dig skapa dynamiskt genererade webbsidor så snabbt som möjligt. Med goda skäl kan vi säga att lärande och användning av PHP kommer att vara till nytta för både nybörjare och professionella programmerare.
PHP: s huvudsakliga konkurrenter är JSP-teknik (Java Server Pages och Java Scriptlets), ASP (Active Server Pages), Perl, SSI (Server Side Includes), Cold Fusion Server Pages.
Tänk på nackdelarna med dessa tekniker. JSP- ett språk som är ganska svårt att lära sig och använda. ASP baserat på VBScript-syntax (Visual Basic), har bara några dussin av sina egna funktioner och måste därför använda COM-objekt; dessutom är det uteslutande fokuserat på Windows. Perl- språket är förbryllande och dess friheter gör det svårt att förstå. SSI låter dig bara skapa en HTML-sida från flera filer. CF- en kommersiell produkt, vilket är den största nackdelen.
Den huvudsakligavärdighet PHP:
fri; ständigt förbättras; fungerar på UNIX- och Windows-plattformar;
tillåter arbete med de flesta DBMS;
har ett brett utbud av funktioner (mer än 3 tusen);
tillåter objektorienterad programmering;
kunna använda HTTP-protokoll, FTP, SHAR, SNMP, NNTP, POP3, nätuttag och andra;
låter dig utföra alla operationer som listas av konkurrenterna och till och med arbeta med grafikfiler. Du kan också köra PHP-skript som tolkade filer och kompilera körbara applikationer(inklusive stöd för GTK GUI).
Om du upptäcker att PHP inte kan något (eller inte fungerar som du vill) kommer ingen att hindra dig från att göra önskade ändringar i PHP-källkoden (skrivet i C). PHP är mjukvaruproduktär öppen källkod, och det är alltid välkommen att göra förbättringar och tillägg till det genom att skapa egna plugins.