Calling method using JavaScript prototype

Question

Is it possible to call the base method from a prototype method in JavaScript if it s been overridden   MyClass   function name       this name   name      this do   function               do somthing            MyClass prototype do   function           if  this name      something               do something new       else             CALL BASE METHOD

User · Answer

No  you would need to give the do function in the constructor and the do function in the prototype different names

User · Answer

An alternative        shape  var shape   function type       this type   type       shape prototype display   function        console log this type        circle var circle   new shape  circle       override circle display   function a b           call implementation of the super class     this   proto   display apply this arguments

User · Answer

function NewClass         var self   this      BaseClass call self               Set base class      var baseModify   self modify      Get base function     self modify   function                 Override code here         baseModify

User · Answer

I m afraid your example does not work the way you think  This part   this do   function      do something        overwrites the definition of   MyClass prototype do   function      do something else        Since the newly created object already has a  do  property  it does not look up the prototypal chain    The classical form of inheritance in Javascript is awkard  and hard to grasp  I would suggest using Douglas Crockfords simple inheritance pattern instead  Like this   function my class name        return           name  name          do  function         do something                function my child name        var me   my class name       var base do   me do      me do   function              if  this name      something                  do something new           else               base do call me                       return me     var o   my child  something    o do       does something new  var u   my child  something else    u do       uses base function   In my opinion a much clearer way of handling objects  constructors and inheritance in javascript  You can read more in Crockfords Javascript  The good parts

User · Answer

Another way with ES5 is to explicitely traverse the prototype chain using Object getPrototypeOf this   const speaker       speak       gt  console log  the speaker has spoken      const announcingSpeaker   Object create speaker      speak        value  function           console log  Attention please          Object getPrototypeOf this  speak                 announcingSpeaker speak

User · Answer

function MyClass       MyClass prototype myMethod   function       alert   doing original       MyClass prototype myMethod original   MyClass prototype myMethod  MyClass prototype myMethod   function       MyClass prototype myMethod original call  this      alert   doing override        myObj   new MyClass    myObj myMethod

User · Answer

If you know your super class by name  you can do something like this   function Base        Base prototype foo   function       console log  called foo in Base       function Sub        Sub prototype   new Base     Sub prototype foo   function       console log  called foo in Sub      Base prototype foo call this      var base   new Base    base foo     var sub   new Sub    sub foo      This will print  called foo in Base called foo in Sub called foo in Base   as expected

User · Answer

If I understand correctly  you want Base functionality to always be performed  while a piece of it should be left to implementations   You might get helped by the  template method  design pattern    Base   function      Base prototype do   function                prologue code     this impldo            epilogue code       note  no impldo implementation for Base   derived   new Base    derived impldo   function        do derived things here safely

User · Answer

I know this post is from 4 years ago  but because of my C  background I was looking for a way to call the base class without having to specify the class name but rather obtain it by a property on the subclass  So my only change to Christoph s answer would be  From this   MyClass prototype doStuff call this     args          To this   this constructor prototype doStuff call this     args

User · Answer

if you define a function like this  using OOP   function Person      Person prototype say   function message      console log message       there is two ways to call a prototype function  1  make an instance and call the object function   var person   new Person    person say  hello       and the other way is    2  is calling the function directly from the prototype   Person prototype say  hello there

User · Answer

I did not understand what exactly you re trying to do  but normally implementing object-specific behaviour is done along these lines   function MyClass name        this name   name     MyClass prototype doStuff   function            generic behaviour    var myObj   new MyClass  foo     var myObjSpecial   new MyClass  bar    myObjSpecial doStuff   function            do specialised stuff        how to call the generic implementation      MyClass prototype doStuff call this     args

User · Answer

In addition  if you want to override all instances and not just that one special instance  this one might help   function MyClass       MyClass prototype myMethod   function       alert   doing original       MyClass prototype myMethod original   MyClass prototype myMethod  MyClass prototype myMethod   function       MyClass prototype myMethod original call  this      alert   doing override        myObj   new MyClass    myObj myMethod      result   doing original doing override

User · Answer

Well one way to do it would be saving the base method and then calling it from the overriden method  like so  MyClass prototype  do base   MyClass prototype do  MyClass prototype do   function           if  this name      something               do something new       else          return this  do base

User · Answer

This solution uses Object getPrototypeOf  TestA is super that has getName  TestB is a child that overrides getName but  also has getBothNames that calls the super version of getName as well as the child version   x000D   x000D  function TestA     x000D    this count   1  x000D    x000D  TestA prototype constructor   TestA  x000D  TestA prototype getName   function ta gn     x000D    this count   2  x000D    return   TestA prototype getName is called       x000D     x000D   x000D  function TestB     x000D    this idx   30  x000D    this count   10  x000D    x000D  TestB prototype   new TestA    x000D  TestB prototype constructor   TestB  x000D  TestB prototype getName   function tb gn     x000D    return   TestB prototype getName is called       x000D     x000D   x000D  TestB prototype getBothNames   function tb gbn     x000D    return Object getPrototypeOf TestB prototype  getName call this    this getName       this object is       JSON stringify this   x000D     x000D   x000D  var tb   new TestB    x000D  console log tb getBothNames     x000D   x000D   x000D

[javascript] Calling method using JavaScript prototype

Examples related to javascript

Examples related to prototype

Examples related to overriding