js总结（二）：函数、作用域和this

function Container( properties ) {
        var objthis = this;
        for ( var i in properties ) {
            (function(){  //闭包，一个封闭的区域，t仅仅在这个区域有效，不能对properties的值做任何修改
                    var t = properties[i];
                    objthis[ "get" + i ] = function() {return t;};
                    objthis[ "set" + i ] = function(val) {t = val;};
            })();
        }
    }  

var prop = {Name : "Jim", Age : 13};
var con = new Container(prop);
console.log(con.getName()); //Jim 

con.setName("Lucy");
console.log(con.getName());  //Lucy
console.log(prop.Name);//Jim

    function Container( properties ) {
        var objthis = this;
        for ( var i in properties ) {
           // (function(){
                   // var t = properties[i];
                    objthis[ "get" + i ] = function() {return properties[i]};
                    objthis[ "set" + i ] = function(val) {properties[i] = val;};
           // })();
        }
    }  

var prop = {Name : "Jim", Age : 13};
var con = new Container(prop);
console.log(con.getName());//13  getName返回的是properties[i],这个时候i已经指向了最后一位，就是13
console.log(con.getAge()); //13
con.setName("Lucy");
console.log(con.getName()); //Lucy 把最后那个变成lucy了
console.log(prop.Name);//Jim
console.log(prop.Age);//Lucy

闭包通过引用而不是值来捕获他的外部变量

使用立即调用的函数表达式，来创建局部作用域

值类型，1：基本类型是值类型，可以用typeof判断，2：占用空间固定保存在栈中 3：保存与复制的是值本身

引用类型 2：使用new 方法创建的对象，使用instanceof判断类型2：占用空间不固定，保存在堆中  3：保存与复制的是指向对象的指针。

关于传递的例子：

var a = [1,2,3]
var b = function(array){
      array = [4,5,6]
      console.log(array)// [4, 5, 6]
}
b(a);
console.log(a)//[1, 2, 3] 

var a = [1,2,3]；
var b = function(array){
      array.push(4);
      console.log(array);// [1,2,3,4]

}
b(a);
console.log(a)//[1, 2, 3,4]

赋值是靠等于号(=)，这样相当于是局部变量了，不会对原有的值改变。

相当于都是引用传递，用等于号相当于给变量赋予一个新的地址，如果继续改变原来地址的值，使用其他方法，2个都会变化。

参考： http://www.cnblogs.com/52cik/archive/2014/07/01/js-assignment-operators.html

var a =1;
function b (x, y, a) {
    arguments[2] = 10;
    alert (a);//10
}
b(1, 2, 3);
console.log(a)//1

二、作用域

函数确定一个作用域的范围，一个变量如果没有定义在函数内，他就是全局变量了。

一个变量在函数里面任何地方声明，都相当于在函数的前面声明，这就是变量提升。

当js查找与关系值时，会遵循一个查找链。这就是作用域链，作用链查找返回的是第一个轮值。也就是谁离得近。

内层函数可以访问外层函数的局部变量，外层函数不能访问内层函数的局部变量。

局部变量高于同名全局变量，参数变量高于同名全局变量，局部变量高于同名参数变量。

全局变量是全局(head/window)对象的属性,局部变量是调用对象的属性，局部变量是那个函数的属性。

this是指的谁调用这个函数了，就是函数前面的.（点），如果直接调用函数相当于window. ，用点调用方法来执行这个函数。

在嵌套函数里面引用this，引用的是head对象（window）

var a = 1,
    b = function a (x) {
        x && a (--x);
    };
console.log (a);//1

function a (x) {
    return x * 2;
}
var a;
console.log (a);//function a()

if (!("a" in window)) {//console.log(undefined in window); true undefined也在window里面
    var a = 1;
}
console.log (a);//undefined

作用域链就是查找返回的第一个值。函数定义时确定作用域，而非调用时

var a =function(){
     var foo = "foo"
     return function(){
         console.log(foo)
    }  

}    

var b =a() ;
b();//"foo"

var a =  10;
var AAA = function (){
    console.log(this.a);
}
var b  = {a:2,bbb:AAA};
b.bbb();

var test=function(){
    var a=1;
    setTimeout(function(){
        console.log(a);
        a=2;
    },1000);
    a=3;
    setTimeout(function(){
        console.log(a);
        a=4;
    },2000);

};
test();　

三、this

创建函数时，系统会在后台创建一个名为this的关键字，它连接到运行该函数的对象。this对函数的作用域是可见的，而且它是函数所在对象的一个引用

if (typeof Array.prototype.forEach != "function") {
  Array.prototype.forEach = function (fn, context) {
    for (var k = 0, length = this.length; k < length; k++) {
      if (typeof fn === "function" && Object.prototype.hasOwnProperty.call(this, k)) {
        fn.call(context, this[k], k, this);
      }
    }
  };
}

function a () {
   console.log (this);//Window {top: Window, window: Window, location: Location, external: Object, chrome: Object…}
}
a.call (null);