Javascript 原型显示模式和使用'；这'；在嵌套函数或返回对象中

我一直在使用原型揭示模式，下面是一个简单的虚构示例

如果我返回未注释的对象以从这里看到的原型函数中公开公共函数，则效果很好

另一方面，如果我使用另一个嵌套对象（注释掉的对象）将返回的公共函数组织在不同的层次结构中，则仍然可以调用函数，但instanceVar在“this”中未定义

我理解为什么（我认为），但我不确定如何传递正确的“this”实例，或者是否可以使用此模式，我想知道是否有人知道如何实现这一点

我已经试过了。打电话的方式很多，但还是得不到任何乐趣

WhoSays = function (sentence) {
    this.instanceVar = sentence;
};

WhoSays.prototype = (function () {

    var jimSays = function () {
        return 'jim says ' + this.instanceVar;
    };
    var bobSays = function () {
        return 'bob says ' + this.instanceVar;
    };

    /*return {
        says : {
            jim : jimSays,
            bob : bobSays
        }
    };*/

    return {
        jim: jimSays,
        bob: bobSays
    };

}());

。 更新：

我不想修改调用，调用方不需要知道如何使用明显的模式之外的模式

---

我确信这可能不是一种明智的做法，命名空间层次结构可能是一种更好的方式，但我仍然感兴趣的是，如果不使用调用来从调用方的角度绑定“this”，例如who.says.jim.apply（who）

调用

new whosay（）.says.jim（）

，

this

是

newwhosays（）。说的是
，而不是你想要的
newwhosays（）

你可以试试：

WhoSays.prototype = (function () {
    return {
        says: function() {
            var self = this;
            return {
                jim : function() {
                    return 'jim says ' + self.instanceVar;
                },
                bob : function() {
                    return 'jim says ' + self.instanceVar;
                },
            }
        };
    };
}());

然后调用
newwhosays（）.says（）.jim（）

或者使用
Object.defineProperty
来定义表示符号首选项的getter
语句

我个人的偏好是使用更传统的方式来获得你想要的东西。
如果你真的想让它像你正在尝试的那样工作，那么就这样使用它：

WhoSays = function (sentence) {
    this.instanceVar = sentence;
};

WhoSays.prototype = function () {
    var jimSays = function () {
        return 'jim says ' + this.instanceVar;
    };
    var bobSays = function () {
        return 'bob says ' + this.instanceVar;
    };

    return {
        says : {
            jim : jimSays,
            bob : bobSays
        }
    };
    /*
    return {
        jim: jimSays,
        bob: bobSays
    };*/

}();

var who = new WhoSays("works!");
console.log(who.says.jim.apply(who)); // logs "jim says works!"

您可以尝试以下代码：

var WhoSays = function (sentence) {
  this.instanceVar = sentence;
  this.says=new Says(this);
};

var Says = function(whoRef) {
  this.whoRef=whoRef;
};
Says.prototype.jim = function () {
  return 'jim says ' + this.whoRef.instanceVar;
};
Says.prototype.bob = function () {
  return 'bob says ' + this.whoRef.instanceVar;
};

var b = new WhoSays("b");
console.log(b.says.jim());
var c = new WhoSays("c");
console.log(c.says.jim());
console.log(b.says.jim());

更多关于原型、继承和重写的信息

理解这个
可以是什么：
我知道如果修改调用，我可以让它工作，我想我应该更清楚这一点。我试图避免打电话的人需要那样做。另外一个是使用apply。我认为这不会起作用，因为原型是一个单例，如果添加var c=new WhoSays（'c'），那么单例版本的_me将被c的this覆盖。除非我在你的答案中遗漏了什么，否则修改过的提琴会显示这一点。我明白为什么它不起作用，我试图确定是否有一些巧妙的技巧来避免改变它的调用方式，我的缺点是没有把它说得更清楚。我开始认为，如果不放弃揭示模式或使用.apply（）等，它是不可行的，这意味着它可能不值得追求。你喜欢什么样的“传统”方式？（1）whosay.prototype.saysJim=
和
whosay.prototype.saysBob=
，或（2）whosay.prototype.says=

和

says.prototype.bob=

和

says.prototype.jim=

。