变量提升

  1. /*
  2.   变量提升：var sum；
  3.   代码执行：
  4.   引用类型值（对象和函数）的处理
  5.       1.开辟一个新的堆内存（16进制的内存地址）
  6.       2.把内容存储到对内存中（对象存储的是键值对，函数存储是函数体中的代码字符串）
  7.       3.让变量和地址关联在一起
  9.       注意：在JS中上一行代码报错，下面的代码都不会再去执行了
  11. */
  12. consoel.log(sum);//undefined ，因为sum已经声明了，但是未定义
  13. var sum=function(n,m){
  14.   return n+m;
  15. }
  16. console.log(sum(10,20));//30
  18. /*
  19.  *let中没有变量提升,首先进行的是词法解析，一旦发现当前栈内存里有这个变量，
  20.    使用let/const重复声明就会报错
  21.  * 
  22.  *
  24. */
  25. console.log(1);//词法解析时，报错了，就不会在执行此行代码了
  26. let a=12;Uncaught SyntaxError: Identifier 'a' has already been declared
  27. console.log(a);
  28. let a=13;//
  29. console.log(a);

重复声明

  1. /*
  2.   变量提升：function fn(){};  var fn
  3.   代码执行：
  4. */
  5. fn();
  6. function fn(){ console.log(1); }
  7. fn();
  8. function fn(){ console.log(2); }
  9. fn();
  10. var fn = function(){ console.log(3); }
  11. fn();
  12. function fn(){ console.log(4); }
  13. fn();
  14. function fn(){ console.log(5); }
  15. fn();

画图思路**：**image.png

堆栈内存释放

  1. var i = 5;
  2. function fn(i) {
  3.     return function (n) {
  4.         console.log(n + (++i));
  5.     }
  6. }
  7. var f = fn(1);
  8. f(2); //=>4
  9. fn(3)(4); //=>8
  10. fn(5)(6); //=>12
  11. f(7); //=>10
  14. console.log(i); //=>5var  obj= {
  15.         i : 10,
  16.         fn:(function () {
  17.            var i = 0;// 加载时开辟的栈内存
  18.            return function (n) {
  19.                console.log(n + i++)
  20.            }
  21.         })()
  22.     };
  23.     var  f = obj.fn;
  24.     f(10);// 10
  25.     f(20);// 21
  26.     obj.fn(30);//32
  27.     obj.fn(40);// 43
  1. var x = 0,
  2.     y = 1;
  3. ~ function (x) {
  4.     //此处x为私有变量，但是没有赋值，因此为undefined，y为全局变量，因此向上级查找
  5.     console.log(x, y); //undefined  1
  6.     //条件： 如果或符号左侧为假，则值为右侧的
  7.       //             左侧为真，则为左侧的
  8.     x = x || 10;
  9.     y = y || 20;
  10.     console.log(x, y);// 10   1
  11. }();
  12. console.log(x, y);//0  1