1.作用域

1.1 函数

  1. 函数是一种对象类型 -> 引用类型 -> 引用值
  2. 常见方法
    1. test.name
    2. test.length
    3. test.prototype

  3. 对象 -> 有些属性是无法访问的，JS引擎内部固有的隐式属性

    1.2 [[scope]]

  4. 函数创建时生成的一个JS内部的隐式属性

  5. 函数存储作用域链的容器
    1. 作用域链存储GO、AO
      1. GO：全局的执行期上下文
      2. AO：函数的执行期上下文
        1. 每次执行时生成AO，函数执行完成以后，AO会被销毁
        2. AO是一个即时的存储容器

  6. [[scope]]的生命周期：

    1. 全局执行 - 函数定义
    2. 函数执行前一刻
    3. 函数执行结束
      1. function a(){
      2. function b(){
      3. var b = 2;
      4. }
      5. var a = 1;
      6. b();
      7. }
      8. var c = 3;
      9. a();
      10. /*
      11. GO = {
      12. c = undefined
      13.   -> 3;  
      14. a = function(){};
      15. }
      16. AO = {
      17. a = undefined
      18.   -> 1;
      19. b = function(){};
      20. AO2 = {
      21. b = undefined
      22.     -> 2;
      23. }
      24. }
      25. */

      2.闭包

      1.1 基础

  7. 当内部函数被返回到外部并保存时，一定会产生闭包，闭包会产生原来的作用域链不释放，过度的闭包可能会导致内存泄漏，或加载过慢。 ```javascript / — 1 — / function test1(){ function test2(){ var b = 2; console.log(a); } var a = 1; return test2(); } var c = 3; var test3 = test1(); test3();

/ — 2 — / function test(){ var n = 100; function add(){ n++; console.log(n); } function reduce(){ n—; console.log(n);
} return [add,reduce]; } var arr = test(); arr0; //101 arr1; //100

/ — 3 — / function breadMgr(num){ var breadNum = arguments[0] || 10;

function supply(){ breadNum += 10; console.log(breadNum); }

function sale(){ breadNum—; console.log(breadNum); } return [supply, sale]; } var breadMgr = breadMgr(50); breadMgr0; breadMgr1; breadMgr1;

/ — 4 — / function sunSched(){ var sunSched = ‘’;

var operation = { setSched: function(thing){ sunsched = thing; }, showSched: function(){ console.log(‘My schedule on sunday is ‘ + sunsched); } }

return operation; }

var sunSched = sunSched(); sunSched.setSched(‘studying’); sunSched.showSched(); ```