Nem csoda, hogy ezt a cikket „Funkciók a programozás szerves részeként” neveztem el, mert nélkülük véleményem szerint egyetlen nyelvnek sincs joga létezni. Mi az? A függvény egy jól megírt program fő építőköve. Ez nemcsak megkönnyíti a kód olvasását, hanem gyökeresen megváltoztatja az elképzelést is strukturált programozás. A függvények segítségével újra felhasználhatja a program egyes részeit, ha bármilyen paramétert átad nekik. Semmilyen komoly program nem képzelhető el a programozási elem e csodája nélkül.

Röviden elmondom, hogyan működik. A függvény egy utasításblokk, amelyet a program meghívhat. Ennek a blokknak a fejlécének elérésekor (a függvény neve) lefut, és végrehajt néhány, a programozó által meghatározott műveletet. Ezt követően ez a blokk visszaadja a kapott értéket és továbbadja a főprogramnak. Hadd magyarázzam el a gyakorlatban.

Nagyjából így néz ki minden. röviden elmagyarázom. Létrehozunk néhány változót, és hozzárendeljük a myfunc függvény végrehajtásának eredményét, amely viszont kiszámítja egy szám négyzetre emelésének értékét. A függvények nem hajtódnak végre azonnal a program indításakor, hanem csak akkor, amikor meghívják őket. Talán egy kicsit zavaró, de ez van.

Hogyan hívjunk függvényt?

Egy függvény meghívásához létre kell hozni azt. Bár vannak beépített funkciók is. Például ez: cos, sin, md5, count, abs stb. Meghívásukhoz csak a kívánt értéket kell hozzárendelnie a változóhoz.

A függvényargumentum az az érték, amelyet a meghívásakor átad neki. A függvényargumentumok zárójelben vannak. Függvény létrehozásakor meg kell adni az argumentumok feltételes nevét. Ezután ezek a nevek használhatók a függvénytörzsben helyi változóként. Térjünk vissza azokhoz a függvényekhez, amelyeket a felhasználó saját maga hoz létre. Ez nagyon könnyen megtehető. Először is létrejön a függvény törzse:

A hello() függvény ( visszhangja "Hello, world!"; )

Akkor hívjuk. És ha nincsenek paraméterei, akkor csak zárójelet teszünk. A függvény meghívásához csak a következő sort használjuk: Szia();. Bármely függvény is visszaadhat értéket a használatával fenntartott szó Visszatérés. Ez az utasítás leállítja a függvény végrehajtását, és elküldi a visszatérési értéket a hívó programnak. function sum($first, $second) ($r=$first + $second; return $r;) echo sum(2,5); a program végrehajtásának eredménye egyenlő lesz 7. Lokális és globális változók

Mint minden más programozási nyelvben, vannak olyan változók, amelyek csak a függvényen belül érhetők el, és olyan változók, amelyek magában a program kódjában érhetők el. Az ilyen változókat helyinek, illetve globálisnak nevezzük. Egy függvényen belül nem csak egy olyan változóhoz férhet hozzá, amelyet azon a függvényen kívül hoztak létre. Ha ezt megpróbálja megtenni, akkor létrehoz egy új változót ugyanazzal a névvel, de helyileg a függvényhez.

$per="Dima"; function primer() // Do: helyi változó kimenete ( echo "A nevem ".$per; ) echo primer();

Ebben az esetben a „My name is” kifejezés jelenik meg a képernyőn. Ez azt jelenti, hogy a primer függvényen belül létrejött a $per változó, és alapértelmezés szerint hozzá lett rendelve nulla érték. Az ilyen akadályok elkerülése érdekében az operátort kell használni globális. Javítsuk ki ennek megfelelően a fenti kódot:

$per="Dima"; function primer() // Végrehajtja: globális változó kimenet ( global $per; echo "A nevem ".$per; ) echo primer();

Most már mindennek rendben kell lennie - a probléma megoldva. Csak ne felejtsük el, hogy ha a függvény megváltoztatja egy külső változó értékét, akkor ez a változás az egész programot érinti, ezért ezt az operátort óvatosan kell használni!

Két vagy több argumentummal rendelkező függvények

A függvénynek átadott argumentumok egy része opcionálissá tehető, így a függvény kevésbé igényes. A következő példa ezt világosan mutatja:

... function font($text, $size=5) // Do: kimeneti betűméret ( echo " ".$text.""; ) font("Szia
",1); font("Helló
",2); font("Szia
",3); font("Helló
",4); font("Helló
",5); font("Helló
",6); font("Szia
");

Alapértelmezés szerint a betűméret 5. Ha kihagyjuk a függvény második paraméterét, akkor az ezzel az értékkel lesz egyenlő.

Következtetés

Mielőtt elköszönnék, egy tanácsra szeretném felhívni a figyelmet. Ez abból áll, hogy az összes beírt függvényt egy fájlba helyezi (például function.php). És akkor abban a fájlban, ahol meg kell hívni a függvényt, csak bele kell foglalni a function.php-t, és minden készen áll a használatra. Így sokkal könnyebb lesz megérteni a program logikáját. A csatlakozáshoz használja:

include_once("function.php");

request_once("function.php");

Ha megérti a cikkben tárgyalt probléma lényegét, akkor biztos vagyok benne, hogy könnyedén használhatja a programjaiban található funkciókat. Ez még egyszer azt jelenti, hogy szerkeszthetőbbé és újrafelhasználhatóbbá tesszük őket.

Számok feletti függvények. A VB nyelvnek a következő matematikai funkciói vannak: abs(x) - modulszámítás; sqr(x) - a négyzetgyök kiszámítása, atn(x) - arctangens számítása; kötözősaláta(x) - koszinusz számítása; bűn(x) - a szinusz számítása; Cser(x) - érintőszámítás; log(x) - a természetes logaritmus kiszámítása, exp(x) - a kitevő számítása, ahol x- numerikus típusú függvény argumentum. A VisualBasic nyelvben hiányzó függvények értékeinek kiszámításához a matematikából ismert képleteket kell használni.

Kifejezés y= a VB-ben így lenne írva: y=sin(x^2)+sqr(tan(x))*(x+5) ^ (1/5).

A függvény argumentumát zárójelbe kell írni.

Az értékek egyik típusból a másikba konvertálására szolgáló függvények. A VB programozási nyelv funkciókat biztosít egy érték adattípusának megváltoztatásához. Például létezik egy a Double típusú változó és egy String típusú s változó.

Ahhoz, hogy a változót s változóba írhassunk, S=CStr(a) típuskonverziót kell végrehajtani, és egy s változót a–a=CDbl(s) változóba kell írni.

VB függvények értéktípus-konverzióhoz:

CStr - konvertálás karakterláncra;

CByte - átalakítás bájtra;

CInt - átalakítás egész számra;

CLng - átalakítás hosszúra;

CSng - átalakítás Single-re;

CDbl - konvertálni duplává.

2.6. Különféle típusú adatok ábrázolása a számítógép memóriájában

A számítógép memóriájában lévő információk (numerikus és nem numerikus) megjelenítésére bináris kódolási módszert alkalmaznak.

A számítógép memória elemi cellája 8 bit (byte) hosszú. Minden bájtnak saját száma van (ezt hívják cím). A legnagyobb bitsorozatot, amelyet a számítógép egészében feldolgozni tud, nevezzük gépszó. A gépi szó hossza a processzor szóhosszától függ, és lehet 16, 32, 64 bit stb.

Karakterkódolás. Egy bájt elég a karakterek kódolásához. Ebben az esetben 256 karakter ábrázolható (a decimális kódok 0-tól 255-ig). Az IBM PC-vel kompatibilis személyi számítógépek karakterkészlete leggyakrabban az ASCII kód ​​(Amerikai Standard Code for Information Interchange - az információcsere szabványos amerikai kódja) kiterjesztése. Jelenleg a karakterek kétbájtos ábrázolását is használják.

Egész számok ábrázolása kettős komplemensben. Az értékek tartománya a tárolásukhoz lefoglalt memóriabitek számától függ. n bites memória tárolható Például az Integer típusú értékek -32768 (-2 15) és 32767 (2 15 - 1) között vannak, és 2 bájt (16 bit) van lefoglalva a tárolásukhoz; hosszú típusú - a -2 31 és 2 31 - 1 tartományban, és 4 bájtban (32 bit) találhatók.

Az egész bináris számok előjel nélküli ábrázolása esetén 0-tól változhat
, és aláírt képviseleten - tól
előtt
. A modern számítógépekben az egész számokból álló bitrács n hosszát szokás 8 többszöröseként (azaz egész számú bájtként) megválasztani.

Egy mennyiség előjellel történő ábrázolása esetén a bal szélső (legmagasabb) számjegy pozitív számot jelez, ha nullát tartalmaz, és negatívot, ha egyet tartalmaz.

A számjegyek jobbról balra vannak számozva, 0-tól kezdve. A .2.2 mutatja a bitek számozását egy kétbájtos gépi szóban.

Rizs. 2.2. Hbitméretezés egy kétbájtos gépi szóban

Kiegészítő kód a pozitív szám megegyezik a vele közvetlen kód. Egy egész szám közvetlen kódját a következőképpen kaphatjuk meg: a számot lefordítják kettes számrendszer számolást, majd a bal oldali bináris jelölését annyi jelentéktelen nullával egészítjük ki, amennyit az adattípus, amelyhez a szám tartozik, megköveteli.

Például, ha a 37 (10) = 100101 (2) szám egész értékként van deklarálva (előjeles tizenhat bit), akkor a közvetlen kódja 0000000000100101, ha pedig hosszú érték (előjeles harminckét bit), akkor közvetlen kódja az. A tömörebb jelölés érdekében a kód hexadecimális ábrázolását gyakrabban használják. Az eredményül kapott kódok átírhatók 0025 (16) és 00000025 (16)-ra.

A negatív egész szám kiegészítő kódja a következő algoritmussal állítható be:

írja le a szám moduljának közvetlen kódját;

megfordítani (az egyeseket nullákra, a nullákat egyesekre cserélni);

adjunk hozzá egyet az inverz kódhoz.

Például írjuk fel a kettő -37-es komplementer kódját, és értelmezzük hosszú (32 bites előjelű) értékként:

a 37-es szám közvetlen kódja ;

inverz kód;

kiegészítő kód vagy FFFFFFDB (16) .

Ha egy számot a kiegészítő kódjával szerez meg, először meg kell határozni az előjelét. Ha a szám pozitívnak bizonyul, egyszerűen fordítsa le a kódját decimális számrendszerre. Negatív szám esetén a következő algoritmust kell végrehajtani:

vonjuk ki a kódból az 1-es számot;

invert kód;

lefordítani decimális rendszer leszámolás. Írja be a kapott számot mínuszjellel!

Példák.Írjuk fel a további kódokhoz tartozó számokat:

0000000000010111. Mivel a nulla a legjelentősebb bitbe van írva, az eredmény pozitív lesz. Ez a 23-as szám kódja.

1111111111000000. Ide írjuk a negatív szám kódját. Végrehajtjuk az algoritmust: 1) 1111111111000000 (2) - 1 (2) = 1111111110111111 (2) ; 2) 0000000001000000; 3) 1000000 (2) = 64 (10) . Válasz: -64.

Célkitűzés: 1) tanulmányozza a függvények leírására vonatkozó szabályokat; 2) elsajátítja a függvények használatának készségeit programírás C++ nyelven.

Elméleti információk

A C++ nyelvű programok fő egysége egy függvény.

Funkció- egy program logikusan befejezett, bizonyos módon megtervezett töredéke, amelynek neve van. A függvények lehetővé teszik a nagy számítási feladatok kisebbekre osztását.

Minden C++ program szükségszerűen tartalmaz egy main nevű függvényt, amely a program törzse. Az összes többi függvényhez, ha jelen vannak a programban, prototípusokat kell deklarálni – sematikus ábrázolásokat, amelyek megmondják a fordítónak a program egyes funkcióinak nevét és alakját.

A függvény prototípusának szintaxisa paraméterekkel:

visszatérési_értéktípus függvénynév (paraméterek_listája_típusok_jelzésével);

A C++ funkciói szabványosak (könyvtárban) és a felhasználó által programozhatók.

Alapfelszereltség

A szabványos funkciók leírása a programban található fájlokban található az #include direktíva használatával. Az ilyen fájlokat fejlécnek nevezzük; h kiterjesztéssel rendelkeznek.

A főprogramban egy függvénynévre való hivatkozást függvényhívásnak nevezzük.

A függvények meghívása bizonyos műveletek végrehajtásához vagy valamilyen érték kiszámításához vezet, amelyet aztán a program felhasznál.

y=sin(x); //szinusz számítási függvény

Funkció meghatározása

Általában a függvények meghatározása a következő:

visszatérési_érték_típusa függvénynév (type paraméter_neve,...,type paraméter_neve)

function_body

Programozható funkciók

A programozó által saját maga által létrehozott függvények leegyszerűsítik a programírás folyamatát, mivel:

segít elkerülni az újraprogramozást, mivel ugyanaz a funkció különböző programokban használható;

növeli a program modularitás szintjét, így könnyebben olvasható, módosítható és javítható a hibák.

Példa9 .1. Hozzunk létre egy függvényt, amely 65 karakter „*” karaktert ír ki egymás után. Annak érdekében, hogy ez a funkció bizonyos körülmények között működjön, a fejléces nyomtatási program tartalmazza. A program a main() és a stars() függvényekből áll.

// levélpapír

#beleértve

const int Limit=65;

void stars(void); // stars() függvény prototípusa

cout<<"Moscow Institute of Electronic Engineering"<

// A stars() függvény meghatározása

for (count=1; count<=Limit; count++)

Megnéztünk egy példát egy egyszerű függvényre, amelynek nincsenek argumentumai, és nem ad vissza semmilyen értéket.

Funkcióparaméterek

Tekintsük példaként a függvényparaméterek használatát.

Példa9. 2. Írjuk fel a space() függvényt, amelynek argumentuma a szóközök száma lesz, amelyet ennek a függvénynek ki kell nyomtatnia.

#define address "Zelenograd"

#define name "Moszkvai Elektronikai Mérnöki Intézet"

#define "Informatika és programozás" osztály

const int LIMIT=65;

#beleértve

üres térköz(int szám);

cout<

szóközök=(LIMIT - strlen(név))/2; // Számítsa ki, mennyi

// szóközökre van szükség

cout<

space((LIMIT - strlen(részleg))/2); // az argumentum egy kifejezés

cout<

// A stars() függvény definíciója

for (count=1; count<=LIMIT; count++)

// A space() függvény definíciója

üres szóköz (int szám)

for (count=1; count<=number; count++)

A változó számot formális argumentumnak nevezzük. Ez a változó az aktuális argumentum értékeit veszi fel a függvény meghívásakor. Más szavakkal, formális érvelés egy változó a hívott szubrutin definíciójában, és tényleges érvelés- a hívó program által ehhez a változóhoz rendelt konkrét érték.

Ha egy bizonyos függvénnyel való kommunikációhoz egynél több argumentum szükséges, akkor a függvény nevével együtt megadhat egy vesszővel elválasztott argumentumot:

érvénytelen nyomtatási szám (int i, int j)

(cout<<"Координаты точек”<< i << j <

A függvény bemeneti értéke a jelenlét miatt feldolgozható érv; a kimeneti érték a return kulcsszó használatával kerül visszaadásra.

Külön rendszer (alrendszer, alprogram), amely a vezérlő bemeneteket argumentumértékek formájában kapja. A kimeneten a függvény egy eredményt ad vissza, amely lehet skaláris érték vagy vektorérték (struktúra, indextömb stb.). A funkció végrehajtása során a felügyelt rendszerben néhány változtatás is végrehajtható, visszafordítható és visszafordíthatatlan.

Mellékhatás

Funkciók és eljárások

Egyes programozási nyelvekben (például Pascalban) a függvényeket és eljárásokat (az értékeket nem adó szubrutinokat) egyértelműen megkülönbözteti a nyelv szintaxisa. Más esetekben - például a C nyelvben - az eljárások olyan függvények speciális esetei (részhalmaza), amelyek egy void típusú (pszeudotípus) értéket adnak vissza - üres értéket.

Érvek és lehetőségek

Egy függvény meghívásakor argumentumok kerülnek átadásra. Ha az argumentum egy memóriaterületre való hivatkozás (változó, mutató vagy hivatkozás), akkor a függvény a paraméterének típusától függően használhatja az értékét (például létrehozhat egy változót, az argumentum értékét másolja oda) ), vagy magát az argumentumot (hivatkozást hozzon létre arra a területre, amelyre a memória hivatkozik az argumentumban).

Funkció argumentumok nélkül

Egy ilyen függvény nem igényel argumentumot.

Lásd még

Linkek

• PHP függvények. Szintaxis és példák a PHP függvények használatára

Wikimédia Alapítvány. 2010 .

Nézze meg, mi a "Funkció (programozás)" más szótárakban:

A Wikiszótárban a "függvény" szócikk szerepel A függvény egy poliszemantikus kifejezés, amely olyan elemek közötti kapcsolatot jelent, amelyekben az egyik változása változást von maga után ... Wikipédia

A csonkfüggvény a programozásban olyan függvény, amely nem hajt végre értelmes műveletet, üres eredményt ad vissza, vagy változatlanul bemeneti adatokat ad vissza. A megfelelő angol szó a stub. Használt: Az egyértelműség kedvéért, amikor ... ... Wikipédia

magasabb pszichés funkció: felépülés- (magasabb mentális funkciók helyreállítása) a neuropszichológia egy része, amely az agy helyi agyának sérülései miatt károsodott magasabb mentális funkciók funkcióinak helyreállítására szolgáló mechanizmusok és módszerek tanulmányozásával foglalkozik. Az ötletek alapján a... Nagy Pszichológiai Enciklopédia

A matematikai programozás egy matematikai tudományág, amely a függvények szélsőségeinek megtalálásának elméletét és módszereit tanulmányozza egy véges dimenziós vektortér halmazain, amelyeket lineáris és nemlineáris kényszerek határoznak meg ... ... Wikipédia

A számítógépesítés területén a hálózati feladatok programozása, vagy más néven hálózati programozás fogalma meglehetősen hasonló a socket programozás és a kliens-szerver programozás fogalmaihoz, ... ... Wikipédia

A magasabb rendű függvény olyan függvény, amely más függvényeket argumentumként vesz fel, vagy eredményként egy másik függvényt ad vissza. Az alapötlet az, hogy a függvények ugyanolyan státuszúak, mint más adatobjektumok... ... Wikipédia

MATEMATIKAI PROGRAMOZÁS- összetett matematikai. modellek és módszerek több változó függvényei szélsőértékének (maximumának vagy minimumának) megtalálásának problémáira, egyenlőtlenségek formájában. Ez azt jelenti, hogy a változók a mechanizmus egyes aspektusait jellemzik ... ... Orosz szociológiai enciklopédia

A matematikát tanulmányozó matematikai tudományág. absztrakciós programok, objektumként kezelt formális nyelven kifejezve, bizonyos információval és logikailag. felépítése és végrehajtása automatikus. eszközöket. P. t....... Matematikai Enciklopédia

A függvény a programozásban egyfajta szubrutin. Az különbözteti meg a többi eljárási szubrutintól, hogy a függvény értéket ad vissza, és a hívása a programban kifejezésként használható. A nézőpontból ... ... Wikipédia

PROGRAMOZÁS, MATE- az alkalmazott matematikának a gazdaságkutatásban módszerként használt ága. Fejleszti a feltételes extrém problémák megoldásának elméletét és módszereit, a formális apparátus fő része a különféle szabályozási problémák elemzésére ... Nagy gazdasági szótár

Ha Ön olyan fejlesztő, mint én, akkor valószínűleg először tanulta meg az OOP paradigmát. Az első nyelved a Java vagy a C++ volt – vagy ha szerencséd van, Ruby, Python vagy C# –, így valószínűleg tudod, mik az osztályok, objektumok, példányok stb. Amit biztosan nem nagyon értesz, az a funkcionális programozásnak nevezett furcsa paradigma alapjai, amely nemcsak az OOP-tól, hanem a procedurális, prototípus-orientált és más típusú programozástól is jelentősen eltér.

A funkcionális programozás egyre népszerűbb – és ennek jó oka van. Maga a paradigma nem új: a Haskell talán a legfunkcionálisabb nyelv, és a 90-es években keletkezett. Az olyan nyelvek, mint az Erlang, Scala, Clojure, szintén a funkcionális definíció alá tartoznak. A funkcionális programozás egyik fő előnye, hogy olyan programokat írhat, amelyek párhuzamosan működnek (ha már elfelejtette, hogy mi ez - frissítse a memóriáját olvasással), és hiba nélkül - vagyis a holtpontok és a szálbiztonság nem zavarja Önt.

A funkcionális programozásnak számos előnye van, de a fő előnye a CPU erőforrások lehetséges maximális kihasználása a versenyképes viselkedés miatt. Az alábbiakban a funkcionális programozás alapelveit tekintjük át.

Bevezetés: Mindezek az alapelvek nem kötelezőek (sok nyelv nem követi őket teljesen). Mindegyik elméleti jellegű, és a funkcionális paradigma legpontosabb meghatározásához szükséges.

1. Minden funkció tiszta

Ez a szabály minden bizonnyal a fő szabály a funkcionális programozásban. Minden függvény tiszta, ha két feltételnek eleget tesz:

1. Az azonos argumentumokkal meghívott függvény mindig ugyanazt az értéket adja vissza.
2. A funkció végrehajtása során nincsenek mellékhatások.

Az első szabály egyértelmű - ha meghívom a sum(2, 3) függvényt, akkor az eredményt mindig 5-re várom. Amint meghívod a rand() függvényt, vagy elérsz egy olyan változót, ami nincs definiálva a függvényben, a funkció tisztasága sérül, és ez a funkcionális programozásban nem megengedett.

A második szabály – nincs mellékhatás – tágabb jellegű. A mellékhatás az éppen futó funkciótól eltérő dolog változása. Egy függvényen kívüli változó megváltoztatása, a konzolra írás, a kivétel dobása, az adatok fájlból való kiolvasása mind olyan mellékhatások példái, amelyek megfosztják a függvény tisztaságát. Ez komoly korlátozásnak tűnhet, de gondolja át újra. Ha biztos abban, hogy egy függvény meghívása nem változtat semmit „kívül”, akkor ezt a funkciót bármilyen forgatókönyvben használhatja. Ez megnyitja az utat a versenyképes programozás és a többszálú alkalmazások előtt.

2. Minden funkció első osztályú és magasabb rendű

Ez a fogalom nem az FP sajátossága (Javascriptben, PHP-ben és más nyelveken is használják), de követelmény. Valójában a Wikipédiában egy teljes cikk van az első osztályú funkcióknak szentelve. Ahhoz, hogy egy függvény első osztályú legyen, változóként deklarálhatónak kell lennie. Ez lehetővé teszi, hogy a függvényt normál adattípusként kezeljük, és továbbra is végrehajtsuk.

3. A változók megváltoztathatatlanok

Itt minden egyszerű. A funkcionális programozásban nem módosítható a változó inicializálása után. Létrehozhat újakat, de nem módosíthatja a meglévőket - és ennek köszönhetően biztos lehet benne, hogy egyetlen változó sem fog megváltozni.

4. A funkciók relatív átláthatósága

Nehéz pontosan meghatározni a relatív átláthatóságot. Szerintem a legpontosabb a következő: ha egy függvényhívást vissza lehet cserélni, és az állapot nem változik, akkor a függvény viszonylag transzparens. Ez nyilvánvaló lehet, de mondok egy példát.

Tegyük fel, hogy van egy Java függvényünk, amely hozzáadja a 3-at és az 5-öt:

Public int addNumbers()( return 3 + 5; ) addNumbers() // 8 8 // 8

Nyilvánvaló, hogy a függvény bármely hívása helyettesíthető 8-cal, ami azt jelenti, hogy a függvény viszonylag átlátható. Íme egy példa egy átlátszatlan függvényre:

Public void printText()( System.out.println("Hello World"); ) printText() // Nem ad vissza semmit, de kiírja, hogy "Hello World"

Ez a függvény nem ad vissza semmit, hanem szöveget ír ki, és ha a függvényhívást semmire cseréljük, akkor a konzol állapota más lesz - ami azt jelenti, hogy a függvény nem relatíve átlátszó.

5. A funkcionális programozás lambda-számításon alapul

A funkcionális programozás nagymértékben támaszkodik a lambda-számításnak nevezett matematikai rendszerre. Nem vagyok matematikus, ezért nem megyek bele a részletekbe, de szeretnék rámutatni a lambda-számítás két kulcsfontosságú elvére, amelyek a funkcionális programozás fogalmát alkotják:

1. A lambda-kalkulusban minden függvény lehet névtelen, mivel a függvényfejléc egyetlen értelmes része az argumentumlista.
2. Meghíváskor minden funkció átmegy egy currying folyamaton. Ez a következő: ha egy függvényt több argumentummal hívunk meg, akkor először csak az első argumentummal hajtódik végre, és egy új, 1 argumentumot tartalmazó függvényt ad vissza, amely azonnal meghívásra kerül. Ez a folyamat rekurzív, és addig folytatódik, amíg az összes argumentumot nem alkalmazzák, visszaadva a végeredményt. Mivel a funkciók tiszták, ez működik.

Mint mondtam, a lambda-számítás ezzel még nem ér véget – de mi csak az FP-vel kapcsolatos legfontosabb szempontokra tértünk ki. Most a funkcionális programozásról szóló beszélgetésben felvillanthatod a „lambda kalkulus” szót, és mindenki azt fogja hinni, hogy te babrálsz 🙂

Következtetés

A funkcionális programozás igazi agyterhelés – de nagyon erőteljes megközelítés, és úgy gondolom, hogy a népszerűsége csak növekedni fog.

Ha többet szeretne megtudni a funkcionális programozásról, javasoljuk, hogy nézze meg az FP elveinek JavaScriptben való használatára vonatkozó példákat ( , ), valamint a funkcionális C#-nak szentelt példát.