Perl (programozási nyelv)

Perl
Paradigma	többelvű: funktionális, imperatív, objectum-orientált (class-based), reflexív, procedurális, generikus
Jellemző kiterjesztés	.pl, .pm, .t
Megjelent	1987
Tervező	Larry Wall
Fejlesztő	Larry Wall
Utolsó kiadás	5.14.2 (2011-09-26)
Típusosság	dinamikus
Hatással volt rá	AWK, Smalltalk 80, Lisp, C, C++, sed, Unix shell, Pascal
Befolyásolt nyelvek	Python, PHP, Ruby, ECMAScript, LPC, Windows PowerShell, JavaScript, Falcon, Perl 6, Qore
Operációs rendszer	multiplatform
Licenc	GNU General Public License vagy Artistic License
Weboldal

A Perl egy általános célú programozási nyelv, melyet Larry Wall tett közzé 1987. december 18-án. Stílusában és funkcionalitásában sokat merít a C, sed, awk, sh és más programozási nyelvekből. A nyelv egyik legfontosabb része a reguláris kifejezések széles körű támogatása és alkalmazása, ezáltal kiválóan alkalmas nagy méretű szöveg- vagy adatfile-ok egyszerű feldolgozására. Egyik elterjedt felhasználása a CGI-szkriptek készítése.

Nagyon sokan felhozzák a rovására, hogy kifejezetten könnyű benne olvashatatlan kódot készíteni, de persze ez a programozótól függ: Perlben éppúgy lehet szép, olvasható programot készíteni, mint ahogy olvashatatlant bármely egyéb nyelven.

Operációs rendszerek és a Perl

Perl programok fizikai megírásához elegendő egy szövegszerkesztő, a teszteléshez/futtatáshoz azonban szükség van a Perl értelmezőre.

A Perl értelmező a legtöbb Linux és *BSD terjesztés alapvető eleme, azonban más rendszerekre is elérhető többféle változat.

A Perl előnyei és hátrányai

Előnyei:

• Gép- és rendszerfüggetlen, szinte mindenütt megvan.
• Gyors és hatékony, nagy könyvtára van.
• Elsőrangú reguláriskifejezés-kezelője (regular expression) van, ragyogó leírással
• Szinte minden számítógépes problémára nyújt megoldást
• Összetett jelkészletének köszönhetően kis helyen nagy mennyiségű információ fogalmazható meg, így egy képernyőn nagyobb információtartalom fér el.

Hátrányai:

• Eklektikus, azaz sokféle nyelvből vett át tulajdonságokat, emiatt tanulása nem triviális
• Gazdag jelrendszert használ a különféle változófajták jelölésére, amit előnynek is lehet tekinteni
• Könyvtárai sokrétűek, de gyakran külön töltendők le egy nagy archívumból (CPAN)

A névről

A nyelvet eredetileg Pearl-nek hívták, ami angolul gyöngyöt jelent. Larry Wall rövid és pozitív hangvételű nevet keresett a nyelvnek, azonban a szótárban végignézve az összes három- és négybetűs szót, egyik sem tetszett neki igazán. Megfordult a fejében az is, hogy feleségéről, Gloriáról nevezze el az új nyelvet. Végül a Pearl szóra esett a választása Máté evangéliuma 13,46 szerint: „the pearl of great price”. A hivatalos kiadás előtt azonban rájött, hogy sajnos már létezik ilyen névvel programnyelv, így gyorsan megváltoztatta a név írásmódját, kihagyva az "a" betűt.

Számos betűrövidítést társítanak a névhez, mint például humorosan a Pathologically Eclectic Rubbish Lister (kb. betegesen túldíszített selejt-listázó). A leginkább elterjedt és szakkönyvekben, illetve a Perl saját oldalán is használt rövidítés-magyarázat a Practical Extraction and Report Language (praktikus (szöveg)kinyerő és jelentéskészítő nyelv). Ez a magyarázat ráadásul összecseng az eredeti Pearl névvel is, amennyiben az And szót is bevesszük a rövidítés betűi közé.

A nevet nagy kezdőbetűvel használjuk (Perl) ha magára a programozási nyelvre hivatkozunk, kicsivel (perl) pedig, ha az fordító-értelmező programra. Ahogy azt a Perl közösség is állítja: „Only perl can parse Perl” (csak a perl képes a Perlt értelmezni). Nem tanácsos azonban a nevet végig nagy betűkkel (PERL), szigorúan betűszóként írni.

Kiejtés

A perl programnyelv kiejtése angolszász nyelvterületen megegyezik az angol pearl szó kiejtésével, azaz /pɜːl/, ami rímel a girl angol szóra. Ennek ellenére magyar anyanyelvű programozók körében gyakori a magyar fonetikus kiejtés is.

Perl humor

Ugyanúgy, mint a C nyelvben, a Perlben is népszerűek az elborult lelkivilágú programírási versenyek. Ezek győztesei olyan kódokat produkálnak, melyekről órákig tart megállapítani, hogy voltaképpen mit is csinálnak, azonban lefuttatva általában valamilyen egyszerű műveletet hajtanak végre – például kiírják, hogy „Helló világ!” (Hello world!).

Népszerű foglalatosság Perlben verset írni, tehát olyan programkódot, ami értelmezhető a perl fordító által, de olvasható angol nyelvű versként is. Ez a hobbi többé-kevésbé egyedi a programnyelvek között, nagyrészt annak köszönhetően, hogy a Perl legtöbb utasítása angol szó. A legújabb verseket rendszeresen közzéteszik a Perl Poetry oldalon.

Érdekes még a Perl golf. Ugyanúgy, mint a fizikai golfban, a lényeg itt is a cél elérése minél kevesebb ütéssel, az ütések azonban billentyű leütést jelentenek. Egy feladat lehet például a „leghosszabb anagramma megtalálása a beolvasott szövegben”. A versenyzők egymást túllicitálva írnak minél kevesebb billentyű leütéssel begépelhető programkódokat.

Az egyik legbizarrabb szórakozás a Lingua::Romana::Perligata CPAN modul, mely képes arra, hogy latin nyelven íródott szöveget értelmezzen és hajtsa végre azt, módot adva a latin nyelvű Perl programozásra.

Megemlítést érdemel továbbá a Perl Linux minimalista disztribúció, amely (ha nem minden, de) sok megszokott Linux parancsot tartalmaz, egytől egyig Perl-ben megírva! (pl. chmod, find, file, ls, touch...). A rendszer mindössze a Linux kernelt, a uClibc -t (minimális alternatíva glibc helyett), a Perl értelmezőt és a Perl nyelven írott parancsokhoz tartozó programokat tartalmazza.

Alapok

A Perl szabad szoftver, amely az Artistic licence és a GPL alatt érhető el.

A Perl használatára jó példa, hogy a Wikipédia is egy Perlben írt CGI szkriptként működött 2002 januárjáig. (A lecserélésének oka sem a Perl bármilyen káros tulajdonsága volt – egyszerűen azok a programozók, akik újraírták, nem a Perlt ismerték jobban.) Egy másik nagyobb alkalmazóként a Slashdot.org említhető, amelyet a Perlben írt Slashcode működtet. Webes alkalmazások esetében a Perlt gyakran Apache web serverrel és annak mod perl moduljával használják.

A nyelvet támogatói és becsmérlői is egyaránt tisztelik szintaxisa és sajátosságai miatt. A két tábor közötti különbség azonban abban rejlik, hogy ezt erényként vagy vétekként értékelik-e. Tulajdonságai miatt gyakran hasonlítják a természetes nyelvekhez (mint az angol), illetve az evolúcióhoz. Larry Wall így érvel:

… gyakran viccelődünk azzal, hogy a teve egy bizottság által tervezett ló, de ha jobban belegondolunk, láthatjuk, hogy a teve elég jól alkalmazkodott a sivatagi élethez. A teve önellátóvá vált. Másrészt a teve nem jutott el odáig, hogy kellemes szaga is legyen. Ugyanígy még a Perl sem.

Felismerve „csúnya, de hasznos” természetét, a tevét választották a Perl kabalafigurájává, és mivel az O’Reilly kiadó által megjelentetett Perl programozás (Programming Perl) című könyv borítójára is a teve került, ezt programozói körökben egyszerűen csak „teve-könyv”-nek („camel book”) hívják.

Implementáció

A Perl egyik bástyája a CPAN, melyről hatalmas mennyiségű, ingyenesen használható modul tölthető le, melyek az elméleti matematikától az adatbáziskezelésen keresztül a hálózati implementációkig sok-sok mindent felölelnek. A CPAN moduljainak túlnyomó többsége az Artistic licence, a GPL, vagy esetleg mindkettő alatt használható. 2004-ben a CPAN több mint 4000 szerző által írt moduljainak száma meghaladta a 7000-et. A CPAN.pm is egy perl modul, melynek segítségével további modulokat lehet letölteni és telepíteni a CPAN-ról vagy tüköroldalairól, tetszés szerint interaktívan, vagy akár teljesen automatikusan.

A jelenlegi verzió

A jelenleg elérhető az 5.12.3-es verzió, melyet 2011. január 21-én adtak ki. Ez a változat is (már az 5.10 óta egyébként elérhető) teljes Unicode támogatást nyújt.

A következő generációs Perl6 nyelv fejlesztése folyamatban van, ezt már a több programozási nyelvet is támogató, Parrot-nak elnevezett virtuális gép fogja futtatni.

A Perl működése

Bár a Perl hordozza az interpretált nyelvek minden előnyét, mégsem szigorúan sorról sorra értelmezi a forráskódot, hanem először egy átmeneti belső formátumra alakítja, amelyet futtatás előtt optimalizál. Ez a működés lehetővé teszi, hogy a szintaktikai hibák már fordításidőben észlelhetők legyenek, a szubrutinok hívásai pedig még a szubrutin definíciója előtt szerepelhetnek a forrásban. Az 5.005-ös verzió óta lehetővé vált az átmeneti bájtkód elmentése későbbi futtatásokhoz, amellyel megspórolható a kezdeti fordítási fázis.

Mindenképpen idekívánkozik, hogy a legtöbb Linuxos (Unixos) gépen a Perl értelmező a /usr/bin könyvtárban van, és hogy alapvető elv egy program elkészítésénél a hordozhatóság, ezért be kell írni a forrás legelső sorába:

#!/usr/bin/perl

ez a Perl-nek egy megjegyzés, viszont segít egyes programokat (főként parancsértelmezőket, mint például bash) abban, hogy rájöjjenek, mivel is lehet futtatni a programot.

Windows rendszerek esetén célszerű a ".pl" fájlokhoz a perl.exe-t társítani, illetve a perl.exe-t tartalmazó könyvtárat hozzáadni a %PATH% környezeti változóhoz.

Adatszerkezetek

Három alapvető adatszerkezet van: skalár, lista (másik nevén tömb) és asszociatív tömb (hash).

• A skalár bármilyen karakterlánc vagy szám lehet, nevük elé $-jelet kell tenni (megjegyzendő, hogy szemben a C-vel, a karakterláncok NULL karaktert is tartalmazhatnak, így bináris adatok feldolgozására is lehetőség van):

$skalar = "Ez egy szoveg"; # skalár változó
$szamskalar = 123.456; # skalár szám értékkel

• A lista vagy tömb a C-hez hasonlóan 0-tól indexelt (ez átállítható) adatsor, a nevük elé @-t kell tenni, amikor viszont egy elemét szeretnénk elérni, akkor már skalárként kell kezelni ($):

@tomb1 = (1011,1012,1013,1014,1015,1016,); # egy tömb
@tomb2 = (2000,2100,2200,2300,2040,2045,); # egy tömb
@tomb8 = (8000,8100,8400,8245,); # egy tömb
$i = $tomb1[0]; # a tömb legelső eleme

• Az asszociatív tömb gyakorlatilag naivan tekinthető egy sztring-indexű tömbnek, de „hivatalosan” név-érték párok halmaza, a név bármilyen sztring lehet, az érték pedig akár hivatkozás is (erről bővebben kicsit később). Az asszociatív tömbök nevét % jellel kezdjük, az egyes értékeket a listához hasonlóan a $ jel segítségével érhetjük el (látható az is, hogy a lekérdezendő elem neve {}-ek köz szerepel):

%asszoc = ('nev1','adat1','nev2','adat2'); # egy asszoc tömb, figyeljük meg, hogy páros számú
                                             elem van felsorolva
%asszoc = (                               # az előző deklaráció más (könnyebben áttekinthető)
              'nev1' => 'adat1',           # stílusban írva
              'nev2' => 'adat2'
           );
$asszoc{'nev3'} = 'adat3'; # új elem hozzáadása az asszociatív tömbhöz
delete $asszoc{'nev2'};    # elem törlése az asszociatív tömbből

Kezdetben zavaró lehet, hogy egy tömb, asszociatív tömb elemének lekérdezésekor is $-jelet kell tenni a változó neve elé, azonban mindig gondoljunk arra, hogy a $, % és @ jelek használata attól függ, hogy mit is szeretnénk értékként visszakapni.

Vezérlő szerkezetek

A Perl vezérlő szerkezetei a C és Java nyelvekéire hasonlítanak.

Ciklusok

''címke'' while ( ''kifejezés'' ) ''blokk''
''címke'' while ( ''kifejezés'' ) ''blokk'' continue ''blokk''
''címke'' for ( ''kifejezés1'' ; ''utasítás2'' ; ''utasítás3'' ) ''blokk''
''címke'' foreach ''változó'' ( ''lista'' ) ''blokk''
''címke'' foreach ''változó'' ( ''lista'' ) ''blokk'' continue ''blokk''

ahol a blokk egy vagy több Perl utasítás kapcsos zárójelek között:

{ ''utasítás(ok)'' }

A kettősponttal lezárt címkét a ciklusvezérlő utasításokban használhatjuk.

• A next utasítás a ciklust a következő elemre lépteti
• A last utasítás azonnal kilép a ciklusból
• A redo utasítás a ciklust az aktuális elemmel indítja újra

Beágyazott ciklusokban címkével együtt használva az utasításokat, azok a címkének megfelelő cikluson értelmeződnek, lehetőséget adva például egy belső ciklusban egy külső megszakítására. A for szerkezet szemantikája megegyezik a C nyelvvel. A kifejezés1 még az első kör előtt kiértékelődik; a kifejezés2 minden iteráció előtt értékelődik ki és amennyiben hamisnak bizonyul, úgy a ciklus befejeződik; a kifejezés3 pedig minden egyes iteráció végén hajtódik végre.

A foreach szerkezetben a var egy skaláris változót jelöl, aminek elhagyása esetén a beépített ciklusváltozó, a $_ veszi fel az értékeket.

Ráadásképpen bármely egyszerű kifejezés (ami nem képez blokkot) végrehajtható akár a következő formákban is:

while ( ''kifejezés'' }
until ( ''kifejezés'' )

Hasonlóképp készíthető hátultesztelő ciklus, ahol a blokk a kifejezés értékétől függetlenül először biztosan lefut. Ezt a do utasítással kell kezdeni:

do ''blokk'' while ( ''kifejezés'' );
do ''blokk'' until ( ''kifejezés'' );

Vigyázat! Ezeket az egyszerűsített kifejezéseket a Perl nem tekinti teljes értékű ciklusnak, így ezekben nem használhatóak a next, last és redo ciklusvezérlő utasítások!

Feltételes elágazások

if ( ''kifejezés'' ) ''blokk''

Amennyiben a kifejezés igaz, úgy végrehajtódnak a blokkban szereplő utasítások.

unless ( ''kifejezés'' ) ''blokk1''
else ''blokk2''

Amennyiben a kifejezés hamis, úgy végrehajtódnak a blokkban szereplő utasítások.

if ( ''kifejezés'' ) ''blokk1''
else ''blokk2''

Ha igaz a kifejezés, akkor a blokk1 fut le, ellenkező esetben pedig a blokk2.

if ( ''kifejezés1'' ) ''blokk1''
elsif ( ''kifejezés2'' ) ''blokk2''
else ''blokk3''

Ha a kifejezés1 igaz, akkor a blokk1 értelmeződik, ellenkező esetben megvizsgálja a kifejezés2-t, és ennek megfelelően vagy a blokk2 vagy pedig a blokk3 lesz értelmezve.

A Perl a kifejezéseket minden esetben igaz-hamis értékekként kezeli. Ha a kifejezés számnak tekinthető, akkor bármely nem nulla érték igazként értékelődik. Ha a kifejezés szöveges érték, akkor bármely nem nulla hosszúságú szöveg igaz, kivéve a "0"-t.

"0" hamis
"0.0" igaz
"00" igaz
"-0" igaz
-1 igaz

Ha listát vagy asszociatív tömböt írunk a kifejezés helyére, akkor annak elemszáma értékelődik ki, tehát az üres lista és asszociatív tömb hamis lesz.

Kifejezésmódosító szerkezetek

Egyszerű kifejezésekben, értékadásokban a while, until, if, unless és foreach direktívák használhatóak kifejezésmódosítóként is, ilyenkor a direktíva eredményétől függ a kifejezés végrehajtása.

''utasítás'' while ( ''logikai kifejezés'' )
''utasítás'' until ( ''logikai kifejezés'' )
''utasítás'' if ( ''logikai kifejezés'' )
''utasítás'' unless ( ''logikai kifejezés'' )
''utasítás'' foreach ( ''logikai kifejezés'' )

A kifejezésmódosítók nem ágyazhatók egymásba, így a következő kódrészlet szintaktikailag hibás:

''utasítás'' if ( ''logikai kifejezés'' ) for ( ''lista'' )

A for és a foreach kulcsszavak egymással tetszőlegesen felcserélhetők a nyelvben. Célszerű azonban, ha konzekvensen használjuk: pl. ha számsorról van szó, akkor for (legyen az akár 1..1e3) és a foreach, ha egy tömb elemeiről. A hátravetett kifejezések használatakor a zárójel elhagyható, ami növelheti az olvashatóságot. A legtöbb esetben azonban célszerű kerülni a ezt az írásmódot, mivel úgy olvasáskor, mint a végrehajtás során előbb azt vizsgáljuk, hogy teljesül-e a feltétel (illetve hányszor, milyen adatokkal stb.), és csak utána hajtódik végre a kódrészlet.

print $a if $a > 5; # az érték csak akkor jelenik meg, ha nagyobb, mint 5
print "$_\n" for 1 .. 10; # 1-től 10-ig kiírja a számokat egymás alá
print "$_: $h{ $_ }\n" foreach sort keys %h; # asszociatív tömb elemeinek kiírása (kulcsok szerint betűrendben)

Többágú feltételes elágazás (switch)

A Perl nyelv 5.8-as változatáig alapjában véve nem volt külön szerkezet a C nyelvben megszokott switch utasításra, azonban az alábbi programozási technikával ez megvalósítható volt:

SWITCH: {
        if ( ''logikai kifejezés'' ) { ''utasítás(ok)''; last SWITCH; }
        if ( ''logikai kifejezés'' ) { ''utasítás(ok)''; last SWITCH; }
# ...
        ''egyéb esetben végrehajtandó utasítások'';
}

avagy

SWITCH:
        ''utasítás1'', ''utasítás2'', last SWITCH if ( ''logikai kifejezés'' );
        ''utasítás1'', ''utasítás2'', last SWITCH if ( ''logikai kifejezés'' );
# ...
        ''egyéb esetben végrehajtandó utasítások'';
}

vagy elsif-et használva

if ( ''logikai kifejezés1'' ) {
    ''utasítás(ok)'';
} elsif( ''logikai kifejezés2'' ) {
    ''utasítás(ok)'';
} elsif( ''logikai kifejezés3'' ) {
    ''utasítás(ok)'';
} else {
    ''egyéb esetben végrehajtandó utasítások'';
}

Jól példázza azonban a Perl nyelv bővíthetőségét, hogy kiegészítő modul segítségével akár "szabványos" switch szerkezet is használható a Switch CPAN modul használatával

use Switch;
 
switch ($val) {
    case 1          { ''utasítás(ok)'' }
    case "a"        { ''utasítás(ok)'' }
    case [1..10,42] { ''utasítás(ok)'' }
    case /\w+/      { ''utasítás(ok)'' }
    ''...''
    else            { ''utasítás(ok)'' }
}

Ezzel azonban bánjunk óvatosan, mivel a Switch modul voltaképp átírja a programkódot az első megoldásra, ezáltal egyes esetekben megnövekedhet a sorok száma. Ekkor egy későbbi hibajelzés olyan sorra mutathat, ahol valójában nem is szerepel a kérdéses hivatkozás.

Az 5.10-es változatban már van valódi beépített „switch” is, csak éppen nem ez a neve, hanem given. (Annyi más újdonsághoz hasonlóan, ezt is a lassan készülő 6.0-s Perlből backportolták.)

use feature "switch";
 
given($_) {
    when (/^abc/) { $abc = 1; }
    when (/^def/) { $def = 1; }
    when (/^xyz/) { $xyz = 1; }
    default { $nothing = 1; }
}

Bonyolultabb adatszerkezetek

Hivatkozások segítségével az alaptípusoknál sokkal összetettebb adatszerkezetek is létrehozhatók, például olyan névsor készíthető, amiben egy névhez több adatot is lehet rendelni (születés helye, ideje, lakcím stb.), míg egyszerű (egy dimenziós) asszociatív tömbök segítségével csak egy adatot lehet minden kulcshoz hozzárendelni.

Skaláris

%tomb1 = (
    nev1 => 'lakcím1',
    nev2 => 'lakcím2',
};
%tomb2 = {
    nev1 => {
         lakcim => 'lakcím1',
         telefonszamok => [ 'telefonszám1', 'telefonszám2' ],
         szuletes => {
             helye => 'szül.hely1',
             ideje => évszám1,
         },
     },
     nev2 => {
         lakcim => 'lakcím2',
         telefonszamok => [ 'telefonszám3', 'telefonszám4', 'telefonszám5' ],
         szuletes => {
             helye => 'szül.hely2',
             ideje => évszám2,
         },
     },
};
 
print $tomb1{nev2};    # ''lakcím2''
print $tomb2->{nev1}->{szuletes}->{helye};    # ''szül.hely1''
print $tomb2->{nev2}->{telefonszamok}->[0];    # ''telefonszám3''

Függvények, szubrutinok

A Perlben a függvényeket a sub kulcsszóval lehet deklarálni. Az átadott paraméterek a @_ nevű listában érhetők el. Ha három paraméterrel hívjuk meg a függvényt, akkor a @_ lista három elemet fog tartalmazni, ezekre $_[0], $_[1] és $_[2]-ként lehet hivatkozhatni, illetve a shift utasítást használva is felhasználhatjuk a lista elemeit. Ha a shift utasításnak nem adunk paramétert, akkor az a @_ listán hajtja végre a műveletet. A függvények a legutoljára végrehajtott utasítás értékével, avagy a return kulcsszó által beállított értékkel térnek vissza.

sub terfogat {
    my $oldalhossz = shift;
    return $oldalhossz ** 3;
}
 
my $oldal = 16;
print terfogat( $oldal );

A paraméterek nevesíthetőek is a függvénynek asszociatív tömböt adva át paraméterként:

sub udvozlet {
    my %szemely = @_;
    return "Szia $szemely{vezeteknev} $szemely{keresztnev}\n";
}
 
print udvozlet(
    vezeteknev => 'Szabo',
    keresztnev => 'Janos',
);

Reguláris kifejezések

A Perlben nagyon hatékony módon lehet mintaillesztést végezni szabályos kifejezések (angolul: regular expression) segítségével. A perl szabályos kifejezések eredetileg a Unix Version 8 szintaxisát követték, de azóta a perl más irányba fejlődött tovább, s mára fogalommá vált a perl-kompatibilis szabályos kifejezés.

Az m// (match) operátor azt vizsgálja meg, hogy egy string illeszkedik-e egy adott szabályos kifejezéshez. Például az alábbi kifejezés értéke pontosan akkor igaz, ha az $x string tartalmazza az abc részt:

$x =~ m/abc/

Az abc string helyén állhat összetettebb szabályos kifejezés is, például a . speciális karakter tetszőleges karaktert jelöl. Az alábbi kifejezés igaz értékű, ha két a betű között egy tetszőleges karakter áll valahol az $x stringben.

$x =~ m/a.a/

Ha a kifejezést i (ignore case) kapcsolóval bővítjük, akkor a kis- és a nagybetűk azonosnak számítanak a mintaillesztésnél. A következő kifejezés igaz értékű, ha az $x string tartalmazza a Nemecsek szót, függetlenül attól, hogy az kis- vagy nagybetűkkel van-e írva.

$x =~ m/Nemecsek/i

Az s// (substitute) operátor adott szabályos kifejezést keres és lecseréli azt a megadott kifejezésre. A következő programsor lecseréli a ló szó első előfordulását tehén-re az $tej stringben.

$tej =~ s/ló/tehén/;

A g (global) kapcsolóval a csere globálissá tehető. Az alábbi programsor lecseréli a megszorítás szó összes előfordulását reformra a $cikk stringben.

$cikk =~ s/megszorítás/reform/g;

Egyszerű példaprogramok

A legegyszerűbb „Helló világ!” program a következőképp fest Perlben:

#!/usr/bin/perl -w
 
print "Helló világ!\n";

Külső hivatkozások

• (angolul) Perl központ
• (angolul) CPAN (Comprehensive Perl Archive Network) A Perl modulok központja
• (angolul) Perl dokumentációk
• (angolul) use Perl; Hírek és közösségi oldalak
• (angolul) A Perl Linux weboldala
• (magyarul) Perl Magyarországon Magyar Perl közösségi oldalak
• Perl.lap.hu - linkgyűjtemény
• (angolul) ActiveState ActivePerl
• (angolul) Strawberry Perl