私有变量和对父对象的访问

发布于 2025-01-03 18:24:57 字数 588 浏览 1 评论 0原文

我想要一个包含子对象 S 的主对象 M，该子对象 S 具有某个方法 E，该方法 E 具有私有变量 P。我还希望方法 E 可以通过另一个变量 V 访问 M。对于私有变量，我这样做：

M.S = function () {
    var P,
        V; // how to set V to M?

    return {
        E: function () {
            // stuff goes here
        }
    }
}();

我想出的一个解决方案是删除最后一行的 () ，然后调用匿名 S 创建函数作为 M 的方法。这解决了问题，但我认为可能有一种更优雅的方法去做吧。

M.S = function () {
    var P,
        V = this;

    return {
        E: function () {
            // stuff goes here
        }
    }
};
M.S = M.S()

大多数情况下，我需要知道什么是好的做法，因为我对 Javascript 中的私有变量很陌生。

原文

I want a main object M containing a sub-object S which has some method E which has a private variable P. I also want the method E to have access to M via another variable V. For the private variables I'm doing this:

M.S = function () {
    var P,
        V; // how to set V to M?

    return {
        E: function () {
            // stuff goes here
        }
    }
}();

One solution I came up with was to remove the () at the last line, and then calling the anonymous S-creating function as a method of M. this solves the problem, but I'm thinking there might be a more elegant way to go about it.

M.S = function () {
    var P,
        V = this;

    return {
        E: function () {
            // stuff goes here
        }
    }
};
M.S = M.S()

Mostly I need to know what is good practice for this, since I'm new to private variables in Javascript.

分享到QQ

分享到微博

如果你对这篇内容有疑问，欢迎到本站社区发帖提问参与讨论，获取更多帮助，或者扫码二维码加入 Web 技术交流群。

发布评论

需要登录才能够评论，你可以免费注册一个本站的账号。

一杯敬自由 2025-01-10 18:24:58

一个非常简单的方法是：

M.S = function (V) { // <-- V is declared locally
    var P;

    return {
        E: function () {
            // stuff goes here
        }
    };
}(M);

通过形式参数在本地声明 V。 M 的引用通过 function(V){...}(M); 分配给 V。

即使稍后重新声明 M，V 仍将指向正确的对象。

A pretty straightforward method to do this is:

M.S = function (V) { // <-- V is declared locally
    var P;

    return {
        E: function () {
            // stuff goes here
        }
    };
}(M);

V is locally declared through the formal parameter. M's reference is assigned to V, through function(V){...}(M);.

Even when M is redeclared at a later point, V will still point to the right object.

回复收藏 0 原文

陌生 2025-01-10 18:24:58

这又如何呢？您在 M 的上下文中调用 S：

M.S = function () {
    var P,
        V = this; // how to set V to M?

    return {
        E: function () {
            // stuff goes here
            // you can refer M via V reference
        }
    }
}.call(M);

What about this? You invoke S in context of M:

M.S = function () {
    var P,
        V = this; // how to set V to M?

    return {
        E: function () {
            // stuff goes here
            // you can refer M via V reference
        }
    }
}.call(M);

回复收藏 0 原文

~没有更多了~