你的位置:首页 > Java教程

[Java教程]JavaScript总结2


一、定义函数

在js中,函数也是对象,能赋值给变量,能当作参数,可以设置属性,和调用他拥有的方法。函数的toString()方法,会返回他完整的函数内容。他有两个定义方法,函数表达式和函数声明。当一个函数作为构造函数时,首字母写!函数声明在js运行前和变量声明一样被js提到所处作用域的最前面。函数可以定义在另一个函数的内部,也可以当作另一个的函数的return返回值。由于变量声明的hoisting特性,所以在函数中最好都在函数顶部声明有可能用到的所有变量。

函数声明: ([ ]括起来表示可有可无。)

function 函数名称 ( [ 参数 ] ){ 函数体 }

函数表达式:

function [函数名称] ([参数]) { 函数体 }

关于函数表达式,(function ([参数]) { 函数体 }([参数]))表示立即执行。eg:

(function (){
  alert("1");
}());

因为在js中函数也是对象,所以可以用构造函数来定义函数。

var f = new Function("x","y","z","return x + y - z;");
f(2,3,9);

Function可以输入任意数量的实参,最后一个字符串表示函数体。

二、函数的调用

第一种就是函数名加括号 FunctionName(),当他作为一个对象方法调用,并且返回自身,然后还可以再接着调用,这是函数的链式调用;

1 var x = {2  count:1,3  add:function(){4   this.count ++;5   return this;6  }7 };8 9 x.add().add().add();//x.count = 4;

 

第二种是用new关键字,作为构造函数条用,new FunctionName();

第三种是利用call(),apply()间接调用。他们的第一个参数都是当前函数执行上下文,也就是this,,如果第一个参数是null或者undefined,那么默认this为window。call后面的参数作为函数的实参,而apply后面的实参都放入一个数组中。

function test(x,y,z){  return x + y + z;}test.call(null,1,2,3);test.apply(null,[1,2,3]);

 

他的调用方式影响他的上下文this。如果就是普通函数调用,this就是window;如果是方法调用,this就是调用这个方法的对象;如果是当作构造函数调用,他会创建一个新对象,那么this就是他创建的这个新对象,如果用call或者apply间接调用,this就是他们的第一个参数。

三、函数传参

JavaScript的函数在传参这点做得很高级,但是不够严谨,太过随意。当传入个数少于函数的形参个数时,剩下的形参都是undefined,为了避免出错,最好用 || 给默认值。

而当传入个数多余形参个数时,也没有关系。虽然没法直接获得未命名值的引用,但是参数对象解决了这个问题。在函数体内,arguments指向实参对象的引用,他是一个类数组对象,从0开始,依次是传入参数的顺序,多余的为undefined。在arguments中有个callee属性,他是指当前正在执行的函数,可以调用的,当然乱用会产生死循环,不断的自己执行自己。

function test(){  console.log(arguments[4]);  console.log(arguments.callee);  return arguments[0] + arguments[1] + arguments[2];}test(1,2,3);var t = test;//函数作为值来使用t(1,2,3,4);

 

四、将函数作为命名空间

如果要写一段可复用的js代码,方便以后在其他项目中的使用,那么就应该把他放在一个函数中,因为并不能保证自己定义的变量是否和当前项目的全局变量重名。此时,这个函数名的作用就类似于命名空间,他把全局变量变成了函数的局部变量,并且可以向全局环境中隐藏一些变量。

五、函数作用域及作用域链(Scope Chain)

函数的作用域决定了参数和变量的生命周期,可见性,并且减少了命名冲突,提供了自动内存管理(GC,垃圾回收)。在一个js文件中,包括很多函数,每个函数都有自己的作用域,他们在一起就有了作用域链。内部的一个[[Scope]]属性包含了函数被创建时所处作用域中的对象集合,这个对象就是函数的作用域链。作用域链用来查找变量,需要注意的是,函数里声明变量一定要用var 否则他会变成全局变量的。例如:

 1 var window_x = "window"; 2 function test(){ 3   var parentsArg = arguments; 4   var test_x = "test";        5   function inner(){ 6     console.log(test_x); 7     console.log(window_x); 8     return parentsArg[0] + parentsArg[1] + parentsArg[2]; 9   }     10   return inner();11 } 

 

变量的查找

函数inner的作用域链可以看作 window--->test--->inner。例如查找window_x,首先查找inner的作用域是否有该变量,没有就接着作用域链上一级(test)查找,直到该标示符被找到,如果查找到window的全局作用域都没有该标示符,那么就要抛出异常了:xxx is not defined.(goolge chrome)。可以猜到,标示符所处的位置越深,他的查找会越慢,window的全局变量总是最后一个查找的。

作用域链(Scope Chain)的创建:inner为例

1.inner被创建,他的作用域链[[ scope ]]被填充test作用域中的对象集合;test被创建时,[[scope]]被填充了全局作用域的对象集合(window,document…….)。这些[[scope]]中的对象代表此函数的中可访问的数据。

2.inner被执行时,他要建立一个内部对象,称为“运行期上下文”,这个对象定义了函数执行时的环境。函数每次执行都会创建一个新的“运行期上下文”,当函数执行完毕时这个对象会自动销毁。一个运行期上下文有自己的作用域链[[scope]],scope中包括运行函数的scopeChain中包含的对象(复制过去的)。

3.上一步完成后,一个被称做“激活对象”的新对象就为运行期上下文创建好了。他包含所有可访问的局部变量,命名参数,参数集合等等。然后这个激活对象被推到作用域链的最前端,生命周期和作用域链一样。

此时,inner的作用域链包含了3个对象,inner的激活对象,outer的激活对象,window对象。

六、闭包 closure

闭包在《JavaScript权威指南》中的解释:函数对象可以通过作用域链相互关联起来,函数体内部的变量都可以保存在函数作用域内,这种特性在计算机科学文献中称为“闭包”。通俗点说,一个函数就是一个闭包。

1.闭包的作用

在js中,函数内可以随意访问全局变量,函数外想访问函数内的变量就不可以了(可以用这个特性来模仿类的私有变量)。但是闭包的特性解决了这个问题,他可以在外面访问函数内的局部变量

 1 function outer(){ 2  var outer_x = 0; 3  4 function inner(i){ 5   i = typeof i == "number" ? i : 0; 6   outer_x += i; 7   console.log("我要把outer_x + " + i + " = " + outer_x); 8  } 9 10 11  return inner;12 13 }14 15 var test = outer();16 test(1);//我要把outer_x + 1 = 117 test(2);//我要把outer_x + 2 = 318 test(3);//我要把outer_x + 3 = 619 test(4);//我要把outer_x + 4 = 1020 21 function outer1(i){22  var outer_x = 0;23  i = typeof i == "number" ? i : 0;24  outer_x += i;25  console.log("我要把outer_x + " + i + " = " + outer_x);26 }27 var test1 = outer1;28 test1(1);//我要把outer_x + 1 = 129 test1(2);//我要把outer_x + 2 = 230 test1(3);//我要把outer_x + 3 = 331 test1(4);//我要把outer_x + 4 = 4

 

在这里例子中,outer返回一个匿名的函数,这个匿名函数可以访问outer的局部变量,并且加一个指定的数字。这样可以通过外部的i来影响outer的局部变量。outer1也实现对局部变量outer_x加一个指定数字。对比一下他们的运行结果,可以发现,在有闭包的函数中,他的变量并没有被垃圾回收机制(GC)回收。那么闭包还可以用来让一些局部变量一直保存在内存中。需要小心内存泄漏。

为什么不会被GC回收?

outer函数返回了inner函数的引用给了test。inner的作用域链包括了inner,outer的激活对象,还有window对象,test在外部引用了inner,这个引用不放手,inner的作用域链就不会被GC回收,又因为inner作用域链包含了outer激活对象,那么处于outer作用域链的局部变量自然也不会被GC回收。

2.同一个作用域中的多个闭包

若同一个作用域链中有多个闭包,他们会共享同一个局部变量。并且关联到闭包的作用域链都是活动的。例如我想在一个函数中创建10个闭包。

function test(){  var arr = [];  for(var i = 0; i < 10; i++){    arr[i] = function(){    return i;    }  }  return arr;}var arr = test();var i = 0;while(i<10){ console.log( i + ":" + arr[i++]());}  

 

可以发现返回的arr数组中,每个都是10。为什么?因为当我执行var arr = test()时,i = 10,所有闭包都会共享这个i。嵌套的函数他不会将作用域内的局部变量复制一份的。arr[i] 的i没有受到影响,是因为这个i属于test的局部变量,并且没有在嵌套函数中。怎么样才能使用闭包达到需要的效果呢?

有2种方法,第一是把变量i变成全局变量,由于这个方法会污染全局变量,并不好。

var i = 0function test(){  var arr = [];  for(; i < 10; i++){    arr[i] = function(){    return i;    }  }  return arr;}  

 

第二种方法是让闭包函数立即执行,并且返回当前的值给外部函数的局部变量。

 

function test(){  var arr = [];  for(var i = 0; i < 10; i++){    arr[i] = (function(){    return i;    })();  }  return arr;}var arr = test();var i = 0;while(i<10){ console.log( i + ":" + arr[i++]);}

View Code

 

3.闭包的上下文this

下面的这个例子很清楚,一个函数内嵌套的函数无论在普通函数中,还是在方法中,他的上下文都是window。

var name = "The Window";  var myObject = {   name : "My Object",   getThis : function(){  console.log("方法:" + this.name);//方法:My Object    return function(){       console.log("方法中的闭包:" + this.name); //方法中的闭包:The Window   };    }  }; myObject.getThis()();function outer(){ var name = "outerName"; function inner(){  //return this.name //The Window  return name; //outerName } return inner;}console.log("普通函数的闭包:" + outer()());