词汇范围的简要介绍是什么？
范围定义了函数、变量等可用的区域。例如，变量的可用性是在其上下文中定义的，比如函数、文件或对象，它们是在中定义的。我们通常称这些局部变量。
词法部分意味着你可以从阅读源代码中获得范围。
词汇范围也称为静态范围。
动态范围定义了全局变量，这些变量在定义后可以从任何地方调用或引用。有时它们被称为全局变量，尽管大多数编程语言中的全局变量都属于词汇范围。这意味着，可以通过读取代码得出变量在此上下文中可用。也许必须遵循uses或includes子句才能找到实例化或定义，但代码/编译器知道此处的变量。
相反，在动态作用域中，首先搜索本地函数，然后搜索调用本地函数的函数，然后在调用该函数的函数中搜索，依此类推，直到调用堆栈。“动态”是指更改，因为每次调用给定函数时，调用堆栈都可能不同，因此函数可能会根据从何处调用而命中不同的变量。（见此处）
要查看动态范围的有趣示例，请参阅此处。
有关详细信息，请参阅此处和此处。
Delphi/Object Pascal中的一些示例
Delphi具有词汇范围。
unit Main;
uses aUnit; // makes available all variables in interface section of aUnit
interface
var aGlobal: string; // global in the scope of all units that use Main;
type
TmyClass = class
strict private aPrivateVar: Integer; // only known by objects of this class type
// lexical: within class definition,
// reserved word private
public aPublicVar: double; // known to everyboday that has access to a
// object of this class type
end;
implementation
var aLocalGlobal: string; // known to all functions following
// the definition in this unit
end.
Delphi最接近动态范围的是RegisterClass（）/GetClass（）函数对。有关其用途，请参见此处。
假设调用RegisterClass（[TmyClass]）来注册某个类的时间无法通过读取代码来预测（它是在用户调用的按钮单击方法中调用的），调用GetClass（'MyClass'）的代码将得到结果或不得到结果。对RegisterClass（）的调用不必在使用GetClass（）单元的词法范围内；
动态范围的另一种可能性是Delphi2009中的匿名方法（闭包），因为它们知道调用函数的变量。它不会递归地遵循调用路径，因此不是完全动态的。
我通过例子来理解它们。：）
首先，词法作用域（也称为静态作用域），在类似C的语法中：
void fun()
{
int x = 5;
void fun2()
{
printf("%d", x);
}
}
每个内部级别都可以访问其外部级别。
还有另一种方式，称为Lisp的第一个实现使用的动态范围，同样是类似C的语法：
void fun()
{
printf("%d", x);
}
void dummy1()
{
int x = 5;
fun();
}
void dummy2()
{
int x = 10;
fun();
}
在这里，fun可以访问dummy1或dummy2中的x，也可以访问任何函数中声明了x的调用fun的任何x。
dummy1();
将打印5，
dummy2();
将打印10。
第一个被称为静态的，因为它可以在编译时推导出来；第二个被称之为动态的，因为外部范围是动态的，并且取决于函数的链调用。
我发现静态观察对眼睛来说更容易。大多数语言最终都走上了这条路，甚至Lisp（两者都能做到，对吧？）。动态作用域类似于将所有变量的引用传递给被调用函数。
作为编译器无法推断函数的外部动态范围的示例，请考虑我们的最后一个示例。如果我们这样写：
if(/* some condition */)
dummy1();
else
dummy2();
调用链取决于运行时条件。如果为真，则调用链看起来像：
dummy1 --> fun()
如果条件为假：
dummy2 --> fun()
在这两种情况下，乐趣的外部范围都是调用者加上调用者的调用者等等。
只需一提，C语言既不允许嵌套函数，也不允许动态作用域。
var scope = "I am global";
function whatismyscope(){
var scope = "I am just a local";
function func() {return scope;}
return func;
}
whatismyscope()()
上述代码将返回“我只是本地人”。它不会返回“我是一个全球人”。因为函数func（）计算最初定义的位置，该位置在函数whatismyscope的范围内。
无论调用什么（全局范围/甚至来自另一个函数），它都不会麻烦，这就是为什么全局范围值“我是全局的”不会被打印出来的原因。
这被称为词法作用域，根据JavaScript定义指南，“函数使用定义时有效的作用域链执行”。
词汇范围是一个非常强大的概念。
我喜欢@Arak这样的人提供的功能齐全、语言不可知的答案。由于这个问题被标记为JavaScript，所以我想插入一些与该语言非常相关的注释。
在JavaScript中，我们的作用域选择如下：
按原样（无范围调整）词法var_this=this；函数callback（）｛console.log（_this）；｝绑定回调.bind（this）
我认为值得注意的是，JavaScript并没有真正的动态范围。bind调整this关键字，这很接近，但在技术上并不相同。
下面是一个示例，演示了这两种方法。每次决定如何确定回调的范围时，都要这样做，因此这适用于承诺、事件处理程序等。
词汇
以下是JavaScript中回调的词法范围：
var downloadManager = {
initialize: function() {
var _this = this; // Set up `_this` for lexical access
$('.downloadLink').on('click', function () {
_this.startDownload();
});
},
startDownload: function(){
this.thinking = true;
// Request the file from the server and bind more callbacks for when it returns success or failure
}
//...
};
跳跃
作用域的另一种方法是使用Function.prototype.bind：
var downloadManager = {
initialize: function() {
$('.downloadLink').on('click', function () {
this.startDownload();
}.bind(this)); // Create a function object bound to `this`
}
//...
据我所知，这些方法在行为上是等效的。
词汇范围意味着函数在其定义的上下文中查找变量，而不是在其周围的范围中查找变量。
如果您想了解更多详细信息，请查看Lisp中词法作用域的工作原理。Kyle Cronin在Common Lisp的动态和词汇变量中选择的答案比这里的答案更清楚。
巧合的是，我只是在Lisp类中了解到这一点，而且它恰好也适用于JavaScript。
我在Chrome控制台中运行了这段代码。
// JavaScript Equivalent Lisp
var x = 5; //(setf x 5)
console.debug(x); //(print x)
function print_x(){ //(defun print-x ()
console.debug(x); // (print x)
} //)
(function(){ //(let
var x = 10; // ((x 10))
console.debug(x); // (print x)
print_x(); // (print-x)
})(); //)
输出：
5
10
5
围绕词汇和动态作用域的对话中有一个重要的部分是缺失的：作用域变量的生存期或何时可以访问变量的简单解释。
动态范围界定与“全局”范围界定在我们传统的思考方式中只是非常松散地对应（我之所以将两者进行比较，是因为已经提到了这一点——我并不特别喜欢链接文章的解释）；我们最好不要在全局变量和动态变量之间进行比较，尽管根据链接文章的说法，“……[它]作为全局范围变量的替代品很有用。”
那么，用简单的英语来说，这两种范围界定机制之间的重要区别是什么？
在上面的答案中，词汇范围定义得很好：词汇范围变量在定义它的函数的本地级别是可用的，或者是可访问的。
然而，由于它不是OP的重点，动态范围界定并没有得到太多的关注，它得到的关注意味着它可能需要更多的关注（这不是对其他答案的批评，而是“哦，那个答案让我们希望有更多的关注”）。所以，这里还有一点：
动态作用域意味着在函数调用的生命周期内，或在函数执行时，较大的程序可以访问变量。实际上，维基百科在解释两者之间的差异方面做得很好。为了避免混淆，下面是描述动态范围的文本：
…[I]n动态作用域（或动态作用域），如果变量名的作用域是则其范围是函数正在执行：当函数运行时，变量name存在，并绑定到其变量，但在函数之后返回，变量名不存在。
IBM将其定义为：
一个程序或段单元的一部分，其中有一个声明应用。例程中声明的标识符在例程和所有嵌套例程中。如果嵌套例程声明具有相同名称的项，外部项在嵌套例程。
示例1：
function x() {
/*
Variable 'a' is only available to function 'x' and function 'y'.
In other words the area defined by 'x' is the lexical scope of
variable 'a'
*/
var a = "I am a";
function y() {
console.log( a )
}
y();
}
// outputs 'I am a'
x();
示例2：
function x() {
var a = "I am a";
function y() {
/*
If a nested routine declares an item with the same name,
the outer item is not available in the nested routine.
*/
var a = 'I am inner a';
console.log( a )
}
y();
}
// outputs 'I am inner a'
x();
在这个问题上，我们可以从另一个角度出发，后退一步，看看范围界定在更大的解释框架（运行程序）中的作用。换句话说，假设您正在为一种语言构建一个解释器（或编译器），并负责计算输出，给定一个程序和一些输入。
解释包括跟踪三件事：
状态-即堆和堆栈上的变量和引用内存位置。对该状态的操作，即程序中的每一行代码给定操作运行的环境，即状态在操作上的投影。
解释器从程序中的第一行代码开始，计算其环境，在该环境中运行该行，并捕获其对程序状态的影响。然后，它遵循程序的控制流执行下一行代码，并重复该过程直到程序结束。
为任何操作计算环境的方式都是通过编程语言定义的一组正式规则。术语“绑定”经常用于描述程序的整体状态到环境中的值的映射。注意，我们所说的“总体状态”不是指全局状态，而是指在执行过程中的任何一点上每个可到达定义的总和）。
这是定义范围问题的框架。现在进入下一部分我们的选择。
作为解释器的实现者，您可以通过使环境尽可能接近程序的状态来简化任务。因此，无论前一行是赋值、函数调用、从函数返回还是控制结构（如while循环），一行代码的环境都将简单地由前一行代码环境定义，并将该操作的效果应用于该行代码。
这就是动态作用域的要点，其中任何代码运行的环境都绑定到由其执行上下文定义的程序状态。
或者，你可以想象一个程序员使用你的语言，简化他或她的跟踪变量取值的任务。关于过去执行的全部结果的推理涉及太多的路径和太多的复杂性。词法作用域通过将当前环境限制在当前块、函数或其他作用域单元及其父级（即包围当前时钟的块或调用当前函数的函数）中定义的状态部分来帮助实现这一点。
换句话说，使用词法作用域，任何代码所看到的环境都绑定到与语言中明确定义的作用域（如块或函数）相关联的状态。
JavaScript中的词法作用域意味着在函数外部定义的变量可以在变量声明之后定义的另一个函数内部访问。但事实并非相反；在函数内部定义的变量在该函数外部无法访问。
这个概念在JavaScript中的闭包中大量使用。
假设我们有以下代码。
var x = 2;
var add = function() {
var y = 1;
return x + y;
};
现在，当您调用add（）-->时，这将打印3。
因此，add（）函数正在访问在方法函数add之前定义的全局变量x。这是由于JavaScript中的词法作用域而调用的。
词汇作用域意味着在嵌套的函数组中，内部函数可以访问其父作用域的变量和其他资源。
这意味着孩子的函数在词汇上与父母的执行上下文绑定。
词汇范围有时也称为静态范围。
function grandfather() {
var name = 'Hammad';
// 'likes' is not accessible here
function parent() {
// 'name' is accessible here
// 'likes' is not accessible here
function child() {
// Innermost level of the scope chain
// 'name' is also accessible here
var likes = 'Coding';
}
}
}
关于词法作用域，你会注意到它是向前的，这意味着可以通过其子级的执行上下文访问该名称。
但它不能向其父代反向工作，这意味着变量likes不能被其父代访问。
这还告诉我们，在不同的执行上下文中具有相同名称的变量从执行堆栈的顶部到底部获得优先级。
在最里面的函数（执行堆栈的最顶层上下文）中，名称与另一个变量类似的变量将具有更高的优先级。
来源
我通常通过举例学习，这里有一点小意思：
const lives = 0;
function catCircus () {
this.lives = 1;
const lives = 2;
const cat1 = {
lives: 5,
jumps: () => {
console.log(this.lives);
}
};
cat1.jumps(); // 1
console.log(cat1); // { lives: 5, jumps: [Function: jumps] }
const cat2 = {
lives: 5,
jumps: () => {
console.log(lives);
}
};
cat2.jumps(); // 2
console.log(cat2); // { lives: 5, jumps: [Function: jumps] }
const cat3 = {
lives: 5,
jumps: () => {
const lives = 3;
console.log(lives);
}
};
cat3.jumps(); // 3
console.log(cat3); // { lives: 5, jumps: [Function: jumps] }
const cat4 = {
lives: 5,
jumps: function () {
console.log(lives);
}
};
cat4.jumps(); // 2
console.log(cat4); // { lives: 5, jumps: [Function: jumps] }
const cat5 = {
lives: 5,
jumps: function () {
var lives = 4;
console.log(lives);
}
};
cat5.jumps(); // 4
console.log(cat5); // { lives: 5, jumps: [Function: jumps] }
const cat6 = {
lives: 5,
jumps: function () {
console.log(this.lives);
}
};
cat6.jumps(); // 5
console.log(cat6); // { lives: 5, jumps: [Function: jumps] }
const cat7 = {
lives: 5,
jumps: function thrownOutOfWindow () {
console.log(this.lives);
}
};
cat7.jumps(); // 5
console.log(cat7); // { lives: 5, jumps: [Function: thrownOutOfWindow] }
}
catCircus();
在简单的语言中，词法作用域是在作用域外部定义的变量，或者更高的作用域在作用域内部自动可用，这意味着您不需要在那里传递它。
例子：
let str="JavaScript";
const myFun = () => {
console.log(str);
}
myFun();
//输出：JavaScript
词汇范围是指从执行堆栈中的当前位置可见的标识符（例如，变量、函数等）的词汇。
- global execution context
- foo
- bar
- function1 execution context
- foo2
- bar2
- function2 execution context
- foo3
- bar3
foo和bar总是在可用标识符的词典中，因为它们是全局的。
当执行function1时，它可以访问foo2、bar2、foo和bar的词典。
当执行function2时，它可以访问foo3、bar3、foo2、bar2、foo和bar的词典。
全局和/或外部函数无法访问内部函数标识符的原因是，该函数的执行尚未发生，因此，其标识符均未分配给内存。此外，一旦内部上下文执行，它就会从执行堆栈中删除，这意味着它的所有标识符都已被垃圾收集，不再可用。
最后，这就是为什么嵌套的执行上下文总是可以访问它的祖先执行上下文，因此它可以访问更大的标识符词典。
See:
https://tylermcginnis.com/ultimate-guide-to-execution-contexts-hoisting-scopes-and-closures-in-javascript/https://developer.mozilla.org/en-US/docs/Glossary/Identifier
特别感谢@robr3rd帮助简化上述定义。
本主题与内置绑定函数密切相关，并在ECMAScript 6 Arrow函数中介绍。这真的很烦人，因为对于我们想要使用的每一个新的“类”（实际上是函数）方法，我们都必须绑定它才能访问作用域。
默认情况下，JavaScript不会在函数上设置this的范围（它不会设置this的上下文）。默认情况下，您必须明确说出您想要的上下文。
箭头函数自动获得所谓的词法范围（可以访问包含块中变量的定义）。当使用箭头函数时，它会自动将其绑定到最初定义箭头函数的位置，并且该箭头函数的上下文是其包含块。
通过以下最简单的示例，了解它在实践中的工作原理。
在箭头函数之前（默认情况下没有词法范围）：
const programming = {
language: "JavaScript",
getLanguage: function() {
return this.language;
}
}
const globalScope = programming.getLanguage;
console.log(globalScope()); // Output: undefined
const localScope = programming.getLanguage.bind(programming);
console.log(localScope()); // Output: "JavaScript"
使用箭头函数（默认为词法范围）：
const programming = {
language: "JavaScript",
getLanguage: function() {
return this.language;
}
}
const arrowFunction = () => {
console.log(programming.getLanguage());
}
arrowFunction(); // Output: "JavaScript"
这是一个古老的问题，但这是我对它的看法。
词法（静态）范围是指源代码中变量的范围。
在JavaScript这样的语言中，函数可以被传递、附加和重新附加到其他对象，您可能会想到，这个范围将取决于当时调用该函数的人，但事实并非如此。以这种方式更改作用域将是动态作用域，而JavaScript不会这样做，除非可能使用此对象引用。
要说明这一点：
var a=“苹果”；函数doit（）{var a=“ardvark”；返回函数（）{警报（a）；}}var test=doit（）；测试（）；
在示例中，变量a是全局定义的，但在doit（）函数中隐藏。此函数返回另一个函数，如您所见，该函数依赖于自身范围之外的变量。
如果您运行这个，您会发现使用的值是aardwark，而不是apple，虽然它在test（）函数的范围内，但不在原始函数的词法范围内。也就是说，使用的范围是源代码中显示的范围，而不是实际使用函数的范围。
这一事实可能会产生令人讨厌的后果。例如，您可能会决定更容易单独组织函数，然后在时间到来时使用它们，例如在事件处理程序中：
var a=“苹果”，b=“香蕉”；函数init（）{var a=“ardvark”，b=“andicoot”；document.querySelector（'button#a'）.onclick=函数（事件）{警报（a）；}document.querySelector（'button#b'）.onclick=doB；}函数doB（事件）{警报（b）；}init（）；<button id=“a”>a</button><button id=“b”>b</button>
此代码示例分别执行其中一项。您可以看到，由于词法作用域，按钮A使用内部变量，而按钮B不使用。您可能最终嵌套的函数比您想要的更多。
顺便说一句，在这两个示例中，您还将注意到，即使包含函数函数已经运行，内部词汇范围内的变量仍然存在。这称为闭包，指的是嵌套函数对外部变量的访问，即使外部函数已经完成。JavaScript需要足够聪明，以确定这些变量是否不再需要，如果不需要，可以垃圾收集它们。
我希望这是有帮助的，这里是我对一个稍微更抽象的定义的尝试：
词汇范围：对程序中其他元素的访问或范围（例如函数或变量），取决于其在源代码中的位置。
事实上，我的逻辑只是建立在以下定义之上：
词汇：与语言的单词或词汇有关（特别是与语法或结构分离的单词）{在我们的情况下，是编程语言}。
作用域（名词）：操作范围｛在我们的例子中，范围是：可以访问的内容｝。
注意，ALGOL 60规范中最初的1960年词汇范围定义远比我上面的尝试更为简洁：
词汇范围：源代码中应用名称与实体绑定的部分。来源
推荐文章
- 如何使用Jest测试对象键和值是否相等?
- 将长模板文字行换行为多行，而无需在字符串中创建新行
- 如何在JavaScript中映射/减少/过滤一个集?
- Bower: ENOGIT Git未安装或不在PATH中
- 添加javascript选项选择
- 在Node.js中克隆对象
- 为什么在JavaScript的Date构造函数中month参数的范围从0到11 ?
- 使用JavaScript更改URL参数并指定默认值
- 在window.setTimeout()发生之前取消/终止
- 如何删除未定义和空值从一个对象使用lodash?
- 检测当用户滚动到底部的div与jQuery
- 在JavaScript中检查字符串包含另一个子字符串的最快方法?
- 检测视口方向，如果方向是纵向显示警告消息通知用户的指示
- ASP。NET MVC 3 Razor:在head标签中包含JavaScript文件
- 禁用从HTML页面中拖动图像
