Câu lệnh
var { bar } = foo; // where foo = { bar:10, baz:12 };
/* This creates a variable with the name 'bar', which has a value of 10 */
8 khai báo một biến phạm vi chức năng hoặc phạm vi toàn cầu, tùy chọn khởi tạo nó thành một giá trịvar varname1 [= value1] [, varname2 [= value2] ... [, varnameN [= valueN]]]
var { bar } = foo; // where foo = { bar:10, baz:12 };
/* This creates a variable with the name 'bar', which has a value of 10 */
9tên biến. Nó có thể là bất kỳ định danh hợp pháp nào
'use strict';
function foo[] {
var x = 1;
function bar[] {
var y = 2;
console.log[x]; // 1 [function `bar` closes over `x`]
console.log[y]; // 2 [`y` is in scope]
}
bar[];
console.log[x]; // 1 [`x` is in scope]
console.log[y]; // ReferenceError in strict mode, `y` is scoped to `bar`
}
foo[];
0 Tùy chọnGiá trị ban đầu của biến. Nó có thể là bất kỳ biểu hiện pháp lý. Giá trị mặc định là
'use strict';
function foo[] {
var x = 1;
function bar[] {
var y = 2;
console.log[x]; // 1 [function `bar` closes over `x`]
console.log[y]; // 2 [`y` is in scope]
}
bar[];
console.log[x]; // 1 [`x` is in scope]
console.log[y]; // ReferenceError in strict mode, `y` is scoped to `bar`
}
foo[];
1Ngoài ra, cú pháp Gán cấu trúc cũng có thể được sử dụng để khai báo các biến
var { bar } = foo; // where foo = { bar:10, baz:12 };
/* This creates a variable with the name 'bar', which has a value of 10 */
Các khai báo của
var { bar } = foo; // where foo = { bar:10, baz:12 };
/* This creates a variable with the name 'bar', which has a value of 10 */
8, bất kể chúng xuất hiện ở đâu, đều được xử lý trước khi bất kỳ mã nào được thực thi. Điều này được gọi là cẩu và được thảo luận thêm dưới đâyPhạm vi của một biến được khai báo với
var { bar } = foo; // where foo = { bar:10, baz:12 };
/* This creates a variable with the name 'bar', which has a value of 10 */
8 là bối cảnh thực thi hiện tại của nó và các bao đóng của nó, là hàm bao quanh và các hàm được khai báo bên trong nó, hoặc đối với các biến được khai báo bên ngoài bất kỳ hàm nào, toàn cục. Khai báo biến trùng lặp bằng cách sử dụng var { bar } = foo; // where foo = { bar:10, baz:12 };
/* This creates a variable with the name 'bar', which has a value of 10 */
8 sẽ không gây ra lỗi, ngay cả trong chế độ nghiêm ngặt và biến sẽ không mất giá trị, trừ khi thực hiện phép gán khác'use strict';
function foo[] {
var x = 1;
function bar[] {
var y = 2;
console.log[x]; // 1 [function `bar` closes over `x`]
console.log[y]; // 2 [`y` is in scope]
}
bar[];
console.log[x]; // 1 [`x` is in scope]
console.log[y]; // ReferenceError in strict mode, `y` is scoped to `bar`
}
foo[];
Các biến được khai báo bằng cách sử dụng
var { bar } = foo; // where foo = { bar:10, baz:12 };
/* This creates a variable with the name 'bar', which has a value of 10 */
8 được tạo trước khi bất kỳ mã nào được thực thi trong một quy trình được gọi là cẩu. Giá trị ban đầu của chúng là 'use strict';
function foo[] {
var x = 1;
function bar[] {
var y = 2;
console.log[x]; // 1 [function `bar` closes over `x`]
console.log[y]; // 2 [`y` is in scope]
}
bar[];
console.log[x]; // 1 [`x` is in scope]
console.log[y]; // ReferenceError in strict mode, `y` is scoped to `bar`
}
foo[];
1var varname1 [= value1] [, varname2 [= value2] ... [, varnameN [= valueN]]]
2Trong bối cảnh toàn cầu, một biến được khai báo bằng cách sử dụng
var { bar } = foo; // where foo = { bar:10, baz:12 };
/* This creates a variable with the name 'bar', which has a value of 10 */
8 được thêm vào dưới dạng thuộc tính không thể định cấu hình của đối tượng toàn cầu. Điều này có nghĩa là không thể thay đổi bộ mô tả thuộc tính của nó và không thể xóa nó bằng cách sử dụng 'use strict';
function foo[] {
var x = 1;
function bar[] {
var y = 2;
console.log[x]; // 1 [function `bar` closes over `x`]
console.log[y]; // 2 [`y` is in scope]
}
bar[];
console.log[x]; // 1 [`x` is in scope]
console.log[y]; // ReferenceError in strict mode, `y` is scoped to `bar`
}
foo[];
8. Tên tương ứng cũng được thêm vào danh sách trên vị trí nội bộ 'use strict';
function foo[] {
var x = 1;
function bar[] {
var y = 2;
console.log[x]; // 1 [function `bar` closes over `x`]
console.log[y]; // 2 [`y` is in scope]
}
bar[];
console.log[x]; // 1 [`x` is in scope]
console.log[y]; // ReferenceError in strict mode, `y` is scoped to `bar`
}
foo[];
9 trên [tạo thành một phần của môi trường từ vựng toàn cầu]. Danh sách các tên trong 'use strict';
function foo[] {
var x = 1;
function bar[] {
var y = 2;
console.log[x]; // 1 [function `bar` closes over `x`]
console.log[y]; // 2 [`y` is in scope]
}
bar[];
console.log[x]; // 1 [`x` is in scope]
console.log[y]; // ReferenceError in strict mode, `y` is scoped to `bar`
}
foo[];
9 cho phép bộ thực thi phân biệt giữa các biến toàn cục và các thuộc tính đơn giản trên đối tượng toàn cầuThuộc tính được tạo trên đối tượng toàn cầu cho các biến toàn cầu, được đặt thành không thể định cấu hình vì mã định danh sẽ được coi là một biến, thay vì thuộc tính đơn giản của đối tượng toàn cầu. JavaScript có tính năng quản lý bộ nhớ tự động và sẽ vô nghĩa nếu có thể sử dụng toán tử
'use strict';
function foo[] {
var x = 1;
function bar[] {
var y = 2;
console.log[x]; // 1 [function `bar` closes over `x`]
console.log[y]; // 2 [`y` is in scope]
}
bar[];
console.log[x]; // 1 [`x` is in scope]
console.log[y]; // ReferenceError in strict mode, `y` is scoped to `bar`
}
foo[];
8 trên một biến toàn cụcvar varname1 [= value1] [, varname2 [= value2] ... [, varnameN [= valueN]]]
8Lưu ý rằng trong cả mô-đun NodeJS CommonJS và mô-đun ECMAScript gốc, các khai báo biến cấp cao nhất được đặt trong phạm vi mô-đun và do đó không được thêm làm thuộc tính cho đối tượng chung
Đối tượng toàn cầu nằm ở đầu chuỗi phạm vi. Khi cố gắng phân giải tên thành giá trị, chuỗi phạm vi được tìm kiếm. Điều này có nghĩa là các thuộc tính trên đối tượng toàn cầu có thể nhìn thấy thuận tiện từ mọi phạm vi mà không cần phải xác định tên bằng
var varname1 [= value1] [, varname2 [= value2] ... [, varnameN [= valueN]]]
22 hoặc var varname1 [= value1] [, varname2 [= value2] ... [, varnameN [= valueN]]]
23 hoặc var varname1 [= value1] [, varname2 [= value2] ... [, varnameN [= valueN]]]
24Vì đối tượng toàn cầu có thuộc tính
var varname1 [= value1] [, varname2 [= value2] ... [, varnameN [= valueN]]]
25 [var varname1 [= value1] [, varname2 [= value2] ... [, varnameN [= valueN]]]
26], bạn có thể sử dụng đoạn mã sauvar { bar } = foo; // where foo = { bar:10, baz:12 };
/* This creates a variable with the name 'bar', which has a value of 10 */
4Vì vậy, đối tượng toàn cầu cuối cùng sẽ được tìm kiếm cho các định danh không đủ tiêu chuẩn. Bạn không cần phải gõ
var varname1 [= value1] [, varname2 [= value2] ... [, varnameN [= valueN]]]
27, bạn chỉ cần gõ var varname1 [= value1] [, varname2 [= value2] ... [, varnameN [= valueN]]]
25 không đủ tiêu chuẩn. Hệ quả tất yếu, ở chế độ không nghiêm ngặt, là việc gán cho các định danh không đủ tiêu chuẩn sẽ, nếu không có biến cùng tên nào được khai báo trong chuỗi phạm vi, giả sử bạn muốn tạo một thuộc tính có tên đó trên đối tượng toàn cầuvar { bar } = foo; // where foo = { bar:10, baz:12 };
/* This creates a variable with the name 'bar', which has a value of 10 */
7Ở chế độ nghiêm ngặt, việc gán cho một mã định danh không đủ tiêu chuẩn ở chế độ nghiêm ngặt sẽ dẫn đến
var varname1 [= value1] [, varname2 [= value2] ... [, varnameN [= valueN]]]
29, để tránh việc vô tình tạo các thuộc tính trên đối tượng chungLưu ý rằng hàm ý của điều trên, trái ngược với thông tin sai lệch phổ biến, JavaScript không có các biến ngầm định hoặc không được khai báo, nó chỉ có một cú pháp trông giống như vậy.
Bởi vì các khai báo
var { bar } = foo; // where foo = { bar:10, baz:12 };
/* This creates a variable with the name 'bar', which has a value of 10 */
8 được xử lý trước khi bất kỳ mã nào được thực thi, khai báo một biến ở bất kỳ đâu trong mã tương đương với khai báo nó ở đầu. Điều này cũng có nghĩa là một biến có thể được sử dụng trước khi nó được khai báo. Hành vi này được gọi là cẩu, vì có vẻ như khai báo biến được di chuyển lên đầu hàm hoặc mã toàn cầu'use strict';
function foo[] {
var x = 1;
function bar[] {
var y = 2;
console.log[x]; // 1 [function `bar` closes over `x`]
console.log[y]; // 2 [`y` is in scope]
}
bar[];
console.log[x]; // 1 [`x` is in scope]
console.log[y]; // ReferenceError in strict mode, `y` is scoped to `bar`
}
foo[];
0Điều này được ngầm hiểu là
'use strict';
function foo[] {
var x = 1;
function bar[] {
var y = 2;
console.log[x]; // 1 [function `bar` closes over `x`]
console.log[y]; // 2 [`y` is in scope]
}
bar[];
console.log[x]; // 1 [`x` is in scope]
console.log[y]; // ReferenceError in strict mode, `y` is scoped to `bar`
}
foo[];
1Vì lý do đó, nên luôn khai báo các biến ở đầu phạm vi của chúng [đầu mã toàn cục và đầu mã chức năng] để rõ ràng biến nào thuộc phạm vi chức năng [cục bộ] và biến nào được giải quyết trên chuỗi phạm vi
Điều quan trọng cần chỉ ra là chỉ phần khai báo của biến được nâng lên chứ không phải phần khởi tạo của nó. Việc khởi tạo chỉ xảy ra khi đạt đến câu lệnh gán. Cho đến lúc đó biến vẫn là
'use strict';
function foo[] {
var x = 1;
function bar[] {
var y = 2;
console.log[x]; // 1 [function `bar` closes over `x`]
console.log[y]; // 2 [`y` is in scope]
}
bar[];
console.log[x]; // 1 [`x` is in scope]
console.log[y]; // ReferenceError in strict mode, `y` is scoped to `bar`
}
foo[];
1 [nhưng được khai báo]'use strict';
function foo[] {
var x = 1;
function bar[] {
var y = 2;
console.log[x]; // 1 [function `bar` closes over `x`]
console.log[y]; // 2 [`y` is in scope]
}
bar[];
console.log[x]; // 1 [`x` is in scope]
console.log[y]; // ReferenceError in strict mode, `y` is scoped to `bar`
}
foo[];
3Điều này được ngầm hiểu là
var { bar } = foo; // where foo = { bar:10, baz:12 };
/* This creates a variable with the name 'bar', which has a value of 10 */
0var { bar } = foo; // where foo = { bar:10, baz:12 };
/* This creates a variable with the name 'bar', which has a value of 10 */
1var { bar } = foo; // where foo = { bar:10, baz:12 };
/* This creates a variable with the name 'bar', which has a value of 10 */
2Điều này tương đương với
var { bar } = foo; // where foo = { bar:10, baz:12 };
/* This creates a variable with the name 'bar', which has a value of 10 */
3Hãy chú ý đến thứ tự
var { bar } = foo; // where foo = { bar:10, baz:12 };
/* This creates a variable with the name 'bar', which has a value of 10 */
4Ở đây,
var varname1 [= value1] [, varname2 [= value2] ... [, varnameN [= valueN]]]
82 và var varname1 [= value1] [, varname2 [= value2] ... [, varnameN [= valueN]]]
83 được khai báo trước khi bất kỳ mã nào được thực thi, nhưng việc gán diễn ra sau đó. Tại thời điểm đánh giá var varname1 [= value1] [, varname2 [= value2] ... [, varnameN [= valueN]]]
84, var varname1 [= value1] [, varname2 [= value2] ... [, varnameN [= valueN]]]
83 tồn tại nên không có var varname1 [= value1] [, varname2 [= value2] ... [, varnameN [= valueN]]]
29 nào được ném ra và giá trị của nó là 'use strict';
function foo[] {
var x = 1;
function bar[] {
var y = 2;
console.log[x]; // 1 [function `bar` closes over `x`]
console.log[y]; // 2 [`y` is in scope]
}
bar[];
console.log[x]; // 1 [`x` is in scope]
console.log[y]; // ReferenceError in strict mode, `y` is scoped to `bar`
}
foo[];
1. Vì vậy, var varname1 [= value1] [, varname2 [= value2] ... [, varnameN [= valueN]]]
82 được gán giá trị không xác định. Sau đó, var varname1 [= value1] [, varname2 [= value2] ... [, varnameN [= valueN]]]
83 được gán giá trị var { bar } = foo; // where foo = { bar:10, baz:12 };
/* This creates a variable with the name 'bar', which has a value of 10 */
40. Do đó, sau dòng đầu tiên, var { bar } = foo; // where foo = { bar:10, baz:12 };
/* This creates a variable with the name 'bar', which has a value of 10 */
41, do đó có kết quảvar { bar } = foo; // where foo = { bar:10, baz:12 };
/* This creates a variable with the name 'bar', which has a value of 10 */
5Ví dụ tương tự như trên nhưng với một chế độ nghiêm ngặt
var { bar } = foo; // where foo = { bar:10, baz:12 };
/* This creates a variable with the name 'bar', which has a value of 10 */
6Các biến dường như là toàn cục tiềm ẩn có thể là tham chiếu đến các biến trong phạm vi hàm bên ngoài