Phương thức gọi bằng nguyên mẫu JavaScript

Có thể gọi phương thức cơ sở từ phương thức nguyên mẫu trong JavaScript nếu nó bị ghi đè?

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

Tôi không hiểu chính xác những gì bạn đang cố gắng làm, nhưng thông thường việc thực hiện hành vi dành riêng cho đối tượng được thực hiện dọc theo các dòng này:

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

Vâng, một cách để làm điều đó là lưu phương thức cơ bản và sau đó gọi nó từ phương thức overriden, như vậy

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

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

        //do something new

    }else{
        return this._do_base();
    }

};

Tôi sợ ví dụ của bạn không hoạt động theo cách bạn nghĩ. Phần này:

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

ghi đè định nghĩa của

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

Vì đối tượng mới được tạo đã có thuộc tính "do", nên nó không tra cứu chuỗi nguyên mẫu.

Hình thức kế thừa cổ điển trong Javascript là khó hiểu và khó nắm bắt. Tôi sẽ đề nghị sử dụng mô hình thừa kế đơn giản Douglas Crockfords thay thế. Như thế này:

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

Theo tôi, một cách rõ ràng hơn nhiều để xử lý các đối tượng, các nhà xây dựng và kế thừa trong javascript. Bạn có thể đọc thêm trong Crockfords Javascript: Những phần hay .

Tôi biết bài đăng này có từ 4 năm trước, nhưng vì nền tảng C # của tôi, tôi đã tìm cách gọi lớp cơ sở mà không phải chỉ định tên lớp mà thay vào đó là một thuộc tính trên lớp con. Vì vậy, thay đổi duy nhất của tôi đối với câu trả lời của Christoph sẽ là

Từ đây:

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

Về điều này:

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

nếu bạn xác định một hàm như thế này (sử dụng OOP)

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

có hai cách để gọi hàm nguyên mẫu: 1) tạo một thể hiện và gọi hàm đối tượng:

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

và cách khác là ... 2) đang gọi hàm trực tiếp từ nguyên mẫu:

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

Giải pháp này sử dụng Object.getPrototypeOf

TestA là siêu mà có getName

TestBlà một đứa trẻ ghi đè getNamenhưng, cũng có phiên bản getBothNamesđó gọi là superphiên bản getNamecũng như childphiên bản

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

Một thay thế:

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

Nếu tôi hiểu chính xác, bạn muốn chức năng Cơ sở luôn được thực hiện, trong khi một phần của nó nên được để lại cho việc triển khai.

Bạn có thể được trợ giúp bởi mẫu thiết kế ' phương thức mẫu '.

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

Nếu bạn biết siêu hạng của mình theo tên, bạn có thể làm một cái gì đó như thế này:

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

Cái này sẽ in

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

như mong đợi.

Một cách khác với ES5 là duyệt qua chuỗi nguyên mẫu một cách rõ ràng bằng cách sử dụng 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()

Không, bạn sẽ cần cung cấp hàm do trong hàm tạo và hàm do trong các tên khác nhau của nguyên mẫu.

Ngoài ra, nếu bạn muốn ghi đè tất cả các phiên bản và không chỉ một trường hợp đặc biệt, thì đây có thể là một trường hợp.

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

kết quả:

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