立即执行函数

  • IIFE immediately invoked function expression
  • 立即执行函数的几种方式
    • (function(){}())
    • (function(){})()
    • +,-,!,||,&& 可以把函数变成表达式。
  • （任何东西）都会把里面东西变成表达式。
    1. //立即执行方法的几种形式
    2. //第一种  
    3. (function(){
    4. }());
    5. //第二种
    6.   (function(){
    7. })();
    8. //第三种
    9. +function(){}()
    10. -function(){}()
    11. !function(){}()
    12. 0||function(){}()
    13. 1&&function(){}();
    ```javascript var a = function(){
    1.   console.log(1);
    }(); console.log(a);// undefined 可以执行。 //是什么把这个匿名函数变成表达式的。

function test(){ console.log(‘x’) }();//报错函数声明加括号肯定会报错。

  2. - 表达式才能被执行符号执行。
  3. - 只要把函数声明成表达式。函数名就没有必要了。
  4. - 立即执行函数执行完毕之后会被立即销毁。这个时候函数名就没有必要了。
  5. ```javascript
  6. function test(a){
  7. console.log(a);
  8. }(6)//不报错、js 引擎会优先解析成(6)表达式、
  10. //相当于下面 
  11. function test(a){
  12.     console.log(a);
  13. }
  15. (6);//表达式

逗号运算符

  • 返回逗号后面的内容 ```javascript var num = (2-1,5+5,10+9);//19

//面试题 var fn = ( function test1(){ return 1 }, function test2(){ return ‘2’ } )(); console.log(typeof(fn))//string, //解释：相当于执行,后的test2,相当于执行test2(); typeof(‘2’) string;

  1. <a name="RXB7R"></a>
  2. ## ()表达式
  3. ```javascript
  4. var a = 10;
  5. if(function b(){}){
  6.   a += typeof(b); 
  7. }
  8.  console.log(a);//10undefined
  9. //解释：(function b(){})是表达式、

闭包深入

  1. //1：test 执行前一刻 生成了自己的AO ,接着test执行.
  2. function test(){
  3.   //2：test的AO里面包含了arr,i.
  4.     var arr = [];
  5.   //3: 执行的时候 arr = []; i=0;
  6.   for(var i = 0;i<10;i++){
  7.     //5: 此时,function(){...}被定义的时候生成了自己的作用域和作用域链.且作用域链第0位是test的AO
  8.      arr[i] = function(){
  9.               document.write(i);
  10.      }    
  11.   };
  12.     return arr;
  13. }
  14. //6: test执行完毕。test与test的AO之间断线
  15. var myArr = test()
  17. //7：myArr 循环的时候，myArr[j]()执行的时候操作的i还是test AO里面的i;
  18. for(var j = 0;j<myArr.length;j++){
  19.         myArr[j]();//10个10;
  20. }
  1. //让这段代码输出0-9;
  2. function test(){
  3.     var arr = [];
  4.   for(var i = 0;i < 10;i ++){
  5.       (function(j){
  6.        arr[j] = function(){
  7.               document.write(j);
  8.      } 
  9.      }(i))//立即执行函数。将i当参数传入到闭包中去。
  10.   };
  11.     return arr;
  12. }
  13. var myArr = test()
  14. for(var j = 0;j<myArr.length;j++){
  15.         myArr[j]();//0,1,2,3,4,5,6,7,8,9
  16. }
  17. //解释。在循环的时候添加一个立即执行函数，并且吧i当做参数传递给里面的函数。此时输出的i就不会变成10

demo

累加器

  1. //count  被定义时 产生了作用域和作用域链 作用域第0位存储着GO
  2. //count.scope_chain ={
  3. //                  0 : GO,   
  4. //                  }
  5. function count(){
  6.   //add 被定义的时候
  7.   //add.scope.chain={
  8.   //  0:count.AO,
  9.   //  1:GO
  10.   //}
  11.   //add.AO ={
  12.   //      n:0,
  13.   //      add:function(){};
  14.   //      }                            }
  15.  var n = 0;
  16.   function add(){
  17.      n++;
  18.     console.log(n);
  19.   }
  20.   return add//add 被返回出去。add的作用域链里还存着count的AO.
  21. }
  22. var countNum = count();
  23.      countNum();

缓存器

  1. // cacheMemory 被定义的时候 产生了cacheMemory作用域和作用域链
  2. // cacheMemory.scope-chain = {
  3. //        0:GO
  4. // }
  5. function cacheMemory(){
  6.    // addStudent 被定义的时候  
  7.    // addStudent.scope-chain{
  8.    //    0:cacheMemory.AO
  9.    //    1:GO
  10.    // }
  11.   var students = [];
  12.   function addStudent(name){
  13.     if(students.indexOf(name)>-1){
  14.        return;
  15.     }
  16.     students.push(name);
  17.     console.log(students);
  18.   }
  19.    // reduceStudent 被定义的时候  
  20.    // reduceStudent.scope-chain{
  21.    //    0:cacheMemory.AO
  22.    //    1:GO
  23.    // }
  24.   function reduceStudent(name){
  25.     var index = students.indexOf(name);
  26.     students.splice(index,1);
  27.     console.log(students);
  28.   }
  29.   return{
  30.     addStudent,
  31.     reduceStudent
  32.   }
  33.   // 返回出去的时候形成闭包。
  34. }