在JS类中这样定义的变量怎么变成了静态变量？一直累加。我知道用this就可以，但我想知道为什么。

静态变量？用this就可以？
说啥呢

解决方案 »

  1.   

    上面的alert(_abc); 应该每次都是1，但它一直会累加，不知道为什么？
    你多点几次按钮嘛
      

  2.   

    function ClassA() 
    { 
    if(typeof ClassA._initialized == "undefined") 
    { 
    ClassA._abc = 0;
    ClassA.prototype.m1 = function() 
    {
    ClassA._abc++; 
    alert(ClassA._abc); 
    } 
    } 
    ClassA._initialized = true; 
    } 这样应该比较容易理解
      

  3.   

    因为变量_abc始终在function ClassA的作用域中，也就是该作用域的“全局变量”，所以每次都会加一。
    而用this时，每次new 都新建了一个ClassA的实例，也就是新建了一个作用域，所以不会出现这个现象。
      

  4.   

    cloudgamer说的和做的，我基本上都能明白。
    不要讨论我的代码的正确与否，我只想明白为什么会累加。
    每次都new 了一个实例啊！难道_abc不是在当前实例的作用域中吗？
    liuhongxing1908901能否讲得更详细一点？恕我愚钝。
      

  5.   

    <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd"> 
    <html> 
    <head> 
    <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1" /> 
    <title> Untitled Document </title> 
    <script type="text/javascript"> 
    function ClassA() 
    { 
        this._abc = 0; 
        if(typeof ClassA._initialized == "undefined") 
        { 
    ClassA.prototype.m1 = function() 
    { 
    this._abc++; 
    alert(this._abc); 
    } 
    } 
        ClassA._initialized = true; 
    } function test1() 
    { 
    var a1 = new ClassA(); 
    a1.m1(); 
    } 
    function test2() 
    { 
    var a2 = new ClassA(); 
    a2.m1(); 
    } 
    </script> 
    </head> 
    <body> 
    <input id="Button1" type="button" value="test1" onclick ="test1();"/> 
    <input id="Button2" type="button" value="test2" onclick ="test2();"/> 
    </body> 
    </html>
      

  6.   

    偶没说lz的错啊
    偶那个只是用来了解的
    就是_abc是属于ClassA的而不是ClassA的实例的
    那些实例的m1的作用只是修改了ClassA的_abc变量的值再显示
    如果用this那么_abc就属于ClassA的实例的了
    这个确实难理解
    偶也是一知半解
      

  7.   

    你看这个代码，点击按钮1和2，_abc会一直累加。 点按钮3，总是显示6。
    _abc有两个值，那就说明_abc又并不属于ClassA
    越来越糊涂了，想哭。
    在类的实例中，用this定义公有变量，如何定义私有变量？<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">
    <html>
    <head>
    <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1" />
    <title>Untitled Document</title>
    <script type="text/javascript">
    function ClassA()
    {
    var _abc = 5;
    this.m2 = function()
    {
    _abc++;
    alert(_abc);
    }
        if(typeof ClassA._initialized == "undefined")
        {
    ClassA.prototype.m1 = function()
    {
    _abc++;
    alert(_abc);
    }
    }
        ClassA._initialized = true;
    }
    var a1 = new ClassA();
    function test1()
    {

    a1.m2();
    }
    function test2()
    {

    a1.m1();
    }
    function test3()
    {
    var a2 = new ClassA();
    a2.m2();
    }
    </script>
    </head>
    <body>
    <input id="Button1" type="button" value="test1" onclick ="test1();"/>
    <input id="Button1" type="button" value="test2" onclick ="test2();"/>
    <input id="Button2" type="button" value="test3" onclick ="test3();"/>
    </body>
    </html>
      

  8.   

    function ClassA() 
    { 
    ClassA._abc = 5; 

    this.m2 = function() 
    { 
    ClassA._abc++; 
    alert(ClassA._abc); 
    }

    if(typeof ClassA._initialized == "undefined") 
    { 
    ClassA.prototype.m1 = function() 
    { 
    ClassA._abc++; 
    alert(ClassA._abc); 
    } 
    } 
    ClassA._initialized = true; 
    }每new一次就相当于运行一次ClassA即ClassA._abc重新赋值一次（等于5）
    那m2的时候当然是6了
      

  9.   

    a1是个全局变量，所以test1和test2每次点击都在同一个作用域中操作。a2是test3的局部变量，每次点击都会产生一个新的ClassA实例，所以不会累加。LZ看来就是要拼命绕糊涂啊。
      

  10.   

    10楼的写法是比较清晰的。
    关键是设计类时你就要清楚，那些属性是类属性，那些属性是对象属性。类属性就写成ClassA.XXX,对象属性就写成this.XXX，不一定要用原帖的那种表达方式啊。
    js的作用域机制其实就是绑定在对象上的。全局变量绑在window上，局部变量绑在相应的function（类）上的。
      

  11.   

    9楼的，你的a1属于全局对象，test1()与test2() 都不是新建立对象，所以，值是变化的。
    a2嘛，是局部的，就算不是局部的，10楼也给解释了。
      

  12.   


    function _x() {
       var x = 0;
       var _setValue = function(value) {
        x = value;
       };
       var _getValue = function() {
        return x;
       };
       this.setValue = function(value) {
        _setValue(value);
       };
       this.getValue = function() {
        return _getValue(); 
       };
       this.tellMeWhoAreYou = function() {
        alert("I'm _x"); 
       };
    }
    function _y() {
       this.tellMeWhoAreYou = function() {
        alert("I'm _y"); 
       };
    }
    _y.prototype = new _x();
    var x = new _x();
    var y = new _y();
    x.setValue(3);
    alert(x.getValue());
    y.setValue(5);
    alert(y.getValue());
    alert("x._getValue is " + typeof x._getValue);
    alert("y._getValue is " + typeof y._getValue);原理是利用变量的作用域, 因为_getValue 与 _setValue 的作用域只存在于 function _x() { } 之间,所只能在内部访问,而外部却访问不了..
      

  13.   

    16楼的意思是不是：因为m1()在function   ClassA() {}里，
    所以，每次调用m1()时，说白了，_abc是同一个 ？
      

  14.   

    引用菜农的"因为变量_abc始终在function   ClassA的作用域中，也就是该作用域的“全局变量”，所以每次都会加一。 
    而用this时，每次new   都新建了一个ClassA的实例，也就是新建了一个作用域，所以不会出现这个现象"
      

  15.   

    收藏了……
    为什么javascript没有一个docment呢……
      

  16.   

    因为你的M1是引用的第一次 new 出来的实例的 _abc后面new 出来 也是调用的 第一个实例的m1(这里注意m1里的_abc); 后面虽然有单独的_abc
    但是M1 始终会 使用 第一个实例的_abc我是这样理解的