วิธีการโทรโดยใช้ต้นแบบ JavaScript

เป็นไปได้หรือไม่ที่จะเรียกเมธอดพื้นฐานจากเมธอดต้นแบบใน JavaScript หากถูกลบล้าง

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
    }
};

ฉันไม่เข้าใจว่าคุณกำลังพยายามทำอะไรกันแน่ แต่โดยปกติแล้วการปรับใช้พฤติกรรมเฉพาะวัตถุจะทำตามบรรทัดเหล่านี้:

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...*/);
}

วิธีหนึ่งที่จะทำได้ก็คือการบันทึกเมธอดพื้นฐานแล้วเรียกมันจากเมธอด overriden เช่นนั้น

MyClass.prototype._do_base = MyClass.prototype.do;
MyClass.prototype.do = function(){  

    if (this.name === 'something'){

        //do something new

    }else{
        return this._do_base();
    }

};

ฉันเกรงว่าตัวอย่างของคุณไม่ได้ผลอย่างที่คุณคิด ส่วนนี้:

this.do = function(){ /*do something*/ };

เขียนทับนิยามของ

MyClass.prototype.do = function(){ /*do something else*/ };

เนื่องจากวัตถุที่สร้างขึ้นใหม่มีคุณสมบัติ "do" อยู่แล้วจึงไม่ค้นหาห่วงโซ่ต้นแบบ

รูปแบบคลาสสิกของการสืบทอดใน Javascript นั้นน่ากลัวและยากที่จะเข้าใจ ฉันขอแนะนำให้ใช้รูปแบบการสืบทอดแบบง่ายๆของ Douglas Crockfords แทน แบบนี้:

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

ในความคิดของฉันวิธีที่ชัดเจนกว่ามากในการจัดการวัตถุตัวสร้างและการสืบทอดในจาวาสคริปต์ คุณสามารถอ่านเพิ่มเติมใน Crockfords Javascript: ส่วนที่ดี

ฉันรู้ว่าโพสต์นี้มาจาก 4 ปีที่แล้ว แต่เนื่องจากพื้นหลัง C # ของฉันฉันกำลังมองหาวิธีเรียกคลาสพื้นฐานโดยไม่ต้องระบุชื่อคลาส แต่ได้มาจากคุณสมบัติในคลาสย่อย ดังนั้นการเปลี่ยนแปลงเพียงคำตอบของคริสตอฟก็คือ

จากนี้:

MyClass.prototype.doStuff.call(this /*, args...*/);

สำหรับสิ่งนี้:

this.constructor.prototype.doStuff.call(this /*, args...*/);

หากคุณกำหนดฟังก์ชันเช่นนี้ (โดยใช้ OOP)

function Person(){};
Person.prototype.say = function(message){
   console.log(message);
}

มีสองวิธีในการเรียกใช้ฟังก์ชันต้นแบบ: 1) สร้างอินสแตนซ์และเรียกใช้ฟังก์ชันวัตถุ:

var person = new Person();
person.say('hello!');

และอีกวิธีหนึ่งคือ ... 2) กำลังเรียกใช้ฟังก์ชันโดยตรงจากต้นแบบ:

Person.prototype.say('hello there!');

วิธีนี้ใช้ Object.getPrototypeOf

TestA เป็นซุปเปอร์ที่มี getName

TestBเป็นเด็กที่แทนที่getNameแต่ยังมี getBothNamesที่เรียกsuperรุ่นgetNameเช่นเดียวกับchildรุ่น

function TestA() {
  this.count = 1;
}
TestA.prototype.constructor = TestA;
TestA.prototype.getName = function ta_gn() {
  this.count = 2;
  return ' TestA.prototype.getName is called  **';
};

function TestB() {
  this.idx = 30;
  this.count = 10;
}
TestB.prototype = new TestA();
TestB.prototype.constructor = TestB;
TestB.prototype.getName = function tb_gn() {
  return ' TestB.prototype.getName is called ** ';
};

TestB.prototype.getBothNames = function tb_gbn() {
  return Object.getPrototypeOf(TestB.prototype).getName.call(this) + this.getName() + ' this object is : ' + JSON.stringify(this);
};

var tb = new TestB();
console.log(tb.getBothNames());

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();
    };
}

ทางเลือก:

// 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);
}

ถ้าฉันเข้าใจถูกต้องคุณต้องการให้ฟังก์ชันพื้นฐานทำงานอยู่เสมอในขณะที่ส่วนหนึ่งควรปล่อยให้ใช้งานได้

คุณอาจได้รับความช่วยเหลือจากรูปแบบการออกแบบ' template method '

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 */ }

หากคุณรู้จักซูเปอร์คลาสตามชื่อคุณสามารถทำสิ่งต่อไปนี้:

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();

สิ่งนี้จะพิมพ์

called foo in Base
called foo in Sub
called foo in Base

อย่างที่คาดไว้.

อีกวิธีหนึ่งสำหรับ ES5 คือการสำรวจโซ่ต้นแบบอย่างชัดเจนโดยใช้ Object.getPrototypeOf(this)

const speaker = {
  speak: () => console.log('the speaker has spoken')
}

const announcingSpeaker = Object.create(speaker, {
  speak: {
    value: function() {
      console.log('Attention please!')
      Object.getPrototypeOf(this).speak()
    }
  }
})

announcingSpeaker.speak()

ไม่คุณจะต้องให้ฟังก์ชัน do ในตัวสร้างและฟังก์ชัน do ในชื่อที่แตกต่างกันของต้นแบบ

นอกจากนี้หากคุณต้องการลบล้างอินสแตนซ์ทั้งหมดไม่ใช่แค่อินสแตนซ์พิเศษอันนั้นอันนี้อาจช่วยได้

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();

ผลลัพธ์:

doing original
doing override

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();