Perl är ett programmeringsspråk för nybörjare. Vanliga frågor om Perl för nybörjare
Denna viktiga händelse i programmeringsvärlden ägde rum 1986, när en till synes vanlig kille Larry Wall, efter mödosamt arbete, tillkännagav för världen att han hade utvecklat programmeringsspråket Perl. Vägen till denna betydelsefulla händelse visade sig vara svår och taggig, men resultatet var värt det. Hur, vem och varför utvecklades nytt språk programmering? Alla dessa frågor besvaras här.
Bakgrund
Drivkraften till denna upptäckt var att han deltog i UNIX-projektet. Arbetet var svårt, eftersom det var nödvändigt att skapa säkert nätverk med många nivåer, så att det är möjligt att kombinera arbetet med flera datorer som arbetar från varandra på betydande avstånd. Hela processen slutfördes framgångsrikt, men rapporterna måste göras mycket tidskrävande, inte bara med stor mängd filer, men också med däremellan.
Wall bestämde sig för att använda awk-filtret för att fungera, men ett oväntat hinder uppstod: det var omöjligt att kontrollera öppningen eller stängningen av ett stort antal filer - ironiskt nog - baserat på informationen de innehöll om platsen för dessa filer.
Till en början bestämde sig Larry för att skriva en specifik systemverktyg... Hon, verkar det som, var en väg ut ur den här situationen. Men innan dess hade han redan sammanställt flera verktyg för att lösa detta problem, som tyvärr inte blev ett utlopp för UNIX-standarderna.
Det är därför en begåvad systemadministratör, språkvetare till utbildning, som hjälpte honom i hans arbete, tog en chans och skapade programmeringsspråket Perl så att han samtidigt kunde bearbeta textfiler, hitta en lösning på systemuppgifter och skapa mer begripliga rapporter . Och samtidigt så att det var lågnivåprogrammering, som skulle finnas på språket C. Därför skrevs Perl-tolken i den.
Nytt programmeringsspråk: anledningen till
Enligt Larry hjälpte lättja honom att skapa ett nytt språk. Men det var just den latheten som gjorde det möjligt att bestämma sig viktig uppgift: hur man undviker att kompilera ett stort antal program på olika språk som var en integrerad del av verktyg UNIX. En sådan procedur var för tråkig.
Det nya språkets värdighet uppskattades av andra, eftersom det harmoniskt kombinerade filbehandlings- och systemadministration... Och detta är exakt två väsentliga fakta som behövs när man programmerar ett UNIX-system.
Det bör noteras att programmeringsspråket Perl har en liten skillnad från andra liknande språk: det dök upp för att det fanns ett behov av det, och inte för att förvåna användare eller komma med ett annat vackert verktyg som inte kommer att spela en speciell roll.
Tvärtom, när Larry introducerade sin uppfinning för användare, bl systemadministratörer det skapade en riktig sensation, för nu behövdes det inte lägga ner mycket tid på att fördjupa sig i flera programmeringsspråk, och det blev möjligt att enkelt lösa problem genom att använda ett enda språk med hjälp av en symboltabell.
Egenheter
Översatt till ryska låter förkortningen Perl som "ett praktiskt språk för att extrahera data och generera rapporter."
De bestämde sig för att göra en kamel till en symbol för denna typ av språk, förmodligen med tanke på att eftersom detta djur är ett ädelt, härdigt, kapabelt att bära en tung börda i många dagar utan ett sorl, liknar samma arbete en belastning på ett nytt språk , också seriöst.
Det finns många anledningar till att det nya språket omedelbart uppskattades av många användare. Alla som använder UNIX vet att inställningarna här går igenom speciella filer - vanlig text, och ändringar görs efter att kommandona har utförts. De är skrivna i ett speciellt skalspråk och exekveras från kommandoraden.
UNIX-systemet låter dig skapa individuella kommandon baserat på kommandon från tolken och spara dem. De finns kvar i textfiler och, om så krävs, körs de som en standarduppsättning operativsystemkommandon - endast via kommandoraden.
Användarkommandon manus heter på annat sätt. V UNIX-system den operativa administratören måste skriva Ett stort antal skript, som i sin tur bearbetar efterföljande skript, d.v.s. textfiler med speciella program:
- Ack. Programmet gör det möjligt att jämföra med dessa prover och fungerar som en rapportgenerator.
- Sed. Fungerar som en batchredigerare för textfiler.
Programmen läser raderna i indatafilerna en efter en som filter. De utför sedan strängspecifika åtgärder som bestäms av programkommandon. Samtidigt väljs en kedja av symboler enligt vissa mönster, ersättning enligt de etablerade reglerna, nya filer genereras.
Stora möjligheter
Det nya programmeringsspråket Perl har öppnat för mycket rika möjligheter i de fall du behöver bearbeta text, ihållande uttryck. Perl har stora alternativ för extramoduler.
Med tiden har detta unika språk vidgat sina gränser, och används nu flitigt inom webbutveckling och spel, om du behöver nätverksprogrammering eller grafik för användare.
Språket slog rot och förälskade sig i dess användarvänlighet, nu är det erkänt som det mest dynamiskt språk programmering. Den stöder en mängd olika paradigm, som inkluderar stilar - funktionella, förfaranden och andra, den har kontroll över minnet, den har stöd för textbehandling.
Inte konstigt att ett av L. Walls motton är att enkla saker kan förbli enkla, men komplexa saker måste göras.
Det är lätt att behärska språket genom att förstå uppdragsuttryck, kodblock, kontrollstrukturer och funktioner.
Likheter med andra språk
Larry lånade mycket från andra programmeringsspråk. Till exempel:
- UNIX kommandoskal. Variabler är markerade med inledande tecken, de uttrycker tydligt typen av variabel och hjälper dessa variabler att interpoleras i strängar. Inbyggda funktioner ger instrumentering, och detta används för skalprogrammering.
- Arrays från Lisp.
- Använder Perl reguljära uttryck från awk, samtidigt som han lånar associativa motiv.
- Från sed.
Men det nya språket klarade sina egna uppgifter mycket snabbare, och därför började de använda det inte bara för att lösa systemadministrationsproblem.
Wall fick ett paket från G. Spencer som hjälpte honom att bemästra Perls reguljära uttryck genom att modifiera det för att passa hans idé. Många av de funktioner som utvecklats är inte bara Larrys kredit. Kollegor och vänner var lika entusiastiska över att ta med sina innovationer i det unika program som utvecklas. Och när språket dök upp på internet bildades en hel gemenskap av likasinnade som också hjälpte till att förbättra det. Sedan dess har, enligt statistiken, över 10 000 programmerare varit involverade i arbetet.
Språket förbättras dock fortfarande tack vare utvecklingen av paket som används med framgång i implementeringen av nya användningsområden för språket för att utveckla teknologier relaterade till information.
Utvecklingsstadier
Små men betydande etapper av vägen kan markeras i tabellen.
Släpp versioner | Tid för skapandet |
perl 1. Innehöll inte många funktioner. Detta var det enklaste sättet att söka efter filer med hjälp av mönster. Men det fanns filbeskrivningar, format och skalära variabler. | 1988 år. januari. |
perl 2. Det finns en ännu inte förbättrad motor för reguljära uttryck. | 1988 år. juni. |
perl 3. Utvecklare har gjort det möjligt att bearbeta binära dataströmmar. | 1989 år. oktober. |
perl 4. Dök upp till stor del tack vare boken som såg dagens ljus, "Programmering Perl”, men mer känd som “The Camel Book”. Fixat ett dokumenterat nytt språk. Denna period gick igenom en serie utgåvor, som så småningom satte sig på version 4.036. Det var redan 1993. Sedan började arbetet med nästa - V - version. | 1991 år. Mars. |
perl 5. Lade till stöd för komplexa datatyper, objektmodell som inkluderar länkar, paket och stängning som ett värde. En e-postlista skapas så att arbetet kan samordnas på olika plattformar. Det var faktiskt det huvudsakliga forumet för utveckling, portering och underhåll. Moduler är nu med viktig del versioner, eftersom de kunde utöka språket, men utan inblandning av att modifiera tolken. Detta kunde stabilisera honom, men utökade hans språkkunskaper. | 1994 år. oktober. |
Perls unika programmeringsspråk: för- och nackdelar
Perl 5 utvecklas aktivt och uppdateras nu med fler och fler versioner. Men all utveckling har flera faktorer gemensamt: automatisk datainmatning utförs, automatisk kontroll över minnet utförs.
Tack vare tolken är inte bara typerna kända, utan också minnesförfrågningarna för varje programobjekt, och det är inte svårt för det att allokera minne, frigöra det när man räknar referenser.
Det bör noteras att Perl-programmering skiljer tolken från andra. Beviset på detta är översättningen av programmet till en mellanbytekod, och först då börjar det exekveras. I jämförelse: den traditionella fungerar lite annorlunda - den inmatade operatorn tolkas och exekveras omedelbart, vilket är fyllt med syntaxfel under arbetsflödet. Perl låter dig upptäcka denna typ av fel redan under översättningen till bikod.
För att överföra en typ av data till en annan krävs en automatisk process, men om översättningar av någon typ av data inte är möjliga kan detta leda till ett fatalt fel.
Fördelen med version 5 004 är att det finns ett UNIVERSAL-paket, som gavs till språket av huvudobjektet, och från det härstammar alla klasser - på automatisk basis. Nu kan du begära versionen av moduler. Det har blivit verklighet att stödja begäran om version av moduler. Utöver detta har perl kommit att stödja många operativsystem, och Microsoft Windows Inklusive.
Version 5.005, släppt 1998, förbättrade avsevärt kvaliteten på processorn för reguljära uttryck, förbättrade nya krokar i backend, vilket löstes med hjälp av vissa moduler och utökat stöd för operativsystem.
Senaste uppdateringarna
År 2000 gav världen en ny, 5.6, version av pärlspråket. Den såg redan mycket mer solid ut än den första, hade 64-bitarssystem, kunde stödja filer över två GB, inkluderade strängrepresentation, med hänsyn till Unicode-standarden, och nyckelord- vår. Under denna period ändras versionens namnschema för att vara närmare andra projekt med öppen källkod.
Ett intressant faktum är detta beslut: om en version är under utveckling kommer den att tilldelas ett nummer med udda siffror, och den stabila kommer att få en jämn numrering.
Wall vände sig sedan till sina följare med en begäran om förslag på en mer avancerad version. Hans vädjan hördes och resultatet blev 361 dokument, vilket hjälpte till att utveckla VI-versionen. Användarna presenterades för ett dokument som med största sannolikhet såg ut som en sammanfattning, och denna version fanns, men bara i form av en beskrivning av språket. Ett antal dokument har blivit specifikationen för denna version. Ett försök att lansera VI-versionstolken 2006 stoppades. Men sedan 2009, under namnet Rakudo Perl, lever denna version vidare och uppdateras med jämna mellanrum.
En betydande förändring i utvecklingsprocessen för Perl 5 kom med tillkomsten av Perl 5.11. Utvecklargemenskapen har gått över till en månatlig releasecykel, med ett releasedatum planerat tre månader i förväg.
En ny version
Version 5.8 dök upp 2002. Det är känt för det faktum att det från den tiden uppdaterades årligen fram till 2008, avsevärt förbättrat stöd för Unicode, lagt till många funktioner, som inkluderar stöd för multithreading, den ursprungliga implementeringen av I / O och ökad precision av det numeriska. Och återigen har nya moduler dykt upp.
Vid 20-årsdagen av skapandet av ett allmänt programmeringsspråk gjorde den nya versionen, numrerad 5.10.0, inte användarna besvikna igen. Det finns nya operatorer, såväl som "smarta" - matchningar, uppdaterade reguljära uttryck.
Vad har de senaste årens arbete fört med sig?
Varje år hjälpte nya förbättringar till att göra språket som uppfanns av Wall enklare och mer tillgängligt. 2010 präglades av att syntaxen för perl-språket fick stöd för paketet NAME VERSION, reguljära uttryck, under de efterföljande åren uppdaterades moduler och operatörsstödet utökades.
Målet uppnåddes - att vid körning indikera versionen som ska emuleras, vilket innebär att tillåta uppdatering av perl, men samtidigt inte förlora arbetsförmågan hos de skript som används, vilket utgör ett hot om att vara inkompatibelt med presenteras ny version... Det finns fler funktioner, ökad säkerhet.
I slutet av maj, ganska nyligen, dök en annan version upp, som alltid, mer förbättrad och bekvämare att arbeta med. Idag kan vem som helst testa det och se till på egen erfarenhet att mycket arbete har gjorts för att skapa detta programmeringsspråk.
I detta Perl-språk är arrayer inte begränsade. Med hjälp av språket kan du lösa icke-traditionella uppgifter, för genomförandet av vilka flera annars skulle vara involverade, utföra administrationsuppgifter, bearbeta högkvalitativa textfiler och inte mycket tid kommer att läggas på alla problem. Genom att utveckla nya program med hjälp av symboltabellen, med hjälp av de nödvändiga operatörerna, blir resultatet korrekt och snabbt.
Denna artikel bevisade återigen att ingenting är omöjligt för entusiaster inom sitt område. Ibland leder även de minsta problem till användbara upptäckter som kan göra vårt liv lite lättare.
Förordet bör enligt vår mening ge läsaren information på grundval av vilken han avgör om han behöver denna bok.
Vad handlar vår bok om. Det handlar förstås om perlspråket, för det är vad namnet säger. Vem behöver denna Perl? De som skapar CGI-skript är engagerade i systemadministration genom att skriva skript, snarare än att klicka med vänster musknapp, bearbeta texter, lösa många andra uppgifter från relaterade områden, och behöver samtidigt ett kraftfullt, men lättanvänt verktyg som låter dig skapa stora program och små program och testa dem snabbt. Det är också användbart för dem som undervisar i programmering att ha en förståelse för detta språk, eftersom det har intressanta egenskaper som inte finns i traditionella programmeringsspråk som används i inlärningsprocessen.
Vi gillar några av språkets egenskaper: resultatets beroende av sammanhanget, associativa arrayer, typglob-datatypen, paket, en objektorienterad programmeringsimplementering och naturligtvis textbearbetningsverktyg. Om du inte åtminstone är intresserad av att veta vad allt detta betyder, då kan du lägga boken åt sidan. Om du redan kan allt ovan, kan du också skjuta upp det, eftersom den här boken är för de läsare som precis har börjat lära sig Perl på egen hand.
Perl-språket skapades av systemprogrammeraren Larry Wall som ett UNIX-verktyg som låter dig "limma" stora skript från program som utför separata funktioner för att lösa ett komplex av uppgifter relaterade till administration, textbehandling etc. Senare gick han bortom dessa ram, förvandlas till riktigt språk programmering, som speglade många av de trender som har dykt upp inom programmeringstekniken under det senaste decenniet, och fick stor spridning i samband med utvecklingen av Inernet. Perl är huvudverktyget för att bygga CGI-applikationer, bekvämt för att administrera webbservrar, e-post och andra system. Tack vare snabbheten och lättheten att skriva skript på detta språk har det spridit sig till andra plattformar: DOS, Windows, OS / 2, Mac, VMS, etc. En av de främsta fördelarna med Perl-språket är dess öppenhet och tillgänglighet. V Internetnätverk du kan få källkoden för perl-tolken (Perl-språket tolkas, vilket är en fördel i vissa fall) och dess tilläggsmoduler helt gratis.
Den här boken är en självinstruktionsmanual för Perl-språket, som studeras, som de säger, från grunden, det vill säga det antas att läsaren inte är bekant med detta språk - han kommer att lära sig allt han behöver genom att sekventiellt studera ämnen och konsolidera det material som täcks, svara på frågor och utföra övningar ges i slutet av varje kapitel. Återigen, detta material är bara grunderna i Perl-språket. Den här boken är inte på något sätt tänkt att vara en lärobok i programmering på Perl-språket. I den hittar du inte en programmeringsmetodik eller färdiga recept för att lösa problem, det gör den inte detaljerad beskrivning de mest använda modulerna och lösa problem med deras hjälp, men efter att ha läst boken kommer du att förvärva grundläggande kunskap som hjälper dig att förstå alla Perl-skript.
Datatyper används i program när variabler deklareras. Kort sagt, en datatyp bestämmer 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 kan data vara ett nummer eller en teckensträng.
Ett värde kallas en skalär eller bara en skalär. 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 nollan anger att ett oktalt tal används)
- Sträng: "Hello World \ n" eller "Hello World"
Till exempel, nästa kommando använder Perl debugger 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 dem till decimaler, som visas.
Notera: Som du kommer att se låter Perl-skriptet dig använda printf-funktionen för att skriva ut värden i ett anropsbart format som oktalt eller hexadecimalt.
Alla siffror representeras internt i flyttalsformat med dubbel precision. Det finns med andra ord inget heltal bland de interna formaten. För det mesta kan du dock ignorera det och Perl kommer att göra det rätt. 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 är en C-programmerare och har använt heltalsdivision med heltalsstympning automatiskt, kom ihåg att programmera i Perl att göra trunkeringen manuellt med int ()-funktionen.
Följande kommando illustrerar hur Perl hanterar heltal och flyttal:
Skriv ut 6 & 3; # prints 2 print 6.9 & 3.1 # print 7/2 # prints 2.3333 inte ett heltals print int (7/3) # prints 2
Precis 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, till exempel sammanlänkande strängar, konverterar det siffrorna till strängar. På samma sätt, om du vill använda strängar där bara 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 booleans, 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 ett värde<истинно>och noll - som<ложно>.
Således bör 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 skalärer och skapa en lista. Om skriptet lagrar listan i någon variabel, blir denna variabel en array.
VARIABLER
Perl stöder tre typer av variabler: skalärer, arrayer och associativa arrayer. Som i C skrivs variabelnamn med en distinktion mellan stora och små bokstäver. Namnen VAR, Var och var beskriver alltså olika variabler. Ett skript kan ha en skalär variabel som heter var och en arrayvariabel som också heter var. De kommer att skilja sig åt i Perl beroende på sammanhanget.
Obs: Perl-variabler är otypade, som görs i C. Till exempel kan en skalär variabel innehålla vilken typ av skalär som helst, och typcasten är automatisk. Dessutom, som du kanske har märkt, behöver Perl-variabler inte deklareras. Om en variabel inte deklareras, behandlar Perl den som global. Nedan får du lära dig om variabeldeklarationer 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. I följande uttryck tilldelas den skalära variabeln $ age värdet 35, och variabeln $ name är strängvärdet
$ å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 enligt följande:
C: \ PERL> Perl SCALAR.PL
ARRASER
Som nämnts ovan är arrayer variabler som tar en lista med skalärer som värde. Följande Perl-kod illustrerar deklarationen av arrayvariabler och deras initiering:
@days = ("sön", "mån", "tis", "ons", "tors", "fre", "lör"); print (@dagar); # kommer att skriva ut "Sön Måndag OnsThuFriSat" ($ dagar); # kommer att skriva ut "tors" @veckodagar = @dagar; # värde ("mån", "tis", "ons", "tors", "fre") @emptylist = (); # väntelista
Refererande typvariabler<массив>börjar vanligtvis med ett @-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 förklaras i det här kapitlet Det tredje uttrycket ($ dagar) ä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 en skalär. Denna kommentar är mycket viktig. Hakparenteserna indikerar att skriptet hänvisar till en array. $-tecknet anger i sin tur en skalär referens. @weekdays arrayen initieras genom att hämta en del av @days arrayen. I föregående exempel användes arrayen @days utan ett index. När index 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 det faktum att en array kan tilldelas literals som värden, kan ett skript också tilldela värden till arrayer eller till och med andra 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); # kommer att skriva ut "måntisdag tor fresön lör"
Om skriptet använder en matrisvariabel i kontexten av en skalär, är värdet antalet matriselement. 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 saker 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) || die "För mycket saker! \ n";
Formfunktionen fungerar som ett direktiv Perl språk avsluta exekveringen och visa det angivna meddelandet. Om meddelandet inte finns, avslutar funktionen helt enkelt skriptkörningen.
Perl stöder också den speciella konstruktionsvariabeln $ #, som returnerar det sista indexvärdet i en array. Till exempel använder följande för uttryck $ [för att bestämma startvärdet för arrayindexet och $ # för att bestämma det sista av arrayelementen. Dessutom använder för uttryck värdena för vart och ett av elementen visas:
För ($ i = $ [; $ i<= $#stuff; $i++) { print $stuff[$i]; }
Den inspelade för loop kan ersättas med följande ekvivalenta uttryck:
Skriv ut @grejer;
KONTEXTS ROLL FÖR VARIABLER AV SKALÄR OCH VEKTORTYP
Observera att den listbyggande operatorn (,) ser exakt likadan ut som operatorn för sekventiell utvärdering (,). 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 sätter skalären $ a_scalar till 5, vilket kasserar 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 för en associativ array med två nycklar att skrivas ut, medan i det andra fallet kommer två värden av en associativ array med en nyckel att skrivas ut. Av följande två uttryck kopierar det första listan, medan det andra tilldelar ett skalärt värde som är lika med storleken på arrayen:
@x = @lista; $ x = @lista;
ASSOCIATIVA 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 värden av vilken typ som helst för att välja arrayelement. Indexvärden för en associativ array kallas nycklar. Tänk på följande exempel:
$ åldrar ("Bob") = 35; $ åldrar ("Mary") = 25; $, = ""; # ändra utdataseparator för utskriftsoperatör print @ages ("Bob", "Mary"); # kommer att skriva ut "25 35" utskriftsnycklar (% åldrar); # kommer att skriva ut "Bob Mary" för $ namn (nycklar (% åldrar)) (skriv ut "$ namn är $ åldrar ($ nycklar) \ 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 så att när utskriftssatsen används vidare kommer utdata inte att slås samman med varandra. Resten av det här kapitlet diskuterar speciella variabler som "$,". Associativa arrayer identifieras med hjälp av lockiga hängslen. Som med arrayer används inte index när man refererar till en associativ array helt och hållet. Till exempel använder @ ages ("Bob", "Mary") index inom parentes för att indikera en associativ array. Prefixet @ indikerar att det är en array. En liknande användning av ett dollartecken framför en array indikerar att en skalär används.
Notera: Om två nycklar är specificerade, så indikerar detta tillsammans med @-tecknet att vi talar om 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).
Utskriften av nycklar (% åldrar) anropar nyckelsatsen, som returnerar hela listan med nycklar i den associativa arrayen. En % åldersreferens med ett procenttecken som prefix betyder att referensen refererar till hela den associativa arrayen. Observera att for-loopen hänvisar till variabler som är 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 den associativa arrayen. 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 enstaka citattecken.
PERL OPERATÖRER
Medan Perls data och variabeltyper skiljer sig 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 typgjutningsoperatorn, * ptr-pekarens innehållsoperator och var.member eller var-> member structure member select operator. Dessutom har Perl många nya operatörer för användning i operationer som strängjämförelser och bearbetning.
ARITMETISKA OPERATORER
Aritmetiska operatorer 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 tal på ett liknande sätt som funktionen C atof () i runtime-bibliotek. Perl stöder för närvarande följande aritmetiska operatorer:
- + tillägg
- - subtraktion eller teckenändring
- * multiplikation
- / division (endast för flyttal)
-% modulo (endast för heltalsvärden)
Låt oss titta på exempel på följande Perl aritmetiska operationer:
$ x = 2,5; $y = 3; print ($ x + 2 * $ y); # utskrifter 8,5 utskrift (7 / $ y); # kommer att skriva ut 2.3333333 print int (7 / $ y); # kommer att skriva ut 2 utskrifter (7% $ y); # kommer att skriva ut 1 utskrift (7,5 % $ y); # kommer att mata ut 1
Notera: I Perl resulterar divisionsoperatorn alltid i ett flyttal, och resultatet av att ta ett tal till en annans modul är ett heltal, och båda operanderna konverteras först till en heltalstyp.
Tänk på följande modulo-operation:
Print (7,9% 3,6); # kommer att mata ut 1 samma (7% 3) = 1
Perl har också stöd för inkrement- och dekrementoperatorerna:
- ++ minskning i prefix- eller postfixform
- - inkrement i prefix- eller postfix-form Betrakta exempel på inkrement- och dekrementeringsoperationer:
$ x = 4; ++ $ x; skriv ut $ x; # kommer att skriva ut 5 $ y = $ x-; # minskar x efter att ha tilldelats y till x skriv ut "$ y $ x" # utskrifter 5 4
Slutligen tillhandahåller Perl den aritmetiska operatorn för exponentiering (**). Betrakta följande exempel på användning av exponentieringsoperationen:
$ x = 2 ** 3; # resultat är 8 $ x = 2 ** 0,5; # kvadratroten av 2 $ x = -2 ** -3; # 1 / (- 2 kuber), resultat -1/8 (-0,125)
BITSOPERATORER
Bitvisa operatorer agerar på den binära representationen av heltal och har ett heltalsresultat. Om operanden är en sträng eller ett bråktal, förkonverterar Perl den till ett heltal, bearbetar operanden med en 32-bitars representation. Alla C bitvisa operatorer representeras i Perl-språk:
- | bitvis ELLER
- & bitvis OCH
- ^ bitvis exklusivt ELLER
- ~ bitvis inversion
- << сдвиг влево
- >> skift å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)
Precis som i C beror beteendet hos de högra skiftoperatorerna på språkets implementering 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 innan jämförelsen utförs. För att tillåta skriptet att jämföra strängar som inte är siffror, har Perl ytterligare operatorer för strängjämförelse. Dessa operatorer 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 listar jämförelseoperatorerna:
Nummersträng Värde = = ekv är lika! = Nе är inte lika> gt är större än< it меньше чем >= gе är större än eller lika<= lе меньше или равно <=>cmp inte lika (signerat resultat)
Flik. 12.1. Perl jämförelseoperatorer.
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 den första operanden är mindre än, lika med eller större än den andra.
Obs: Perl cmp-operatorn beter sig på samma sätt som Strcmp ()-funktionen i C runtime-biblioteket.
Tänk på följande jämförelseexempel:
$ 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 booleska operander som booleaner, dvs. som ett sant eller falskt värde.
Perl logiska operatorer inkluderar följande:
- || logiskt ELLER
- && logiskt OCH
Perl bearbetar alltid logiska 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. Förutom vanliga logiska operatorer stöder Perl följande ytterligare logiska operatorer:
-! logisk negation ()
-
-: villkorlig drift
-, sekventiell exekvering
Den logiska negationsoperatorn (!) Ersätter ett booleskt värde med dess motsats. 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å samma sätt använder följande uttryck en villkorlig operator för att ge Bob full kontroll och begränsa alla andra:
$ access = ($ user eq "Bob"
- "Full": "Begränsad");
Operatör för sekventiell exekvering<,>(ä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 operator 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 }
LINE OPERATÖRER
Eftersom Perl är ett textbearbetningsspråk bör det inte komma som någon överraskning att det inkluderar ytterligare strängoperatorer. Följande är strängbearbetningsoperatorer:
-. strängsammansättning
- x replikering
- = ~ matcha variabel till mönster
-! ~ samma som ovan, men med förstärkt negation av resultatet
De två första operatörerna illustreras enkelt med ett exempel:
Skriv ut "b". "en" x 2. "a"; # kommer att skriva ut "banan"
Som visas använder detta uttryck strängsammansättning och replikeringsoperatorn för att skriva ut strängen
$ var = "banan"; print ($ var = ~ / ana /)
- SANT FALSKT;
I det här fallet användes mönstersträngens förekomsttestoperator (= ~) för att kontrollera om mönstret ana är i $ var. I det här fallet får uttrycket värdet<истинно>.
UPPDRAG OPERATÖRER
Om du är bekant med programmeringsspråket C, bör formerna för Perl-uppdragssatserna vara helt bekanta för dig. Precis som i C tvingar dessa uttalanden Perl att utföra speciella operationer på värdena som visas på höger sida av uttalandet och sedan utföra uppdraget:
= += -= *= /= %= |= &= ^= ~= <<= >> = ** =. = x =
LVÄRDEN I Perl, som i C, är ett lvärde namnet på det på vänster sida av en tilldelningssats. Således representerar ett lvärde en integritet 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
@färg = ($ r, $ g, $ b); # färgpaket ($ r, $ g, $ b) = @color; # uppackningsfärg
När du arbetar med listor i Perl gäller inte nödvändigtvis uppdragsoperatorn 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å samma sätt packar följande uttryck upp elementen i listan, tilldelar värdena för de två första elementen till de två skalära variablerna och resten av arrayen till listvariabeln:
($ arg1, $ arg2, @ rest) = @ARGV; # du kan blanda skalärer och arrayer
OPERATIONER FÖR ATT ARBETA MED LISTER
Operationerna för att arbeta med listor 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 en sekvens av heltal som ett värde som börjar vid 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 @-siffror som innehåller siffror från noll till nio:
@siffror = 0..9; #list (1,2,3,4,5,6,7,8,9)
På samma sätt kan det här uttrycket använda scope-operatorn för att skapa arrayindexens omfattning Antag att @days-listan innehåller veckodagarna (med början från söndag). Följande uttryck tilldelar @veckodagar-listan till värden från måndag till fredag:
@helg = @dagar;
Slutligen använder följande uttryck två scope-operatorer för att skapa en lista med hexadecimala siffror:
@hex_digits = (0..9, a..f);
Replikeringsoperatorn gör 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 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 fungerar på alla system:
D kontrollerar om det finns en katalog
--e upptäcker närvaron av en fil
--s anger storleken på filen
--w bestämmer om den givna filen kan skrivas
De följande två filoperatorerna returnerar ett booleskt värde. Den tredje operatorn returnerar filstorleken 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 ";
OPERATORENS IMPLEMENTERINGSPRIORITETER
Liksom alla programmeringsspråk prioriterar Perl exekveringen av satser, med hjälp av vilka sekvensen av deras exekvering beställs. Tabell 12.2 listar operatörens prioritet från högsta till lägsta:
- ++
-! ~ unär minus
- **
- =~ !~
- * / % NS
- +
- <<>>
- -d -e -s -w (och andra filoperatorer)
- <> <= >= Det gt le ge
- = = != < =>eq ne cmp
- &
- |^
- &&
- ||
- ..
-
- : = += -= *=
Flik. 12.2. Perl-operatörsprioriteter Högst till Lägst
I ditt skript kan du ändra sekvensen för exekvering av satser med parenteser.
PERL SPRÅK KONSTRUKTIONER
Perl stöder alla C-uttryck med ett nästan identiskt format. Till exempel, kontrollstrukturer om, medan, gör det. for och goto används på båda språken i samma form. Som du kommer att se senare har fortsätt-satsen en något annan innebörd i Perl. Dess tidigare värde kallas nu next, och break-satsen kallas nu sist. Perl implementerar inte en switch-sats. Dessutom finns vissa C-uttryck i Perl i olika format, och många nya uttryck har lagts till.
ENKLA OCH KOMPOSITA OPERATÖRER
Alla giltiga kombinationer av operatorer och operander kallas ett enkelt uttryck. I Perl är en operator ett uttryck som slutar med ett semikolon. Som i programmeringsspråket C slutar alla påståenden med semikolon. När du anger kod i felsökaren kan du utelämna semikolon, eftersom felsökaren tillhandahåller det åt dig. Följande text illustrerar en enkel Perl-tilldelningsoperator:
$ Title = "(! LANG: Webbprogrammering"; !}
Precis som med C-programmering kan Perl-skript innehålla satsblock, eller sammansatta satser, som är inneslutna i klammerparenteser (()), som visas nedan:
(# Operatörer # Ännu ett block med operatorer)
Dina skript kommer att göra omfattande användning av satsblock tillsammans med mer komplexa satser. Som i 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. Skriptet måste använda det lokala nyckelordet för att deklarera dem. Senare i det här kapitlet kommer vi att titta på variabel omfattning i detalj.
VILLKORLIGA OPERATÖRER
Många av de tidigare exemplen har använt 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 hängslen, medan i Perl måste satserna inneslutas i hängslen för att bilda ett block...
If (expr) uttalande; // acceptabelt för C men inte för Perl if (expr) (påstående; # så här ska du göra det i Perl)
På liknande sätt fungerar Perl else-satsen något annorlunda än motsvarande C-sats. I Perl måste satser också vara inneslutna i hängslen och bilda ett block:
// Exempel i C är inte acceptabelt i Perl om (expr1) statament1; annat om (uttr2) uttalande2; annat ststement3;
Följande visar att Perl tillåter användningen av elsif-konstruktionen:
If (expr1) (statament1;) elsif (expr2) (statement2;) else (ststement3;)
OPERATÖR OM INTE
I programmeringsspråket C använder programmerare logisk negation (!) För att vända ett booleskt värde, som visas nedan:
If (! (Expr)) // Negation i C (påstående;)
Tillsammans med användningen av logisk negation innehåller Perl-skript ofta en unless-sats, som ger samma som C-koden ovan.
Om inte (expr) (uttalande;)
Obs: Till skillnad från C innehåller Perl ingen switch-sats.
OPERATÖR GÖR
Ett av de speciella fallen med blockoperatorer är do-operatorn, som tillåter ett block av satser att returnera värden. Värdet som do-satsen returnerar är värdet av det sista 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 (om ($ Month eq "September" || $ Month eq "April" || $ Month eq "Juni" || $ Month eq "November") (30;) elsif ($ Month eq "Februry" ) ($ år & 3
- 28:29; # Kontrollera för viktminskning å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 implementeringen av C. Den betydande skillnaden är att Perl kräver att satser används i block inneslutna i hängslen. Dessutom, som du kommer att lära dig senare, utökar Perl loopkonstruktionen för att tillhandahålla några nya former. I följande exempel fungerar for, while och do loopar 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 loopar i C skiljer sig från konstruktionen i Perl också genom att Perl inte innehåller en break-sats, och continu-satsen fyller en helt annan funktion. Lyckligtvis ger Perl några nya, mer flexibla och mer intuitiva konstruktioner:
- sista utgången från slingan (som en C break-sats)
- starta nästa en ny iteration (som en C continuation-sats)
- upprepa den aktuella iterationen
För att förstå loopkonstruktionerna i Perl måste du 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 det tredje uttrycket i for-slingan som exekveras vid varje iteration. På samma sätt kör Perl ett fortsättningsblock i slutet av varje iteration. Men som du kommer att lära dig senare, ger fortsätt-blocket skriptet mer kontroll över processen än for-loopen gör. 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 continue-blocket.
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-satsen kan skriptet hoppa till etiketten. Alternativt kan operatorerna last, next och redo 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 om ($ needToAboutLoop) (sista yttre loop;)))
I det här fallet innehåller satsen en sista gren för att förgrena sig till den yttre slingan och avsluta slingan.
CYKLA TILL
En annan loopkonstruktion i Perl är tills-loopen, som är motsatsen till while-loopen. Kom ihåg att i en while-loop exekveras satser så länge som det angivna villkoret är uppfyllt. Däremot exekverar en tills-loop instruktioner tills ett villkor är uppfyllt. Tänk till exempel på en while-loop som den som visas på nästa sida.
Medan (! (Expr)) (påstående;)
Genom att använda till-slingan kan du skapa en identisk slinga enligt nedan:
Tills (expr) (uttalande;)
På samma sätt använder följande do while-konstruktion den logiska negationsoperatorn för att gå igenom tills ett givet booleskt uttryck utvärderas till sant:
Gör (påstående;) while (! (Expr));
Genom att använda konstruktionen gör tills kan du bilda en identisk slinga utan att använda boolesk negation:
Gör (påstående;) tills (expr);
FÖR OCH FÖRE CYKLER
Perl stöder en for-loop 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 ($ siffra = 0; $ siffra<=100; $digit++) { print $digit, " "; }
Dessutom innehåller Perl en foreach loop-konstruktion som gör att skriptet kan iterera över listor och arrayer. 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 itererade foreach loop över värdena för @list listvariabeln. I det andra exemplet itererar foreach loop över siffror i intervallet 1 till 10. Foreach loop kan innehålla en lista med bokstaver eller en array, som illustreras i föregående exempel. Efter att ha kört 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 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 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) (skriv ut "$ i \ n"; # slingan kommer att skriva ut 123456789) skriv ut "$ i \ n";
Som du kan se från det här exemplet kommer variabeln $ i som används för att iterera genom slingan inte i konflikt med variabeln $ i som definieras utanför slingan. 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 detta!) Tänk på följande foreach-loop, som lägger till ett värde på 10 till varje array-element:
@lista = 1..5; foreach $ i (@list) ($ i + = 10;) $, = ""; skriv ut @lista; # kommer att skriva ut 11 12 13 14 15
Låt oss göra några sista anteckningar om foreach loop. Perl behandlar namnen både för och för som synonymer. Därför kan du använda dessa namn omväxlande i skript. Perl kommer i sin tur att bestämma typen av loop baserat på dess sammanhang.
OVILLKORLIG ÖVERGÅNGSOPERATOR GÅ TILL
Perl stöder en ovillkorlig goto-operator, som är identisk med samma operator i programmeringsspråket C. Nedan finns ett exempel på hur man använder goto-operatorn för att skriva ut nummer 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 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 innebörd tydligare är det lämpligt att välja ett lämpligt format för skrivning. Tänk på följande uttryck som använder tärningsfunktionen för att avsluta skriptkörning om antalet $ är mindre än 10:
Om ($ räkna< 10) { die; }
Att sätta tärningsfunktionen före if-satsen, som visas nedan, minskar antalet rader kod:
Dö om ($ räkna< 10);
På samma sätt kan samma uttryck skrivas så här:
($ count> = 10) || dö;
I det här fallet, om variabeln $ count är större än eller lika med 10, stoppar Perl ytterligare beräkning på denna rad och tärningsfunktionen exekveras inte. Annars, om variabeln $ count är mindre än 10, efter beräkning av den första delen av uttrycket startar koden tärningsfunktionen och avslutar därmed skriptexekveringen ... Slutligen, i följande exempel, kan användningen av unless också minska antalet rader till en:
Dö om inte ($ count> = 10);
På samma 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 en designmodifiering, låter skriptet dig minska antalet rader i loopposten till en. På samma 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 ligger efter exekveringssatsen, analyserar Perl först villkoret och kör sedan satsen.
GENERA DYNAMISKA UTTRYCK MED EVAL-FUNKTIONEN
Eftersom Perl är ett tolkat språk kan dina skript använda Perl för att generera kod.<налету>, det vill säga dynamiskt under skriptkörning. Så här fungerar Perl-debuggern (som i sig är ett Perl-program som heter Perldb.PL). När du designar skript kan du använda den här dynamiska koden för att skapa dynamiska variabelnamn, eller till och med bygga anpassade rutiner. Perl utvärderar dynamiska uttryck med hjälp av eval-funktionen. Följande exempel skapar en dynamisk instruktion genom att tilldela en variabel som ett värde till text som faktiskt innehåller den nödvändiga 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 Hej världen $ i = 1001; $ varname = "$ i"; print eval $ varname; # kommer att skriva ut värdet på $ i
Obs: Det är farligt att använda eval-funktionen i ett skript, särskilt om skriptet skickar data som tas emot från användaren till eval-funktionen. Genom att använda eval-funktionen kan ett skript köra godtyckliga Perl-kommandon, inklusive till och med 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 specificeras med hjälp av undernyckelordet, som visas nedan:
Sub demo_sub (skriv ut "demo_sub kallas \ 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 Perl-subrutin kan parentesen utelämnas. Du kan placera subrutinen var som helst inom skriptets källkod eftersom Perl kommer att analysera all källkod innan du börjar köra skriptet. Du kan deklarera en subrutin i källkoden omedelbart efter den första användningen av subrutinen (framåtriktad referens). Subrutiner kan ha argument och returvärden. Följande kodavsnitt innehåller en subrutin med namnet show_value som matar ut värdet som mottas av subrutinen som en parameter:
Sub show_value (skriv ut "The value id", $ _;) & show_value (1001);
Formellt deklarerar en Perl-subrutin inte variabler för att hålla argument. Istället skickas en arrayvariabel med namnet @_ till subrutinen och innehåller parametervärdena. I sin tur får subrutinen tillgång till värdena för argumenten med hjälp av följande notation för arrayelement: $ _, $ _, etc. Att skicka parametrar på detta sätt kan dock försämra läsbarheten för koden, och därför använder de flesta subrutiner kopiering 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 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 som den tar emot. Funktionen använder en array för att definiera numret 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 sagt kan Perl-rutiner returnera värden. För detta används returuppgiften. Till skillnad från C kräver Perl inte användningen 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(retur $ _ + $ _;) print "Resultatet är:", & add_values(1001,2002);
BIBLIOTEK MED DELPROGRAM
Till skillnad från C stöder Perl faktiskt inte konceptet med ett bibliotek. Den har dock en mekanism som tillåter skript att använda källkod från en annan fil. Anta till exempel att du lagrar subrutinen add_valuesl i en fil som heter addvalue.pl. Med hjälp av 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 require-satsen 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-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ärdes av require-satsen och laddar dem bara en gång, även om filerna nås flera gånger. Det finns många standardbibliotek som utökar kapaciteten för Perl-språket. Nu är det dags att vandra genom katalogen där Perl-biblioteksfilerna 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 dig att undvika detta genom att använda paket. Som du vet kan namnkollisioner undvikas 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 en namnkollision. Med hjälp av paket kan du gruppera globala data i privata namnutrymmen, utanför vilka globala variabler inte är synliga , dvs okänt. Betrakta följande enkla exempel där två subrutiner (som finns i olika filer) använder privata, distinkta namnutrymmen.
# Kod i one.pl fil sub sub_one (paket demo_one; $ some_data = 10;) # * * * * * * * * # Kod i fil two.pl sub sub_one (paket demo_two; $ some_data = 20;)
Som du kan se 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 det organiserar åtkomst till det, använder paketnamnet som ett prefix till variabelns namn. Följande exempel prefix paketnamnet package_one eller package_two till namnet på some_data-variabeln:
& sub_one; & sub_två; print "Variabel 1 $ package_one" some_data \ n "print" Variabel 2 $ package_two "some_data \ n"
När du använder Perl-paket 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 (retur $ 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å samma utrymme för data som i programmeringsspråket C, där globala variabler scoped 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"; print & some_package_name "some_sub;
BEHANDLINGSLINJE
I de tidigare exemplen har du lärt dig hur man konstruerar strängliteraler med variabel interpolation. Du lärde dig också hur man sammanfogar strängliteraler 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.
CHOP FUNKTION
Chop-funktionen tar bort det sista tecknet från strängen. Den har följande format:
$ tecken = hacka (Str);
Chop-funktionen returnerar det raderade tecknet. Perl-skript använder chop i stor utsträckning för att ta bort nyrads- och radsluttecken.
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 en delsträng (SubStr) i en sträng (Str). Valfritt kan en offset anges från början (Offset), varefter sökningen börjar. Om en delsträng hittas returneras -1. I följande exempel söker indexfunktionen efter förekomster av delsträngen "na" efter det tredje tecknet i strängen "banana":
Skriv ut index ("banan", "na", 3); # Kommer att mata ut 4.
RINDEX FUNKTIONFunktionen rindex söker 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 senaste 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"); # Kommer att mata ut 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 visa antalet tecken i en sträng:
Utskriftslängd ("banan"); # Kommer att mata ut 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 en sträng som inte överskrider längden som anges av den valfria parametern Len. 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.
Skriv ut substr ("orange", 3); # Skriver ut "nge" print substr ("orange", - 2); # Skriver ut "ge" print substr ("orange", 2,2); # Skriver ut "an" $ str = "äpple"; substr ($ str, -3) = "rikot"; skriv ut $ str; # Skriver ut "aprikos"
Obs: Ofta är det mer effektivt att använda Perl-operatorer för reguljära uttryck än substr-funktioner. Reguljära uttryck diskuteras senare i detta kapitel.
JOIN-FUNKTION
Join-funktionen sammanfogar en lista med element till en sträng och separerar varje element med det angivna tecknet. Den har följande format:
$ new_string = join (Str, List);
Join-funktionen konverterar varje objekt i listan till en sträng och sammanfogar strängarna. Följande kodsnutt 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 det tecken som ska avgränsas, såsom 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 splitfunktionen.
FUNKTIONER FÖR BEHANDLING AV LISTER
I exemplen vi såg tidigare i det här kapitlet såg vi hur man skapar en lista, lagrar den som ett variabelvärde, itererar över alla listobjekt och får åtkomst till ett enskilt listobjekt. 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:
@new_list = omvänd (@List);
Den omvända funktionen vänder på 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 @lista = omvänd (@lista); # Resultat 1,2,3,4,5
SORTERINGSFUNKTION
Sorteringsfunktionen sorterar elementen i listan. Den har följande format:
@ny_lista = sortera (@lista);
@new_list = sortera (Subrutin @List);
@new_list = sortera (BlockStatement @List);
Sorteringsfunktionen placerar objekten i en lista genom att ordna dem enligt ordningsnumren för tecken i ASCII-tabellen. Precis som omvänt returnerar sortering en ny lista som ett värde och påverkar inte den ursprungliga listan. Följande exempel illustrerar användningen av sorteringsfunktionen:
@lista = sortera (1,5,2,3,4); # Resultat 1,2,3,4,5 @lista = sortera (1,2,10); # 1,10,2 sortering 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 = sortera (($ a<=>$ b) (2,1,10)); # @lista 1,2,10 @lista = sortera (($ b<=>$ a)) (2,1,10); # @list 10,2,1 sub mycomp ($ b<=>$ a) @list = sortera (mycomp (2,1,10)); # @lista 10,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 innehåller flera inbyggda funktioner som hjälper dig att manipulera matriselement. Följande avsnitt diskuterar 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 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:
Tryck (@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 det sista elementet som trycktes på stacken och returnerar värdet för det elementet. Popfunktionen har följande format:
$ värde = pop (@ARRAY);
Följande kodsnutt illustrerar användningen av pop-funktionen:
# Ta @list från föregående exempel print pop (@list); # Skriver ut 3 print pop (@list); # Kommer att mata ut 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 (<первым вошел, первым вышел>). Skiftfunktionen har följande format:
$ värde = skift (@ARRAY);
Följande kodavsnitt illustrerar användningen av skiftfunktionen:
# Ta @list från föregående exempel
Skriv ut skift (@lista); # Skriver ut 10 utskriftsskift (@list); # Kommer att mata ut 20 # Nu @lista ()
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 kodsnutt 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 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]]);
Splitsfunktionen extraherar ett specificerat antal element (Count) från en array (@Array), med början på det element som pekas på av Offset-värdet, och ersätter elementen med element från en annan lista. Om parametern Count inte anges i funktionsanropet, hämtar funktionen elementen 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; skarv (@ lista, 1,8,5,6); # @list = (1,5,6,10)
SKALÄR FUNKTION
Den skalära funktionen bestämmer antalet objekt i listan. Den har följande format:
Rsult = skalär (lista);
Vanligtvis behöver Perl-skript inte använda skalärt på arrayer, för när ett skript får åtkomst till en array och skriver det i ett skalärt sammanhang, får det antalet element i arrayen som returvärde. Skript kan dock använda den skalära funktionen nä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; skriva ut skalär (@lista); # Skriv ut storleken på @lista
GREP-FUNKTION
grep-funktionen filtrerar listobjekten för vilka det givna uttrycket utvärderas<ложно>... 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 till den resulterande listan. Följande programutdrag 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 uttryck, ändrar variabeln. $ _, då kommer den ursprungliga listan också att ändras.
ASSOCIATIV ARRAY-BEHANDLINGSFUNKTIONER
Som du vet är associativa arrayer sådana arrayer, 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 associativa arrayer.
FUNKTIONSTANGENTER
Nycklarfunktionen returnerar värdena för nycklar som motsvarar en associativ array. Den har följande format:
@key_list = nycklar (% Array);
Nycklarfunktionen returnerar en uppsättning nycklar som en vanlig lista. Följande kodsnutt illustrerar användningen av tangentfunktionen:
$ åldrar ("Bob") = 25; $ åldrar ("Mary") = 30; $ åldrar ("Zack") = 15; @list = nycklar (% åldrar); # @list kommer att vara "Zack", "Bob", "Mary" @list = sorteringsnycklar% åldrar # @ lista "Bob", "Mary", "Zack" för $-nyckel (sorteringsnycklar% åldrar) (skriv ut "$ nyckeln är $ åldrar ($ nyckel) \ n ")
VÄRDEN FUNKTION
Funktionen värden returnerar en vanlig matris med värden från en associativ matris. Den har följande format:
@value_list = värden (% Array)
Funktionen värden returnerar en array av värdena för en associativ array som en vanlig lista. Följande kodsnutt illustrerar användningen av värdefunktionen:
# Använda värdena från föregående exempel% ages = ("Bob", 25, "Mary", 30, "Zack", 15); @list = sorteringsvärden% åldrar; # @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 returnerar den en tom lista. Nästa gång funktionen anropas startar iterationsprocessen från början. Följande kodsnutt illustrerar användningen av varje funktion:
# Använda värdena från föregående exempel% ages = ("Bob", 25, "Mary", 30, "Zack", 15); medan (($ namn, $ ålder) = varje % åldrar) (# Utdata åldrar skriv ut "$ nyckel är $ åldrar ($ nyckel) \ n";)
DELETE-FUNKTION
Raderingsfunktionen tar bort elementen i en associativ array. Den har följande format:
Ta bort $ Array (nyckel)
Följande sats använder delete-funktionen för att ta bort objektet som motsvarar nyckeln Bob från den associativa arrayen $ Employees:
Ta bort $-anställda ("Bob")
KOMMANDORAGUMENT
Perl-skript kan enkelt komma åt kommandoradsargument. Närhelst ett skript körs, lägger Perl skriptets kommandoradsargument i listvariabeln @ARGV. Följande kodavsnitt används för att visa kommandoradsargument:
While ($ arg = shift @ARGV) (skriv ut "$ arg \ n";)
TILLGÅNG TILL MILJÖVARIABLER
Att komma åt miljövariabler i Perl-skript är också mycket enkelt. Närhelst skriptet körs lägger Perl kopior av miljövariablerna i en associativ array av % ENV-namn. Följande sats använder % ENV-matrisen för att lista den aktuella katalogen:
Skriv ut "$ ENV (PATH) \ n"; # Skriv ut den aktuella katalogen
Förutom att få värden från % ENV-matrisen kan skript också modifiera matriselement. Om du ändrar % ENV-matrisen så här ändras miljövariabelinställningen för alla underordnade processer som skapas av skriptet. Till exempel, följande instruktion använder % 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, 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 binära I/O-funktioner. Filoperationer 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 skriptet körs: STDIN, STDOUT, STDERR. Dessa tre standardpekare motsvarar standardströmmarna STDIN, STDOUT, STDERR i programmeringsspråket C. Dessutom kan Perl-skriptet öppna ytterligare pekare för andra specifika filer.
ÖPPNING AV FILER OCH ANDRA STRÖMAR
För att skriptet ska kunna använda filen måste det anropa den öppna funktionen. Det ser ut så här:
Öppna (FileHandle [, Filnamn])
Till skillnad från den öppna funktionen i C runtime-biblioteket, inkluderar den öppna funktionen i Perl inte en lägesparameter i funktionsanropet. Perl bestämmer läget (läget) 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. Namnkonventioner och åtkomstlägen för Perl-filer
-Obs: Rörströmningsläget kanske inte finns på alla system.
Om ett filnamn utelämnas i ett anrop till den öppna funktionen, 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:
Stäng (FileHandle);
Utdraget illustrerar användningen av öppna och stängningsfunktionerna:
Öppna (InFile, "test.dat") || dö; # öppen för läsning # test.dat öppen (OutFile, "> test.dat") || dö; # create test.dat $ AuxFile = ">> test.dat"; öppen (Aux, $ AuxFile) || dö; # öppnar för addon # test.dat close (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 ytterligare en 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 skillnaden mellan text och binära lägen irrelevant. Men för operativsystemet MS-DOS är tecknet ny linjeär en sekvens av två tecken (CR + LF). Eftersom de flesta program inte förväntar sig att stöta på 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);
RAD-FÖR-RAD LÄS OCH SKRIV DATA
Det enklaste sättet för ett skript att läsa en rad från en fil är att använda operatorn
Öppna (InFile, "Test.dat") || dö; while ($ rad =
När inmatningstecknet når slutet av filen returnerar det false, vilket i detta fall avslutar while-loopen. Det finns ett speciellt (tomt) inmatningstecken<>som har en mycket speciell men användbar applikation. Första gången skriptet använder ett tomt inmatningstecken<>, analyserar den kommandoradsargument. Om @ARGV-strängen är tom, då inmatningstecknet<>lyder från STDIN. Om @ARGV inte är tomt istället, öppnar Perl den första av de filer 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. När skriptet har läst alla filer visas symbolen<>returnerar falskt. Perl-skript kan också använda inmatningstecknet 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äses följande sats från STDIN-filen till @lines-arrayen:
@linjer =
Att skriva data till en fil är också ganska enkelt. Faktum är att du gjorde detta när du använde utskriftsfunktionen. Det fullständiga formatet för utskriftsfunktionen är som följer:
Skriv ut lista;
Om utskriftsfunktionen inte tar emot en filpekare som ett argument, skickar den utdata till STDOUT. Följande kodsnutt illustrerar användningen av utskriftsfunktionen för att lägga till data till en utdatafil:
Öppna (LogFile, ">> logfile.dat") || dö; ############## ($ m, $ d, $ y) = (lokal tid (tid)); skriv ut LogFile "Captain"s logg, Stardate ++ m $ / $ d / $ y \ n "; stäng (LogFile);
Obs: Filpekaren och utdatalistan är inte kommaseparerade.
LÄS OCH SKRIV 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 fungera med en fil som är blockorienterad snarare än trådorienterad, kan skriptet använda sysread- och syswrite-funktionerna för att bearbeta fasta datablock. Funktionerna sysread och syswrite har följande format:
$ resultat = sysread (FileHandle, $ Var, Length [, Offset]); $ resultat = syswrite (FileHandle, $ Var, Length [, Offset]);
Om en offset från början av filen (Offset) anges i funktionsanropet, kommer funktionerna att söka efter den plats där de kommer att starta I/O-operationer. Funktionerna sysread och syswrite skickar båda data med hjälp av en skalär strängvariabel. Eftersom funktioner bearbetar 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 platsen i filen varifrån man ska börja utföra I/O-operationer. 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 C runtime-biblioteksfunktion. Positionsparametern anger positionen i förhållande till ursprunget, som i sin tur specificeras av Base-parametern enligt följande:
- 0 Sök från början av filer
- 1 Sök från den aktuella positionen
- 2 Sök från slutet av filen
Perls tellfunktion fungerar precis som ftell ftell i runtime-biblioteket C. Denna funktion returnerar den aktuella positionen i filen från vilken läs- eller skrivoperationer utförs. Slutligen returnerar eof-funktionen, liksom C-funktionen feof, värdet<истинно>eller<ложино>som skriptet kan använda för att fastställa att slutet av filen har nåtts.
BINÄR DATABEHANDLING
Även om Perl främst är inriktat på textbearbetning, 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 åstadkomma något<полезное>med data tvingas skriptet konvertera data till sin egen<родные>skalära format.
LAGRING AV BINÄR DATA
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 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 nollterminerade strängar. Om data överensstämmer med ASCII-kodtabellen kan skriptet behandla det som vilken text som helst, men om data är binära värden måste skriptet packa upp det innan Perl kan bearbeta data.
UPPACKNING AV BINÄRA DATASTRÄNGAR TILL PERL-VARIABLER
För att skriptet ska få tillgång till binära data måste det packas upp det i sitt skalära format. Perl-skript packar upp data med hjälp av uppackningsfunktionen, som har följande format:
$ resultat = packa upp (mall, uttryck);
Expression är en vanlig strängvariabel som innehåller binär data som läses av sysread, men kan också vara ett uttryck som ska tolkas som en sträng. Mall är en teckensträngsmall som beskriver hur man tolkar värdena i Expression-operanden. Följande kodsnutt illustrerar användningen av uppackningsfunktionen:
($ r, $ g, $ b) = packa upp ("C3", $ färg); # packa upp i 3 tecken
- @longwords = packa upp ("L *", $ data); # kommer att packa upp i en lista med långa # ord @stuff = packa upp ("S2L", $ bin); # packa upp i 2 shorts och långa
Varje tecken i mönstret 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 på alla återstående data på raden. Om inget nummer anges exekveras det en gång. Skriptet kan placera valfritt antal malltecken i mallsträngen. Tabell 12.4 listar symbolerna som ingår i strängparametern Template, tillsammans med en beskrivning av hur var och en påverkar utförandet av uppackningsfunktionen.
Flik. 12.4. Mallsymboler
| Mönster symbol | Beskrivning |
| a | |
| A | ASCII-sträng utan nolltecken |
| b | Bitsträng (minst signifikant bit först) |
| V | Bitsträng (den viktigaste biten först) |
| med | Signerat en-byte-tecken |
| MED | Osignerat enbyte-tecken |
| d | Dubbel precision med flyttal |
| f | Flytpunkt, enkelprecisionsmönster |
| h | Hexadecimal sträng (minst signifikanta bitar först) |
| H | Hexadecimal sträng (de mest signifikanta bitarna 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 en byte framåt |
| X | Hoppa tillbaka en byte |
| @ | Flytta till en angiven position på en rad |
PACKNINGSDATA I BINÄRA STRÄNGAR
För att mata ut binär data måste skriptet packa skalära värden i strängar av binära tecken. För att göra detta, använd packfunktionen, vars format visas nedan:
$ resultat = pack (mall, lista);
Följande kodavsnitt illustrerar användningen av packfunktionen:
$ färg = pack ("C3", $ r, $ g, $ b); $ data = pack ("L *", @longword); $ bin = pack ("S2L", @stuff);
Packfunktionen använder samma jokertecken som uppackningsfunktionen, med undantag för 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å flera mycket bekväma funktioner för att skanna kataloger. I de följande avsnitten kommer vi att titta på några av de grundläggande funktionerna för att arbeta med kataloger i detalj.
ÖPPNA, LÄSA OCH STÄNGA MATALOG
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, som skickar in en katalogpekare och sökväg till den. Skriptet använder readdir-funktionen för att läsa en lista med filer som finns i en katalog. Slutligen används closedir-funktionen för att stänga katalogen. Följande kodsnutt 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 filerna som finns i katalogen du angav på kommandoraden.
Utöver katalogfunktionerna som diskuterats ovan, erbjuder Perl en uppsättning funktioner som låter dig placera den aktuella pekaren i en kataloglista:
$ result = rewinddir (DirHandle); $ resultat = telldir (DirHandle); $ resultat = seekdir (DirHandle, Position);
FORMATERAD UTGÅNG
I det här kapitlet lärde du dig om flera sätt att formatera utdata från ett skript med utskriftsfunktionen. Liksom C stöder Perl även printf och sprintf. Dessutom stöder Perl också generering av kolumnformaterade rapporter med formulärmallar.
ANVÄNDA UTSKRIFTSFUNKTIONEN
I det här kapitlet har manus i stor utsträckning använt utskriftsfunktionen. Dessutom tillhandahåller Perl speciella variabler som påverkar hur utskriftsfunktionen fungerar. Tabell 12.5 sammanfattar dessa specialvariabler.
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. Till exempel använder följande kodavsnitt variabeln $ för att ställa in avgränsaren mellan utskriftsobjekt:
$, = "*"; @lista = 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. Oftast kommer du dock att använda den för att ändra värdet som skrivs ut av utskriftsfunktionen.
FORMATERAD DATAUTSKRIFT AV PRINTF
Perl har printf- och sprintf-funktioner som är mycket lika de motsvarande C runtime-biblioteksfunktionerna. De har följande format: $ result = printf (Format, List); $ resultat = sprintf (Format, Lista);Som standard skickar printf-funktionen formaterad utdata till standard STDIO-utdata, och sprintf-funktionen returnerar den formaterade strängen. I båda fallen är formatet på strängar nästan identiskt med funktionerna i C-språket, förutom avsaknaden av stöd för Perl-språkfunktionerna i längdspecificeraren (*). Följande kodsnutt illustrerar användningen av funktionerna printf och sprintf.
$ precision = 2; $ pi = 3,1415; printf ("%. 2f \ n", $ pi); # kommer att skriva ut 3.14 printf ("%. $ (precision) f", $ pi); # kommer att mata ut 3.14
RINGA EXTERNA PROGRAM FRÅN ETT SCRIPT PÅ PERL-SPRÅK
På sätt och vis vara ett substitut för skalskript Perl tillhandahåller stöd för systemkommunikation, inklusive samtal externa program... Följande avsnitt diskuterar flera sätt att anropa externa program från Perl-skript. Kom dock ihåg att genom att tillåta skript att köra systemkommandon, öppnar du säkerhetshål på din webbplats. Pinne allmän regel exekvera inte externa kommandon från ett Perl-skript. Däremot om du tvingas göra externa team från skriptet kan du använda den inbyggda systemfunktioner, exec eller gaffel.
VANLIGA UTTRYCK
I det här kapitlet 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 i stor utsträckning reguljära uttryck för att bearbeta text. Om reguljära uttryck är nytt för dig, oroa dig inte. Inom en kort tid efter att du har läst några avsnitt i detta kapitel kommer reguljära uttryck att vara enkla och okomplicerade för dig.
ÖVERSIKT ÖVER VANLIGA UTTRYCK
Reguljära uttryck är en fancy 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 för att helt enkelt analysera indata genom att dela isär den. Ofta kan ett skript analysera indata baserat på mellanslag, kommatecken, tabbar och andra avgränsare. Men när indata är i ett godtyckligt format, är reguljära uttryck bäst lämpade för denna uppgift.
SYNTAX FÖR VANLIGA UTTRYCK
Perl använder specialtecken för att minska storleken på reguljära uttryck. Tabell 12.6 listar 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 tecken (exklusive nyradstecken) |
| (..) | Grupperar en sekvens av element |
| + | Uppfyller föregående mönster en eller flera gånger |
- |
Uppfyller mönstret noll eller en gång |
| * | Matchar mönstret en eller noll gånger |
| [...] | Matchar en karaktär från en given uppsättning |
| [^...] | Matchar ett tecken från uppsättningen som erhålls genom negation |
| (...|...|...) | Matchar ett av alternativen |
| ^ | Matchar början av en rad |
| $ | Matchar mönstret i slutet av raden |
| (n, m) | Matchar mönstret n till m gånger |
| (n) | Matchar mönstret exakt n gånger |
| (n,) | Matchar provet minst n gånger |
| \ n \ t osv. | Matchar ett nyradstecken, tabbtecken och så vidare. |
| \b | Matcher vid ordgräns |
| \B | Matchningar 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 siffra |
| \W | Matchar ett tecken som varken är en bokstav eller en siffra |
Perl sätter reguljära uttryck (mönster, mönster) i snedstreck, det vill säga i sneda streck, till exempel i formen / mönster /. Följande kodsnutt 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 "big", "dig" eller "fig" / + / # sträng innehåller ett nummer / * / #-strängen 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 sätter reguljära uttryck mellan de 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 strängjämförelser enklare. 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 de reguljära uttrycken värdet<истинно>om mönstret finns i sträng ($ str). Om strängen innehåller ett mönster, returnerar uttrycket värdet<ложно>... Till exempel kontrollerar följande uttryck om strängen innehåller texten WebProgramming:
If ($ str = ~ / Webbprogrammering /)
För att kontrollera 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 bara om $ str-variabeln tar ett av tre värden:
($ str = ~ / ^ ba (na) (2,4) $ /)
På liknande sätt är följande uttryck sant om och endast om variabeln $ str innehåller ordet
($ 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 hämta ett specifikt strängvärde. Genom att använda grupperingstecken () i ett reguljärt uttryck kan skriptet extrahera värden från strängen som matchar mönstret och bilda en lista från dem. Till exempel använder följande kodavsnitt 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 någon först speciell karaktär;
- skriv alla icke-specialtecken till variabeln $ m
- (variabel för att ange månader);
- hoppa över ett specialtecken;
- lägg 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 för att indikera årtal).
Perl stöder också en annan form av mönstermatchning, med operatorn (= ~), som lägger till negation till resultatet: (! ~). Denna operator motsvarar! ($ Str = ~ / mönster /).
VANLIGA UTTRYCK FÖR SÖKNING OCH BYTE AV STRÄNGAR
Hittills har du använt mönstermatchningsoperatorer. 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 en given sträng:
$ str = ~ s / mönster / ersättning /;
Till exempel kommer följande påstående att ersätta ordet
$ str = ~ s / \ bcolour \ b / color /;
En liten modifiering gör att du kan ersätta alla ord
$ str = ~ s / \ bcolour \ b / color / g;
I det här fallet säger g i slutet av uttrycket till Perl att global substitution krävs.
Med i-suffixet kan du göra sökningen skiftlägeskänslig. I motsats till enkel mönstermatchning utför följande uttryck även substitution:
$ str = ~ tr / Söklista / Ersättningslista /;
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
Analysera själv följande exempel:
$ letters = "abcde"; skriv ut "$ bokstäver \ n" # Skriver ut abcde $ bokstäver = ~ tr / a-z / A-Z /; skriv ut "$ bokstäver \ n" # Skriver ut ABCDE
SAMMANFATTNING
Det här kapitlet ger en introduktion till programmering i Perl-språket. Med hjälp av de begrepp som diskuteras här kan du skriva komplext CGI-skript på Perl-språket. Nästa kapitel hjälper dig att få kläm på att skapa Perl CGI-skript som du kan köra på din egen server. Innan du går vidare, 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 konstruktioner liknar på många sätt de i C, men Perl erbjuder många ytterligare funktioner, speciellt 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.
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 du använder Perl för att skriva ganska komplexa CGI-skript. Med den teknik som du känner till kan du tillhandahålla en professionell programmerare 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 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 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, såväl som traditionella program för dagligt bruk.
- Perl lämpar sig väl 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 i stor utsträckning 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 inkräkta på Perls monopol.
Allt det följande gör inte på något sätt anspråk på att vara fullständigt och tillförlitligt.
Jag vill varna dig i förväg att den här artikeln inte kommer att göra dig till en super PERL-programmerare, men den kommer att ge dig några nödvändiga initial information för att hjälpa dig utforska detta ytterligare mest intressanta språket programmering.
Jag bestämde mig för att skriva den här artikeln efter att jag fick reda på hur svårt det är att "klippa" i allt, även om du har någon manual på PERL till hands. Överallt, redan i början, börjar de hänvisa till några mystiska termer och kommandon, och allt du behöver göra är att blinka förvånat, eller (om du fortfarande förstår något) få dessa program att fungera (inte "som det ska", men i allmänhet!). Den här artikeln skulle kunna kallas "PERL for Dummies" om den täckte allt material, men här satte jag mig som mål att bara ge dig de nödvändiga initiala koncepten, och så att säga "förbereda dig för ytterligare strider" :). Även om det är fullt möjligt att i framtiden, "på begäran av arbetarna", kommer denna lilla artikel att växa till något mer.
Så ... låt oss komma igång!
Låt mig först berätta att PERL måste installeras på din dator. Några av mina vänner hoppade helt över denna till synes enkla operation, och efter att ha skrivit ett enkelt program försökte de köra det länge...;) Mest tillgängligt paket PERL (enligt mig) är ActivePerl, även om detta paket riktar sig till Windows-användare, och om du har UNIX kan du ladda ner något inbyggt från www.perl.com. Hur som helst kommer du att skaffa och installera perl själv (om du inte redan har gjort det). Så: du kommer att ha en ny pappa "perl", men det betyder inte alls att alla program behöver placeras där :) Perl, som sitter där, kör bara alla dina geniala skapelser med tillägget * .pl, och var de är sig själva - en användare vet :) (sant för Windows-användare med ActivePerl-paketet installerat, sedan det associerar *.pl-filer).
Eftersom Eftersom den här artikeln främst är avsedd för Windows-användare, anser jag mig vara skyldig att berätta att för program som körs på det här operativsystemet är det inte alls nödvändigt att starta varje program från raden:
#! / usr / bin / perl
Saken är att det här språket skapades på basis av UNIX OS, och de försöker skicka denna linje till oss som ett "arv" från deras operativsystem. Du bör dock komma ihåg att UNIX också kan installeras på servern (om du bestämmer dig för att släppa dina program där).
Nu lite om skrivsättet.
Jag råder dig att börja använda ett enkelt anteckningsblock för att memorera alla kommandon och programmeringssyntax. I framtiden kan du använda någon form av editor, men detta är inte längre sportigt :), och ännu mer oönskat för dem som precis ska bekanta sig med detta programmeringsspråk, och programmering i allmänhet.
Nästan alla tutorials på detta språk börjar med det enklaste programmet, som ser ut ungefär så här:
print ("hej, VÄRLDEN! \ n");
Några av er har förmodligen redan kopierat det givna programmet till din fil och märkt att det öppnas snabbt och stängs lika snabbt. Detta beror på det faktum att programmet är ett program, och efter att det har körts kommer det att stängas omedelbart, så lägg till en rad till i programmet med följande innehåll:
Som ett resultat kommer allt detta att ta följande form:
print ("hej, VÄRLDEN! \ n");
<>;
Det ser inte så lätt ut för den oinvigde ... Även lite läskig ... Men det här är bara för den oinvigde, faktiskt, allt är ingenstans lättare! :) Kan inte tro det? Jag ska bevisa det nu.
Först måste du veta att print är ett kommando som skriver ut information till standardutgången STDOUT (STanDart OUT eller, med andra ord, utmatning till monitorn).
För det andra är obegripligheten i form av \ n en nyrad, men inte program, som vissa kan vara rädda för, utan information på skärmen, d.v.s. om du fortsatte med texten inom citattecken, skulle den efter det tecknet skrivas ut på en ny rad. Och om du behöver använda ett omvänt snedstreck (skal :) i själva texten, så måste du lägga ett skal till framför det. Till exempel:
skriv ut "\ a"; # Kommandot efter vilket Perl # skriver ut en signal till SPICER skriv ut "\\ a"; #Perl skriver bara ut \ a
Sedan vill jag glädja dig: fästena behövs inte nafig :) Användningen av dem beror helt på ditt humör, även om de i manualerna säger att detta lär hjälpa till att markera texten i programmet. I allmänhet - eftersom du gillar det mer ...
Som du säkert redan gissat – det behövs citat för att omsluta texten i dem, så det finns två obegripliga punkter kvar. Men innan jag uppehåller mig vid dem anser jag att det är nödvändigt att förklara för dig vilken information som finns i Perl.
Den grundläggande informationsenheten i Perl är en skalär, dvs. ett separat värde lagrat i en separat variabel.
$ a = "hej världen!"; # Tilldela lite text till variabeln $ a
$ b = 777; # Tilldela ett nummer till $ b
Dessa variabler lagrar strängar, siffror och referenser. Det är nödvändigt att förstå skillnaden mellan siffrorna som sådana och siffrorna i strängen.
$ abc = "123"; # Nummer i rad
123 $ = 123; # Själva numret
Om du behöver ett nummer för beräkningar, sätt bara inte dubbla citattecken.
Semikolonet i slutet av varje rad är egentligen ... slutet av raden, varav det följer att man kan skriva hela programmet på en rad, men vi tycker inte synd om raderna :) Det finns ett undantag från ovan: #-tecknet säger om att allt som står i raden efter det är en kommentar och inte längre gäller för programmet.
Romb tecken<>- detta är standard
Låt oss nu komplicera vårt program lite:
skriv ut "skriv in ditt namn:";
$ namn =<>;
print "hej $ namn!";
<>;
Du bör förstå att program exekveras rad för rad, d.v.s. först den första raden, efter den den andra osv.
Så på första raden visar vi en uppmaning att ange ett användarnamn. På den andra raden läser vi in det i $ name-variabeln. $ name är, som nämnts, en Perl skalär variabel som börjar med ett dollartecken. Framöver kommer jag att berätta att förutom variabler som börjar med en dollar, finns det också arrayer (@array), hash (% hash) och några fler typer, som det är för tidigt att prata om. Det är likhet mellan variabeln och diamanten, vilket innebär att vi tilldelar resultatet av frågan till variabeln. På den tredje raden skriver vi ut ordet hej och efter det skriver vi ut vad som lagrats i variabeln $ name. I vårt fall är detta namnet vi bad om.
Låt oss göra en annan distraktion, där jag kommer att berätta vad du kan göra med variabler ... Du kan göra ALLT med dem! Och detta är inte en överdrift. Detta är till exempel möjligt:
$a = 3;
$ b = 4;
$ c = $ a + $ b; # Lägg till två variabler och
# tilldela dem till tredje
tryck $ c; # Skriv ut det resulterande numret
skriv ut $ a + $ b; # samma, bara utan
# anropar den tredje variabeln
Jag hoppas att allt är klart med detta ... Under tiden, det kommer till vissa, kommer vi att skriva ett program som kör DOS dir-kommandon. För de som inte vet - dir är ett kommando som visar innehållet i katalogen där du befinner dig.
$ dos = `dir`;
skriv ut $ dos;
<>;
Det här programmet läser in i $ dos-variabeln resultatet av dir-kommandot, som är omgivet av bakre citattecken (om dessa var enkla citattecken skulle det inte vara ett kommando, utan bara ett ord) och visar sedan samma resultat på monitorn.
Låt oss nu återgå till våra baggar, eller snarare bara till baggarna hittills :) Vi lärde oss hur man visar texten vi behöver på skärmen, tar emot information från användaren och lärde oss också att DOS-kommandon i bakre citattecken kommer att utföras som DOS-kommandon :) Det är dags att skriva ett program som inte kräver mer än dessa kommandon:
skriv ut "enter command:";
chmod ($ com =<>);
skriv ut `$ com`;
<>;
Av säkerhetsskäl avråder jag starkt från att gå in i FORMAT-kommandot, gissa varför :) chmod kommandon(). Detta kommando tar bort nyradstecknet \ n från informationen som vi får i begäran, som finns där som standard. Det som står på den andra raden är en förkortning för två rader:
Vi gissar bara några få symboler med detta, men det är ändå trevligt :)
På detta tror jag att du har klarat de första stegen och är redo att fortsätta den svåra vägen att lära dig Perl.
Det mest använda skriptspråket är dock Perl.
Det här kapitlet fokuserar på Perl-språket och dess användning. När du har lärt dig hur du programmerar med Perl kan du använda den för att skriva skript som löser en mängd olika internet- och webbprogrammeringsproblem.
Särskild vikt kommer att läggas på de funktioner som används när man skriver CGI-skript. Om du aldrig har programmerat i Perl tidigare, använd det här kapitlet som utgångspunkt för att bemästra det.
Begreppen du kommer att lära dig i det här kapitlet lär dig hur du skriver professionella manus i Perl.
Det här kapitlet täcker inte bara grunderna i Perl-programmering, utan även flera andra aspekter. När du har läst klart det här kapitlet kommer du att kunna förstå följande nyckelbegrepp: Perl är ett tolkat programmeringsspråk specifikt inriktat på textbehandling.
Programmerare refererar ofta till Perl-program som skript. Med hjälp av Perl skapar programmerare CGI-formulär.
P erl stöder fil- och databasoperationer. Detta gör den väl lämpad för att lagra och hämta information enligt webbanvändarnas behov.
P erl kommer med ett felsökningsprogram som du testar din Perl-kod med
I denna avdelning:
8
PERL programmeringsspråk
Den här artikeln kommer att introducera dig till en kurs i Perl-språket jämförande egenskaper Perl och C / C ++, kommer att prata om rikedomen i Perl.
8
Använder PERL
Principer för att använda Perl, eller vad du kan göra med Perl.
8
Introduktion till PERL-språket
Grundläggande begrepp i Perl-språket, första exemplet.
8
Installerar PERL
En snabb tips om hur du kommer igång med Perl.
8
Använder PERL Debugger
Grundläggande principer för att arbeta med Perl debugger; felsökningskommandon; exempel på användning.
8
Datatyper i PERL
Kapitlet ägnas åt datatyper och övergången från en typ till en annan.
8
Variabler
Perl stöder tre typer av variabler: skalärer, arrayer och associativa arrayer. Om dem och tal. ;-)
8
PERL-operatörer
En översikt över de grundläggande operatörerna av Perl.
8
PERL-språkkonstruktioner
En beskrivning av funktionerna i Perl-syntaxen. Grundläggande operatörer.
8
Subrutiner
Syntax och semantik för subrutiner i Perl.
8
Strängbearbetning
Beskrivning av funktioner för bearbetning av strängvariabler.
8
Listbearbetning
Flera funktioner som utökar utbudet av möjligheter att arbeta med listor.
8
Arbeta med arrayer
Perl innehåller flera inbyggda funktioner som hjälper dig att arbeta med arrayelement.
8
CGI-skript med PERL
I det här kapitlet kommer du att lära dig hur du använder Perl för att skapa CGI-skript.