Fő tartalom

Programozás

Tantárgy/kurzus: Programozás > 1. témakör

10. lecke: Függvények

Áttekintés: Függvények

Az alábbiakban áttekintjük mindazt, amit a függvényekről szóló interaktív videóban tanultunk.

Gyakran szeretnénk egy adott kódblokkot újra meg újra futtatni programírás közben, anélkül, hogy a kódblokkot többszöri alkalommal beillesztenénk a programunkba. Emiatt olyan megoldásra van szükségünk, amellyel a kódunkat egy csoportba, névvel ellátva rendezhetjük, majd később pedig meghívhatjuk azt. Ez a függvények feladata lesz.

Ahhoz, hogy először létrehozzunk egy függvényt, deklarálnunk kell azt, el kell hogy nevezzük ugyanolyan módon, ahogy a változókat, azután pedig a függvény definícióját kell megadnunk.

var sayHello = function() {
};

Akármilyen kódot írhatunk ebbe a függvénybe - egy utasítást, több utasítást - attól függően, hogy mit várunk a függvénytől. Az alábbi függvényben egy üzenetet íratunk ki véletlenszerű helyre:

var sayHello = function() {
   text("Helllllllo!", random(200), random(200));
};

Nos, hogyha csak definiálunk egy függvényt, akkor semmi sem fog történni. Ahhoz, hogy a programunk futtassa a kódot, mely a függvény kódblokkjában található, a programozónak "hívnia" kell a függvényt, a függvény nevével és üres zárójel használatával.

sayHello();

Ezután pedig hívhatjuk a függvényünket, amikor akarjuk és ahányszor csak akarjuk!

sayHello();
sayHello();
sayHello();

Gyakran szeretnénk egyedi függvényeket létrehozni, esetleg azt mondani a programnak, hogy "futtasd le ezt a kódblokkot, de változtass meg pár dolgot!" Ezzel a módszerrel kódunk újra felhasználhatóvá és rugalmasabbá válik. Ezt úgy tudjuk elérni, hogy "argumentumokat" határozunk meg a függvények létrehozásánál, majd ezeket az argumentumokat felhasználhatjuk függvényeink működésének megváltoztatására, valamint átadhatjuk az argumentumokat, amikor a függvényeinket hívjuk.

Például mi lenne akkor, hogyha pontosan meg szeretnénk határozni, hogy hol jelenjen meg az üzenetünk, éppen úgy, ahogyan meg tudjuk határozni, a rect() és az ellipse() függvények által alkotott alakzatok helyzetét? Az alábbi módon képzelhetjük el az üzenet két, pontos koordinátán történő megjelenítését:

sayHello(50, 100);
sayHello(150, 200);

Ahhoz, hogy az előző kód működjön, meg kell változtatnunk a sayHello függvény definícióját, olyan módon, hogy 2 argumentumot vegyen át, és ezeket a függvény belsejében használja.

var sayHello = function(xPos, yPos) {
   text("Helllllllo!", xPos, yPos);
};

Az argumentumok, melyeket a függvény kap, lényegében változók lesznek a függvényen belül. A nevük attól függ, hogy minek nevezzük el a zárójelben őket. Ezért akár adhatunk nekik valamilyen rövidebb nevet is:

var sayHello = function(x, y) {
   text("Helllllllo!", x, y);
};

Függvényeink tetszőleges mennyiségű argumentumot tartalmazhatnak - nullát, egyet, kettőt, vagy akár többet. Úgy is határozhattunk volna, hogy függvényünket megváltoztatjuk annak érdekében, hogy egy nevet vegyen át, melyet később üdvözlünk:

var sayHello = function(name) {
   text("Helllllllo, " + name, random(200), random(200));
};

Majd így hívhattuk volna:

sayHello("Winston");
sayHello("Pamela");

Akár kombinálhatjuk ezeket az ötleteket, és három argumentumot is elfogadtathatunk függvényünkkel a névnek és a pozíciónak.

var sayHello = function(name, x, y) {
   text("Helllllllo " + name, x, y);
};

Azután pedig ilyen módon hívhatjuk a függvényt:

sayHello("Winston", 10, 100);

A függvények létrehozása valójában azon múlik, hogy milyen tudással szeretnéd függvényeid felruházni, és hogy mennyire szeretnéd azokat testre szabni. Legtöbb esetben kezdhetünk argumentum nélkül, majd mikor szükségünk lesz rájuk, akkor hozzáadhatunk függvényeinkhez tetszőleges számú argumentumot.

Nos, az eddigiekben te is függvényeket használtál - ennek köszönhetően hoztál létre rajzokat, animációkat - mint például rect, ellipse, triangle stb. Az előbb említett függvények a ProcessingJS könyvtárból származnak, melyeket mindegyik programba betöltünk, így mindig tudod őket használni. Mi definiáltuk a függvényeket számodra, mivel úgy gondoltuk, hogy hasznos lesz, és most már tőled függ, hogy milyen egyedi függvényeket szeretnél használni saját programjaidban. Például mi biztosítjuk az ellipse függvényt, de ezzel szemben nem biztosítjuk a cat függvényt - ha a programod sok különböző macskát tartalmaz különböző elhelyezkedéssel, akkor hozd létre a saját "cat" függvényedet!

Van még egy erős tulajdonsága a függvényeknek - felhasználhatjuk őket, hogy átvegyenek egy értéket, számoljanak azzal, majd visszatérjenek egy új, a számítás során keletkezett értékkel. Gondold végig, hogy mennyi műveletet lehet akár egy számológéppel végezni - összeadni értékeket, kivonni, kiszámolni egy szám négyzetgyökét, szorozni, stb. Mindezek megvalósíthatóak függvényekkel is, melyek bemenetet vesznek, elvégeznek egy adott műveletet, majd az eredményt visszaadják. A függvények a bemenetet argumentumként kezelnék, majd az eredményt pedig egy visszatérési utasítással közölnék. Az alábbi függvény két számot ad össze, majd az eredménnyel tér vissza:

var addNumbers = function(num1, num2) {
  var result = num1 + num2;
  return result;
};

var sum = addNumbers(5, 2);
text(sum, 200, 200); // Kiírja, hogy 7 (a két szám összege)

A visszatérési utasítás két feladatot lát el: visszaad egy értéket, annak ami hívta (ezért tudjuk tárolni a visszatérési értéket egy sum nevezetű változóban), majd azonnal megszakítja a függvény végrehajtási menetét. Emiatt ha az alábbi módon hozunk létre függvényt, a visszatérési utasítás után található kód nem kerül végrehajtásra:

var addNumbers = function(num1, num2) {
  var result = num1 + num2;
  return result;
  result = result * 2; // semmi értelme!
};

Azok a függvények, melyek visszatérési értékkel rendelkeznek, kifejezetten hasznosak olyan programokban, melyekkel adatokat szeretnénk valamilyen módon manipulálni, változtatni. Ezen felül, kifejezésekben is használhatunk egy adott függvényt - akár többször is -, ily módon:

var biggerSum = addNumbers(2, 5) + addNumbers(3, 2);

Akár még függvényeket is megadhatunk függvényhívásokban, habár néha ez nehezen olvasható kódot eredményez:

var hugeSum = addNumbers(addNumbers(5, 2), addNumbers(3, 7));

Most, hogy már tudod, hogyan hozunk létre olyan függvényeket, melyek kódblokkokat tartalmaznak, egy másik fontos fogalmat kell felvetnünk: a lokális változó és a globális változó közötti különbséget.

Ha új változót hozunk létre a függvényen belül, akkor az a változó lokális változó. Ez azért van, mert csak az az egy függvény képes a változót kezelni, a program többi része nem. Amikor a program végrehajtási menete elhagyja a függvényt, akkor a változó lényegében már nem létezik többé. Az alábbi függvényben localResult lokális változóként van jelen.

var addNumbers = function(num1, num2) {
  var localResult = num1 + num2;
  println("The local result is: " + localResult);
  return localResult;
};
addNumbers(5, 7);
println(localResult); // error, nem elérhető a változó a globális hatókörben!

Ha lefuttatjuk az előbbi kódot, a program végrehajtási folyamata az utolsó sornál hibát mutat: "localResult is not defined" (localResult nincs meghatározva). A változó csak a függvényen belül létezik, mivel ott lett létrehozva a var localResult = sorral, és a függvényen kívül nincs definiálva.

Ha függvényeken kívül hozunk létre egy változót, akkor globális változót hozunk létre. Az elnevezést onnan kapta, hogy minden függvény hozzáférhet, és bármiféle műveletet végezhet a változóval.

var globalResult;

var addNumbers = function(num1, num2) {
  globalResult = num1 + num2;
  println("A globális eredmény az alábbi: " + globalResult);
};
addNumbers(5, 7);
println(globalResult);

Ha az előbbi kódot lefuttatjuk, nem fogunk hibát kapni a program futtatása közben, mivel a globalResult változót a függvényen kívül hoztuk létre, így akármikor hozzáférhetünk.

⚠️ Lehet, hogy kísértésbe esel majd, hogy mindenre globális változót használj, hiszen így sosem fogsz olyan hibaüzenetet kapni, hogy a változód nem definiált. Viszont az az igazság, hogy a globális változók nagyon gyakran okoznak nehezen megtalálható hibákat. Nagyobb méretű vagy együttműködésben készülő programoknál nagyon könnyű elveszteni a fonalat annak kapcsán, hogy hol és hogyan használtál (vagy használtak mások!) globális változókat. Ahol lehetséges, használj lokális változókat.

Minden programozási nyelv különböző, de a JavaScript esetében, fontos tudni, hogy a változók rendelkeznek „függvény értelmezési térrel” - egy függvény hozzáférhet azokhoz a változókhoz melyek a függvény kódblokkjában lettek létrehozva, és a globális változókhoz is, melyek természetesen a függvényen kívül lettek létrehozva, azonban nem látja azokat a változókat, melyek más függvényekben lettek létrehozva.

Szeretnél részt venni a beszélgetésben?

Jelentkezz be

Rendezés:

Még nincs hozzászólás.

Tudsz angolul? Kattints ide, ha meg szeretnéd nézni, milyen beszélgetések folynak a Khan Academy angol nyelvű oldalán.