Alapok

Ebben a fejezetben bemutatjuk azokat az alapvető építőkockákat, melyek kombinálásával és egymáshoz illesztésével elkészül egy program.

Megjegyzések

Amikor programot írsz, nem csak számítógépeknek, de embereknek is írod. Az idő nagy részében, miután egy program elkészült, te vagy valaki más módosítani akarja majd, hogy új funkciókat adjon hozzá, vagy hogy a benne lévő hibákat javítsa. Elmondok egy viccet, amit édesapám szeretett mondogatni:

Egy építőmunkás ebédszünetben kinyitja az ételhordó dobozát, és felkiált: "Már megint szalámi! Utálom a szalámit!"

Aztán másnap, azt mondja: "Egész nap azon töprengek, ma mit kaptam." Kinyitja az ételes dobozt, és felkiált: "Már megint szalámi! Utálom a szalámit!"

Ez így megy egy hétig. Végül az egyik munkás odaszól neki: "Miért nem kéred meg a feleséged, hogy valami mást csomagoljon ebédre? Akkor nem kellene állandóan szalámit ebédelned."

Erre az építőmunkás: "Ó, de hisz nekem nincs is feleségem! Saját magam készítem az ebédem!"

Ebben a viccben a munkás olyan szendvicseket eszik, amelyeket nem szeret, és amelyeket korábban ő készített -- magának. Ez sokban hasonlít a programozásra. A munkás olyan, mint a programozó, és a gusztustalan szendvics mint az a program, amelyik nem tartalmaz elegendő mennyiségű magyarázó megjegyzést. Ez nagyon nehéz is lehet, még egy tapasztalt programozónak is, hogy emlékezzen rá, vagy kitalálja hogy mit is csinál egy program ha nincsenek emlékeztető magyarázatok, melyek ebben segítik. Ezeket a kis magyarázatokat megjegyzések (comments) -nek hívjuk, ezekben bármit leírhatunk magunknak, amit szeretnénk. (Elsősorban a program magyarázatát szokás megjegyzésben leírni.)

A megjegyzések eltérőek lehetnek különböző számítógépes nyelveken, de mindig van valami jelölés ami megmutatja a számítógépnek hogy mely rész a megjegyzés és mi tartozik a programhoz. Perl-ben a megjegyzés kettős kereszt (hash mark) ('#') jelöli, és a jeltől a sor végéig tart. Ha több soros megjegyzést szeretnél írni, csak tegyél egy hash jelet a többi sor elejére is. Álljon itt néhány példa arra, hogy mi számít megjegyzésnek és mi nem:

# Ez egy megjegyzés.

# Ez egy megjegyzés, ami
# több sort használ.

#
# Ez is egy megjegyzés.  Üres sorokat is használhatunk
# hogy a dolgok jobban látsszanak.
#

                # Ez egy olyan megjegyzés, ami a
      # sor közepén kezdődik.  Teheted a megjegyzést
      # valaminek a jobb oldalára magyarázni,
      # hogy mi az ami ott van.

Na, ez nem egy megjegyzés.

A megjegyzés majd csak #itt kezdődik.

Lásd még:

Utasítások

Változók

Az iskolában arra használhattad a változókat, hogy különböző számokra utalj velük. A változó x lehetett 3, 4, 0, vagy akár -9.5. Egy változó jelenthet bármely számot több különböző számból. (De egyszerre csak egyet.)

Számítógép programozásban a változók mindenféle különböző dolgokat képviselhetnek. Perlben három változó típust fogunk használni: a skalárt (scalars), a listát (lists), és a hash-t (hashes). A nevek kissé furcsán hangozhatnak, de ez ne ijesszen meg bennünket.

Lásd még:

Skalár (Scalars) - Listák (Lists) - Hash (Hashes) - Változók értékadása

Skalár (Scalars)

A skalár (scalar) olyan változó, amely jelenthet számot, vagy szöveget is, amit stringnek (string) nevezünk. Egy szöveg (string) általában idézőjelek közé van téve, mint itt:

"Ez egy szöveg (string)."

Figyeld meg, hogy az idézőjelek nem részei a szövegnek; ezek körülveszik a szöveget, így mutatva meg hol kezdődik és hol végződik.

Egy változónak nagyjából bármilyen nevet adhatsz, amit betűkből, számokból és aláhúzás ('_') karakterből állíthatsz össze. Annyi megkötés azonban van, hogy egy dollár jelet ('$') kell tenned a skalár elé, innen fogja tudni a Perl, hogy ez skalár.

Általában véve jó ötletnek tűnik ha egy változó neve több szóból áll, és leírja hogy mit tartalmaz a változó. Több módja is van, ahogy az emberek összefűzik a szavakat. (Valamit tenned kell, hogy látsszon, hol kezdődnek a változók nevében a szavak, mert nehézfelismerniaszövegethanemválasztodelaszavakat.) Ennek egyik bevett módja ha a szavak első betűjét nagybetűnek írjuk; másik szokásos módszer ha a szavak közé aláhúzás ('_') karaktert írsz. Teljesen mindegy, hogyan csinálod, de javasolt hogy következetesen azonos módon tedd azt. Nagyon fontos, hogy pontosan azonosan írva használd a változókat mindenhol ahol szükség van rájuk; ellenkező esetben a gép azt hiszi majd, hogy másik változót szeretnél használni. Most mutatunk pár példát a helyes névhasználatra:

$NumberOfTrucks
$AverageHeight
$PlayerName

Vagy, ha jobban tetszik az aláhúzás, akkor így fog kinézni:

$number_of_trucks
$average_height
$player_name

A továbbiakban mi az első módszert fogjuk követni.

Lásd még:

Változók (Variables) - Listák (Lists) - Hashes - Változók értékadása - Skalár értékadása - Számtan

Listák

Egy lista egy olyan változó, ami lehetővé teszi, hogy nyomon kövess több dolgot. Mikor elmégy a vegyesboltba bevásárolni, jó ha van egy listád: alma, ketchup, kenyér, tej, kolbász… Egy lista egy olyan változó, ami lehetővé teszi, hogy nyomonkövess egy helyett több dolgot is. Az elnevezése olyan mint a skaláré (scalar), de a dollárjel ('$') helyett a név elején egy kukac ('@') karakter áll. Egy lista változó nevének valahogy így kell kinéznie:

@BoltiVasarloLista

Lásd még:

Változókról általában - Skalárok (Scalars) - Hashes - Változók értékadása általánosan - Listák értékadása

A Hash

A hash változók kicsit bonyolultabbak mint a skalárok vagy listák, de nagyon hasznosak.

Tegyük fel, ismersz pár embert, és nyomon szeretnéd követni milyen háziállataik vannak. Mondjuk legyenek ők John, Sue és Mary. Tegyük fel továbbá, hogy Johnnak van egy qtyája, Sue-nak macskája, Marynek pedig aranyhala. Milyen jó volna ha volna egy egyszerű változó, legyen mondjuk Pet: ha Johnra vonatkoztatom, akkor kutya az értéke, ha Sue-ra akkor macska, végül Mary esetében aranyhal.

A hash pontosan egy ilyen változó. Egészen eltérő módokon hivatkozhatunk a hash-re, attól függően, mi a célunk. Ha az egész hash-re hivatkozunk, akkor a hash elejére egy százalékjelet ('%')kell tennünk. Tehát a kisállatok számára létrehozott hash így néz ki:

%pet

Ha viszont egy kiválasztott állatkára akarsz hivatkozni -- mondjuk azt szeretnénk kitalálni milyen állatkája van Marynek -- azt így teheted meg:

$pet{"Mary"}

(A "Mary" nevet idézőjelek közé tettük, mert ez egy string, és ezt a számítógép csak így érti meg.)

A kifejezés tehát

$pet{"Mary"}

úgy értendő, hogy "Mary állatkája".

Lásd még:

Változókról általában - Skalárok (Scalars) - Listák (Lists) - Változók értékadása - Hash értékadása

Utasítások

Mondjuk egy barátodhoz készülsz, játszani. Az amit ilyenkor tenned kell, leírható egy cselekvési listával:

Kérj engedélyt a szüleidtől hogy meglátogathasd a barátod.
Hívd fel a barátodékat, hogy megkérd, átmehess hozzájuk.
Öltözz fel.
Menj át a barátodékhoz.
Vedd le a rágót a cipődről...
Üdvözöld a barátod.
Játssz a barátoddal.
Egyél egy kis rágcsálnivalót.
Játssz még.
Köszönj el.
Menj haza.
Vedd le a cipőd.

Amit most tettünk az nem más, mint hogy egy összetett cselekvést (ez most a látogatás) egyszerű cselekvések sorozatára bontjuk. Másképpen, így írhatjuk le kis lépésekkel, mit kell tenned hogy meglátogasd a barátod.

Amikor számítógépet programozol, ugyanezt teszed. A kis parancsokat utasításoknak (statements) nevezzük. Az utasítás nem más mint egy parancs, ami megmondja a számítógépnek hogy tegyen valami egyszerű dolgot, ami része valami nagyobbnak. (Mondjuk az előző felsorolásban az, hogy sétálj át a barátodékhoz, olyan mint egy utasítás)

Ahogy haladunk előre, egyre több utasításról fogunk tanulni. De először is legyünk biztosak abban, hogy értjük, mi is az utasítás: az utasítás a számítógépnek adott önálló parancs, része annak ahogyan megmondjuk a gépnek, hogy tegyen meg valamit. A látogatásunk leírásában minden sor, mint például a "Köszönj el" vagy a "Vedd le a cipődet" olyan mint egy utasítás. A teljes lista pedig, így együtt, pont olyan mint egy program.

Egy utolsó megjegyzés az utasításokról: magyarul egy mondatot leírva, a végére pontot ('.') teszünk. Perlben, és még sok programnyelvben a legtöbb utasítást pontosvessző (';') zárja. Például:

Ez a mondat olyan mint egy utasítás;

Lásd még:

Változók értékadása - Bemenet (Input) és kimenet (output) - Blokk (Blocks) - If-then - Ciklusok (Loops) - Szubrutinok (Subroutines)

Változók értékadása

Képzeljük el hogy matekórán, szöveges feladat megoldásakor a tanár valami ilyesmit mond: "Tegyük fel, van öt macskánk..." Vagyis itt arról van szó, hogy van valamilyen számú macskánk, és ez a szám ebben az esetben éppen öttel egyenlő.

Másképpen megfogalmazva amit a tanár mondott,

Legyen a macskák száma öt.

A macskák számának meghatározásához használhatunk egy változót. Tegyünk hát be egy változót:

Legyen a MacskákSzáma öt.

Vagy mondjuk kicsit másképp,

Legyen a MacskákSzáma egyenlő öttel.

A számítógép esetében elhagyhatjuk a 'legyen' szót, mert így is érthető marad a mondat.

MacskákSzáma egyenlő öt.

(Itt most nem egyszerűen azt állítjuk hogy a macskák száma egyenlő öttel. Most épp parancsoltuk hogy legyen annyi.)

Végül a Perl esetében egyenlőségjelet ('=') használunk amikor arra gondolunk hogy 'egyenlő', és számot használunk '5' ahelyett hogy leírnánk azt hogy "öt". Ne feledjük hogy a legtöbb utasítást pontosvesszővel zárjuk, és egy dollárjelet ('$') kell tennünk a skalár (scalars) változó elejére. Na akkor tehát tegyünk pontosvesszőt a pont helyére, és dollárjelet a változó elejére:

$MacskakSzama = 5;

Hát így kell ezt csinálni Perlben. Így most hozzárendeltünk a MacskákSzáma változóhoz egy értéket ami ebben az esetben az öt.

Persze rendelhetünk változót egyéb dolgokhoz is. Például, ha ismerjük a macskák számát, és tudjuk hány macska és kutya van összesen, akkor megtudhatjuk a kutyák számát egy egyszerű kivonással. Ha van összesen tizenhárom állatunk, és ebből öt macska, akkor a kutyák számát így fogjuk tudni kiszámolni:

$MacskakSzama = 5;
$AllatokSzama = 13;
$KutyakSzama = $AllatokSzama - $MacskakSzama;

A gép elvégzi a kivonást, és megadja a választ.

Megjegyzés: egy hozzárendelésnél (értékadásnál) az egyenlőségjel bal oldalán egy változó van, amit megváltoztatunk. A jobb oldalon nincs semmi ( hacsak ez nem a bal oldalon van, majd később erről még beszélünk) ami megváltozna.

Lásd még:

Utasítások - Skalár értékadás - Lista értékadás - Számtan - Függvények

Skalárok értékadása

Több módon is értéket adhatunk egy skalárnak (scalar). Hozzárendelhetsz a skalárhoz egy adott értéket:

$MacskakSzama = 5;
$MacskamNeve = "Cirmi";

De használhatsz értékadásra egy másik változót is:

$OrrokSzama = $EmberekSzama;

Ez megmondja a gép számára, hogy az orrok száma megegyezik az emberek számával. Vagy még egy lehetőség, hogy fogjuk az $EmberekSzáma változóban tárolt értéket és átmásoljuk az $OrrokSzáma változóba.

Van egy rakás dolog amit megtehetsz egy sztringgel. Az egyik fontos dolog, hogy összefűzhetsz két sztringet. Például, ha összefűzzük a következőket "A macskám neve" és " Cirmi" ezt kapjuk: "A macskám neve Cirmi"

Megfigyelted a szóköz karaktert az idézőjel és a "Cirmi" között? Ez a szóköz fontos. A számítógép nem tudja hogy a szavak közé szóközt kell tenni, hogy elválasszuk őket. Ha összefűzzük a következőket "A macskám neve" és "Cirmi" az extra szóköz nélkül, ezt kapjuk: "A macskám neveCirmi".

Perlben két sztringet összefűzhetsz ha pontot ('.') teszel közéjük. Például így is megkapjuk a teljes mondatot:

$TeljesMondat = "A macskám neve" . " Cirmi.";

Vagy másik módon,

$MondatEleje = "A macskám neve";
$MondatVege = "Cirmi.";
$TeljesMondat = $MondatEleje . " " . $MondatVege;

Láttad, mit csináltunk? Nem tettünk a "Cirmi" elé szóközt, viszont amikor összefűztük a két fél mondatot, közé betettünk egyet külön. Így aztán három sztring volt itt: $MondatEleje, " " (ez a sztring csak egy szóközből áll), és $MondatVege. Úgy fűztük össze ezeket, ahogyan összeadunk 3 + 2 + 1 -et hogy megkapjuk a 6-ot. Egy extra szóköz beszúrása hasznos lehet ha azt szeretnénk, hogy a szöveg jól nézzen ki.

Van még más módja is hogy a skalároknak értéket adjunk, erről még beszélünk majd a számtan és a függvények leírásánál.

Lásd még:

Változókról általában - Skalárok - Utasítások - Változók értékadása általában - Számtan - Listák értékadása - Hash értékadása - Függvények

Számtan

A Perl, mint sok más nyelv, lehetővé teszi számunkra hogy műveleteket végezzünk el számokkal. Lehet egy ilyen utasítás

$Atlag = ($ElsoSzam + $MasodikSzam + $HarmadikSzam) / 3;

és a komputer elvégzi a számítást. Összeadja a három számot, majd az eredményt elosztja hárommal. Az eredményt pedig az $Atlag változóban tárolja.

Észrevehetted, hogy zárójeleket használtunk -- miért szükségesek ezek? Azért, mert létezik valami amit úgy hívnak hogy műveleti sorrend. Mondjuk ki akarjuk számolni hogy mennyi 3 * 4 + 5. Rendben, de mit számolunk ki először -- összeszorozzuk a hármat a néggyel, vagy előbb összeadjuk a négyet az öttel? Ha előbb szorzunk, akkor azt kapjuk, hogy 3 * 4 = 12, 12 + 5 = 17. Vagyis az eredmény 17. De mi történik, ha előbb összeadunk? Akkor 4 + 5 = 9, és 3 * 9 = 27, tehát itt az eredmény 27. A szám amit kapunk, bizony függ a sorrendtől.

A zárójelek egy lehetőséget adnak arra, hogy megmondjuk a számítógépnek, mit tegyen elsőnek. Minden, ami egy zárójel páron belül van, hamarabb lesz kiszámolva, mint ami ezen a zárójelen kívül van. Továbbá minden ami egy belső zárójelpáron belül van, előbb lesz kiszámolva, mint ami a külsőbb zárójelpárban van. Ha például vesszük a következő számítást (((3 * 4) + 6) / 9), itt elsőnek a szorzást végezzük el 3 * 4 = 12, így kapjuk ((12 + 6) / 9); azután összeadunk 12 + 6 = 18, és kapjuk a végén (18 / 9), majd ha elvégezzük az osztást 18 / 9 = 2, kapjuk meg a végeredményt, ami 2.

Ahogyan most, úgy máskor is mindig arra kell használnod a zárójeleket, hogy megmondd a komputernek, mit kell tennie elsőnek. Használd a zárójeleket, hogy a számítógép pontosan tudja, milyen sorrendben kell tennie a dolgokat.

Két megjegyzés:

Először is, ha azt kéred, hogy számoljon ki valamit a gép ami tört számot fog eredményezni, (mint az 5/3) tizedesjegyet is kapni fogsz az eredményben. Általában ha a számolásban szerepel tizedesjegy, akkor az eredményben is fog. (Tizedessel a válasz többnyire kevesebb vagy több, mint aminek lennie kellene. Ez egy jellegzetes hiba a számítógépeknél.)

Másodszor, nem oszthatsz nullával. Ha mégis megpróbálod, akkor a program le fog állni. Az egy jó gyakorlat, hogy osztás előtt megvizsgáljuk, nem nulla-e az osztó (lásd if-then).

Ezért is hasznos, ha számtani műveleteket hajtunk végre, akkor azokat bontsuk a lehető legkisebb lépésekre. Sokkal jobb egy több soros, egyszerű lépésekből álló kalkuláció, mint egy hosszú, de zavaróan bonyolult.

Lásd még:

Skalár - Skalár értékadása - Feltételes utasítások - If-then

Listák értékadása

Van néhány ,ód, ahogyan értéket adhatsz egy listának. Az egyik módszer ilyen:

@Barataim = ("John", "Susan", "Mary");

A listához hozzárendelünk valamit, amit a nyitó zárójel ('('), néhány skalár vesszővel (',') elválasztva, egy záró zárójel (')'), valamint a pontosvessző (';') határoz meg. Természetesen használhatsz változókat, számokat, sztringeket is, mint itt:

@Szamok = ($UtolsoSzam, 9);

És persze ami egy listában van, azt is át lehet tenni egy másik listába. Mondjuk, írjatjuk ezt is:

@Ismerosok = (@Csaladom, @Barataim, "Jane", "Bob");

Így az ismerőseim listájában szerepelni fog a családom, a barátaim, plusz még Jane és Bob is.

Van egy dolog, amit gyakran meg kell tennünk, egy újabb elemmel bővíteni egy listát. Tegyük fel, hogy van egy új barátod, Fred, akit hozzá akarsz adni a barátok listához. Ezt így teheted meg:

@Barataim = (@Barataim, "Fred");

Akkor most megválaszolom azt a kérdésed, amit még fel sem tettél == hogyan lehet egyenlő a @Barátaim önmagával plusz Freddel a végén? Ez olyan mintha egy szám egyenlő lenne önmaga plusz eggyel.

A válasz tehát az, hogy az utasítást úgy kell olvasni, hogy "Legyen a @Barátaim új értéke egyenlő a @Barátaim régi értékével plusz "Fred" a végén. Ez lehetséges, és nagyon hasznos egy változót használni az egyenlőségjel ('=') mindkét oldalán ily módon.

Lásd még:

Változók általában - Listák - Utasítások - Változók értékadása általában - Skalár értékadása - Hash értékadása - Függvények

Hash értékadása

A Hash két mód egyikével kaphat értéket: az egyik emlékeztet a skalárok értékadására, a másik olyan, mint a lista hozzárendelés.

Vegyünk elő egy korábbi pédát ahol John, Sue, és Mary tart kutyát, macskát és aranyhalat. A legegyszerűbb mód, és ahogyan ezt a legtöbbet használnod kell (amíg ki nem növöd ezt a könyvet), azt mondani, hogy John állata kutya. Sue állatkája cica. Mary állata aranyhal." Perlben ezt így írjuk le:

$Allat{"John"} = "kutya";
$Allat{"Sue"} = "cica";
$Allat{"Mary"} = "aranyhal";

Emlékezzünk rá, hogy az $Allat{"John"}-t úgy olvassuk, hogy "John állata". Ezek szerint az utasítást úgy kell olvasni, hogy "Legyen John állata egy kutya".

A másik módszer, hogy tegyük egy kötegbe az értékadásokat -- ez akkor lehet hasznos, ha egy vázlatból készítesz hash-t. Ugyanannak a hash-nek a létrehozása tehát így is nézhet ki:

%Allat = ("John" => "kutya",
     "Sue"  => "cica",
    "Mary" => "aranyhal");

Feltűnt, hogy az utasítást több sorra bontottuk? Teljesen rendben van, ha egy utasítást több sorra osztunk, és szóközökkel formázunk. Így sokkal átláthatóbb lesz a kód. Ezt az eljárást "Spacing"-nek nevezzük.

Lásd még:

Változók általában - Hash - Utasítások - Változók értékadása általában - Skalárok értékadása - Listák értékadása - Függvények

Bemenet és kimenet (Input és output)

Egy nagyon fontos dolog amit egy programnak tudnia kell, hogy képes legyen figyelni, amit az ember mond neki, és képes legyen dolgokat közölni az emberrel.

Rengeteg különböző módszer létezik erre a célra, mi ebből csak a néhány legegyszerűbbet fogjuk megnézni. Ezek mind használják a billentyűzetet. Az egyik az amikor beolvas egy egész sort a billentyűzetről egy változóba -- ez az amikor mindent, amit a felhasználó begépel, a return leütéséig beolvas -- a másik az amikor kiír valamilyen speciális szöveget.

Lásd még:

Utasítások - Bemenet (Input) - Kimenet (Output)

Bemenet (Input)

Ahogyan én szeretném hogy használjuk a bemenetet, az a következő: mondjuk be akarunk olvasni egy egész sor szöveget amit a felhasználó gépel be, majd ezt betesszük a $UserResponse változóba. A következő két sorral tehetjük meg ezt:

$UserResponse = <>;
chomp $UserResponse;

Az első sor beolvassa a sort a $UserResponse változóba. Igen ám, de ez tartalmazza a return karaktert a sor végén, amire általában nincsen szükségünk. A második sor eltávolítja ezt a karaktert.

Általában valami ehhez hasonló két sor programmal lehet beolvasni egy sort amit a felhasználó gépel be.

Lásd még:

Utasítások - Skalár - Input és Output - Output

Kimenet (Output)

A print utasítás igen hasznos a kimenet kezelésére. Hadd mutassak egy igencsak híres programot példának:

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

Az első sor az a sor, amit minden Perl program elejére oda kell tenned. A második sor kiírja hogy "Helló, világ!", és ez pontosan az amiről most beszélünk.

Mi az a fura "\n"? Mit jelent ez? Rendben, a Perl nem tudja magától, hogy hol végződik egy sor. Ezért teszünk egy "\n" karaktert annak érdekében, hogy a tudassuk, itt egy új sort kell kezdenie.

Íme egy másik példa arra ahol a kód használja a print utasítást:

print "Az átlag " . $Atlag . ".\n";

Tehát mit is jelentenek ezek a sorok?

Jusson eszünkbe, hogy korábban amikor a skalárokról (scalars) beszéltünk, hogyan fűztünk össze két sztringet a pont ('.') segítségével, közéjük írva. Ez most három sztringből áll: "Az átlag", $Atlag, és az ".\n", és így rakjuk őket egybe. Mondjuk azt, hogy az $Atlag legyen 4.5. Ekkor az eredmény így fog kinézni:

Az átlag 4.5.

A "." a ".\n"-ben a mondat végét jelöli, a "\n" jelenti a sor végét.

Lásd még:

Utasítások - Skalárok - Input és output - Input

Folyamat irányítás

Sok programnyelvben létezik egy igen erőteljes utasítás, amit goto utasításnak nevezünk. Gyakran előfordul a programozásban, hogy a kód egy részén vagy, ahol áll egy rakás instrukció, és ezek szerint neked valahol máshol kellene lenned. Ilyenkor a programozó beszúr egy goto utasítást és hoppá! máris a program egy más részén találod magad.

Rendben van, a goto az nagyon erőteljes, de van vele egy kis gond. Ha úgy használod a goto utasítást, ahogy az adja magát, az eredmény olyan valami lesz, amit spagetti kódnak neveznek: a program ki-be járkál, egy nagy rendetlenségben gubancolódik össze, és lehetetlen lesz követni, akár a spagettit. Ennek eredményeképpen a kód tele lesz hibákkal, és lehetetlen javítani.

Éppen ezért a legtöbb esetben erősen javasolt elkerülni a goto utasítás használatát. A goto utasítást kockázatosnak tekintjük az egészségünkre, sok programozó sötét szónak tartja a goto utasítást.

Na de várjunk egy kicsit. A goto nagyon erőteljes. Ha azt mondjuk, hogy "nincs goto", akkor csak van valami helyette?

A válasz természetesen az hogy "Igen". Vannak egyéb lehetőségek amik hasonló eredményre vezetnek mint a goto -- csak sokkal jobban és átláthatóbban teszik azt. Sokkal könnyebben érthetőbbé teszik a dolgokat, és sokkal kevesebb hibát eredményeznek. Sőt ezek a hibák így jóval egyszerűben javíthatók.

Van két alapvető struktúra amivel ugyan azt érhetjük el mint a goto-val, csak sokkal jobban. Ennek a két struktúrának a neve feltételek és ciklusok, ezeket fogjuk most felfedezni. Vannak még szubrutinok és függvények, ezeket majd később vesszük, de ezek is igen hatékonyak.

Lásd még:

Utasítások - Blokkok - If-then - If-then-else - If-then-else lánc - Ciklusok - Foreach ciklus - While cilus - For ciklus

Blokkok

Mind a feltételes utasítások és ciklusok esetében is nagyon hasznos, ha az utasításokat csoportokba fogjuk össze. A kód egy blokkja nyitó kapcsos zárójellel ('{') kezdődik, és záró kapcsos zárójellel ('}') végződik. Érdemes még a blokk kódját behúzni (margót hagyni bal oldalon) kettő vagy négy szóközzel. Nem számít menyire fogod behúzni a kódot, de érdemes azonos behúzást alkalmazni mindenhol. Nézzünk akkor egy néhány utasításból álló programot:

print "Írj be valamit: "; # A \n hiánya szándékos, azt akarjuk hogy
                             # a kurzor maradjon ott a sor végén.
$UserInput = <>;
chomp $UserInput;
print "Ezt írtad " . $UserInput . ".\n";

Most pedig lássuk ugyanezt az utasítás csoportot, blokkba foglalva:

    {
    print "Írj be valamit: "; # A \n hiánya szándékos, azt akarjuk hogy
             # a kurzor maradjon a sor végén.
    $UserInput = <>;
    chomp $UserInput;
    print "You typed in " . $UserInput . ".\n";
    }

Magyarán ha blokkot akarunk létrehozni, akkor nyissunk egy { karakterrel, írjuk be a kódot, majd zárjuk le a blokkot a } jellel. Az egész dolgot pedig igazítsuk beljebb négy szóköznyit.

Lásd még:

For ciklus Utasítások - Folyamat irányítás - If-then - If-then-else - If-then-else lánc - Ciklusok - Foreach ciklus - While ciklus - For ciklus - Függvények

Feltételes utasítások

A feltételek lehetnek igazak vagy hamisak. A komputernek el kell tudnia döntenie, hogy valami igaz vagy hamis-e.

A feltételes utasításoknak számos különböző típusa van. Amiről kezdésnek beszélni fogunk az az egyezés. A kifejezés így néz ki:

($UserResponse == "i")

egy példa a feltételes utasításokra.

Feltételes utasításokban használhatunk and, or, és not operátorokat, valamint zárójeleket is. Íme itt egy példa egy kissé bonyolultabb kifejezésre:

(($Allatkam == "kutya") || ($Allatkam == "cica"))

A zárójeleket pontosan úgy kell használnod a feltételek esetében mint a számolásnál. Továbbá a zárójelek jelentése is többé-kevésbé azonos.

Most pedig látom a kérdésed. Miért használtunk dupla egyenlőségjelet? A válasz pedig az, hogy a Perl egyszeres egyenlőségjelet használ az értékadáshoz, és kettőt a feltételek kiértékeléséhez. Amikor egy egyenlőségjelet használsz, a Perl azt gondolja, értéket szeretnél adni valaminek. Ha például ezt írod::

($UserResponse = "i")

az fog történni, hogy értéket kap a $UserResponse változó, amely érték az "i" lesz, ahelyett hogy ellenőrizné, a $UserResponse értéke vajon "i"-e. Ez egy nagyon könnyen elkövethető hiba; mindig ellenőrizd, ha úgy tűnik, hogy a program hibásan működik.

Az If-then utasításpár, és a ciklusok különbözőként működnek, ha valami igaz. A feltételes utasítás olyan valami, ami lehet igaz vagy hamis, amit a Perl fel tud használni annak eldöntésére, hogy valami igaz-e, mert ha igaz akkor futtatja az if-then utasítást és a ciklusokat.

A skalárok feltételként is működhetnek. Az a skalár, aminek az értéke nulla, vagy egy üres sztring (olyan sztring ami nem tartalmaz egyetlen karaktert sem, még szóközt sem -- valahogy így néz ki ""), érthető 'hamis' értékűnek. Bármely más skalár értéke 'igaz' Általánosságban, az 1 jelentése 'igaz', a 0 jelentése 'hamis'.

Megjegyzés: a feltételek után nem kell pontosvesszőt tenni.

Lásd még:

Utasítások - Számtan - Folyamat irányítás - Blokkok - If-then - If-then-else - If-then-else lánc

If-then

Emlékezzünk vissza, amikor ismerkedtünk az utasításokkal, mit is beszéltünk hogyan menjünk el a barátunk házához? Elevenítsük fel azt a listát, amit a tennivalókról írtunk:

Kérj engedélyt a szüleidtől hogy átmehess a barátodhoz.
Hívd fel a barátodékat, hogy megkérd, átmehess hozzájuk.
Öltözz fel.
Menj át a barátodékhoz.
Vedd le a rágót a cipődről...
Üdvözöld a barátod.
Játssz a barátoddal.
Egyél egy kis rágcsálnivalót.
Játssz még.
Köszönj el.
Menj haza.
Vedd le a cipőd.

Nos, ebben a listában nincsenek döntések, pedig azok nagyon fontosak. Például csak akkor fogsz átmenni a barátodék házába, ha arra engedélyt kapsz, igaz?

Nosza, írjuk újra a listát az if-then logika szerint:

Kérj engedélyt a szüleidtől hogy átmehess a barátodhoz.
Ha a szüleid megengedik hogy átmenj a barátodhoz:
    {
    Hívd fel a barátodat, és kérj engedélyt hogy átmehess.
    Ha a barátod szülei megengedik hogy átmenj:
   {
   Öltözz fel.
   Menj át a barátodékhoz.
   Ha beleléptél egy rágógumiba:
       {
       Szedd le a rágót a cipőd talpáról.
       }
   Üdvözöld a barátod.
   Játssz a barátoddal.
   Egyetek rágcsát.
   Játsszatok még.
   Köszönj el.
   Sétálj haza.
   Vedd le a cipőd.
   }
    }

Ami most itt van előttünk, az egy módosított lista arról, hogyan látogasd meg a barátod, amiben figyelembe van véve hogy csak akkor teszel meg valamit ha az helyes -- például hogy csak akkor mész át hozzájuk, ha van rá engedélyed.

A szintaxis Perlben a következő:

if (feltétel)
    {
    végrehajtandó kód, ha a feltétel igaz
    }

Az "if" utasítást pontosan így kell begépelni, kisbetűvel 'i', és a végrehajtandó kódot kapcsos zárójelbe kell foglalni. A Perl ilyenkor, ha ezt látja megnézi hogy a feltétel igaz-e, és ha igen, végrehajtja a blokkot amit a zárójelek jelölnek ki.

Lásd még:

Utasítások - Folyamat irányítás - Blokkok - Feltételes utasítások - If-then-else - If-then-else lánc

If-then-else

Feltételezzük azt, hogy valamit csinálni akarok egy programnyelvben. A pszeudokód valami ilyesmi lehet:

if (tudom, hogyan csináljam meg)
    {
    tedd ezt;
    }
else
    {
    próbáld meg kitalálni, hogyan hogyan tedd meg ezt;
    }

Van valami amit akkor akarok csinálni, ha a feltétel igaz, és egy másik valami amit akkor, ha a feltétel hamis. Ennek ez a helyes szintaktikája:

if (feltétel)
    {
    kód blokk, amit akkor kell végrehajtani ha a feltétel igaz
    }
else
    {
    kód blokk, amit akkor kell végrehajtani ha a feltétel hamis
    }

Lásd még:

Utasítások - Számtan - Folyamat irányítás - Blokkok - Feltételek - If-then - If-then-else lánc

If-then-else lánc

Van még egy lépés ha if-then-else szerkezetet használunk. Ezt a következő kódrészlettel mutatjuk be:

if ($Allatka == "kutya")
    {
    print "Vau, vau!\n";
    }
elsif ($Allatka == "cica")
    {
    print "Miaú, miaú!\n";
    }
elsif ($Allatka == "aranyhal")
    {
    print "Locs-pocs!\n";
    }
else
    {
    print "Nem tudom milyen hangot ad az állatkád.\n";
    }

Néha előfordul, hogy kettőnél több dologból kell választanod -- akárcsak most, kettőnél több fajta állatka is előfordulhat. Az if-then-else lánc ideális ehhez a következők szerint; a program megnézi, hogy az első feltétel igaz-e, ha ez hamis, akkor megnézi a második feltételt hogy az igaz-e, és így tovább… Az általános szintaktikája a következő:

if (első feltétel)
    {
    végrehajtandó kód ha a feltétel igaz
    }
elsif (második feltétel)
    {
    végrehajtandó kód ha az első feltétel hamis, de a második feltétel igaz
    }
…
elsif (utolsó feltétel)
    {
    végrehajtandó kód ha az eddigi összes feltétel hamis volt, de az utolsó fetétel igaz
    }
else
    {
    végrehajtandó kód, ha az feltételek közül egyik sem volt igaz.
    }

Az utolsó else elhagyható ugyan, de ajánlott odaírni.

Lásd még:

Utasítások - Számtan - Folyamat irányítás - Blokkok - Feltételek - If-then - If-then-else

Ciklusok

A ciklus az olyan valami, amit akkor használunk, ha ugyan azt a kódot akarjuk futtatni több dolog miatt. Itt egy példa arra, hogy télen hogyan öltözünk fel rétegesen:

while (van újabb ruha amit fel kell venni)
    {
    Újabb ruhát választasz amit felveszel.
    Emeld fel.
    Bújj bele.
    }

Különböző célokra különböző ciklusok léteznek.

Lásd még:

Utasítások - Folyamat irányítás - Feltételek - Foreach ciklus - While ciklus - For ciklus

Foreach ciklusok

A ciklusok egyik hasznos típusa egy lista minden elemével teszi ugyanazt a dolgot. Íme egy példa, hogyan rakhatunk össze egy kódot arra öltözködjünk fel télen a szánkózáshoz,

@WinterClothing = ("kabátot", "vastag zoknit", "csizmát", "kesztyűt", "sálat", "sapkát");
foreach $ArticleOfClothing (@WinterClothing)
    {
    print "Felveszem a  $ArticleOfClothing.\n";
    }

Mielőtt megvizsgálnánk hogyan is működik ez a ciklus, nézzük meg, mit is csinál. Ki fogja írni a következőket:

Felveszem a kabátot.
Felveszem a vastag zoknit.
Felveszem a csizmát.
Felveszem a kesztyűt.
Felveszem a sálat.
Felveszem a sapkát.

Egy rakás dolog történik itt..

Először is egy listát hozunk létre.

Azután végigmegyünk egy cikluson többször is -- minden esetben a $ArticleOfClothing változó megkapja egy elemét a @WinterClothing listának, majd végrehajtódik a kód blokkja.

Ebben a kódban amikor a Perl meglátja a $ArticleOfClothing változót, az behelyettesítődik a változó értékével, vagyis az $ArticleOfClothing változó felveheti a "kesztyű", "sapka" stb. értéket. Első alkalommal tehát a "Felveszem a $ArticleOfClothing.\n" a "Felveszem a kabátot.\n", szöveggé válik, ahol a "\n" azt mondja meg a Perlnek, hogy ez itt a sor vége.

A Foreach ciklust tehát akkor használjuk, amikor egy lista összes elemével ugyanazt a dolgot akarjuk tenni.

Lásd még:

Utasítások - Lista - Folyamat iránytás - Blokkok - Ciklusok - While ciklus - For ciklus

While ciklus

A while ciklus egy olyan ciklus, ami akkor hajtódik végre amíg a feltétel igaz. Például:

$Folytassuk = "i";
$AhanyszorACiklusLefutott = 0;
while (not($Folytassuk == "n"))
    {
    ++$AhanyszorACiklusLefutott;
    if ($AhanyszorACiklusLefutott == 1)
   {
   print "A cilus első alkalommal futott le.\n";
   }
    else
   {
   print "A ciklus lefutásának száma $AhanyszorACiklusLefutott.\n";
   }
    print "Futtassuk újra a ciklust (i/n)? ";
    $Folytassuk = <>;
    chomp $Folytassuk;
    }

Akkor hát nézzük, mit is csinál ez a ciklus.

A $Folytassuk változó értéke mondja meg, hogy folytassuk-e tovább a futtatást. Az "n" jelenti a "nem" választ, vagyis hogy álljon le a ciklus, minden más esetben folytatjuk. A ciklus azt mondja tehát, "Amíg folytatnom kell".

Az $AhanyszorACiklusLefutott változó értékét beállítjuk 0-ra mielőtt a ciklus elkezdődne. Azután az első dolog a ciklusban, hogy a "++$AhanyszorACiklusLefutott;" utasítással megnöveljük a $AhanyszorACiklusLefutott változó értékét eggyel. Általánosan, a kifejezés:

++$változó név;

ahol a változó név egy "skalár" változó neve, jelentése "növeld a változó neve értékét eggyel."

Azután van egy feltételünk is. A feltétel kiértékelésnél a program látja, hogy első alkalommal fut le a ciklus. Miért csináljuk ezt?

Az if utasítás utáni blokk utasítása az első lefutást jelzi szövegesen, míg az else utáni blokk kiírja számmal a lefutások számát. Vagyis az első körben a program ki fogja írni:

A ciklus első alkalommal futott le.

de másodjára, harmadjára stb. valami ilyesmit fogunk kapni:

A ciklus lefutásának száma 2.

Majd ez után rákérdez, hogy akarjuk-e még folytatni a futtatást. Majd pedig beolvas egy értéket a $Folytassuk változóba -- ha a felhasználó "i"-t gépel be, $Folytassuk értéke "i" lesz, ha a felhasználó "n"-t ír be, $Folytassuk értéke "n" lesz.

Ezek után a program ellenőrzi, hogy kell-e folytatnia (a feltétel közvetlen a "while" szó mellett áll), és ha kell, lefuttatja a ciklust újra.

Lásd még:

Utasítások - Folyamat irányítás - Blokkok - Feltételek - If-then-else - Ciklusok - Foreach ciklus - For ciklus

For ciklus

A for ciklus a while ciklus egy speciális formája, akkor használjuk, ha meg van adva hogy valamit hányszor kell végrehajtani.

Tegyük fel, hogy ki szeretném íratni tízszer a szöveget, hogy "Helló világ". Ezt tíz sorban lehet megtenni, így:

print "Helló, világ!\n";
print "Helló, világ!\n";
print "Helló, világ!\n";
print "Helló, világ!\n";
print "Helló, világ!\n";
print "Helló, világ!\n";
print "Helló, világ!\n";
print "Helló, világ!\n";

Ez OK, de mi van ha meg akarom változtatni a kiírások számát -- mondjuk ötre, vagy ötvenre? Hát az elég sok szerkesztési munka lenne.

Van erre jobb módszer is. Meg tudjuk mondani a számítógépnek, hogy számoljon el tízig, és közben mindig írja ki hogy "Helló világ!". Ha ezt tesszük, akkor megváltoztatni a kinyomtatások számát csak annyit jelent, hogy megváltoztatni azt a számot, ameddig a gép elszámol.

Hadd mutassak egy kódot ami ezt teszi, aztán majd elmagyarázom, hogyan.

for($CurrentLine = 0; $CurrentLine < 10; ++$CurrentLine)
    {
    print "Helló, világ!\n";
    }

Ez a teljes kód, ami megteszi a fent elvártakat. És mi van akkor ha a "Helló, világ" szöveget mondjuk ezerszer szeretném kiíratni? Nagyon egyszerű -- átírjuk a 10-et 1000-re:

for($CurrentLine = 0; $CurrentLine < 1000; ++$CurrentLine)
    {
    print "Helló, világ!\n";
    }

Nos, akkor elmagyarázom, mi is történik itt. Nézzük az első sort. Ennek a formátuma a következő:

for(első rész; második rész; harmadik rész)

Három része van, pontosvesszővel (';') elválasztva. Mindhárom rész másért felel.

Az első rész pontosan egyszer fut le. Ez arra való, hogy dolgokat beállítsunk vele -- ebben az esetben hogy hozzárendeljük a skalár változóhoz az értékét, ami jelen esetben nulla.

Hogy a későbbiekben is megértsük, amikor programozunk, ezért tisztázzuk most, hogy a számítógépnek nullától kell kezdenie a számolást. Tehát ahelyett hogy 1-től számoltatnánk 10-ig, 0-tól fog számolni 9-ig -- ez is pont tíz alkalmat jelent.

A második rész tartalmazza a feltételt amit a gép ellenőriz minden alkalommal amikor lefut a ciklus. Ebben az esetben egy számtani állítást ellenőriz: a CurrentLine értéke kevesebb-e mint 10. Ahogy a ciklus fut, a komputer ellenőrzi, hogy a második rész igaz-e -- ha igaz, lefuttatja még egyszer a ciklust.

A harmadik részben lévő dolgot a gép minden alkalommal elvégzi, miután a ciklus lefutott, és mielőtt ellenőrizné a második részben foglalt feltételt. Ebben az esetben ez a rész megnöveli a $CurrentLine értékét eggyel.

Összegezve tehát a számítógép elszámol nullától kilencig, miközben minden alkalommal kiírja a "Helló világ!" üzenetet.

Lásd még:

Utasítások - Skalár - Skalár értékadása - Számtan - Folyamat irányítás - Blokkok - Feltételek - Ciklus - Foreach ciklus - While ciklus

Szubrutinok és függvények

Amikor megtanultál sétálni, egy kicsit kemény volt tanulni -- de ha már egyszer megtanultál, akkor ismered a módját hogy bárhová eljuss (persze adott határokon belül), bármilyen felületen (szintén adott korlátok között). Megtanultál úgy általában járni, és nem kell újra tanulnod ezt, ha valami újjal találkozol.

A számítógép esetében mindig találsz rengeteg dolgot, amit sokszor akarsz majd elvégezni, különböző helyeken - miközben ez valóban teljesen ugyan az a dolog. A szubrutinok és a függvények segítségével mini programokat írhatsz -- és innen kezdve erndelkezésedre fog állni egy új utasítás, ami csak egy sor, amikor erre a dologra lesz szükséged.

A szubrutinok igen jól használhatóak. A szubrutinok nagyon jók. Ha úgy látod, hogy valamit egynél többször kell majd megcsinálnod, máris érdemes belőle szubrutint készítened magadnak.

Lásd még:

Változók - Utasítások - Folyamat irányítás - Blokkok - Argumentumok - Szubrutinok - Függvények

Argumentumok

Néhány szubrutin és függvény adatokat, információkat kér a működéséhez. Például lehet hogy van egy szubrutinod, amivel meg tudod mondani az alma, narancs és banán árát -- de ehhez előbb meg kell mondanod neki, hogy mennyi almáról, narancsról vagy banánról van szó.

Na erre való, amikor a szubrutinokat vagy függvényeket ellátjuk argumentumokkal. Szubrutint vagy függvényt úgy tudunk használni, hogy egy ('&') jelet teszünk a nevük elé, majd jön a nevük, végül az argumentumok listája lista. Például az előbb említett szubrutint így hívhatjuk segítségül:

&TellPrice($NumberOfApples, $NumberOfOranges, $NumberOfBananas);

Azt is meg fogjuk nézni, hogyan kell egy szubrutint megírni, mégpedig itt.

Lásd még:

Változók - Skalárok - Listák - Folyamat irányítás - Szubrutinok és függvények - Szubrutinok - Függvények

Szubrutinok

A szubrutin egy miniatűr program amit a saját programodon belül futtathatsz. Korábban már beszéltünk arról az eljárásról, ami megmondja az árát valamilyen menyiségű gyümölcsnek. Álljon hát itt hogy hogyan kell megírni egy ilyen eljárást. Mielőtt az eljárást használnánk, tételezzük fel, hogy van egy olyan kódrészlet, ami megadja a különböző gyümölcsök egységárát:

$PricePerApple = .25;
$PricePerOrange = .30;
$PricePerBanana = .20;

És itt a szubrutin maga:

sub TellPrice()
    {
    $NumberOfApples = shift(@_);
    $NumberOfOranges = shift(@_);
    $NumberOfBananas = shift(@_);
    @RemainingArguments = @_;
    $PriceForApples = $NumberOfApples * $PricePerApple;
    $PriceForOranges = $NumberOfOranges * $PricePerOrange;
    $PriceForBananas = $NumberOfBananas * $PricePerBanana;
    $TotalPrice = $PriceForApples + $PriceForOranges + $PriceForBananas;
    print "A gyümöcsök teljes ára $TotalPrice.\n";
    }

Akkor most nézzük át részről-részre:

    $NumberOfApples = shift(@_);
    $NumberOfOranges = shift(@_);
    $NumberOfBananas = shift(@_);
    @RemainingArguments = @_;

Ez a szakasz találja ki hogy mely argumentumokat használ az eljárás, és a megfelelő változókba tárolja le őket. Ezt rögtön a szubrutin elején meg kell tennünk; a szintaxisa a következő:

&TellPrice($NumberOfApples, $NumberOfOranges, $NumberOfBananas);

A szubrutin azon része, amelyik bekéri az argumentumokat, a következőképpen néz ki:

    $első argumentum = shift(@_);
    $második argumentum = shift(@_);
    $harmadik argumentum = shift(@_);
    …
    @RemainingArguments = @_;

ahol az első argumentum, második argumentum, és így tovább, végig sorban az argumentumok listáján.

Miután kitaláltuk, milyen argumentumokkal dolgozunk, a szubrutin elvégez néhány számítást hogy megállapítsa a teljes árat, aztán kiírja azt.

Még egy dolog… A program elején deklarálnod kell a szubrutint, a következő sor szerint:

sub &TellPrice();

Lásd még:

Utasítások - Folyamat irányítás - Blokkok - Szubrutinok és függvények - Argumentumok - Függvények

Függvények

A szubrutinok egyik igen hasznos típusa az, amelyik elvégez valamilyen kalkulációt, vagy valami olyasmit, és egy eredményt ad válaszként vissza. Például, tegyük fel, hogy az előző gyümölcs üzlet példánkban szereplő teljes árat egy változóhoz szeretnénk hozzárendelni. Pontosan erre valók a függvények.

A függvények használatához valami ilyesmire van szükség:

$TotalPrice = &CalculatePrice($NumberOfApples, $NumberOfOranges,
  $NumberOfBananas);

Így a CalculatePrice függvény nagyjából azonos a TellPrice eljárással. Íme a változások listája vastaggal kiemelve:

sub CalculatePrice()
    {
    $NumberOfApples = shift(@_);
    $NumberOfOranges = shift(@_);
    $NumberOfBananas = shift(@_);
    @RemainingArguments = @_;
    $PriceForApples = $NumberOfApples * $PricePerApple;
    $PriceForOranges = $NumberOfOranges * $PricePerOrange;
    $PriceForBananas = $NumberOfBananas * $PricePerBanana;
    $TotalPrice = $PriceForApples + $PriceForOranges + $PriceForBananas;
    return $TotalPrice;
    }

Most ahelyett hogy kinyomtatná, a szubrutin visszatér az eredménnyel. ehát a program azon része, amelyik meghívta ezt a rutint, meg fogja kapni az eredményt, amint az rendelkezésre áll.

Másik hasznos fügvény lehet a felhasználó válaszának bekérését végző program. Ez a szubrutin nem mondja meg a felhasználónak, mire vonatkozik a kérdés, azt a rutin meghívása előtt nekünk kell megtennünk.

sub confirm()
    {
    $UserAnswer = <>;  # Beolvassa a felhasználó válaszát.
    chomp $UserAnswer;
    if ((not($UserAnswer eq "n")) and # Ellenőrizzük hogy a válasz igen vagy nem
      (not($UserAnswer eq "i")) and
      (not($UserAnswer eq "N")) and
      (not($UserAnswer eq "I")))
   {
   while ((not($UserAnswer eq "n")) and # Tegyük ezt addig míg Igent vagy
     (not($UserAnswer eq "i")) and      # nem-et kapunk.
     (not($UserAnswer eq "N")) and
     (not($UserAnswer eq "I")))
       {
       print "Válaszolj \"i\"-t az igen, \"n\"-t a nem válaszhoz.\n";
       $UserAnswer = <>;
       chomp $UserAnswer;
       }
   }
    # Ha eljutottunk idáig, akkor a felhasználó igen vagy nem választ adott.
    return (($UserAnswer eq "I") or ($UserAnswer eq "i"));
    }

Ez az eljárás megbizonyosodik arról, hogy a felhasználó igen vagy nem választ adott, majd annak a feltétel vizsgálatnak az eredményével tér vissza, hogy a válasz igen volt-e. Példaként lássuk most a következő kódot:

print "Akarod folytatni? (i/n)? ";
if (&confirm())
    {
    print "Folytatás...\n";
    }
else
    {
    print "Viszlát!\n";
    exit 0;
    }

Ez a kódrészlet azt kérdezi a felhasználótól, hogy szeretné-e folytatni. Ha a válasz igen, akkor kiírja "Folytatás...", és a program folytatódik. Ha a válasz nem, akkor kiírja "Viszlát!", és kilép.

És ennyi amit a programozásról röviden el akartam mondani. Lépjünk tovább és nézzünk meg néhány példaprogramot, majd kezdjünk neki a kontárkodásnak!

Lásd még:

Utasítások - Változók - Folyamat irányítás - Blokkok - Szubrutinok és függvények - Argumentumok - Szubrutinok