A prototípus -programozás az objektum-orientált programozás olyan stílusa , amelyben nincs osztályfogalom , és az öröklődés egy objektum egy létező példányának – prototípusnak – klónozásával történik .
A prototípus-orientált nyelv kanonikus példája az Self . A jövőben ez a programozási stílus kezdett népszerűvé válni, és olyan programozási nyelvek alapja volt, mint a JavaScript , Lua , Io , REBOL stb.
Az „osztály” fogalmán alapuló nyelvekben az összes objektumot két fő típusra osztják - osztályokra és példányokra . Az osztály egy struktúrát és funkcionalitást ( viselkedést ) határoz meg, amely az osztály minden példányára azonos. A példány egy adathordozó – vagyis van egy állapota , amely az osztály által meghatározott viselkedés szerint változik.
A prototípus programozás hívei gyakran érvelnek azzal, hogy az osztályalapú nyelvek az osztályok taxonómiájának és a köztük lévő kapcsolatoknak a túlzott hangsúlyozásához vezetnek. Ezzel szemben a prototípuskészítés egy (kis) számú „minta” viselkedésére összpontosít, amelyeket azután „alap” objektumok közé sorolnak, és más objektumok létrehozására használnak fel. Sok prototípus-orientált rendszer támogatja a prototípusok futás közbeni megváltoztatását, míg az osztályorientált rendszereknek csak egy kis része (pl. Smalltalk , Ruby ) teszi lehetővé az osztályok dinamikus megváltoztatását.
Bár a prototípus-alapú rendszerek túlnyomó többsége dinamikusan tipizált értelmezett nyelveken alapul, technikailag lehetséges a statikusan típusellenőrzött nyelvekhez prototípusokat is hozzáadni. Az Omega nyelv egy példa egy ilyen rendszerre.
Az osztályorientált nyelvekben egy új példány jön létre az osztálykonstruktor meghívásával (talán egy paraméterkészlettel). Az eredményül kapott példány szerkezete és viselkedése az osztálya által keményen kódolt.
A prototípuskészítő rendszerek két módszert kínálnak új objektumok létrehozására: egy meglévő objektum klónozása vagy egy objektum létrehozása a semmiből . Ahhoz, hogy egy objektumot a semmiből hozzon létre, a programozó szintaktikai eszközökkel rendelkezik, amelyekkel tulajdonságokat és metódusokat adhat hozzá az objektumhoz. A jövőben ennek teljes másolata - egy klón - beszerezhető a kapott objektumból. A klónozás során a másolat örökli prototípusának minden tulajdonságát, de ettől a pillanattól kezdve függetlenné válik és megváltoztatható. Egyes megvalósításokban a másolatok hivatkozásokat tárolnak a prototípus objektumokra, átruházva a funkciók egy részét rájuk; míg a prototípus megváltoztatása az összes példányát érintheti. Más megvalósításokban az új objektumok teljesen függetlenek a prototípusaiktól. Mindkét esetet az alábbiakban tárgyaljuk.
//Példa az öröklődésre a prototípus programozásban //a JavaScript nyelv példáján //Új objektum létrehozása let foo = { name : "foo" , one : 1 , two : 2 }; //Újabb új objektum létrehozása let bar = { two : "two" , three : 3 }; bár . __proto__ = foo ; // A foo most a bar prototípusa //Ha most megpróbáljuk elérni a foo mezőit a bar -ból //akkor működni fog a bar . egy // Egyenlő 1-gyel //Egyéni mezők is rendelkezésre állnak bar . három // Egyenlő 3 //Az egyéni mezők prioritása magasabb, mint a prototípus mezők sávja . kettő ; // egyenlő "kettővel"A delegálást használó prototípus-orientált nyelvekben a futtatókörnyezet képes metódushívásokat küldeni (vagy megkeresni a megfelelő adatokat), egyszerűen követve a delegálási mutatók láncát (egy objektumtól a prototípusig), amíg az egyezés létre nem jön. Az osztály-példány kapcsolattól eltérően a prototípus-gyermek kapcsolat nem követeli meg a leszármazott objektumoktól, hogy megőrizzék szerkezeti hasonlóságukat prototípusukhoz. Idővel alkalmazkodhatnak és fejlődhetnek, de nincs szükség a prototípus újratervezésére. Fontos, hogy ne csak adatokat, hanem függvényeket is hozzáadhassunk/törölhessünk/módosítsunk, miközben a függvények is első szintű objektumokká válnak . Ennek eredményeként a legtöbb prototípus-orientált nyelv az objektum adatait és metódusait "helynek" (celláknak) nevezi.
A „tiszta” prototípuskészítésben – amelyet lépcsőzetesnek is neveznek, és a Kevo -ban bevezették – a klónozott objektumok nem tárolnak hivatkozásokat prototípusaikra. A prototípust egy az egyben másolják, minden metódussal és attribútummal, és új nevet (hivatkozást) rendelnek a másolathoz. A biológiai sejtek mitózisához hasonlít .
Ennek a megközelítésnek az előnyei közé tartozik, hogy a másolat készítője anélkül tudja megváltoztatni, hogy félne a mellékhatásoktól az őse más leszármazottai körében. A kiküldés számítási költsége is drasztikusan csökken, mivel nem kell végigmenni a lehetséges delegáltak teljes láncán a megfelelő slot (módszer vagy attribútum) keresésében.
A hátrányok közé tartoznak a rendszerben bekövetkezett változások terjesztésének nehézségei: egy prototípus módosítása nem változtatja meg azonnal és automatikusan az összes leszármazottját. A Kevo azonban további eszközöket biztosít a változások közzétételére több objektum között azok hasonlósága („családi hasonlóság”) alapján, nem pedig a közös ős jelenléte alapján, ami jellemző a delegált modellekre.
További hátránya, hogy ennek a modellnek a legegyszerűbb megvalósítása megnövekedett (a delegálási modellhez képest) memóriafelhasználáshoz vezet, mivel minden klón, amíg meg nem változtatja, tartalmazni fogja a prototípus adatainak másolatát. Ez a probléma azonban megoldható a változatlan adatok optimális elkülönítésével és a Kevóban használt " lusta másolat " használatával.
Az osztályorientált objektummodellek támogatói, akik kritizálják a prototipikus megközelítést, gyakran ugyanazok miatt aggódnak, mint a statikus gépírók a dinamikusan tipizált nyelvek miatt. A megbeszélések különösen olyan témák körül forognak, mint a helyesség , a biztonság , a kiszámíthatóság és a programhatékonyság .
Ami az első három pontot illeti, az osztályokat gyakran típusként kezelik ( és valóban ezek a legtöbb statikusan típusos objektumorientált nyelvben vannak), és az osztályoknak bizonyos konvenciókat kell biztosítaniuk, és garantálniuk kell, hogy a példányok jól meghatározott módon fognak viselkedni.
A hatékonyság szempontjából az osztályok deklarálása nagymértékben leegyszerűsíti a fordító optimalizálási feladatát, hatékonyabbá téve a metódusok és az attribútumok keresését a példányokon. Az Self nyelv esetében az idő nagy részét olyan fordítási és értelmezési technikák kidolgozásával töltötték , amelyek közelebb hozták a prototípus-alapú rendszerek teljesítményét az osztályorientált versenytársakhoz. Az ebben az irányban végzett további munka, valamint a JIT fordítók elméletének fejlődése oda vezetett, hogy jelenleg az osztály-orientált és a prototípus-orientált megközelítések megkülönböztetése kevés hatással van az eredményül kapott kód hatékonyságára. Különösen a prototípus-alapú Lua az egyik leggyorsabban értelmezett nyelv, és közvetlenül versenyez sok lefordított nyelvvel, [1] a Lisaac nyelvi fordító pedig olyan ANSI C kódot generál , amely majdnem olyan jó, mint a natív. [2]
Végül talán a leggyakoribb kritika a prototípus-programozással szemben, hogy a szoftverfejlesztő közösség nem ismeri eléggé a JavaScript népszerűsége és elterjedtsége ellenére . Ezen túlmenően, mivel a prototípus-alapú rendszerek viszonylag újak, és még mindig nagyon kevés, az ezeket használó fejlesztési technikák még nem terjedtek el.
| Adattípusok | |
|---|---|
| Értelmezhetetlen | |
| Numerikus | |
| Szöveg | |
| Referencia | |
| Összetett | |
| absztrakt | |
| Egyéb | |
| Kapcsolódó témák | |