Javascript 对象：如何创建工作对象的包容性封装？

Question

我想使用面向对象的 Javascript，但我的“对象”的行为并不像我期望的那样。

这是我的对象：

var Test = function(a){
    var variable = a;

    this.getA = function(){
        return this.variable;
    }

    this.setA = function(a){
        this.variable = a;
    }
}

现在我运行这段代码：

var a = new Test("foo");
var b = new Test("bar");

alert(a.getA());                //undefined, but "foo" expected
alert(a.getA() == b.getA());    //true, but false expected

alert(a.variable);              //undefined, as expected

a.variable = "whatever";
alert(a.getA());                //"whatever", but undefined expected
alert(a.variable);              //"whatever", but undefined expected

a.setA("somewhere");
alert(a.getA());                //"somewhere", as expected
alert(a.variable);              //"somewhere", but undefined expected

有谁知道如何创建一个功能对象，而不需要在开始时调用“setA(a)”，并且对象封装不允许 a.variable = “whatever”;？

Answer 1

如果您要封装a 的值，则无需使用this.variable 来访问该值，只需将this.variable 更改为variable 即可解决此问题。

变量具有函数作用域，因此var variable 定义了一个变量，该变量不仅适用于Test，还适用于setA 和getA：

var Test = function(a){
    var variable = a;

    this.getA = function(){
        //you want to access the variable,
        //not the property on the instance
        return variable;

    }

    this.setA = function(a){
        variable = a;
    }
}

Answer 2

在 JS 中引用的任何 this 都将可公开访问。

但是，由于 closure 的概念，您可以拥有完全私有的状态，只需在函数内部声明变量（或函数）。

此外，除非您希望通过编码获得原型，否则您甚至不需要new，也不需要this。

一个例子：

var makePerson = function (secret) {

    var is_alive = true,

        sayName = function () {
            if (!is_alive) { return; }
            console.log("My name is " + secret.name + ".");
        },

        sayAge = function () {
            if (!is_alive) { return; }
            console.log("My age is " + secret.age + ".");
        },

        haveBirthday = function () {
            if (!is_alive) { return; }
            secret.name += 1;
            console.log("I'm " + secret.name + 
                        ", and today I turned " + secret.age + ".");
        },

        die = function () {
            is_alive = false;
            console.log(secret.name + " died today;" +
                        " they were " + secret.age + " year" +
                        (secret.age > 1 ? "s" : "") + " old."   );
        },

        public_interface = { sayName      : sayName,
                             sayAge       : sayAge,
                             haveBirthday : haveBirthday,
                             die          : die           };

    return public_interface;
};


var bob = makePerson({ name : "Bob", age : 32 });

任何人都不能从外面触摸secret.name、secret.age 或is_alive。

bob.name; // undefined
bob.is_alive = false;  // Doesn't matter -- the code isn't relying on a public property.


bob.sayAge();       // "My age is 32"
bob.haveBirthday(); // "I'm Bob, and today I turned 33"
bob.die();          // "Bob died today; they were 33 years old"

更好的是，JS 允许你随时更改分配，所以你可能会担心这样的事情：

// person overwriting the function
bob.haveBirthday = function () { is_alive = false; };

...但是绝对没有理由担心有人这样做，因为他们无法访问这些内部属性。

bob.haveBirthday(); // window.is_alive = false;
bob.sayAge(); "My age is 33";

同样，如果你试图重写一个函数来窃取一个值：

bob.sayName = function () { return secret.name; };
bob.sayName(); // window.secret.name;  OR  ERROR: can't call `name` of `undefined`

任何未定义INSIDE函数的函数都NO可以访问内部属性或方法.

您可以以完全相同的方式拥有私有方法 - 事实上，所有这些函数都是私有的，直到我将它们全部附加到 public_interface 对象（这是我返回的）。

如果您开始使用prototype，请务必记住这一点。

var Thing = function (secret) {};
Thing.prototype.sayName = function () { console.log("My name is " + secret.name); };
var thing = new Thing({ name : "Bob", age : 32 });

thing.sayName(); // "My name is undefined"

甚至原型函数都不能访问私有状态——它们必须使用公共状态（通过this）。

您可以使用更复杂的结构，使多个闭包具有public、private、private static 和public static（这是prototype 最相似的）属性，但这是一个更高级一点，一开始会更混乱。

Answer 3

只是为了好玩（或出于演示目的），我同时找到了另一个解决方案：

var Test = function(x){
    var variables = function(){}
    variables.variable = x; 

    this.getA = function(){
        return variables.variable;
    }

    this.setA = function(x){
        variables.variable = x;
    }
}

测试结果：

    var a = new Test("foo");
    var b = new Test("baz");

    alert(a.getA());                //"foo" as expected
    alert(a.getA() == b.getA());    //false as expected

    a.variable = "whatever";
    alert(a.getA());                //"foo" as expected
    alert(a.variable);              //"whatever", doesn't seem preventable

    a.setA("somewhere");
    alert(a.getA());                //"somewhere", as expected
    alert(a.variable);              //"whatever", doesn't seem preventable