词汇范围意味着函数在其定义的上下文中查找变量，而不是在其周围的范围中查找变量。

如果您想了解更多详细信息，请查看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

这是一个古老的问题，但这是我对它的看法。

词法（静态）范围是指源代码中变量的范围。

在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需要足够聪明，以确定这些变量是否不再需要，如果不需要，可以垃圾收集它们。

我通过例子来理解它们。：）

首先，词法作用域（也称为静态作用域），在类似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语言既不允许嵌套函数，也不允许动态作用域。

范围定义了函数、变量等可用的区域。例如，变量的可用性是在其上下文中定义的，比如函数、文件或对象，它们是在中定义的。我们通常称这些局部变量。

词法部分意味着你可以从阅读源代码中获得范围。

词汇范围也称为静态范围。

动态范围定义了全局变量，这些变量在定义后可以从任何地方调用或引用。有时它们被称为全局变量，尽管大多数编程语言中的全局变量都属于词汇范围。这意味着，可以通过读取代码得出变量在此上下文中可用。也许必须遵循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中的匿名方法（闭包），因为它们知道调用函数的变量。它不会递归地遵循调用路径，因此不是完全动态的。

我希望这是有帮助的，这里是我对一个稍微更抽象的定义的尝试：

词汇范围：对程序中其他元素的访问或范围（例如函数或变量），取决于其在源代码中的位置。

事实上，我的逻辑只是建立在以下定义之上：

词汇：与语言的单词或词汇有关（特别是与语法或结构分离的单词）{在我们的情况下，是编程语言}。

作用域（名词）：操作范围｛在我们的例子中，范围是：可以访问的内容｝。

注意，ALGOL 60规范中最初的1960年词汇范围定义远比我上面的尝试更为简洁：

词汇范围：源代码中应用名称与实体绑定的部分。来源

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();