Một trong những đặc điểm cơ bản nhất của ngôn ngữ lập trình là tập hợp các kiểu dữ liệu mà nó hỗ trợ. Đây là những loại giá trị có thể được biểu diễn và thao tác trong ngôn ngữ lập trình
JavaScript cho phép bạn làm việc với ba kiểu dữ liệu nguyên thủy –
Số, ví dụ. 123, 120. 50 vv
Chuỗi văn bản e. g. "Chuỗi văn bản này", v.v.
Boolean e. g. đúng hay sai
JavaScript cũng định nghĩa hai loại dữ liệu tầm thường, null và không xác định, mỗi loại chỉ xác định một giá trị duy nhất. Ngoài các kiểu dữ liệu nguyên thủy này, JavaScript hỗ trợ một kiểu dữ liệu tổng hợp được gọi là đối tượng. Chúng tôi sẽ đề cập chi tiết về các đối tượng trong một chương riêng
Lưu ý - JavaScript không phân biệt giữa giá trị số nguyên và giá trị dấu phẩy động. Tất cả các số trong JavaScript được biểu diễn dưới dạng giá trị dấu phẩy động. JavaScript đại diện cho các số sử dụng định dạng dấu phẩy động 64-bit được xác định bởi tiêu chuẩn IEEE 754
Biến JavaScript
Giống như nhiều ngôn ngữ lập trình khác, JavaScript có các biến. Các biến có thể được coi là các thùng chứa được đặt tên. Bạn có thể đặt dữ liệu vào các vùng chứa này và sau đó tham khảo dữ liệu chỉ bằng cách đặt tên cho vùng chứa
Trước khi bạn sử dụng một biến trong chương trình JavaScript, bạn phải khai báo nó. Các biến được khai báo với từ khóa var như sau
Bạn cũng có thể khai báo nhiều biến với cùng một từ khóa var như sau -
Lưu trữ một giá trị trong một biến được gọi là khởi tạo biến. Bạn có thể thực hiện khởi tạo biến tại thời điểm tạo biến hoặc tại thời điểm sau đó khi bạn cần biến đó
Chẳng hạn, bạn có thể tạo một biến có tên money và gán giá trị 2000. 50 đến nó sau. Đối với một biến khác, bạn có thể gán giá trị tại thời điểm khởi tạo như sau
Lưu ý - Chỉ sử dụng từ khóa var để khai báo hoặc khởi tạo, một lần cho vòng đời của bất kỳ tên biến nào trong tài liệu. Bạn không nên khai báo lại cùng một biến hai lần
JavaScript là ngôn ngữ chưa gõ. Điều này có nghĩa là một biến JavaScript có thể chứa giá trị của bất kỳ loại dữ liệu nào. Không giống như nhiều ngôn ngữ khác, bạn không cần phải thông báo cho JavaScript trong khi khai báo biến loại giá trị mà biến đó sẽ giữ. Loại giá trị của một biến có thể thay đổi trong quá trình thực thi chương trình và JavaScript sẽ tự động xử lý nó
Phạm vi biến JavaScript
Phạm vi của một biến là vùng chương trình của bạn mà nó được định nghĩa. Biến JavaScript chỉ có hai phạm vi
Biến toàn cục - Một biến toàn cục có phạm vi toàn cầu, nghĩa là nó có thể được xác định ở bất kỳ đâu trong mã JavaScript của bạn
Biến cục bộ - Một biến cục bộ sẽ chỉ hiển thị trong một hàm nơi nó được xác định. Các tham số chức năng luôn là cục bộ của chức năng đó
Trong phần thân của hàm, biến cục bộ được ưu tiên hơn biến toàn cục có cùng tên. Nếu bạn khai báo một biến cục bộ hoặc tham số hàm có cùng tên với biến toàn cục, bạn sẽ ẩn biến toàn cục một cách hiệu quả. Hãy xem xét ví dụ sau
Điều này tạo ra kết quả sau -
local
Tên biến JavaScript
Khi đặt tên cho các biến của bạn trong JavaScript, hãy ghi nhớ các quy tắc sau
Bạn không nên sử dụng bất kỳ từ khóa dành riêng nào của JavaScript làm tên biến. Những từ khóa này được đề cập trong phần tiếp theo. Ví dụ: tên biến break hoặc boolean không hợp lệ
Tên biến JavaScript không được bắt đầu bằng chữ số [0-9]. Chúng phải bắt đầu bằng một chữ cái hoặc ký tự gạch dưới. Ví dụ: 123test là tên biến không hợp lệ nhưng _123test là tên biến hợp lệ
Tên biến JavaScript phân biệt chữ hoa chữ thường. Ví dụ: Tên và tên là hai biến khác nhau
Các từ dành riêng cho JavaScript
Danh sách tất cả các từ dành riêng trong JavaScript được đưa ra trong bảng sau. Chúng không thể được sử dụng làm biến JavaScript, hàm, phương thức, nhãn vòng lặp hoặc bất kỳ tên đối tượng nào
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 name1;
var name1 = value1;
var name1 = value1, name2 = value2;
var name1, name2 = value2;
var name1 = value1, name2, /* …, */ nameN = 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, `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, `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 */
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, 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________số 8_______
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, `y` is scoped to `bar`
}
foo[];
1'use strict';
console.log[x]; // undefined [note: not ReferenceError]
console.log['still going...']; // still going...
var x = 1;
console.log[x]; // 1
console.log['still going...']; // still going...
Trong 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, `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, `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, `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, `y` is scoped to `bar`
}
foo[];
8 trên một biến toàn cục'use strict';
var x = 1;
Object.hasOwn[globalThis, 'x']; // true
delete globalThis.x; // TypeError in strict mode. Fails silently otherwise.
delete x; // SyntaxError in strict mode. Fails silently otherwise.
Lư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
'use strict';
console.log[x]; // undefined [note: not ReferenceError]
console.log['still going...']; // still going...
var x = 1;
console.log[x]; // 1
console.log['still going...']; // still going...
2 hoặc 'use strict';
console.log[x]; // undefined [note: not ReferenceError]
console.log['still going...']; // still going...
var x = 1;
console.log[x]; // 1
console.log['still going...']; // still going...
3 hoặc 'use strict';
console.log[x]; // undefined [note: not ReferenceError]
console.log['still going...']; // still going...
var x = 1;
console.log[x]; // 1
console.log['still going...']; // still going...
4Vì đối tượng toàn cầu có thuộc tính
'use strict';
console.log[x]; // undefined [note: not ReferenceError]
console.log['still going...']; // still going...
var x = 1;
console.log[x]; // 1
console.log['still going...']; // still going...
5 ['use strict';
console.log[x]; // undefined [note: not ReferenceError]
console.log['still going...']; // still going...
var x = 1;
console.log[x]; // 1
console.log['still going...']; // still going...
6], bạn có thể sử dụng đoạn mã saufunction foo[] {
String['s'] // Note the function `String` is implicitly visible
}
Vì 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õ
'use strict';
console.log[x]; // undefined [note: not ReferenceError]
console.log['still going...']; // still going...
var x = 1;
console.log[x]; // 1
console.log['still going...']; // still going...
7, bạn chỉ cần gõ 'use strict';
console.log[x]; // undefined [note: not ReferenceError]
console.log['still going...']; // still going...
var x = 1;
console.log[x]; // 1
console.log['still going...']; // still going...
5 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ầufoo = 'f' // In non-strict mode, assumes you want to create a property named `foo` on the global object
Object.hasOwn[globalThis, 'foo'] // true
Ở 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
'use strict';
console.log[x]; // undefined [note: not ReferenceError]
console.log['still going...']; // still going...
var x = 1;
console.log[x]; // 1
console.log['still going...']; // still going...
9, để tránh việc vô tình tạo ra 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, nên việc khai báo một biến ở bất kỳ đâu trong mã tương đương với việc 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ầubla = 2;
var bla;
Điều này được ngầm hiểu là
var bla;
bla = 2;
Vì 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ầu 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, `y` is scoped to `bar`
}
foo[];
1 [nhưng được khai báo]function do_something[] {
console.log[bar]; // undefined
var bar = 111;
console.log[bar]; // 111
}
Đ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,
'use strict';
var x = 1;
Object.hasOwn[globalThis, 'x']; // true
delete globalThis.x; // TypeError in strict mode. Fails silently otherwise.
delete x; // SyntaxError in strict mode. Fails silently otherwise.
2 và 'use strict';
var x = 1;
Object.hasOwn[globalThis, 'x']; // true
delete globalThis.x; // TypeError in strict mode. Fails silently otherwise.
delete x; // SyntaxError in strict mode. Fails silently otherwise.
3 đượ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á 'use strict';
var x = 1;
Object.hasOwn[globalThis, 'x']; // true
delete globalThis.x; // TypeError in strict mode. Fails silently otherwise.
delete x; // SyntaxError in strict mode. Fails silently otherwise.
4, _____23_______3 tồn tại nên không có _______17_______9 nào được ném ra và giá trị của nó là ____8_______1. Vì vậy, 'use strict';
var x = 1;
Object.hasOwn[globalThis, 'x']; // true
delete globalThis.x; // TypeError in strict mode. Fails silently otherwise.
delete x; // SyntaxError in strict mode. Fails silently otherwise.
2 được gán giá trị không xác định. Sau đó, 'use strict';
var x = 1;
Object.hasOwn[globalThis, 'x']; // true
delete globalThis.x; // TypeError in strict mode. Fails silently otherwise.
delete x; // SyntaxError in strict mode. Fails silently otherwise.
3 được gán giá trị function foo[] {
String['s'] // Note the function `String` is implicitly visible
}
0. Do đó, sau dòng đầu tiên, function foo[] {
String['s'] // Note the function `String` is implicitly visible
}
1, 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