Mi az elsőbbség a JavaScripten?
A JavaScript felülírásának fogalmának megértése érdekében először vizsgáljuk felül az általános érvényesítés fogalmát.
A módszer felülbírálása az örökléssel szorosan összekapcsolt OOP-koncepció. Ha egy gyermekosztály-módszer felülírja az azonos nevű, paraméterekkel és visszatérő típusú szülőosztály-módszert, akkor módszer-felülírónak nevezzük. Felhívjuk figyelmét, hogy ez teljesen eltér a módszer túlterhelésének fogalmától. A módszer túlterhelése akkor fordul elő, ha két azonos nevű, de eltérõ paraméterû funkció van.
Most próbáljuk megérteni ezt a fogalmat a JavaScript szempontjából. Tudjuk, hogy a JavaScript „viszonylag” nem objektum-orientált. Van egy Objektumok fogalma, amely azt objektív-orientáltnak minősíti, de nem rendelkezik az osztályok fogalmával. Prototípus jellegű. Igen, igen, hallom, hogy hangosan kiabálják, hogy osztályokat deklarálhatunk JavaScript-ben, de hadd emlékeztessem önöket, hogy ez az osztályjelölés csupán az alapjául szolgáló prototípusos architektúra szintaktikai cukorja.
Tehát a JavaScript támogatja a módszer felülbírálásának fogalmát. És nagyon furcsa módon csinálja. Végül is, ez a leginkább félreértett nyelv a programozási világban. A JavaScript támogatja a felülbírálást, de nem terhelheti túl.
Megjegyzés: A cikkben szereplő példákban a böngészők fejlesztői konzolját használjuk. Egyszerűen nyissa meg a böngésző fejlesztői eszközöket (Ctrl / Cmd + Shift + C), és lépjen a Fejlesztői eszközök ablak Konzol fülére.
A Chrome-ban így néz ki:
Ez a játszótér a legtöbb JavaScript-rel kapcsolatos koncepció számára. Ezt a játszóteret az egész cikkben használnánk.
Hogyan működik a felülírás a JavaScriptben?
A JavaScript-ben az összes objektum az Object prototípustól örököl. Minden objektum az Object példányai. Így minden új objektum létrehozásakor a JavaScript automatikusan meghatározza az új objektum _proto_ (prototípus) tulajdonságát. Ha létrehoz egy gyermekobjektumot, akkor ismét _proto_ tulajdonsággal rendelkezik és így tovább. Most, amikor megpróbál hozzáférni egy módszerhez vagy egy objektum tulajdonságához, a JavaScript először ellenőrzi, hogy az objektum rendelkezik-e ezzel a módszerrel / tulajdonsággal. Ha nem, a JavaScript ellenőrzi, hogy az objektum _proto_-e rendelkezik-e ezzel a módszerrel / tulajdonsággal. Ha nem, a JavaScript ellenőrzi, hogy a szülőobjektum _proto_-e rendelkezik-e ezzel a módszerrel / tulajdonsággal. Folytatja a lánc felkutatását mindaddig, amíg vagy meg nem találja a módszert / tulajdonságot, vagy az Object _proto_ elemét meg nem találja és megkeresi. Például a Date.prototype. ((Prototype)) az Object.prototype.
Most nézze meg a láncot fejjel lefelé. Így működik a felülbírálás a JavaScript-ben. Egy módszer továbbra is felülírja a szülőobjektum módszerét, még akkor is, ha ez objektummódszer. Például felülbírálhatjuk az alapvető funkciókat, például a Dátum objektum létrehozását.
Nézzük meg ezt egy példával:
new Date(); //the JavaScript Date() method
//overriding the JavaScript Date() method
function Date()(
this.date = "This method overrides the default constructor of Date class.";
);
var date2 = new Date();
console.log(date2);
A felülírások típusai a JavaScript-ben
Nincsenek a JavaScriptekben meghatározott felülírási típusok. A programozási nyelv viselkedése alapján azonban azt mondhatjuk, hogy a JavaScripten felülbíráló módszer a következő módon működik.
1) Az első viselkedés
Az első módszer a fenti, amikor egy módszert definiáltunk, amely felülbírálja a JavaScript alapértelmezett Date konstruktorát. Ez hasonló az alábbiakban bemutatott harmadik módszerhez, mivel a JavaScriptben minden objektum az Object prototípus példánya. A harmadik viselkedés megkülönbözteti a szuper kulcsszó használatát. Többet fogunk látni, amikor a harmadik viselkedést szemléltetjük.
Lássuk egy másik hasonló példát. Ezúttal felülbíráljuk a riasztási funkciókat. A riasztási funkció alapértelmezett viselkedése a JavaScriptben az, hogy egy kis párbeszédpanelt jelenít meg az oldal tetején az üzenettel, amelyet paraméterként adunk át.
Most, amikor felülbíráljuk a saját kóddal, az alapértelmezett riasztási funkciót már nem hívjuk meg.
function alert(msg) (
console.log(msg);
);
alert("This is an alert.");
2) A második viselkedés
A második módszer az, amikor megpróbálunk túlterhelni a JavaScript funkcióit. Ne feledje, hogy a JavaScript nem támogatja a funkciók túlterhelését. Tehát a funkció túlterhelése helyett a JavaScript felülbírálja a funkció minden korábbi meghatározását a legújabb értékkel.
Lássuk ezt működés közben.
//Calculate area of rectangle
function calculateArea(x, y)(
return x*y;
)
//Calculate area of square
function calculateArea(a)(
return a*a;
)
console.log("Area of rectangle 2x3 is : " + calculateArea(2, 3));
console.log("Area of square 5x5 is : " + calculateArea(5));
Figyelje meg az eredményt. A JavaScript mindig meghívja a függvény második meghatározását, és visszatér az első paraméter négyzetére. A következő paramétereket nem veszik figyelembe.
3) A harmadik viselkedés
A harmadik viselkedés akkor jön létre, amikor az osztályokat és az öröklést bevonjuk a JavaScript-be. Ha egy gyermekosztály örökli a szülőosztály módszereit, és meghatározza a saját módszereit azonos néven, akkor a szülőosztály módszerei felülbírálódnak. Nem erre lenne szükségünk a valós alkalmazásokban. Szeretnénk, ha a szülői osztály módszerei akkor is elérhetők lennének, ha a gyermek osztály módszereit felülbírálják. Tehát a szuper kulcsszó ment megmentésre. A szuper kulcsszó segítségével hozzáférhetünk a szülő osztály módszereihez.
Lássuk ezt működés közben.
//the parent class
class Person (
greet() (
console.log("Hello. I am a person.");
);
)
//the child class
class Employee extends Person (
greet() (
super.greet(); //calling parent class method via keyword 'super'
console.log("Hello. I am an employee.");
)
)
let per = new Person(); //parent class object
let emp = new Employee(); //child class object
per.greet();
emp.greet();
Most térj vissza az első viselkedési példához, és próbáld meg használni a szuper kulcsszót. Észre fogja venni, hogy nem működik. Ennek oka az, hogy amikor az első példában elkészítettük a módszert, nem bővítettük a szülőosztályt. A módszert a globális hatályban hoztunk létre, így felülbírálva a módszer összes többi meghatározását.
Következtetés
Vizsgáljuk felül a JavaScript értelmezésében alkalmazott módszer-megértésünket. Megtudtuk, hogy a JavaScript támogatja a felülbírálást, de nem terheli túl. Ha megpróbáljuk túlterhelni a módszereket, a JavaScript felülírja az összes korábbi meghatározást a legfrissebbnel. Ez igaz az alapvető funkciókra is!
Ezután megláttuk, hogyan lehet felülbírálni a módszereket a gyermek osztályokban, és később hozzáférhetünk a szülő osztály módszereihez, amikor és amikor szükséges. Ez egy nagyon hasznos koncepció, mivel lehetővé teszi számunkra, hogy kibővítsük szülőosztályaink funkcionalitását, és ezáltal javítja a kód újrafelhasználhatóságát.
Ajánlott cikkek
Ez egy útmutató a felülírásra a JavaScripten. Itt tárgyaljuk, hogyan működik a felülbírálás a JavaScript-ben és a felülbírálás típusa a JavaScript-ben. A következő cikkben további információkat is megnézhet -
- Mit tehet a Javascript?
- Mi a JavaScript?
- Hogyan kell telepíteni a JavaScriptet
- Python keretek - mi a python keret?
- Bevezetés a C ++ felülbírálásába
- Bevezetés az OOP-ok felülbírálásához
- A Java alapon érvényes
- Módszertúlterhelés C # -ben
- Túlterhelés és felülbírálás a C # -ben