var与this，{}与function 小记

JavaScript var是用来定义一个变量，this常用来定义或调用一个属性或方法。但是在全局范围内，this和var定义变量是等价的。

window

 console.log('window:', name);
 var name = 'stone';
 this.name = 'niqiu';
 console.log('var:',name);
 console.log('this:',this.name);

 window对象有name属性，初始值为空，但第一个console的时候怎么获取值了呢。 发现这个window记录的是上次的值。重新打开页面，只执行 console.log('window:', name); 输出为空。 

  console.log('window:', name);
  var name = 'stone';

刷新两次后输出stone. 所以window对象在刷新的时候并没有重新创建。window是的{}对象。没有构造函数，不能new。

function与{}

在函数内部，var定义的是局部变量，而this定义的是属性。这两者没有覆盖。但新创建的对象是无法获取到局部变量的。

     var Fool = function () {
            var name = 'stone';
            var nikename = 'stoneniqiu';
            this.name = 'niqiu';
            this.getName = function () {
                console.log('var', name);
                console.log('this', this.name);
            };
            this.getNickname = function() {
                return nikename;
            };
        };

    console.log(f.name); //niqiu
    console.log(f.nikename);//undefined
    console.log(f.getNickname());//stoneniqiu

但是如果使用{}定义对象，内部变量等于全部都是属性。

  var block = {
            name: 'stone',
            nickname:'stoneniqiu',
            getName: function () {
                // return this.name;//stone
                return name; //'windows name';
            },
            getNickname:function() {
                return this.nickname;
            },
            printAllName:function() {
                console.log(this.getNickname());
                console.log(this.getName());
            }

        };

       console.log(block.name);//stone
       console.log(block.getName()); //windows name

像window对象一样，{}创建的对象不能new，因为没有构造函数。

所以如果对象复用，比较大，还是用function的形式比较好，分开私有变量和公共属性或方法，function的内部模块可以用{}的形式。

通过this可取得它们所属的上下文的方法称为公共方法。this到对象的绑定发生在调用的时候，这个“超级”延迟绑定使得函数可以对this高度复用。

 this指的是当前执行的对象，为避免this发生变化。常用一个变量暂存一下this。

var self=this 

神奇的回调

下面看个例子，对象的参数中定义了回调方法，但我们传入Fool自身的一个方法，居然执行了。

 var Fool = function (config) {
           var parmas = {
               callback: function() {
                   console.log('raw callback');
               }
           };
           parmas = $.extend(parmas, config);

           var name = 'stone';
           var nikename = 'stoneniqiu';
           this.name = 'niqiu';
           this.getName = function () {
               console.log('var', name);
               console.log('this', this.name);
           };
           this.getNickname = function () {
               return nikename;
           };
           this.doSomething = function () {
               parmas.callback();
           };
       };
       var f = new Fool({callback:function() {
           $("#bt").click(function() {
               f.getName()
           });
       }});

       f.doSomething();

运行无误，点击button 触发getName方法。但如果直接下面这样写，就会报错了，这错的很符合常理。

 var f = new Fool({callback:f.getName()});

 再修改下，用匿名函数包起来，也能跑。

var f = new Fool({callback:function() {
             (function() {
               f.getName();
            })();
       }});
       f.doSomething();

 今天弄明白，这其实是一个闭包问题，函数内部执行的f.getName()相当于是一个变量，它绑定外部的f，而并不是函数构建那一刻的f，所以在匿名函数构建时不会在意f是否创建了。相当于下面的这个经典问题：

var addhandle=function(node){
var i
for(i=0;i<node.length;i++){
 node[i].onclick=function(e){
 alert(i);
} 
}
}

如果执行上面的方法，绑定的就是循环结束之后的i。而不是循环那一刻的i。上面循环中的代码如果修改成下面这样。

nodes[i].onclick=function(i){
 return function(e){
 alert(e)
 }
}(i)

就是函数构建时的变量i了。