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

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

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

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

作用域是可访问变量/绑定的上下文。词法范围是指封闭词法块的局部范围，而不是全局范围。

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

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

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

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

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

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

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

var scope = "I am global";
function whatismyscope(){
   var scope = "I am just a local";
   function func() {return scope;}
   return func;
}

whatismyscope()()

上述代码将返回“我只是本地人”。它不会返回“我是一个全球人”。因为函数func（）计算最初定义的位置，该位置在函数whatismyscope的范围内。

无论调用什么（全局范围/甚至来自另一个函数），它都不会麻烦，这就是为什么全局范围值“我是全局的”不会被打印出来的原因。

这被称为词法作用域，根据JavaScript定义指南，“函数使用定义时有效的作用域链执行”。

词汇范围是一个非常强大的概念。

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