在这个问题上，我们可以从另一个角度出发，后退一步，看看范围界定在更大的解释框架（运行程序）中的作用。换句话说，假设您正在为一种语言构建一个解释器（或编译器），并负责计算输出，给定一个程序和一些输入。

解释包括跟踪三件事：

状态-即堆和堆栈上的变量和引用内存位置。对该状态的操作，即程序中的每一行代码给定操作运行的环境，即状态在操作上的投影。

解释器从程序中的第一行代码开始，计算其环境，在该环境中运行该行，并捕获其对程序状态的影响。然后，它遵循程序的控制流执行下一行代码，并重复该过程直到程序结束。

为任何操作计算环境的方式都是通过编程语言定义的一组正式规则。术语“绑定”经常用于描述程序的整体状态到环境中的值的映射。注意，我们所说的“总体状态”不是指全局状态，而是指在执行过程中的任何一点上每个可到达定义的总和）。

这是定义范围问题的框架。现在进入下一部分我们的选择。

作为解释器的实现者，您可以通过使环境尽可能接近程序的状态来简化任务。因此，无论前一行是赋值、函数调用、从函数返回还是控制结构（如while循环），一行代码的环境都将简单地由前一行代码环境定义，并将该操作的效果应用于该行代码。

这就是动态作用域的要点，其中任何代码运行的环境都绑定到由其执行上下文定义的程序状态。

或者，你可以想象一个程序员使用你的语言，简化他或她的跟踪变量取值的任务。关于过去执行的全部结果的推理涉及太多的路径和太多的复杂性。词法作用域通过将当前环境限制在当前块、函数或其他作用域单元及其父级（即包围当前时钟的块或调用当前函数的函数）中定义的状态部分来帮助实现这一点。

换句话说，使用词法作用域，任何代码所看到的环境都绑定到与语言中明确定义的作用域（如块或函数）相关联的状态。

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

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

我通常通过举例学习，这里有一点小意思：

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

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

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

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

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

词汇作用域意味着在嵌套的函数组中，内部函数可以访问其父作用域的变量和其他资源。

这意味着孩子的函数在词汇上与父母的执行上下文绑定。

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

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不能被其父代访问。

这还告诉我们，在不同的执行上下文中具有相同名称的变量从执行堆栈的顶部到底部获得优先级。

在最里面的函数（执行堆栈的最顶层上下文）中，名称与另一个变量类似的变量将具有更高的优先级。

来源

词法范围：在函数外部声明的变量是全局变量，在JavaScript程序中随处可见。在函数内声明的变量具有函数范围，并且仅对该函数内出现的代码可见。