一、形参赋值默认值

1.1、ES6形参赋值默认值

在传递实参值时，可以用undefined来进行占位

  1.         // 初始化参数-默认值
  2.         // ES6形参赋值默认值
  3.         function test(a = 1, b = 2){
  4.             console.log(a, b);
  5.         }
  6.         test();
  9.         // 在传递实参值的时候，可以用undefined来进行占位
  10.         function func1(a = 1, b){
  11.             console.log(a, b);
  12.         }
  14.         func1(undefined, 10)

1.2、ES5形参赋值默认值

利用实参集合和或运算的特点进行形参赋值默认值

  1.         // ES5形参赋值默认值
  2.         // 利用实参集合和或运算的特点
  3.         function func(a, b){
  4.             var a = arguments[0] || 1;
  5.             var b = arguments[1] || 2;
  6.             return a + b;
  7.         }
  9.         console.log(func());

利用typeof的特点来进行形参赋值默认值

  1.         // ES5形参赋值默认值
  2.         // 利用实参集合和typeof的特点以及三目运算符来实现形参赋值默认值
  3.         function func(a, b){
  4.             var a = typeof(arguments[0]) !== 'undefined'? arguments[0]: 1;
  5.             var b = typeof(arguments[1]) !== 'undefined'? arguments[1]: 2;
  6.             return a + b;
  7.         }
  9.         console.log(func());

二、作业「递归」

三、预编译流程

3.1、JS代码解析的过程

  • 通篇检查语法错误
  • 预编译

  • 解释一行执行一行 ```javascript

    1.   // 预编译的流程
    2.   // 1. 通篇检车语法错误
    3.   // 2. 预编译的过程
    4.   // 3. 解释一行执行一行
    6.   // 函数声明整体会被提升
    7.   test();
    9.   function test(){
    10.       console.log(1);
    11.   }
    13.   test();
  1.     // 变量只有声明会提升，赋值不会被提升
  2.     console.log(a);
  3.     var a = 10;
  5.     console.log(b);
  6.     var b;
  8.     var c;
  9.     console.log(c);
  11.     // 1. 先声明变量a
  12.     // 2. 再把值1赋值给变量a
  13.     var a = 1;
  15.     function a(){
  16.         var a = 10;
  17.         var a = function(){}
  18.     }
  20.     var a = 10;
  1. <a name="aZ0bp"></a>
  2. # 四、暗示全局变量
  3. > - 暗示全局变量：imply global variable
  4. > - 在全局作用域下，写不写var都是属于暗示全局变量
  5. > - 没有声明直接赋值的，属于暗示全局变量
  7. ```javascript
  8.         // 暗示全局变量：imply global variable
  9.         // 在全局作用域下，写不写var都是属于暗示全局变量
  10.         // 没有声明直接赋值的，属于暗示全局变量
  11.         var a = 1;
  12.         b = 2;
  13.         console.log(a); // a = window.a
  14.         console.log(window.b); // b = window.b
  16.         // GO = {
  17.         //     a: 1,
  18.         //     b: 2
  19.         // }

暗示全局变量：imply global variable，没有声明就直接赋值的

  1.         // 暗示全局变量：没有声明就直接赋值
  2.         function func(){
  3.             var a = b = 1;
  4.         }
  6.         func();
  7.         console.log(b);
  8.         console.log(window.b);
  9.         console.log(typeof(a));
  10.         console.log(a);
  11.         console.log(window.a);

五、预编译的流程

5.1、函数作用域下的预编译流程

  • 寻找形参和变量声明
  • 统一形参和实参的值
  • 寻找函数声明并赋值
  • 执行

预编译练习

  1.         // 练习：预编译做过的事情，函数执行的时候就不用再去做了
  2.         function func(a, b){
  3.             console.log(a);
  4.             c = 0;
  5.             var c;
  6.             a = 5;
  7.             b = 6;
  8.             console.log(b);
  9.             function b(){}
  10.             function d(){}
  11.             console.log(b);
  12.             console.log(a, c);
  13.         }
  15.         func(1);
  17.         // 函数预编译流程分析
  18.         // AO = {
  19.         //     a: undefined -> 1 -> 5
  20.         //     b: undefined -> function b(){} -> 6
  21.         //     c: undefined -> 0
  22.         //     d: function d(){}
  23.         // }
  25.         // 1
  26.         // 6
  27.         // 6
  28.         // 5 0

5.2、全局作用域下的预编译流程

  • 寻找变量声明
  • 寻找函数声明并赋值
  • 执行

  • GO === window

    1.       // 全局作用域下的预编译分析
    2.       // 1. 寻找变量声明
    3.       // 2. 寻找函数声明
    4.       // 3. 执行
    5.       // GO: global object
    7.       console.log(a);
    8.       var a = 1;
    10.       function a(){
    11.           console.log(2);
    12.       }
    14.       console.log(a);
    16.       // 全局作用域下的预编译分析
    17.       // GO = {
    18.       //     a: undefined -> function a(){...}
    19.       // }
    21.       // function a(){...}
    22.       // 1
    1.       // 练习
    2.       console.log(a ,b);
    3.       function a(){}
    4.       var b = function(){}
    5.       console.log(b);
    7.       // 分析
    8.       // GO = {
    9.       //     b: undefined
    10.       //     a: function(){}
    11.       // }
    13.       // function a(){} -> undefined
    14.       // function(){}
    1.       // 练习
    2.       console.log(a);
    3.       var a = 1;
    4.       function a(){
    5.           console.log(2);
    6.       }
    8.       // 分析
    9.       // GO = {
    10.       //     a: undefined -> function a(){...}
    11.       // }
    13.       // function a(){....}
    1.       // 练习
    2.       var b = 1;
    3.       function func(){
    4.           var a = 1; 
    5.           var b = 2;
    6.           console.log(a, b);
    7.       }
    9.       func();
    10.       console.log(b);
    12.       // 分析
    13.       // GO = {
    14.       //     b: undefined -> 1
    15.       //     func: function func(){....}
    16.       // }
    18.       // AO = {
    19.       //     a: undefined -> 1
    20.       //     b: undefined -> 2
    21.       // }
    23.       // 1 2
    24.       // 1
    1.       // 练习
    2.       var b = 3;
    3.       console.log(a);
    4.       function a(a){
    5.           console.log(a);
    6.           var a = 2;
    7.           console.log(a);
    8.           function a(){}
    9.           var b = 5;
    10.           console.log(b);
    11.       }
    13.       a();
    15.       // 分析
    16.       // GO = {
    17.       //     b: undefined -> 3
    18.       //     a: function a(){....大函数}
    19.       // }
    21.       // AO = {
    22.       //     a: undefined -> function a(){....小函数} -> 2
    23.       //     b: 5
    24.       // }
    26.       // function a(){....大函数}
    27.       // function a(){....小函数}
    28.       // 2
    29.       // 5
    1.       // 练习
    2.       a = 1;
    3.       function test(){
    4.           console.log(a);
    5.           a = 2;
    6.           console.log(a);
    7.           var a = 3;
    8.           console.log(a);
    9.       }
    11.       test();
    12.       var a;
    14.       // 分析
    15.       // GO = {
    16.       //     a: undefined -> 1
    17.       //     test: function test(){...}
    18.       // }
    20.       // AO = {
    21.       //         a: undefined -> 2 -> 3
    22.       // }
    24.       // undefined
    25.       // 2
    26.       // 3

    5.3、条件判断下的变量提升

    在条件判断中，不管条件是否成立都要进行变量提升；因为在预编译阶段，函数内部的代码是还没有执行的，所以是不看条件是否成立的

  1.         // 条件判断下的变量提升：不管条件是否成立，都要进行变量提升
  2.         function test(){
  3.             console.log(b);
  4.             if(a){
  5.                 var b = 2;
  6.             }
  7.             c =3;
  8.             console.log(c);
  9.         }
  11.         var a;
  12.         test();
  14.         // 分析
  15.         // GO = {
  16.         //     a: undefined
  17.         //     test: function test(){...}
  18.         // }
  20.         // AO = {
  21.         //     b: undefined
  22.         // }
  24.         // undefined
  25.         // 3
  1.         // 练习
  2.         function test(){
  3.             console.log(b);
  4.             if(a){
  5.                 var b = 2;
  6.             }
  7.             c = 3;
  8.             console.log(c);
  9.         }
  11.         var a;
  12.         test();
  13.         a = 1;
  14.         console.log(a);
  16.         // 分析
  17.         // GO = {
  18.         //     a: undefined -> 1
  19.         //     test: function test(){....}
  20.         // }
  22.         // AO = {
  23.         //     b: undefined
  24.         // }
  26.         // undefined
  27.         // 3
  28.         // 1

六、作业

写出下面函数的AO

  1.         // 写出AO
  2.         function test(){
  3.             return a;
  4.             a = 1;
  5.             function a(){
  6.                 var a = 2;
  7.             }
  8.         }
  10.         console.log(test());
  12.         // 分析
  13.         // AO = {
  14.         //     a: function a(){...}
  15.         // }
  17.         // a: function a(){...}

特别注意：函数不写return，那么默认的返回值是undefined

  1.         // 写出AO
  2.         function test(){
  3.             a = 1;
  4.             function a(){
  5.                 var a = 2;
  6.                 return a;
  7.             }
  8.         }
  10.         console.log(test());
  12.         // 分析
  13.         // AO1 = {
  14.         //     a: function a(){...} -> 1
  15.         // }
  17.         // AO2 = {
  18.         //     a: undefined -> 2
  19.         // }
  21.         // undefined
  1.         // 写出AO
  2.         a = 1;
  3.         function test(e){
  4.             function e(){}
  5.             arguments[0] = 2;
  6.             console.log(e);
  7.             if(a){
  8.                 var b = 3;
  9.             }
  10.             var c;
  11.             a = 4;
  12.             var a;
  13.             console.log(b);
  14.             f = 5;
  15.             console.log(c);
  16.             console.log(a);
  17.         }
  19.         var a;
  20.         test(1);
  22.         // 分析
  23.         // GO = {
  24.         //     a: undefined -> 1
  25.         //     test: function test(){...}
  26.         // }
  28.         // AO = {
  29.         //     a: undefined - > 4
  30.         //     e: undefined -> 1 -> function e(){} -> 2
  31.         //     b: undefined 
  32.         //     c: undefined
  33.         // }
  35.         // 2
  36.         // undefined
  37.         // undefined
  38.         // 4

七、练习题

  1.         var a = false + 1;
  2.         console.log(a);
  4.         var b = false == 1;
  5.         console.log(b);

八、面试题

  1.         if(typeof(a) && (-true) + (+undefined) + ''){
  2.             console.log('pass');
  3.         }else{
  4.             console.log('no pass');
  5.         }
  1.         // 输出结果是什么？
  2.         console.log(!!" " + !!'' + !!false || 'pass');
  4.         // 输出结果是什么？为什么？
  5.         window.a || (window.a = '1');
  6.         console.log(a);