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

我喜欢@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`
  }
//...

据我所知，这些方法在行为上是等效的。

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

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

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

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

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

词汇范围是指从执行堆栈中的当前位置可见的标识符（例如，变量、函数等）的词汇。

- 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帮助简化上述定义。

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

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