Analisis mendalam tentang skop dan konteks dalam kemahiran JavaScript

Skop dan konteks dalam JavaScript adalah unik kepada bahasa, sebahagiannya disebabkan oleh fleksibiliti yang dibawanya. Setiap fungsi mempunyai konteks dan skop pembolehubah yang berbeza. Konsep ini mendasari beberapa corak reka bentuk yang berkuasa dalam JavaScript. Walau bagaimanapun, ini juga membawa kekeliruan besar kepada pembangun. Perkara berikut secara komprehensif mendedahkan perbezaan antara konteks dan skop dalam JavaScript, dan cara pelbagai corak reka bentuk menggunakannya.

Konteks dan Skop

Perkara pertama yang anda perlu tahu ialah konteks dan skop adalah dua konsep yang sama sekali berbeza. Selama bertahun-tahun, saya mendapati bahawa ramai pembangun (termasuk saya sendiri) mengelirukan kedua-dua konsep ini dan tersilap mencampurkan kedua-dua konsep tersebut. Untuk bersikap adil, banyak istilah telah digunakan secara mengelirukan selama ini.

Setiap panggilan ke fungsi mempunyai skop dan konteks yang berkait rapat dengannya. Pada asasnya, skop adalah berasaskan fungsi, manakala konteks adalah berasaskan objek. Dalam erti kata lain, skop melibatkan akses berubah dalam fungsi yang dipanggil, dan senario panggilan yang berbeza adalah berbeza. Konteks sentiasa merupakan nilai kata kunci ini, yang merupakan rujukan kepada objek yang memiliki (mengawal) kod yang sedang dilaksanakan.

Skop pembolehubah

Sesuatu pembolehubah boleh ditakrifkan dalam skop tempatan atau global, yang menetapkan skop berbeza untuk kebolehaksesan pembolehubah semasa masa jalan. Sebarang pembolehubah global yang ditakrifkan bermakna ia perlu diisytiharkan di luar badan fungsi, bertahan sepanjang masa jalan dan boleh diakses dari mana-mana skop. Sebelum ES6, pembolehubah tempatan hanya boleh wujud dalam badan fungsi, dan mereka mempunyai skop yang berbeza setiap kali fungsi itu dipanggil. Pembolehubah setempat hanya boleh ditugaskan, diambil dan dimanipulasi dalam skop masa ia dipanggil.

Perlu diambil perhatian bahawa sebelum ES6, JavaScript tidak menyokong skop peringkat blok, yang bermaksud bahawa skop peringkat blok tidak boleh disokong dalam pernyataan if, switch statement, untuk gelung dan gelung while. Dalam erti kata lain, JavaScript sebelum ES6 tidak boleh membina skop peringkat blok yang serupa dengan yang di Java (pembolehubah tidak boleh diakses di luar blok pernyataan). Walau bagaimanapun, bermula dari ES6, anda boleh menentukan pembolehubah melalui kata kunci let, yang membetulkan kekurangan kata kunci var, membolehkan anda mentakrifkan pembolehubah seperti bahasa Java dan menyokong skop peringkat blok. Lihat dua contoh:

Sebelum ES6, kami menggunakan kata kunci var untuk menentukan pembolehubah:

function func() {
if (true) {
var tmp = 123;
}
console.log(tmp); // 123
}

Salin selepas log masuk

Sebab mengapa ia boleh diakses ialah pembolehubah yang diisytiharkan oleh kata kunci var mempunyai proses promosi berubah-ubah. Dalam senario ES6, adalah disyorkan untuk menggunakan kata kunci let untuk menentukan pembolehubah:

function func() {
if (true) {
let tmp = 123;
}
console.log(tmp); // ReferenceError: tmp is not defined
}

Salin selepas log masuk

Dengan cara ini, banyak kesilapan boleh dielakkan.

Apakah konteks ini

Konteks biasanya bergantung pada cara fungsi dipanggil. Apabila fungsi dipanggil sebagai kaedah pada objek, ini ditetapkan kepada objek yang kaedah dipanggil:

var obj = {
foo: function(){
alert(this === obj); 
}
};
obj.foo(); // true

Salin selepas log masuk

Garis panduan ini juga terpakai apabila menggunakan operator baharu untuk mencipta tika objek apabila memanggil fungsi. Dalam kes ini, nilai ini dalam skop fungsi ditetapkan kepada contoh yang baru dibuat:

function foo(){
alert(this);
}
new foo() // foo
foo() // window

Salin selepas log masuk

当调用一个为绑定函数时，this默认情况下是全局上下文，在浏览器中它指向window对象。需要注意的是，ES5引入了严格模式的概念，如果启用了严格模式，此时上下文默认为undefined。

执行环境（execution context）

JavaScript是一个单线程语言，意味着同一时间只能执行一个任务。当JavaScript解释器初始化执行代码时，它首先默认进入全局执行环境（execution context），从此刻开始，函数的每次调用都会创建一个新的执行环境。

这里会经常引起新手的困惑，这里提到了一个新的术语——执行环境（execution context），它定义了变量或函数有权访问的其他数据，决定了它们各自的行为。它更偏向于作用域的作用，而不是我们前面讨论的上下文（Context）。请务必仔细的区分执行环境和上下文这两个概念（注：英文容易造成混淆）。说实话，这是个非常糟糕的命名约定，但是它是ECMAScript规范制定的，你还是遵守吧。

每个函数都有自己的执行环境。当执行流进入一个函数时，函数的环境就会被推入一个环境栈中（execution stack）。在函数执行完后，栈将其环境弹出，把控制权返回给之前的执行环境。ECMAScript程序中的执行流正是由这个便利的机制控制着。

执行环境可以分为创建和执行两个阶段。在创建阶段，解析器首先会创建一个变量对象（variable object，也称为活动对象 activation object），它由定义在执行环境中的变量、函数声明、和参数组成。在这个阶段，作用域链会被初始化，this的值也会被最终确定。在执行阶段，代码被解释执行。

每个执行环境都有一个与之关联的变量对象（variable object），环境中定义的所有变量和函数都保存在这个对象中。需要知道，我们无法手动访问这个对象，只有解析器才能访问它。

作用域链（The Scope Chain）

当代码在一个环境中执行时，会创建变量对象的一个作用域链（scope chain）。作用域链的用途是保证对执行环境有权访问的所有变量和函数的有序访问。作用域链包含了在环境栈中的每个执行环境对应的变量对象。通过作用域链，可以决定变量的访问和标识符的解析。注意，全局执行环境的变量对象始终都是作用域链的最后一个对象。我们来看一个例子：

var color = "blue";
function changeColor(){
var anotherColor = "red";
function swapColors(){
var tempColor = anotherColor;
anotherColor = color;
color = tempColor;
// 这里可以访问color, anotherColor, 和 tempColor
}
// 这里可以访问color 和 anotherColor，但是不能访问 tempColor
swapColors();
}
changeColor();
// 这里只能访问color
console.log("Color is now " + color);

Salin selepas log masuk

上述代码一共包括三个执行环境：全局环境、changeColor()的局部环境、swapColors()的局部环境。上述程序的作用域链如下图所示：

从上图发现。内部环境可以通过作用域链访问所有的外部环境，但是外部环境不能访问内部环境中的任何变量和函数。这些环境之间的联系是线性的、有次序的。

对于标识符解析（变量名或函数名搜索）是沿着作用域链一级一级地搜索标识符的过程。搜索过程始终从作用域链的前端开始，然后逐级地向后（全局执行环境）回溯，直到找到标识符为止。

闭包

闭包是指有权访问另一函数作用域中的变量的函数。换句话说，在函数内定义一个嵌套的函数时，就构成了一个闭包，它允许嵌套函数访问外层函数的变量。通过返回嵌套函数，允许你维护对外部函数中局部变量、参数、和内函数声明的访问。这种封装允许你在外部作用域中隐藏和保护执行环境，并且暴露公共接口，进而通过公共接口执行进一步的操作。可以看个简单的例子：

function foo(){
var localVariable = 'private variable';
return function bar(){
return localVariable;
}
}
var getLocalVariable = foo();
getLocalVariable() // private variable

Salin selepas log masuk

模块模式最流行的闭包类型之一，它允许你模拟公共的、私有的、和特权成员：

var Module = (function(){
var privateProperty = 'foo';
function privateMethod(args){
// do something
}
return {
publicProperty: '',
publicMethod: function(args){
// do something
},
privilegedMethod: function(args){
return privateMethod(args);
}
};
})();

Salin selepas log masuk

模块类似于一个单例对象。由于在上面的代码中我们利用了(function() { ... })();的匿名函数形式，因此当编译器解析它的时候会立即执行。在闭包的执行上下文的外部唯一可以访问的对象是位于返回对象中的公共方法和属性。然而，因为执行上下文被保存的缘故，所有的私有属性和方法将一直存在于应用的整个生命周期，这意味着我们只有通过公共方法才可以与它们交互。

另一种类型的闭包被称为立即执行的函数表达式（IIFE）。其实它很简单，只不过是一个在全局环境中自执行的匿名函数而已：

(function(window){ 
var foo, bar;
function private(){
// do something
}
window.Module = {
public: function(){
// do something 
}
};
})(this);

Salin selepas log masuk

对于保护全局命名空间免受变量污染而言，这种表达式非常有用，它通过构建函数作用域的形式将变量与全局命名空间隔离，并通过闭包的形式让它们存在于整个运行时（runtime）。在很多的应用和框架中，这种封装源代码的方式用处非常的流行，通常都是通过暴露一个单一的全局接口的方式与外部进行交互。

Call和Apply

这两个方法内建在所有的函数中（它们是Function对象的原型方法），允许你在自定义上下文中执行函数。不同点在于，call函数需要参数列表，而apply函数需要你提供一个参数数组。如下：

var o = {};
function f(a, b) {
return a + b;
}
// 将函数f作为o的方法，实际上就是重新设置函数f的上下文
f.call(o, 1, 2); // 3
f.apply(o, [1, 2]); // 3

Salin selepas log masuk

两个结果是相同的，函数f在对象o的上下文中被调用，并提供了两个相同的参数1和2。

在ES5中引入了Function.prototype.bind方法，用于控制函数的执行上下文，它会返回一个新的函数，并且这个新函数会被永久的绑定到bind方法的第一个参数所指定的对象上，无论该函数被如何使用。它通过闭包将函数引导到正确的上下文中。对于低版本浏览器，我们可以简单的对它进行实现如下（polyfill）：

if(!('bind' in Function.prototype)){
Function.prototype.bind = function(){
var fn = this, 
context = arguments[0], 
args = Array.prototype.slice.call(arguments, 1);
return function(){
return fn.apply(context, args.concat(arguments));
}
}
}

Salin selepas log masuk

bind()方法通常被用在上下文丢失的场景下，例如面向对象和事件处理。之所以要这么做，是因为节点的addEventListener方法总是为事件处理器所绑定的节点的上下文中执行回调函数，这就是它应该表现的那样。但是，如果你想要使用高级的面向对象技术，或需要你的回调函数成为某个方法的实例，你将需要手动调整上下文。这就是bind方法所带来的便利之处：

function MyClass(){
this.element = document.createElement('div');
this.element.addEventListener('click', this.onClick.bind(this), false);
}
MyClass.prototype.onClick = function(e){
// do something
};

Salin selepas log masuk

回顾上面bind方法的源代码，你可能会注意到有两次调用涉及到了Array的slice方法：

Array.prototype.slice.call(arguments, 1);
[].slice.call(arguments);

Salin selepas log masuk

我们知道，arguments对象并不是一个真正的数组，而是一个类数组对象，虽然具有length属性，并且值也能够被索引，但是它们不支持原生的数组方法，例如slice和push。但是，由于它们具有和数组类似的行为，数组的方法能够被调用和劫持，因此我们可以通过类似于上面代码的方式达到这个目的，其核心是利用call方法。

这种调用其他对象方法的技术也可以被应用到面向对象中，我们可以在JavaScript中模拟经典的继承方式：

MyClass.prototype.init = function(){
// call the superclass init method in the context of the "MyClass" instance
MySuperClass.prototype.init.apply(this, arguments);
}

Salin selepas log masuk

也就是利用call或apply在子类（MyClass）的实例中调用超类（MySuperClass）的方法。

ES6中的箭头函数

ES6中的箭头函数可以作为Function.prototype.bind()的替代品。和普通函数不同，箭头函数没有它自己的this值，它的this值继承自外围作用域。

对于普通函数而言，它总会自动接收一个this值，this的指向取决于它调用的方式。我们来看一个例子：

var obj = {
// ...
addAll: function (pieces) {
var self = this;
_.each(pieces, function (piece) {
self.add(piece);
});
},
// ...
}

Salin selepas log masuk

在上面的例子中，最直接的想法是直接使用this.add(piece)，但不幸的是，在JavaScript中你不能这么做，因为each的回调函数并未从外层继承this值。在该回调函数中，this的值为window或undefined，因此，我们使用临时变量self来将外部的this值导入内部。我们还有两种方法解决这个问题：

使用ES5中的bind()方法

var obj = {
// ...
addAll: function (pieces) {
_.each(pieces, function (piece) {
this.add(piece);
}.bind(this));
},
// ...
}

Salin selepas log masuk

使用ES6中的箭头函数

var obj = {
// ...
addAll: function (pieces) {
_.each(pieces, piece => this.add(piece));
},
// ...
}

Salin selepas log masuk

在ES6版本中，addAll方法从它的调用者处获得了this值，内部函数是一个箭头函数，所以它集成了外部作用域的this值。

注意：对回调函数而言，在浏览器中，回调函数中的this为window或undefined（严格模式），而在Node.js中，回调函数的this为global。实例代码如下：

function hello(a, callback) {
callback(a);
}
hello('weiwei', function(a) {
console.log(this === global); // true
console.log(a); // weiwei
});

Salin selepas log masuk

Résumé

Avant d'apprendre les modèles de conception avancés, il est important de comprendre ces concepts, car la portée et le contexte jouent les rôles les plus fondamentaux dans le JavaScript moderne. Qu'il s'agisse de fermetures, d'orientation objet, d'héritage ou de diverses implémentations natives, le contexte et la portée jouent un rôle crucial. Si votre objectif est de maîtriser le langage JavaScript et de comprendre en profondeur ses composants, la portée et le contexte sont votre point de départ.

Le contenu ci-dessus est la portée et le contexte en JavaScript introduits par l'éditeur. J'espère qu'il vous sera utile !