对作用域、作用域链的理解

合集下载

JS核心知识梳理

JS核⼼知识梳理前⾔本⽂⽬标从JS的运⾏，设计，数据，应⽤四个⾓度来梳理JS核⼼的知识点主题⼤纲1. JS运⾏变量提升执⾏上下⽂作⽤域let作⽤域链闭包事件循环2. JS设计原型原型链thiscallapplybindnew继承3. JS数据数据类型数据的存储（深浅拷贝）数据类型判断（隐式转换，相等和全等，两个对象相等）数据的操作（数组遍历，对象遍历）数据的计算（计算误差）4. JS应⽤防抖，节流，柯⾥化⼀. JS运⾏⼤概分为四个阶段1. 词法分析：将js代码中的字符串分割为有意义的代码块，称为词法单元浏览器刚拿到⼀个JS⽂件或者⼀个script代码段的时候，它会认为⾥⾯是⼀个长长的字符串这是⽆法理解的，所以要分割成有意义的代码块，⽐如: var a = 12. 语法分析：将词法单元流转换成⼀颗抽象语法树(AST)，并对⽣成的AST树节点进⾏处理，⽐如使⽤了ES6语法，⽤到了let,const，就要转换成var。

为什么需要抽象语法树呢？抽象语法树是不依赖于具体的，不依赖于语⾔的细节，⽅便做很多的操作另⼀⽅⾯说，现在有许多语⾔，C，C++，Java，Javascript等等，他们有不同的语⾔规范但是转化成抽象语法树后就都是⼀致的了，⽅便编译器对其进⾏进⼀步的增删改查等操作，3. 预解析阶段：会确定作⽤域规则变量和函数提升4. 执⾏阶段：创建执⾏上下⽂，⽣成执⾏上下⽂栈执⾏可执⾏代码，依据事件循环1.作⽤域指定了函数和变量的作⽤范围分为全局作⽤域和函数作⽤域，JS不像C，JAVA语⾔⼀样，没有块级作⽤域,简单说就是花括号的范围2.变量和函数提升全局变量和函数声明会提升函数声明⽅式有三种，function foo() {}var foo = function () {}var foo = new Function()可归为两类，直接创建和变量赋值变量赋值函数和赋值普通变量的优先级按位置来，变量名相同前者被覆盖函数直接创建优先级⾼于变量赋值，同名取前者，与位置⽆关，也就是说函数直接创建即使再变量声明后⾯，也是优先级最⾼3. 执⾏上下⽂有不同的作⽤域，就有不同的执⾏环境，我们需要来管理这些上下⽂的变量执⾏环境分为三种，执⾏上下⽂对应执⾏环境全局执⾏环境函数执⾏环境eval执⾏环境（性能问题不提）1. 全局执⾏上下⽂先找变量声明，再找函数声明2. 函数执⾏上下⽂先找函数形参，和变量声明把实参赋值给形参找函数声明多个函数嵌套，就会有多个执⾏上下⽂，这需要执⾏上下⽂栈来维护，后进先出执⾏上下⽂⾥包含着变量环境和词法环境变量环境⾥就包含着当前环境⾥可使⽤的变量当前环境没有⽤哪的, 这就说到了作⽤域链4. 作⽤域链引⽤JS⾼程的定义：作⽤域链来保证对执⾏环境有权访问的变量和函数的有序访问变量的查找顺序不是按执⾏上下⽂栈的顺序，⽽是由词法作⽤域决定的词法作⽤域也就是静态作⽤域，由函数声明的位置决定，和函数在哪调⽤⽆关，也就js这么特殊5. 静态作⽤域和动态作⽤域词法作⽤域是在写代码或者定义时确定的⽽动态作⽤域是在运⾏时确定的（this也是！）var a = 2;function foo() {console.log(a); // 静态2 动态3}function bar() {var a = 3;foo();}bar();复制代码闭包由于作⽤域的限制，我们⽆法在函数作⽤域外部访问到函数内部定义的变量，⽽实际需求需要，这⾥就⽤到了闭包引⽤JS权威指南定义：闭包是指有权访问另⼀个函数作⽤域中的变量的函数1. 闭包作⽤for循环遍历进⾏事件绑定输出i值时为for循环的长度+1这结果显⽰不是我们想要的, 因为JS没有块级作⽤域，var定义的i值，没有销毁，存储与全局变量环境中在事件具体执⾏的时候取的i值，就是全局变量中经过多次计算后的i值for(var i = 0;i < 3;i++){document.getElementById(`item${i+1}`).onclick = function() {console.log(i);//3，3，3}}复制代码闭包特性：外部函数已经执⾏结束，内部函数引⽤外部函数的变量依然保存在内存中,变量的集合可称为闭包在编译过程中，对于内部函数，JS引擎会做⼀次此法扫描，如果引⽤了外部函数的变量，堆空间创建换⼀个Closure的对象,⽤来存储闭包变量利⽤此特性给⽅法增加⼀层闭包存储当时的i值，将事件绑定在新增的匿名函数返回的函数上for(var i = 0;i < 3;i++){document.getElementById(`item${i+1}`).onclick = make(i);}function make(e) {return function() {console.log(e)//0，1，2};复制代码闭包注意我们在不经意间就写成了闭包，内部函数引⽤外部函数的变量依然保存在内存中，该销毁的没有销毁，由于疏忽或错误造成程序未能释放已经不再使⽤的内存，就造成了内存泄漏同时注意闭包不会造成内存泄漏，我们错误的使⽤闭包才是内存泄漏事件循环JS代码执⾏依据事件循环JS是单线程，通过异步保证执⾏不被阻塞1. 执⾏机制简单说就是，⼀个执⾏栈，两个任务队列发现宏任务就放⼊宏任务队列，发现微任务就放⼊微任务队列，执⾏栈为空时，执⾏微任务队列所有微任务，再取宏任务队列⼀个宏任务执⾏如此循环2. 宏&微任务 macroTask: setTimeout, setInterval, I/O, UI rendering microTask: Promise.then⼆. JS设计1. 原型1. JS的设计有new操作符，构造函数，却没有类的概念，⽽是使⽤原型来模拟类来实现继承2. JS设计⼼路历程JS在设计之初，给的时间较短，并且定义为简单的⽹页脚本语⾔，不⽤太复杂，且想要模仿Java的理念，(这也是为什么JS叫JavaScript的原因)因此就借鉴了Java的对象、构造函数、new操作符理念，⽽抛弃掉了了复杂的class(类)概念3. 继承机制需要有⼀种继承的机制，来把所有对象联系起来，就可以使⽤构造函数但是构造函数⽣成实例对象的缺点就是⽆法共享属性和⽅法4. prototype属性为解决上⾯问题，就引⼊了prototype属性，就是我们常说的原型为构造函数设置⼀个prototype属性，实例对象需要共享的⽅法,都放在此对象上，整个核⼼设计完成后，后⾯的API也就顺理成章原型每⼀个js对象在创建的时候就会与之关联另⼀个对象这个对象就是原型，每个对象都会从原型继承属性proto每个对象都有⼀个属性叫proto,该属性指向对象的原型构造函数的prototype属性等于实例化对象的proto属性此属性并不是ES5 中的规范属性，只是为了在浏览器中⽅便获取原型⽽做的⼀个语法糖，我们可以使⽤Object.getPrototype()⽅法获取原型constructor 原型没有指向实例，因为⼀个构造函数可以有多个对象实例但是原型指向构造函数是有的，每个原型都有⼀个constructor属性指向关联的构造函数function Per() {} // 构造函数const chi = new Per() // 实例对象chi.__proto__ === Per.prototype // 获取对象的原型也是就构造函数的prototype属性Per.prototype.constructor === Per // constructor属性获取当前原型关联的构造函数复制代码实例与原型读取实例属性找不到时，就会查找与对象关联的原型的属性，⼀直向上查找，这种实例与原型之间的链条关系，这就形成了原型链function Foo() {} = 'tom'const foo = new Foo() = 'Jerry'console.log(); // Jerrydelete console.log(); // tom复制代码2.原型链⾸先亮出⼤家熟悉的⽹图就是实例与构造函数，原型之间的链条关系实例的 proto 指向原型构造函数的 prototype 属性指向原型原型的 constructor 属性指向构造函数所有构造函数的 proto 指向 Function.prototypeFunction.prototype proto 指向 Object.prototypeObject.prototype proto 指向 null函数对象原型（Function.prototype）是负责造构造函数的机器，包含Object、String、Number、Boolean、Array，Function。

JavaScript经典语录

JavaScript经典语录Js的解析与执⾏过程：全局中的解析和执⾏过程：⼀：预处理：创建⼀个此法环境LE，扫描JS：1.⽤声明的⽅式声明的函数（不是函数表达式），2.⽤var定义的变量。

加到预处理阶段的此法环境中全局环境中的预处理：预处理创建的词法作⽤域LE相当于windows⼆：命名冲突的处理：1.处理函数声明有冲突时，会覆盖，处理变量声明有冲突时，会忽略。

2.两者都有时，函数声明的权重⾼⼀些，最终结果指向函数声明的引⽤三：全局函数的执⾏1.⾸先进⾏全局预处理2.执⾏完预处理后，代码⼀步步解析补充：运⽤词法的作⽤域，可以很好的解释⼀个带多个参数的函数只传递⼀个参数的例⼦。

函数中的解析和执⾏过程：函数中的解析和执⾏过程区别不是很⼤，有⼀个（arguments）注意⼀下：1.函数的预处理和全局的预处理类似（只是加了⼀个arguments，调⽤函数时实际调⽤的参数个数）如果不是var 声明的变量，会变成最外部LE的成员，即全局变量JS的作⽤域和作⽤域链：作⽤域⼀般分为四类：块级作⽤域、函数作⽤域、动态作⽤域、词法作⽤域（静态作⽤域）块级作⽤域：（js没有块级作⽤域）函数作⽤域：没有纯粹的函数作⽤域动态作⽤域：没有动态作⽤域词法作⽤域（静态作⽤域）javascript的作⽤域为静态作⽤域f[[scope]]==LE==window分析：1.创建⼀个作⽤域对象f[[scope]]==创建它时的词法环境LE（LE==window）2.真正执⾏的时候（⼀步⼀步往上找）LE--->f.[[scope]]==window在词法解析阶段，就已经确定了相关的作⽤域。

作⽤域还会形成⼀个相关的链条，称为作⽤域链new Function的情况⼜不⼀样问题：多个函数都想要⼀个变量，每次都要写⼀个好⿇烦⽅法：将变量设置为全局变量问题：不是说要减少全局⽤量的使⽤么？因为在我们做⼤项⽬的时候难免要引⼊多个JS库，变量间的命名可能会有冲突，且出错后不易查找，这个时候我们该怎么办呢？⽅法：将变量设置在⼀个function中，问题：在外⾯⼜访问不到了，怎么办？⽅法：我们使⽤匿名函数的⽅法Javascript中的作⽤域链：当执⾏⼀段JavaScript代码（全局代码或函数）时，JavaScript引擎会创建为其创建⼀个作⽤域⼜称为执⾏上下⽂（Execution Context）在页⾯加载后会⾸先创建⼀个全局的作⽤域，然后每执⾏⼀个函数，会建⽴⼀个对应的作⽤域，从⽽形成了⼀条作⽤域链。

闭包的深度理解

闭包的深度理解
闭包是JavaScript中一个非常重要的概念，它也是许多开发者在学习JavaScript时遇到的一个难点。

简单来说，闭包就是在一个函数内部定义另一个函数，并返回这个函数，使得这个函数可以访问到父函数的变量，即使父函数已经执行完毕。

理解闭包需要掌握以下几个概念：
1. 函数作用域：每个函数都有自己的作用域，作用域中的变量只能在该函数内部访问。

2. 作用域链：当访问一个变量时，JavaScript引擎会先在当前函数的作用域中查找，如果找不到就会沿着作用域链往上查找，直到找到全局作用域。

3. 内存管理：JavaScript使用垃圾回收机制来管理内存，当一个变量不再被引用时，JavaScript引擎就会将其从内存中删除。

当一个函数内部定义了另一个函数并返回时，返回的函数就形成了一个闭包。

闭包中的函数可以访问到外部函数中的变量，这是因为JavaScript引擎会在闭包中保存对外部变量的引用，使得这些变量不会被垃圾回收机制删除。

使用闭包可以实现许多有趣的功能，例如封装私有变量、实现模块化开发等。

但是闭包也有一些需要注意的地方，如可能导致内存泄漏和影响性能等问题。

总之，理解闭包是学习JavaScript的关键之一，掌握了闭包的使用方法和注意事项，可以让我们编写出更加优秀的JavaScript代
码。

详细图解作用域链与闭包

详细图解作⽤域链与闭包因此本⽂的⽬的就在于，能够清晰明了得把闭包说清楚。

⼀、作⽤域与作⽤域链在详细讲解作⽤域链之前，我默认你已经⼤概明⽩了JavaScript中的下⾯这些重要概念。

这些概念将会⾮常有帮助。

基础数据类型与引⽤数据类型内存空间垃圾回收机制执⾏上下⽂变量对象与活动对象作⽤域在JavaScript中，我们可以将作⽤域定义为⼀套规则,这套规则⽤来管理引擎如何在当前作⽤域以及嵌套的⼦作⽤域中根据标识符名称进⾏变量查找。

这⾥的标识符，指的是变量名或者函数名JavaScript中只有全局作⽤域与函数作⽤域(因为eval我们平时开发中⼏乎不会⽤到它，这⾥不讨论)。

作⽤域与执⾏上下⽂是完全不同的两个概念。

我知道很多⼈会混淆他们，但是⼀定要仔细区分。

JavaScript代码的整个执⾏过程，分为两个阶段，代码编译阶段与代码执⾏阶段。

编译阶段由编译器完成，将代码翻译成可执⾏代码，这个阶段作⽤域规则会确定。

执⾏阶段由引擎完成，主要任务是执⾏可执⾏代码，执⾏上下⽂在这个阶段创建。

作⽤域链⽣命周期，如下图。

执⾏上下⽂⽣命周期我们发现，作⽤域链是在执⾏上下⽂的创建阶段⽣成的。

这个就奇怪了。

上⾯我们刚刚说作⽤域在编译阶段确定规则，可是为什么作⽤域链却在执⾏阶段确定呢？之所有有这个疑问，是因为⼤家对作⽤域和作⽤域链有⼀个误解。

我们上⾯说了，作⽤域是⼀套规则，那么作⽤域链是什么呢？是这套规则的具体实现。

所以这就是作⽤域与作⽤域链的关系，相信⼤家都应该明⽩了吧。

我们知道函数在调⽤激活时，会开始创建对应的执⾏上下⽂，在执⾏上下⽂⽣成的过程中，变量对象，作⽤域链，以及this的值会分别被确定。

之前⼀篇⽂章我们详细说明了变量对象，⽽这⾥，我们将详细说明作⽤域链。

作⽤域链，是由当前环境与上层环境的⼀系列变量对象组成，它保证了当前执⾏环境对符合访问权限的变量和函数的有序访问。

为了帮助⼤家理解作⽤域链，我我们先结合⼀个例⼦，以及相应的图⽰来说明。

执行环境,作用域理解

Javascript学习---2、执行环境，作用域作者：名刘天下来源：博客园发布时间：2010-12-10 17:03 阅读：155 次原文链接[收藏]在javascript的学习中，执行环境、作用域是2个非常非常重要和基本的概念，理解了这2个概念对于javsacript中很多脚本的运行结果就能明白其中的道理了，比如搞清作用域和执行环境对于闭包的理解至关重要。

一、执行环境（exection context,也有称之为执行上下文）所有JavaScript 代码都是在一个执行环境中被执行的。

执行环境是一个概念，一种机制，用来完成JavaScript运行时在作用域、生存期等方面的处理，它定义了变量或函数是否有权访问其他数据，决定各自行为。

在javascript中，可执行的JavaScript代码分三种类型：1. Global Code，即全局的、不在任何函数里面的代码，例如：一个js文件、嵌入在HTML页面中的js代码等。

2. Eval Code，即使用eval()函数动态执行的JS代码。

3. Function Code，即用户自定义函数中的函数体JS代码。

不同类型的JavaScript代码具有不同的执行环境，这里我们不考虑evel code，对应于global code和function code存在2种执行环境：全局执行环境和函数执行环境。

在一个页面中，第一次载入JS代码时创建一个全局执行环境，全局执行环境是最外围的执行环境，在Web浏览器中，全局执行环境被认为是window对象。

因此，所有的全局变量和函数都是作为window对象的属性和方法创建的。

当调用一个JavaScript 函数时，该函数就会进入与该函数相对应的执行环境。

如果又调用了另外一个函数（或者递归地调用同一个函数），则又会创建一个新的执行环境，并且在函数调用期间执行过程都处于该环境中。

当调用的函数返回后，执行过程会返回原始执行环境。

函数级作用域和块级作用域

函数级作用域和块级作用域变量作用域是指在程序中一些特定位置，变量被声明后的可访问范围。

它决定了变量在哪些地方可以被访问和使用。

变量作用域可以分为函数级作用域和块级作用域。

函数级作用域是指变量在函数内部声明后，只能在这个函数内部被访问和使用。

函数级作用域的变量在函数执行结束后会被销毁，无法在函数外部被访问。

一个经典的例子是在JavaScript中使用关键字var声明的变量，它的作用域就是函数级作用域。

举个例子来说明函数级作用域：```javascriptfunction examplvar x = 10;console.log(x);example(; // 输出10console.log(x); // 报错，x未定义```在这个例子中，变量x只能在函数example内部使用，无法在函数外部访问。

当函数执行结束后，变量x也会被销毁，因此在函数外部访问x会报错。

块级作用域是指变量在代码块内部声明后，只能在这个代码块内部被访问和使用。

代码块是由一对花括号{}包裹的一段代码。

在ES6之前的JavaScript版本中，块级作用域是不存在的，变量的作用域只能是函数级别的。

但是，在ES6中引入了let和const关键字，它们具有块级作用域的特性。

举个例子来说明块级作用域：```javascriptfunction examplif (true)var x = 10;let y = 20;}console.log(x); // 输出10console.log(y); // 报错，y未定义example(;```在这个例子中，变量x是用var关键字声明的，它的作用域是全局的，所以在if语句块内部声明的x可以在if语句块外部访问。

而变量y是用let关键字声明的，它的作用域只限于if语句块内部，所以在if语句块外部无法访问。

函数级作用域的优点是可以有效地控制变量的作用范围，避免变量冲突和污染全局作用域。

它适用于那些需要在函数内部执行一些特定任务的情况，可以避免函数之间的变量互相干扰和影响。

作用域和作用域链的理解

作用域和作用域链的理解1.作用域的定义作用域是一个定义了变量和函数可访问性的规则集合。

它决定了在特定区域内定义的变量和函数在哪里可见和可访问。

2.作用域的分类作用域通常分为两种类型：全局作用域和局部作用域。

- 全局作用域：全局作用域是在整个程序中都可访问的作用域。

在JavaScript中，全局作用域是指在脚本中定义的变量和函数可以在整个脚本中的任何位置被访问。

-局部作用域：局部作用域是指在函数或块级作用域中定义的变量和函数只能在其所在的函数或块级作用域中被访问。

3.作用域链的定义作用域链是指在嵌套的作用域中，变量和函数的访问规则。

当一个程序中存在多个嵌套的作用域时，每个作用域都有一个连接到父级作用域的链，这些链组成了作用域链。

4.作用域链的工作原理在JavaScript中，函数在创建时会保存一个内部属性[[Scope]]，该属性包含了函数所在的作用域，即创建时的上下文环境。

当函数被调用时，会创建一个称为活动对象的对象，它包含了函数的参数和局部变量。

同时，JavaScript解释器会通过作用域链来查找变量的值。

作用域链的查找过程是由内向外的，即从当前作用域开始一级一级向上查找，直到找到所需的变量或到达全局作用域。

如果在局部作用域中找不到变量，它会沿着作用域链向上查找，直到找到变量或到达最外层的全局作用域。

以下是一个示例来说明作用域链的工作原理：```var a = 1; // 全局变量function outevar b = 2; // 外部函数变量function inner(var c = 3; // 内部函数变量console.log(a + b + c);}inner(;outer(; // 输出结果：6```在以上示例中，全局作用域中有一个变量a。

在outer(函数中，有一个变量b。

在inner(函数中，有一个变量c。

当inner(函数被调用时，它会先从自身作用域中查找变量c，如果找不到，就会向上一级作用域outer(中查找变量b，再找不到就继续向上查找全局作用域，直到找到全局作用域中的变量a。

什么是闭包？请举例说明（面试题目）

什么是闭包？请举例说明（⾯试题⽬）⼀、变量的作⽤域要理解闭包，⾸先必须理解Javascript特殊的变量作⽤域。

变量的作⽤域⽆⾮就是两种：全局变量和局部变量。

Javascript语⾔的特殊之处，就在于函数内部可以直接读取全局变量。

Js代码 var n=999; function f1(){ alert(n); } f1(); // 999另⼀⽅⾯，在函数外部⾃然⽆法读取函数内的局部变量。

Js代码 function f1(){ var n=999; } alert(n); // error这⾥有⼀个地⽅需要注意，函数内部声明变量的时候，⼀定要使⽤var命令。

如果不⽤的话，你实际上声明了⼀个全局变量！Js代码　function f1(){ n=999; } f1(); alert(n); // 999--------------------------------------------------------------------------------------------------------⼆、如何从外部读取局部变量？出于种种原因，我们有时候需要得到函数内的局部变量。

但是，前⾯已经说过了，正常情况下，这是办不到的，只有通过变通⽅法才能实现。

那就是在函数的内部，再定义⼀个函数。

Js代码 function f1(){ n=999; function f2(){ alert(n); // 999 } }在上⾯的代码中，函数f2就被包括在函数f1内部，这时f1内部的所有局部变量，对f2都是可见的。

但是反过来就不⾏，f2内部的局部变量，对f1 就是不可见的。

这就是Javascript语⾔特有的“链式作⽤域”结构（chain scope），⼦对象会⼀级⼀级地向上寻找所有⽗对象的变量。

所以，⽗对象的所有变量，对⼦对象都是可见的，反之则不成⽴。

既然f2可以读取f1中的局部变量，那么只要把f2作为返回值，我们不就可以在f1外部读取它的内部变量了吗！Js代码function f1(){ n=999; function f2(){ alert(n); } return f2; } var result=f1(); result(); // 999--------------------------------------------------------------------------------------------------------三、闭包的概念上⼀节代码中的f2函数，就是闭包。

ActionScript编程函数的作用域

ActionScript编程函数的作用域作用：定义函数在ActionScript代码中可调用的范围，以及决定函数可以访问那些范围的属性、方法和常量。

说明：在ActionScript3.0中，函数和变量都有作用的范围。

例如，之前介绍的全局函数，在整个代码中都可使用，其作用域最大。

而某些特定对象中的方法，则有一定的作用域限制。

例如，只能在链接其所在类为外部类之后才可使用。

1．作用域链当开始执行函数时，都会创建许多对象和属性。

首先，会创建一个名称为“激活对象”的特殊对象，该对象用于存储在函数体内声明的参数以及任何局部变量或函数。

接着，会创建一个“作用域链”，其中包含由Flash Player检查标识符声明的对象的有序列表。

在ActionScript3.0中，执行的每个函数都有一个存储在内部属性中的作用域链。

作用域链以这种方式延伸，直至到达全局对象。

全局对象是在ActionScript程序开始时创建的，其中包含所有全局变量和函数。

2．函数闭包函数闭包是一个对象，其中包含函数的快照及其“词汇环境”。

函数的词汇环境包括函数作用域链中的所有变量、属性、方法和对象以及它们的值。

无论何时在对象或类之外的位置执行函数，都会创建函数闭包。

方法的行为与函数闭包相似，因为方法也保留有关创建它们的词汇环境的信息。

当方法提取自它的实例（这会创建绑定方法）时，此特征尤为突出。

函数闭包与绑定方法之间的主要区别在于，绑定方法中this关键字的值始终引用它最初附加到的实例，而函数闭包中this关键字的值可以改变。

示例：函数闭包的作用通常体现在嵌套函数中。

例如，通过以下3个函数，可以清晰地体现出函数闭包的思想，如下所示。

javascript作用域、原型及原型链继承

作用域、原型及原型链继承
function initUI() {
前端主题分享 by 张臣
var doc = document,
links = doc.getElementsByTagName( "a" );
doc.getElementById( 'class-btn' ).onclick = function() {
前端主题分享 by 张臣
}
} 当assignEvents()函数被执行时，它的活动对象被创建，成为执行环境作用域链中的第一个对象，全局对象紧跟其后，当闭包被创建时，它的[[scope]] 属性被初始化为这些对象，如下图所示：
作用域、原型及原型链继承
前端主题分享 by 张臣
作用域、原型及原型链继承
解决方法：对于上例代码，闭包始终都会包含对element的引用，这里可以
将element设置为null，减少引用数，回收占用的内存，如下代码所示：
function assignEvents() { var element = YUD.get( 'elementId' ), id = element.id; YUD.get( 'save-btn' ).onclick = function( event ) { saveDocument( id );
前端主题分享 by 张臣
当函数add()创建时，它的作用域链中填入了一个单独的可变对象，
这个可变对象表示所有全局范围定
义的变量，如下图说明它们之间的关系:
作用域、原型及原型链继承
var total = add( 5, 10 );
前端主题分享 by 张臣

闭包的理解和应用场景

闭包的理解和应⽤场景1.什么是闭包？？在了解闭包之前，我们要清楚js的另⼀个知识，那就是作⽤域链。

什么是作⽤域链，⽐如⼀个函数⾥⾯包含着另⼀个函数，⾥⾯的函数在使⽤⼀个变量的时候会在函数⾃⼰的作⽤域内去查找这个变量，如果没有，就会沿着作⽤域链向上级函数的作⽤域去查找，这样的⼀个过程我们就叫做作⽤域链。

作⽤域链是可以有函数内部向外部去查找使⽤需要的变量，但是⽆法从上到下去查找函数内部的变量，所以这时候就出现了闭包，闭包就是解决这⼀问题。

简单来说，闭包就是⼀个可以访问另⼀个函数内部变量的函数。

1function f1(){2var n = 1003function f2(){4 n=n+1005 console.log(n);6 }7return f28 }9var temp = f1()10 temp() // 200在上述代码中创建了⼀个函数f1()，并在其内部创建了⼀个函数f2()，在正常情况下，在f2中可以访问f1中的变量n，但是f1不能访问f2中定义的变量，但是通过return将f2作为参数返回给f1，通过f2闭包来建⽴起与f1的联系，这样就可以访问f1中的变量例⼦2.var aaa = (function(){var a = 1;function bbb(){a++;console.log(a);}function ccc(){a++;console.log(a);}return {b:bbb, //json结构c:ccc}})();console.log(aaa.a);//undefinedaaa.b(); //2aaa.c() //3在上述代码中，由于闭包的作⽤，变量在函数使⽤后并没有被回收，⽽是继续存在内存中，当第⼆次使⽤该变量的时候，它的值应该是第⼀次试⽤后改变后的值，因此，aaa.c(),的值是在aaa.b()使⽤后的值得举出上在加1，最后输出的结果是32.闭包的应⽤场景当我们使⽤计时器的时候setTimeout(function(){},1000)的时候，第⼀个参数是⼀个函数，或者是⼀段执⾏的js代码，第⼆参数是第⼀个参数执⾏的时间间隔。

executioncontext用法

executioncontext用法ExecutionContext 是 JavaScript 中的一个重要概念，它表示代码在运行时的执行环境。

在每次 JavaScript 代码执行时，都会创建一个新的 ExecutionContext，并将其添加到执行上下文栈（Execution Context Stack）中。

下面是关于 ExecutionContext 的用法的详细解释，超过1200字。

1. 执行上下文栈（Execution Context Stack）：执行上下文栈是一个记录执行上下文的数据结构，用于管理代码的执行顺序。

栈的顶部始终是当前正在执行的上下文。

当 JavaScript 引擎遇到一个函数调用时，会创建一个新的 ExecutionContext，并将其压入栈顶。

函数执行完毕后，ExecutionContext 将会被弹出，指针重新回到上一个上下文。

2. 全局执行上下文（Global Execution Context）：在 JavaScript 中，全局执行上下文是代码执行的初始上下文。

在页面加载完成后，全局上下文会被创建并推入执行上下文栈中。

全局上下文有以下特点：- 全局对象（Global Object）：在浏览器环境中，全局对象指的是window 对象。

全局上下文中的变量和函数都会成为全局对象的属性和方法。

- this 值为全局对象。

- 全局对象预定义一些属性和方法，如 Object、Array、setTimeout 等。

3. 函数执行上下文（Function Execution Context）：函数执行上下文是在函数调用时创建的上下文。

它与全局上下文有类似的特点，如有自己的变量、函数和 this 值。

函数执行上下文有以下特点：-函数参数创建局部变量。

- 创建并维护自己的变量环境（Variable Environment）。

- 维护作用域链（Scope Chain）用于解析变量和函数的引用。

ef作用域

ef作用域一个程序中的每个函数及其参数和变量都拥有自己的作用域，作用域定义了这些函数和变量在程序中的可见性和访问性。

作用域规定了一个程序中的某个位置上那些标识符可见和可访问，同时也决定了如何解析名称冲突。

在本文中，我们将探讨EF （Entity Framework）中的作用域以及其相关参考内容。

1. EF作用域概述：在EF中，作用域是指在上下文中创建和使用实体对象的范围。

作用域控制了实体对象的生命周期和持久化，并确保只有在适当的时候才能访问它们。

作用域中的实体对象可以保存在数据库中，也可以被丢弃而不进行持久化。

2. EF作用域的管理：EF作用域由DbContext类来管理。

每个DbContext实例都代表一个作用域，它可以访问特定的数据库，并负责创建、更新和删除实体对象。

在一个作用域内，可以使用DbContext的各种API来操作实体对象和执行数据库操作。

3. EF作用域的创建：EF作用域可以通过创建DbContext实例来创建。

可以根据需要创建多个DbContext实例，每个实例代表一个独立的作用域。

创建DbContext实例的方式有多种，包括使用构造函数创建、继承DbContext类并创建自定义的DbContext子类等。

4. EF作用域的范围：EF作用域的范围可以是整个应用程序、单个请求、某个事务等。

根据具体的需求，可以决定每个作用域的范围和生命周期。

作用域的范围和生命周期会影响到实体对象的生命周期，以及对数据库的访问和效率。

5. EF作用域的嵌套：EF允许在作用域内嵌套其他作用域。

通过嵌套作用域，可以实现对实体对象和数据库操作的更细粒度的控制。

嵌套作用域的创建方式类似于创建普通的作用域，只是需要使用不同的DbContext实例。

总结：EF作用域在应用程序中起到非常重要的作用，它决定了实体对象的可见性和访问性，并控制了数据库操作的范围和效率。

了解EF作用域的概念和管理方式，对于编写高效且可维护的EF代码非常重要。

scopedvalue原理

scopedvalue原理一、概述scopedValue是Go语言中用于实现作用域范围隔离的值。

它是一种特殊的数据类型，可以在不同的作用域之间共享数据，同时保证了数据的安全性和隔离性。

在Go语言中，scopedValue常用于实现Web 应用程序中的会话管理、缓存等场景。

二、原理介绍1. 作用域概念：在Go语言中，作用域是指变量有效的作用范围。

在同一个作用域内，多个变量可以共存并相互影响；而在不同的作用域内，变量是独立的，无法相互访问。

2. scopedValue实现：scopedValue是一个接口类型，由实现了特定接口的变量类型所组成。

它通过在变量声明时指定作用域范围，来控制变量的生命周期和访问权限。

3. 作用域范围：在Go语言中，作用域范围可以通过关键字`new`、`func`等语法来指定。

scopedValue接口要求实现类型必须提供相应的范围限制方法。

4. 共享数据：由于scopedValue保证了不同作用域之间的隔离性，因此可以在不同的组件或线程之间共享数据。

通过将数据存储在scopedValue中，可以实现跨组件的数据传递和共享。

5. 安全性和可靠性：由于scopedValue对变量的访问进行了限制，只有符合作用域要求的人员或组件才能访问相应的数据，从而避免了非法访问和数据泄露的风险。

三、使用示例下面是一个使用scopedValue实现会话管理的示例代码：import "sync"type scopedValue struct {data interface{}mu sync.Mutex}func (sv *scopedValue) Set(data interface{}) {sv.mu.Lock()defer sv.mu.Unlock()sv.data = data}func (sv *scopedValue) Get() interface{} {sv.mu.Lock()defer sv.mu.Unlock()return sv.data}// 创建一个全局的scopedValue对象，用于存储会话数据var sessionData *scopedValue = &scopedValue{}func main() {// 在一个作用域中设置会话数据sessionData.Set("Hello, world!")// 在另一个作用域中获取会话数据并输出fmt.Println(sessionData.Get()) // 输出: Hello, world! }在上述示例中，我们使用`scopedValue`接口来实现会话数据的存储和获取。

js函数嵌套函数

js函数嵌套函数JavaScript中的函数嵌套函数是一种非常有用的编程技术，可以让我们在代码中更加灵活地组织和处理数据。

在这篇文章中，我们将会介绍函数嵌套、闭包、作用域链等概念，并且接下来的几个例子将会展示函数嵌套函数的应用场景和实现方法。

1. 函数嵌套的基础概念函数嵌套是Javascript中一个非常基础的概念，可以用来组织复杂的代码和数据。

嵌套函数是指一个函数中包含了其他函数。

嵌套函数有时也被称为“内部函数”。

在Javascript中，内部函数可以轻松地访问外部函数的所有变量、对象和方法。

这就是函数的作用域链。

2. 闭包的定义和原理一个函数作用域是指函数内部的变量和参数可以被该函数里嵌套的所有内部函数所访问。

而在javascript中，函数可以返回一个函数，这个函数可以继续使用该函数的变量和参数，这样的就形成了一个闭包。

闭包由两部分组成：环境和函数。

环境就是闭包创建时的作用域链，函数就是闭包里嵌套的函数。

闭包的原理可以通过这个例子来理解：``` function outerFunction() { var outerVariable = "I am a variable from outer function"; return function (){ console.log(outerVariable); } } var innerFunction = outerFunction(); innerFunction(); ```这段代码首先定义了一个函数 `outerFunction`。

该函数返回了一个新的函数，这个函数又被赋值给了一个变量 `innerFunction`。

最后执行了这个函数。

重点在于嵌套函数可以访问外部函数的变量。

这就是闭包的概念。

在这个例子中，内部函数可以访问外部函数的变量 `outerVariable`，并把该变量的值输出到控制台上。

3. 闭包的作用闭包可以用于实现一下几个常见场景：（1）依赖注入：闭包能够轻松地实现依赖注入。

C语言作用域

C语⾔作⽤域C语⾔作⽤域类型作⽤域⽣命周期auto变量⼀对{}内当前函数static局部变量⼀对{}内整个程序运⾏期extern变量整个程序整个程序运⾏期static全局变量当前⽂件整个程序运⾏期extern函数整个程序整个程序运⾏期static函数当前⽂件整个程序运⾏期register变量⼀对{}内当前函数局部变量与全局变量⼀、变量作⽤域C语⾔变量的作⽤域分为：代码块作⽤域(代码块是{}之间的⼀段代码)函数作⽤域⽂件作⽤域⼆、局部变量1、说明局部变量也叫auto⾃动变量(auto可写可不写)，⼀般情况下代码块{}内部定义的变量都是⾃动变量，它有如下特点：在⼀个函数内定义，只在函数范围内有效在复合语句中定义，只在复合语句中有效随着函数调⽤的结束或复合语句的结束局部变量的声明声明周期也结束如果没有赋初值，内容为随机2、案例#include <stdio.h>void test(){//auto写不写是⼀样的//auto只能出现在{}内部auto int b = 10;}int main(void){//b = 100; //err，在main作⽤域中没有bif (1){//在复合语句中定义，只在复合语句中有效int a = 10;printf("a = %d\n", a);}//a = 10; //err离开if()的复合语句，a已经不存在return0;}局部变量案例使⽤#define _CRT_SECURE_NO_WARNINGS#include <stdio.h>#include <string.h>#include <stdlib.h>#include <math.h>#include <time.h>void fun01(int a){return0;}int main(void){// 局部变量// 定义变量：局部变量在函数内部定义的变量使⽤auto修饰、栈区存储// 作⽤域：在函数内部// ⽣命周期：从创建到函数结束// 局部变量未初始化，值为乱码auto int a = 10;printf("%d\n", a);// 局部变量I，只限于for循环使⽤for (int i = 0; i < 10; i++){break;}return0;}局部变量案例使⽤：2三、全局变量1、说明在函数外定义，可被本⽂件及其它⽂件中的函数所共⽤，若其它⽂件中的函数调⽤此变量,须⽤extern声明全局变量的⽣命周期和程序运⾏周期⼀样不同⽂件的全局变量不可重名2、案例#define _CRT_SECURE_NO_WARNINGS#include <stdio.h>#include <string.h>#include <stdlib.h>#include <math.h>#include <time.h>// 全局变量// 全局变量、在函数外部定义的变量、存储数据区、可以和局部变量重名// 作⽤域：整个项⽬中所有⽂件、如果在其他⽂件中使⽤需要声明 extern// ⽣命周期：从程序创建到程序销毁// 全局变量未初始化、值为0extern int a = 10;int main(void){printf("%d\n", a);int a = 123;// 匿名内部函数、执⾏完销毁{int a = 123456;printf("%d\n", a);}// 数据在操作时会采⽤就近原则printf("%d\n", a);return0;}全局变量使⽤案例四、静态(static)局部变量1、说明static局部变量的作⽤域也是在定义的函数内有效static局部变量的⽣命周期和程序运⾏周期⼀样，同时staitc局部变量的值只初始化⼀次，但可以赋值多次static局部变量若未赋以初值，则由系统⾃动赋值：数值型变量⾃动赋初值0，字符型变量赋空字符2、案例#include <stdio.h>void fun1(){int i = 0;i++;printf("i = %d\n", i);}void fun2(){//静态局部变量，没有赋值，系统赋值为0，⽽且只会初始化⼀次static int a;a++;printf("a = %d\n", a);}int main(void){fun1();fun1();fun2();fun2();return0;}静态局部变量使⽤案例#define _CRT_SECURE_NO_WARNINGS#include <stdio.h>#include <string.h>#include <stdlib.h>#include <math.h>#include <time.h>void fun04(){// 静态局部变量// 静态局部变量只会初始化⼀次，可以多次赋值// 正常局部变量函数执⾏完后会被销毁// 在数据区进⾏存储// 作⽤域：只能在函数中使⽤// ⽣命周期：从程序创建到程序销毁// 静态局部变量未初始化、值为0static int b = 10;b++;printf("%d\n", b);}int main(void){for (int i = 0; i < 10; i++){fun04();}return0;}静态局部变量使⽤案例：2五、静态(static)全局变量1、说明在函数外定义,作⽤范围被限制在所定义的⽂件中不同⽂件静态全局变量可以重名,但作⽤域不冲突static全局变量的⽣命周期和程序运⾏周期⼀样，同时staitc全局变量的值只初始化⼀次2、案例#define _CRT_SECURE_NO_WARNINGS#include <stdio.h>#include <string.h>#include <stdlib.h>#include <math.h>#include <time.h>// 静态全局变量// 作⽤域：可以在本⽂件中使⽤、不可以在其他⽂件中使⽤// ⽣命周期：程序创建到程序销毁// 静态全局变量未初始化、值为0static int c = 10;int main(void){printf("%d\n", c);return0;}静态全局变量使⽤案例六、extern全局变量声明声明⼀个变量，这个变量在别的⽂件中已经定义了，这⾥只是声明，⽽不是定义。

js作用域链的理解

js作用域链的理解javascript作用域链是一种在javascript编程中使用的重要机制，可以帮助开发者正确的定位变量的位置，并帮助开发者更容易的管理变量作用域。

下面将介绍js作用域链的基本概念、有关概念和函数作用域链的相关内容，以帮助读者更好地理解js作用域链。

#### 一、js作用域链的基本概念在js中，作用域被称为变量作用范围。

作用域指的是变量、函数等在何处可以被定义或访问到，它是用来控制变量和函数的访问权限。

作用域可以分为全局作用域和局部作用域，当我们在js中定义变量或函数时，它们就默认在该作用域中声明。

在js定义的函数，其作用域是一种封闭的空间，它只有在函数内部可以被访问到。

js语言拥有自己独有的作用域链机制，它可以看做一种框架，用来管理变量和函数的作用域。

js作用域链机制分为三种：全局作用域链、函数作用域链和eval作用域链。

这三种作用域的作用不同，在不同的地方起到不同的效果。

#### 二、全局作用域链所有的代码都是在全局作用域中运行的，整个文件就是一个全局作用域，所有的函数和变量都在全局作用域中被定义，可以在全局作用域中访问到。

全局作用域链也被称为全局对象，它是程序执行的起点，因此它是整个作用域链中最顶端的变量或函数。

全局作用域链主要用于管理变量和函数的作用域，它还能够控制特定变量或函数在全局空间中的行为。

#### 三、函数作用域链函数作用域链也被称为局部作用域，其主要用于管理函数定义在函数本身内部的变量和函数的作用域，它可以帮助开发者更容易地管理变量作用域。

函数作用域链中，函数体内部可以访问函数作用域和全局作用域，但不能访问函数作用域外的任何变量。

在函数作用域链中，变量有优先顺序，全局变量优于局部变量，如果一个变量同时被定义在局部变量和全局变量中，则函数会优先访问局部变量，忽略全局变量。

####、eval作用域链eval是一个js函数，它的作用是把字符串作为js代码执行，也就是把字符串当作代码运行。

setlocal语法

setlocal语法5.1、setlocal：用于设置局部变量，作用域仅限于当前函数或代码块。

示例：```javascriptfunction test() {var a =10;setlocal var b =20;console.log(a); //输出：10console.log(b); //输出：20}test();```5.2、let：用于声明块级变量，作用域仅限于代码块。

示例：```javascriptlet a =10;console.log(a); //输出：10{let b =20;console.log(b); //输出：20}console.log(a); //输出：10console.log(b); //报错：ReferenceError: b is not defined```5.3、const：用于声明常量，一旦声明，值就不能被修改。

示例：```javascriptconst a =10;console.log(a); //输出：10a =20; //报错：Error: Cannot assign to read only property 'a'5.4、变量提升：JavaScript会在解析代码时将变量提升到当前作用域的顶部。

示例：```javascriptfunction test() {console.log(a); //报错：ReferenceError: a is not definedvar a =10;console.log(a); //输出：10}test();```5.5、作用域链：JavaScript通过作用域链来查找变量。

作用域链的顺序为：当前作用域 ->祖先作用域 ->全局作用域。

示例：```javascriptfunction test() {var a =10;function inner() {console.log(a);}inner(); //输出：10}test();```5.6、闭包：闭包是指一个函数可以访问其词法作用域之外的变量。

变量的作用域

变量的作⽤域变量的作⽤域：作⽤：起作⽤。

域：范围，区域。

1，变量的⽣命周期。

2，哪⾥可以访问变量。

----------------作⽤域-----------1，全局作⽤域全局都可以访问的变量的区域2，局部作⽤域：主要就是函数作⽤，理解为：函数体内部的执⾏环境。

不存在的变量或函数会报错；不存在的属性或⽅法，返回undefined；javascript 没有块级作⽤域：⽐如{ ...... } //在这个花括号⾥⾯的变量就叫块级作⽤域，但JS中没有块级作⽤。

⽐如：if(){......} for(){.....)等等：<script>if (true) {var a=0;//属于全局变量，因为JS不存在块级作⽤域，即：{}花括号之间的作⽤域，其他语⾔会有}for (var i = 0; i < elements.length; i++) {var b=1;//属于全局变量，因为JS不存在块级作⽤域，即：{}花括号之间的作⽤域，其他语⾔会有}</script>----------------------------------------<script>function fn(){var x=y=1;console.log(x);//返回 1console.log(y);//返回 1}// console.log(x);//报错，因为x是局部变量，不能再函数体以外进⾏访问。

fn();//如果不执⾏该⽅法，则输出下⾯y就会报错: y is undefinedconsole.log(y);//返回 1</script>---------js没有块级作⽤，所以变量都是全局作⽤域------------script type="text/javascript">if (true) {var name="xm"; //在js中没有块级作⽤域，所以，这⾥的name是全局变量。

经典闭包例子详解

经典闭包例⼦详解之前花了很多时间看书上对闭包的介绍，也看了很多⼈的写的关于闭包的博客，然后我就以为⾃⼰懂了。

结果，下午在⼀个QQ群⾥，有⼈问了这道经典的闭包问题，如下图：我告诉他去看书上的闭包介绍。

告诉他之后，我想我⾃⼰要不也写⼀下，反正花不了多少时间，结果花了好久怎么写也不对..............后来看了看书上的，然后⾃⼰总结了下，觉得这次应该懂了。

下次还不理解我就可以去跳楼了............-----------------------------------分割线-----------------------------------分割线--------------------------⾸先我们来了解⼏个概念：⽴即执⾏函数：形如（function(){}）();的⼀类函数；闭包：闭包是指有权访问另⼀函数作⽤域中的变量的函数。

作⽤域链：当代码执⾏的时候，会创建变量对象的⼀个作⽤域链....（具体百度）我们再来看这个问题，我重新写了⼀个，源码如下：<!DOCTYPE html><html><head><meta charset="utf-8"><title>闭包经典例⼦详解——huansky</title></head><body><div id="ttt"><p >000000000000000000</p><br><p >111111111111111111</p><br><p >222222222222222222</p></div></body><script>var dom=document.getElementsByTagName("p");for(var i=0;i<dom.length;i++){dom[i].onclick=function(){console.log(i);//3};}</script></html>View Code⾸先，代码中的匿名函数没有变量 i，所以它必须向上查找，在全局环境中找到了 i。

1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。

对作用域、作用域链的理解
作用域和作用域链是JavaScript中非常重要的概念，对于理解JavaScript的运行机制和编程思想有着至关重要的作用。

作用域是指变量和函数的可访问范围，也就是说，每个变量和函数都有自己的作用域。

在JavaScript中，作用域分为全局作用域和局部作用域。

全局作用域是指在整个程序中都可以访问的变量和函数，而局部作用域则是指在函数内部定义的变量和函数，只能在函数内部访问。

作用域链是指在JavaScript中，每个函数都有一个作用域链，用于查找变量和函数。

当一个函数需要访问一个变量或函数时，它会先在自己的作用域中查找，如果找不到，就会沿着作用域链向上查找，直到找到为止。

作用域链的顶端是全局作用域，也就是说，所有的变量和函数都可以在全局作用域中访问。

作用域和作用域链的理解对于编写高质量的JavaScript代码非常重要。

首先，我们需要避免变量和函数名的冲突，因为在JavaScript 中，变量和函数名的作用域是全局的。

其次，我们需要合理地使用作用域链，避免出现不必要的性能问题。

例如，在循环中定义函数会导致每次循环都会重新创建一个函数，从而影响性能。

作用域和作用域链是JavaScript中非常重要的概念，对于理解JavaScript的运行机制和编程思想有着至关重要的作用。

我们需要深
入理解作用域和作用域链的概念，合理地使用它们，才能编写出高质量的JavaScript代码。