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!"

Eben a viccben a munkáas 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) ('#') 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öb 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) - Lista (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 nyomonkö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 haszá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, sztringket 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 renben 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ő: nmondjuk 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 programnyelvebn 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észeteen 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 vezérlés - If-then - If-then-else - If-then-else lánc - Ciklusok - Foreach ciklus - While ciklus - For ciklus - Függvények