Question

Here就是我做的。

＆＃13;

var A = function() {
  var internal = 0;
  this.increment = function() {
    return ++internal;
  };
};

var B = function() {};
// inherit from A
B.prototype = new A;
//first case
x = new B;
y = new B;
//second case
z = new A;
z1 = new A;

alert(x.increment() + " - " + y.increment());
alert(z.increment() + " - " + z1.increment());

＆＃13;

在第一种情况下，私有变量的行为类似于静态变量，在第二种情况下，它们的行为与普通变量相似。

1）我们可以从上述行为中得出关于私有变量或其他任何东西的结论吗？

2）刚出现的一个补充问题 - 当我们使用原型向构造函数添加属性和方法时，只有一个方法，这是在创建的所有实例（对象）之间共享的，同样的东西应用于变量？

Answer 1

要回答第二项补充质询，请考虑以下事项：

var A = function(){};
A.prototype.num = 0;
A.prototype.num2 = 0;

A.prototype.increment = function(modifyNum){
    console.log("increment");
    ++A.prototype.num;
    if(modifyNum == true){
        console.log("modifying num");
        this.num = 0;
    }
    console.log("num", this.num);

    ++this.num2;
    console.log("num2", this.num2);    
}


var test1 = new A();
test1.increment();

var test2 = new A();
test2.increment();

var test3 = new A();
test3.increment(true);

var test4 = new A();
test4.increment();

输出将是：

increment
num 1
num2 1
increment
num 2
num2 1
increment
modifying num
num 0
num2 1
increment
num 4
num2 1

您可以看到类实例将尊重原型，直到类本身直接修改num，因此它在自己的范围内重新定义它。在第三个测试中，num直接修改，其值不再指向原型。对于初学者而言，当在实践中使用诸如跟踪类实例之类的数字而不是递增数字时，所有这些本质上都是泄漏的。小心那里。

Answer 2

这只是该变量范围的概念。

第一种情况。

在第一种情况下，您继承了A类，即使用A类实例返回的原型创建另一个类。

这就是为什么变量增量将以静态方式工作，因为它只被声明一次。

第二种情况

在第二种情况下，您要创建两次A类的实例。所以变量实例将被声明两次，并为两个实例分别设置内存位置。

请记住，

当您调用该函数或创建该函数的实例时，将执行函数体。

Javascript - 私有变量的行为？

2 个答案: