Tanulási perl
Mi továbbra is tanulni Perl. Ebben a fejezetben térünk szemünk működéséhez. Funkció - egy blokk kódok, hogy adja a nevét, így tudjuk használni őket, ha szükséges. Funkciók segít megszervezni a kódot egy egyszerű érthető darabokra. Ezek lehetővé teszik, hogy hozzon létre egy programot lépésről lépésre, tesztelés útközben.
Miután a program akkor van egy ötlete, amire szükség van egy olyan rendszerre, az építkezés - a fejedben, vagy papíron. Minden lépés a rendszer mutathat egy funkció a programban. Ez az úgynevezett moduláris programozás. Moduláris programozás nagyon jól teszi, hogy elrejtse a részleteket a program, ezáltal javítva az olvashatóságot a forráskód a program.
Például, ha a program tartalmaz egy funkció, amely kiszámítja a területet a kör, a következő sorban akkor hivatkozni rá:
Nézzük ezeket függvényhívás, az ember elolvassa a forráskód a program, hogy megértsék, mi a program teszi. Ugyanakkor, azt nem kell tudni, hogyan kell pontosan végrehajtani ezt vagy azt a funkciót. Ezért fontos, hogy a funkciók „beszélő” neveket - így nevezték volna megérteni, mi az adott függvény.
Egy funkció azt jelenti, hogy a Perl értelmező helyett a függvényhívás megszakítja az aktuális sor sornyi kódot, és továbblép a funkció kódot. A befejezése funkció kód tolmács visszatér pont hívást, és folytatja a program végrehajtását a következő sorban.
Nézzük a függvényhívás - először látunk egy skalár változót, majd - az értékadó operátor. Már tudom, hogy mit jelent - Perl kiosztja változó $ areaOfFirstCircle érték kereshetőségi jogot a megbízás jel. De ami igazán áll jobbra?
Az első dolog, amit látsz - ez a funkció neve areaOfCircle (). Zárójelben vannak jobb és nincs neve előtt $ szimbólumok @ és% azt jelenti, hogy ez - a függvényhívás. Zárójelbe listáját tartalmazza paraméterek vagy értékek átadását a függvénynek.
Terület kiszámításával a kör:
$ AreaOfFirstCircle = areaOfCircle (5);
print ( "$ areaOfFirstCircle \ n");
sub areaOfCircle $ sugara = $ _ [0];
visszatérési (3.1415 * ($ sugár ** 2));
>
sub FunctionName függvény törzse
>
Ez minden. A funkció kész.
Nehezebb a paraméterekkel. Paraméterek - olyan értékeket, átadjuk a funkciót. A paramétereket tartalmazza zárójelben, közvetlenül a függvény neve. A fenti példában a függvény hívás - ez areaOfCircle (5). Itt már csak egy paramétert. De még ebben az esetben, ha ez a funkció csak az egyik paraméter, Perl függvényhívás létrehoz egy sor lehetőséget használatáért a funkciójukat.
Bent a funkció paramétereit tömb van neve @_. Minden paraméter át a funkciót tartalmazza a tömb @_, ahol el lehet távolítani, ha szükséges.
A mi kis funkció a fenti példában is csinálni a következő sort:
Ez a vonal határozza meg az első eleme a tömb @_ skalár változó $ sugara.
Ha azt szeretnénk, akkor nem használhatja függvény visszatérési nyilatkozat visszatérési értéke, - Perl automatikusan visszatér az érték az utolsó kifejezés értékelni. De jobb lenne, ha az összes fog használni a return - így elkerülhető a sok véletlenszerű hibákat.
Talán láttad egyes programozási nyelvek, a különbség a rutinok és funkciókat. Ezekben a nyelvekben, akkor a függvény értéke szükségszerűen egyidejűleg, a rutin nem ad vissza értéket. A Perl, nincs ilyen - csak van egy funkció - függetlenül attól, hogy vissza semmilyen értéket, vagy sem.
Használata tömb paraméter (@_)
Mint korábban említettük - az összes paraméter a funkció megtalálható tömb paraméter @_. Ez nagyon kényelmes -, hogy megtudja, hogy hány paramétert adtak át a funkciót, akkor csak olvassa el a tömb @_ paraméter skalár környezetben.
firstSub (1, 2, 3, 4, 5, 6);
firstSub (1..3);
firstSub ( "A" .. "Z");
sub firstSub $ numParameters = @_;
print ( "A paraméterek száma is $ numParameters \ n");
>
A program kiírja:
A paraméterek száma 6
A paraméterek száma 3
A paraméterek száma 26
Perl lehetővé teszi, hogy adja át tetszőleges számú paramétert a funkciót. A függvény maga meg tudja határozni, milyen beállításokat kell használni, és milyen sorrendben. paraméterek @_ tömb ugyanúgy használható, mint bármely más tömb.
Persze, ez nem túl kényelmes - paraméterek eléréséhez át a funkciót számuk - @_ [0] vagy @_ [1]. Csak akkor veheti igénybe a kényelmesebb technológia:
areaOfRectangle (2, 3);
areaOfRectangle (5, 6);
sub areaOfRectangle ($ magasság, $ szélesség) = @_;
$ Area = $ magasság * $ szélessége;
print ( „A magasság $ magassága A szélesség $ szélesség terület $ terület \ n \ n ...”);
>
A magasság 2. A szélesség 3. A terület 6.
A magasság 5. A szélesség 6. A terület 30.
Paraméterátadás referenciaként funkciót.
Ha át a funkciót nem minden számot, és változó, abban az esetben a változás annak értékét egy függvényen belül, ez is változott a többi program. Ezt nevezik szerint átadott paramétereket.
@array = (0..5);
print ( "Mielőtt függvényhívásnál array = @array \ n");
firstSub (@array);
print ( "Miután a funkció hívás, tömb = @array \ n");
sub firstSub $ _ [0] = "A";
$ _ [1] = "B";
>
Mielőtt a funkció hívás, tömb = 0 1 2 3 4 5
Miután a funkció hívás, array = A B 2 3 4 5
Mint látható, a funkció megváltozott értékét az átadott paraméterek, és ez is befolyásolta a munkát a többi program - amelynek @array tömb megváltozott nemcsak funkciója, hanem a többi program. Ez egy rossz programozási gyakorlat - ha nincs éppen egy ilyen konkrét cél, akkor nem használhatja az ilyen díjak - ezek tele finom hibákat. Másrészt, ha az elején a funkció az érték a számukra átadott új változók (mint azt korábban bemutattuk), és a munka a jövőben csak velük - a probléma nem lesz -, mert ebben az esetben valójában nem módosítja az átadott értékeket a függvény paramétereket.
Itt egy példa ugyanazt a programot, de írt több helyesen:
@array = (0..5);
print ( "Mielőtt függvényhívásnál array = @array \ n");
firstSub (@array);
print ( "Miután a funkció hívás, tömb = @array \ n");
sub firstSub ($ firstVar, $ secondVar) = @_;
$ FirstVar = "A";
$ SecondVar = "B";
>
Mielőtt a funkció hívás, tömb = 0 1 2 3 4 5
Miután a funkció hívás, tömb = 0 1 2 3 4 5
Mint látható - függvény értékeket rendel a paraméterek átadott az új változók, és rendszerint csak a jövőjük - nem csak a változó tömb lehetőséget.
De aztán befut egy másik probléma:
$ FirstVar = 10;
@array = (0..5);
print ( "Mielőtt függvényhívás \ n");
print ( "\ tfirstVar = $ firstVar \ n");
print ( "\ tarray = @array \ n");
firstSub (@array);
print ( "Miután függvényhívás \ n");
print ( "\ tfirstVar = $ firstVar \ n");
print ( "\ tarray = @array \ n");
sub firstSub ($ firstVar, $ secondVar) = @_;
$ FirstVar = "A";
$ SecondVar = "B";
>
Mielőtt függvényhívás
firstVar = 10
array = 0 1 2 3 4 5
Miután függvényhívás
firstVar = A
array = 0 1 2 3 4 5
Ez alapértelmezés szerint az összes változó a Perl-programot elérhető bármilyen kódrészletet. Ez nagyon hasznos, sok esetben, de gyakran okoz kényelmetlenséget, és vezet egy csúnya hibát. Következő megtudhatja, hogyan hozhat létre változókat, amelyek csak akkor láthatók, a funkcióit.
Scope változó.
Terjed ki a változó - ezek olyan kódrészletek, amelyek segítségével ezt a változót. Alapértelmezés szerint minden változó Perl-program „látható” bármely pontjáról a program.
Néha ez nagyon hasznos, hogy korlátozza az egy bizonyos változó egy függvényen belül. Ebben az esetben a változás változó értékét a függvény belsejében nem befolyásolja a többi program. A Perl, két funkció - az én () és a helyi (). Az első létrehoz egy változót, ami látható, csak a függvény belsejében. A második létrehoz egy változót, amely szintén „látni” a funkció, hívott ezt a funkciót.
firstSub ( "AAAAA", "BBBBB");
sub firstSub helyi ($ firstVar) = $ _ [0];
én ($ secondVar) = $ _ [1];
print ( "firstSub: firstVar = $ firstVar \ n");
print ( "firstSub: secondVar = $ secondVar \ n \ n");
secondSub ();
print ( "firstSub: firstVar = $ firstVar \ n");
print ( "firstSub: secondVar = $ secondVar \ n \ n");
>
sub secondSub print ( "secondSub: firstVar = $ firstVar \ n");
print ( "secondSub: secondVar = $ secondVar \ n \ n");
$ FirstVar = "CCCCC";
$ SecondVar = "DDDDD";
print ( "secondSub: firstVar = $ firstVar \ n");
print ( "secondSub: secondVar = $ secondVar \ n \ n");
>
firstSub: firstVar = AAAAA
firstSub: secondVar = BBBBB
secondSub: firstVar = AAAAA
Használata nem inicializált értéke test.pl 19. sor.
secondSub: secondVar =
secondSub: firstVar = CCCCC
secondSub: secondVar = DDDDD
firstSub: firstVar = CCCCC
firstSub: secondVar = BBBBB
Mint látható, secondSub () függvény nem férnek hozzá a változó $ secondVar, amelyet azért hoztak létre funkciót én () belső firstSub () függvényt. Perl is hozott egy üzenetet, hogy figyelmeztesse Önt erre. Ugyanakkor, a változó $ firstVar hozzáférhető és módosítható secondSub () függvényt.
Ha lehetséges, próbálja meg csak egy funkciója én (), és nem használja a helyi () funkció - így biztosítja a szigorúbb ellenőrzést hatálya változók.
Tény, hogy a funkció az én () sokkal összetettebb és funkcionális. De ez lesz szó a 15. fejezetben - „Modules Perl”.
Emlékszel a különbség a függvény paraméter elhaladó referencia és érték? Ha át paramétereket az érték, a függvény nem módosíthatja az értékeket a paraméterek átadott (változó), ami azt jelenti, hogy nem befolyásolja az egész programot. Ha át paramétereket hivatkozással, hogy a funkció változtatni az értékeket a paraméterek (változók), és ez hatással lesz a fő program. Tehát, ha a helyi () paraméter elhaladó eljárás linket kicsit másként működik - függvény megváltoztathatja az értékeket a paraméterek át nekik (változó), de ez csak akkor érinti a nagyon „top” funkció - az egyik, ahol a függvény helyi felhasználásra került ( ), - a fő program, mivel nem befolyásolja.
A lista a függvény paraméter.
Most, hogy már foglalkozott hatálya változók, nézzük meg a paramétereket a funkciók a másik kezét. Amint már mondtuk - az összes funkció paraméterek továbbítják az azonos tömb, de mi van, ha meg kell, hogy adja át a függvény egyetlen paramétere - skalár, és a második érv - egy tömb? A következő példa azt mutatja, hogy mi történik:
firstSub ((0..10), "AAAA");
sub firstSub helyi (@array, $ firstVar) = @_;
print ( "firstSub: array = @array \ n");
print ( "firstSub: firstVar = $ firstVar \ n");
>
firstSub: array = 0 1 2 3 4 5 6 7 8 9 10 AAAA
Használata nem inicializált értéke test.pl 8-as vonal.
firstSub: firstVar =
Láthatjuk, hogy az inicializálás során változó tömb @array elnyeli az összes elemet a tömb @_ paraméter, így semmi skalarnoy változó $ firstVar. Ezt támasztja alá a figyelmeztető üzenetet a Perl interpreter. Meg lehet oldani ezt a problémát áthelyezésével paramétereit helyek - ha tesz az első skalár változót, majd a tömböt, akkor minden rendben lesz, ahogy kellene:
firstSub ( "AAAA", (0..10));
sub firstSub helyi ($ firstVar, @array) = @_;
print ( "firstSub: array = @array \ n");
print ( "firstSub: firstVar = $ firstVar \ n");
>
firstSub: array = 0 1 2 3 4 5 6 7 8 9 10
firstSub: firstVar = AAAA
Akkor át a függvényt tetszőleges számú skalár mennyiségek, de csak egy tömb. Ha megpróbálja átadni a függvény több tömböt, az elemek egyszerűen beolvadt egy tömbben, és a funkció nem lesz képes, hogy megtudja, - ahol az egyik tömb vége, és kezdődik a másik.
Az egymásba ágyazott (rekurzív) függvény.
Funkciók nevezik magukat, hogy részletezném több szinten. Mennyi - ez függ a konkrét megvalósítására Perl, a hardver- és a konfigurációt. Általában, akkor a forrásokat a gép, és aggódni, hogy nem éri meg. De ha kíváncsi, akkor futtassa a programot itt:
firstSub ();
sub firstSub print ( "$ count \ n");
$ Count ++;
firstSub ();
>
Hiba: futásidejű kivételt
Mielőtt kinyomtatni hibát jelzett, a program növeli az értékét a $ count változó, ameddig lehetséges olyan rekurzív hívást. Így a változó értéke $ count lehet megtudni, hogy hány szintet rekurzió lehetővé teszi a rendszert.
De ne elragadtatva rekurzió által - meg kell részt szorosan különleges esetekben, például amikor néhány matematikai számítások.
Szükség lehet használni a korlátozott. Hogyan rendezzük a változók már foglalkozott. Ez így van megvalósítva esetében funkciók:
$ Temp = performCalc (10, 10);
print ( "temp = $ temp \ n");
sub performCalc én ($ firstVar, $ secondVar) = @_;
my $ négyzet = sub visszatérő ($ _ [0] ** 2);
>;
return ($ négyzet ($ firstVar) + $ Square ($ secondVar));
>;
Mint látható, van egy függvény $ téren. Pontosabban $ tér - ez egy közös skalár változó, amely utal a funkciót. Egy funkció elérése, akkor használja a megjelölés neve előtt a változó $ téren. Ez a funkció csak akkor használható egy függvényen belül performCalc () - ez nem áll rendelkezésre, a többi program.