javascript中内部函数的重写行为

我想在javascript中重写一个内部函数。代码如下：

function Menu(x, y, z) {    
  this.createMenu = function(x, y) {
    //Some functionality
  }    
}

---

我想覆盖createMenu函数，而不覆盖整个菜单函数。有什么方法可以这样做。

您可以在它的实例中覆盖它

功能菜单（x，y，z）{
this.createMenu=函数（x，y）{
返回x+y；
}    
}
var m=新菜单；
log（m.createMenu（3,5））；
m、 createMenu=函数（x，y）{返回x*y；}；
log（m.createMenu（3,5））您可以在其实例中覆盖它


功能菜单（x，y，z）{
this.createMenu=函数（x，y）{
返回x+y；
}    
}
var m=新菜单；
log（m.createMenu（3,5））；
m、 createMenu=函数（x，y）{返回x*y；}；
log（m.createMenu（3,5））有两种可能的方法，一种是包装和覆盖
最初的构造器和引入工厂的构造器
创建构造函数的实例，并重新指定新行为
已存在的属性

采用后一种方法是可靠和安全的，但需要加以控制
将
新菜单（…）
中出现的所有代码更改为例如
createModifiedMenu

只有当一个人不想或根本无法改变上述内容时
仅当一个人的类型检查不依赖于操作时，代码才会出现
用<代码>实例< /代码>应该考虑采用前一种方法…

“覆盖和包装”方法

工厂方法

有两种可能的方法，一种是包装和覆盖
最初的构造器和引入工厂的构造器
创建构造函数的实例，并重新指定新行为
已存在的属性

采用后一种方法是可靠和安全的，但需要加以控制
将
新菜单（…）
中出现的所有代码更改为例如
createModifiedMenu

只有当一个人不想或根本无法改变上述内容时
仅当一个人的类型检查不依赖于操作时，代码才会出现
用<代码>实例< /代码>应该考虑采用前一种方法…

“覆盖和包装”方法

工厂方法

你尝试过什么吗？没有，
createMenu
本身不是一个属性，因此无法直接访问和覆盖。你能说说你到底想做什么以及为什么吗？你尝试过什么吗？没有，
createMenu
本身不是一个属性，所以不能直接访问和覆盖。你能说说你到底想做什么以及为什么吗？
//
//  closed implementation of code one does not own.
//
function Menu(x, y, z) {
    this.createMenu = function(x, y) {
        //Some functionality
    }
}

//
//  "overwriting and wrapping" approach.
//
Menu = (function (proceed) {

    function alternativeCreateMenu(x, y) {
        // alternative createMenu implementation
    }

    function ModifiedMenu(/*x, y, z*/) {
        // "restoration fake" of the original constructor.
        this.constructor = proceed;

        // super call via original constructor.
        proceed.apply(this, arguments);

        // altering the behavior.
        this.createMenu = alternativeCreateMenu;
    }
    // finsihing the inheritance step.
    ModifiedMenu.prototype = (new proceed);

    return ModifiedMenu;

}(Menu));


var menu = new Menu("a", "b", "c"); // ... thus, no instantiation shipped with
                                    // already existing code needs to be touched.
console.log("menu : ", menu);

//
//  closed implementation of code one does not own.
//
function Menu(x, y, z) {
    this.createMenu = function(x, y) {
        //Some functionality
    }
}

//
//  factory approach.
//
var createModifiedMenu = (function (Menu) {

    function alternativeCreateMenu(x, y) {
        // alternative createMenu implementation
    }
    return function (x, y, z) { // factory.
        var
            menu = new Menu(x, y, z);

        menu.createMenu = alternativeCreateMenu;

        return menu;
    };
}(Menu));


var menu = createModifiedMenu("a", "b", "c"); // ... thus, every instantiation shipped with
                                              // already existing code needs to be changed
console.log("menu : ", menu);                 // from `new Menu( ... )` to `createModifiedMenu( ... )`