Wat overschrijft JavaScript?
Om het concept van het negeren in JavaScript te begrijpen, moeten we eerst het concept van het negeren als geheel herzien.
Methode Overriding is een OOPs-concept dat nauw verbonden is met overerving. Wanneer een methode van de onderliggende klasse de methode van de bovenliggende klasse met dezelfde naam, dezelfde parameters en hetzelfde retourtype overschrijft, wordt deze methode als vervangende methode genoemd. Houd er ook rekening mee dat dit volledig verschilt van het concept van methode-overbelasting. Overbelasting van de methode treedt op wanneer er twee functies zijn met dezelfde naam maar verschillende parameters.
Laten we nu proberen dit concept te begrijpen vanuit het standpunt van JavaScript. We weten dat JavaScript 'relatief' niet objectgericht is. Het heeft het concept van objecten waardoor het objectgericht is, maar het heeft geen concept van klassen. Het is prototypisch van aard. Ja ja, ik hoor je luid schreeuwen dat we klassen in JavaScript kunnen verklaren, maar ik wil je eraan herinneren dat deze Klasse-notatie slechts een syntactische suiker is voor de onderliggende prototypische architectuur.
JavaScript ondersteunt dus wel het concept van het negeren van methoden. En het doet het op heel vreemde manieren. Het is tenslotte de meest onbegrepen taal in de programmeerwereld. JavaScript ondersteunt overschrijven, maar niet overbelasten.
Opmerking - In de voorbeelden in dit artikel zouden we de ontwikkelaarsconsole van de browsers gebruiken. Open eenvoudigweg de ontwikkelaarstools van de browser (Ctrl / Cmd + Shift + C) en ga naar het tabblad Console in het venster met ontwikkelaarstools.
Het ziet er zo uit in Chrome:
Dit is de speeltuin voor de meeste JavaScript-gerelateerde concepten. We zouden deze speeltuin in dit artikel gebruiken.
Hoe werkt opheffen in JavaScript?
In JavaScript nemen alle objecten over van het prototype Object. Alle objecten zijn exemplaren van Object. Dus wanneer u een nieuw object maakt, definieert JavaScript automatisch een _proto_ (prototype) eigenschap voor het nieuwe object. Wanneer een onderliggend object wordt gemaakt, heeft het opnieuw de eigenschap _proto_ enzovoort. Wanneer u nu probeert toegang te krijgen tot een methode of een eigenschap van een object, controleert JavaScript eerst of het object die methode / eigenschap heeft. Als dit niet het geval is, controleert JavaScript of de _proto_ van het object die methode / eigenschap heeft. Als dit niet het geval is, controleert JavaScript of de _proto_ van het bovenliggende object die methode / eigenschap heeft. Het blijft de keten doorzoeken totdat de methode / eigenschap is gevonden of de _proto_ van Object wordt aangetroffen en gezocht. Bijv. Date.prototype. ((Prototype)) is Object.prototype.
Zie nu de ketting ondersteboven. Dit is hoe het negeren werkt in JavaScript. Een methode zou de methode van het bovenliggende object blijven overschrijven, zelfs als het een methode van Object is. We kunnen bijvoorbeeld zelfs de kernfunctionaliteit vervangen, zoals het maken van een object Date.
Laten we dit zien met een voorbeeld:
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);
Soorten overschrijven in JavaScript
Er zijn geen soorten overschrijvingen gedefinieerd in JavaScript. Op basis van het gedrag van de programmeertaal kunnen we echter zeggen dat het opheffen van de methode in JavaScript op de volgende manieren werkt.
1) Het eerste gedrag
De eerste manier is degene die we hierboven zagen toen we een methode definieerden om de standaard Date-constructor van JavaScript te overschrijven. Dit is vergelijkbaar met de derde manier die hieronder wordt geïllustreerd, omdat alle objecten in JavaScript een instantie zijn van het prototype Object. Wat het derde gedrag onderscheidt, is het gebruik van het superzoekwoord. We zullen meer zien als we het derde gedrag illustreren.
Laten we nog een soortgelijk voorbeeld bekijken. Deze keer zouden we de waarschuwingsfunctionaliteit vervangen. Het standaardgedrag van de waarschuwingsfunctie in JavaScript is om een klein dialoogvenster boven aan de pagina weer te geven met het bericht dat we als parameter doorgeven.
Wanneer we het nu met onze eigen code overschrijven, wordt de standaardwaarschuwingsfunctie niet meer aangeroepen.
function alert(msg) (
console.log(msg);
);
alert("This is an alert.");
2) Het tweede gedrag
De tweede manier is wanneer we proberen functies in JavaScript te overbelasten. Onthoud dat JavaScript geen functie-overbelasting ondersteunt. Dus in plaats van uw functie te overbelasten, zou JavaScript alle eerdere definities van uw functie vervangen door de nieuwste.
Laten we dit in actie zien.
//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));
Let op het resultaat. JavaScript roept altijd de tweede definitie van de functie aan en retourneert het kwadraat van de eerste parameter. De volgende parameters worden genegeerd.
3) Het derde gedrag
Het derde gedrag komt in beeld wanneer we klassen en overerving in JavaScript betrekken. Wanneer een onderliggende klasse de methoden van de bovenliggende klasse overneemt en zijn eigen methoden met dezelfde naam definieert, worden de methoden van de bovenliggende klasse genegeerd. Dit is niet wat we zouden willen in echte toepassingen. We zouden willen dat onze methoden van de bovenliggende klasse toegankelijk zijn, zelfs wanneer ze worden overschreven door de methoden van de onderliggende klasse. Dus komt het superzoekwoord ons te hulp. Met het superzoekwoord hebben we toegang tot de methoden van de bovenliggende klasse.
Laten we dit in actie zien.
//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();
Ga nu terug naar het eerste gedragsvoorbeeld en probeer het superzoekwoord daar te gebruiken. Je zou merken dat het niet werkt. Dit komt omdat we bij het maken van onze methode in het eerste voorbeeld de bovenliggende klasse niet hebben uitgebreid. We hebben de methode in de globale scope gemaakt en alle andere definities van de methode vervangen.
Conclusie
Laten we ons begrip van het negeren van methoden in JavaScript herzien. We hebben geleerd dat JavaScript wel het negeren ondersteunt, maar niet het overbelasten. Als we proberen methoden te overbelasten, overschrijft JavaScript alle eerdere definities door de nieuwste. Dit geldt zelfs voor kernfuncties!
Vervolgens hebben we gezien hoe we methoden in onderliggende klassen kunnen overschrijven en vervolgens waar nodig toegang krijgen tot methoden van de bovenliggende klasse. Dit is een zeer nuttig concept omdat het ons in staat stelt de functionaliteit van onze bovenliggende klassen uit te breiden en dus de herbruikbaarheid van codes verbetert.
Aanbevolen artikelen
Dit is een gids voor overschrijven in JavaScript. Hier bespreken we hoe werkt overschrijven in JavaScript en typen overschrijven in JavaScript. U kunt ook het volgende artikel bekijken voor meer informatie -
- Wat kan Javascript doen?
- Wat is JavaScript?
- Hoe JavaScript te installeren
- Python Frameworks - wat is python framework?
- Inleiding tot negeren in C ++
- Inleiding tot overschrijven in OOP's
- Overschrijven in Java
- Methode Overbelasting in C #
- Overbelasting en opheffen in C #