Bản dịch này đang trong quá trình.

Chương này mô tả biểu thức và toán tử của JavaScript, bao gồm toán tử gán, toán tử so sánh, arithmetic, thao tác bit, toán tử logic, chuỗi, toán tử ba ngôi và nhiều hơn nữa.

Để xem danh sách đầy đủ và chi tiết các toán tử và biểu thức, mời truy cập vào reference.

Toán tử

JavaScript có các loại toán tử như sau. Phần này mô tả về các toán tử và có bao gồm thông tin về thứ tự ưu tiên của chúng.

JavaScript có cả toán tử hai ngôimột ngôi, và một toán tử đặc biệt ba ngôi, toán tử quan hệ. Toán tử hai ngôi yêu cầu hai toán hạng, một toán hạng ở trước và một toán hạng ở sau toán tử:

toán_hạng_1 toán_tử toán_hạng_2

Chẳng hạn, 3+4 hoặc x*y.

Toán tử một ngôi yêu cầu một toán tử, ở trước hoặc ở sau toán tử:

toán_tử toán_hạng

hoặc

toán_hạng toán_tử

Chẳng hạn, x++ hoặc ++x.

Toán tử gán

Toán tử gán gán giá trị cho toán hạng bên trái nó dựa theo giá trị của toán hạng bên phải nó. Toná tử gán đơn giản là toán tử bằng (=), gán giá trị cho toán hạng bên trái nó bằng giá trị của toán hạng bên phải nó. Vậy, x = y tức là gán giá trị của y cho x.

Ngoài ra còn có các toán tử gán kết hợp được liệt kê trong bảng dưới:

Toán tử gán kết hợp
Tên Viết tắt Ý nghĩa
Toán tử gán x = y x = y
Cộng xong rồi gán x += y x = x + y
Trừ xong rồi gán x -= y x = x - y
Nhân xong rồi gán x *= y x = x * y
Chia xong rồi gán x /= y x = x / y
Chia lấy dư xong rồi gán x %= y x = x % y
Exponentiation assignment x **= y x = x ** y
Dịch bit trái rồi gán x <<= y x = x << y
Dịch bit phải rồi gán x >>= y x = x >> y
Unsigned right shift assignment x >>>= y x = x >>> y
AND bit rồi gán x &= y x = x & y
XOR bit rồi gán x ^= y x = x ^ y
OR bit rồi gán x |= y x = x | y

Phân rã

Với phép gán phức tạp hơn, cú pháp phân rã rồi gán là một biểu thức JavaScript cho phép phân tách dữ liệu từ mảng hoặc object sử dụng cú pháp sao chép cấu trúc của mảng hoặc object literal.

var foo = ['one', 'two', 'three'];

// không dùng phân rã
var one   = foo[0];
var two   = foo[1];
var three = foo[2];

// dùng phân rã
var [one, two, three] = foo;

Toán tử so sánh

Toán tử so sánh so sánh toán hạng của nó và trả về giá trị logic dựa theo tính đúng sai của phép so sánh. Toán hạng có thể thuộc là số, chuỗi, logic, hoặc object. Chuỗi được so sánh theo thứ tự từ điển, qua giá trị mã Unicode. Trong nhiều trường hợp, nếu hai toán hạng không cùng kiểu, JavaScript sẽ tự động ép kiểu sao cho phù hợp. Hành vi này thường xảy ra khi so sánh dữ liệu kiểu số. Duy có hai toán tử so sánh, bao gồm ===!==, không tự động ép kiểu mà sẽ so sánh bằng chính xác. Bảng sau mô tả các toán tử so sánh bao gồm cả code mẫu:

var var1 = 3;
var var2 = 4;
Toán tử so sánh
Toán tử Mô tả Ví dụ trả về true/th>
Bằng (==) Trả về true nếu các toán hạng bằng nhau. 3 == var1

"3" == var1

3 == '3'
Không bằng (!=) Trả về true nếu các toán hạng không bằng nhau. var1 != 4
var2 != "3"
Bằng chính xác (===) Trả về true nếu các toán hạng bằng nhau và cùng kiểu. Xem thêm tại Object.issameness in JS. 3 === var1
Không bằng chính xác (!==) Trả về true nếu các toán hạng không bằng nhau, hoặc khác kiểu. var1 !== "3"
3 !== '3'
Lớn hơn (>) Trả về true nếu toán hạng bên trái lớn hơn toán hạng bên phải. var2 > var1
"12" > 2
Lớn hơn hoặc bằng (>=) Trả về true nếu toán hạng bên trái lớn hơn hoặc bằng toán hạng bên phải. var2 >= var1
var1 >= 3
Nhỏ hơn (<) Trả về true nếu toán hạng bên trái nhỏ hơn toán hạng bên phải. var1 < var2
"2" < 12
Nhỏ hơn hoặc bằng (<=) Trả về true nếu toán hạng bên trái ?nhỏ hơn hoặc bằng toán hạng bên phải. var1 <= var2
var2 <= 5

Lưu ý: (=>) không phải là toán tử, mà là cú pháp của Hàm mũi tên.

Toán tử số học

Toán tử số học nhận giá trị kiểu số (cả literal lẫn biến) là toán hạng của nó và trả về một giá trị kiểu số. Các toán tử số học thông thường là toán tử cộng (+), trừ (-), nhân (*), và chia (/). Những toán tử này hoạt động tương tự như trong các ngôn ngữ lập trình khác khi xử lý với số thực dấu phẩy động (nói chung, ?phép chia cho 0 sẽ trả về Infinity). Ví dụ:

1 / 2; // 0.5
1 / 2 == 1.0 / 2.0; // this is true

Ngoài những toán tử số học thông thường (+, -, * /), JavaScript cung cấp thêm các toán tử số học được liệt kê trong bảng sau:

Toán tử số học
Toán tử Mô tả Ví dụ
Chia lấy dư (%) Toán tử hai ngôi. Trả về phần nguyên trong phép chia của hai toán hạng. 12 % 5 trả về 2.
Tăng (++) Toán tử một ngôi. Cộng thêm một đơn vị cho toán hạng. Nếu dùng như tiền tố (++x), trả về giá trị sau khi cộng thêm một; nếu dùng như hậu tố (x++), trả về giá trị trước khi cộng thêm một. Nếu x bằng 3, rồi ++x sẽ thiết lập giá trị của x lên 4 và trả về 4, trong khi x++ trả về 3 và sau đó mới thiết lập giá trị của x lên 4.
Giảm (--) Toán tử một ngôi. Trừ đi một đơn vị cho toán hạng. Giá trị trả về tương tự như toán tử tăng. Nếu x bằng 3, rồi --x sẽ thiết lập giá trị của x về 2 và trả về 2, trong khi x-- trả về 3 và sau đó mới thiết lập giá trị của x về 2.
Phủ định một ngôi (-) Toán tử một ngôi. Trả về giá trị phủ định của toán hạng. Nếu x bằng 3, thì -x trả về -3.
Cộng một ngôi (+) Toán tử một ngôi. Ép kiểu toán hạng về dạng số học, nếu kiểu của toán hạng đó không phải là số. +"3" trả về 3.
+true trả về 1.
Toán tử luỹ thừa (**) Tính toán giá trị cơ số theo luỹ thừa số mũ, tức là, cơ sốsố mũ 2 ** 3 trả về 8.
10 ** -1 trả về 0.1.

Toán tử thao tác bit

Toán tử thao tác bit coi toán hạng của nó là một tập 32 bit (gồm 0 và 1), thay vì là kiểu thập phân, thập lục phân, hay bát phân. Chẳng hạn, số thập phân 9 được biểu diễn trong hệ nhị phân là 1001. Toán tử thao tác bit xử lý phép toán dựa theo dạng biểu diễn nhị phân ấy, nhưng trả về giá trị kiểu số thông thường trong JavaScript.

Bảng tóm tắt các toán tử thao tác bit của JavaScript.

Toán tử thao tác bit
Toán tử Cách dùng Mô tả
Bitwise AND a & b trả về a one in each bit position for which the corresponding bits of both operands are ones.
Bitwise OR a | b trả về a zero in each bit position for which the corresponding bits of both operands are zeros.
Bitwise XOR a ^ b trả về a zero in each bit position for which the corresponding bits are the same.
[trả về a one in each bit position for which the corresponding bits are different.]
Bitwise NOT ~ a Inverts the bits of its operand.
Left shift a << b Shifts a in binary representation b bits to the left, shifting in zeros from the right.
Sign-propagating right shift a >> b Shifts a in binary representation b bits to the right, discarding bits shifted off.
Zero-fill right shift a >>> b Shifts a in binary representation b bits to the right, discarding bits shifted off, and shifting in zeros from the left.

Bitwise logical operators

Conceptually, the bitwise logical operators work as follows:

  • The operands are converted to thirty-two-bit integers and expressed by a series of bits (zeros and ones). Numbers with more than 32 bits get their most significant bits discarded. Chẳng hạn, the following integer with more than 32 bits will be converted to a 32 bit integer:
    Before: 11100110111110100000000000000110000000000001
    After:              10100000000000000110000000000001
  • Each bit in the first operand is paired with the corresponding bit in the second operand: first bit to first bit, second bit to second bit, and so on.
  • The operator is applied to each pair of bits, and the result is constructed bitwise.

Chẳng hạn, the binary representation of nine is 1001, and the binary representation of fifteen is 1111. So, when the bitwise operators are applied to these values, the results are as follows:

Bitwise operator examples
Expression Result Binary Description
15 & 9 9 1111 & 1001 = 1001
15 | 9 15 1111 | 1001 = 1111
15 ^ 9 6 1111 ^ 1001 = 0110
~15 -16 ~00000000...00001111 = 11111111...11110000
~9 -10 ~00000000...00001001 = 11111111...11110110

Note that all 32 bits are inverted using the Bitwise NOT operator, and that values with the most significant (left-most) bit set to 1 represent negative numbers (two's-complement representation). ~x evaluates to the same value that -x - 1 evaluates to.

Bitwise shift operators

The bitwise shift operators take two operands: the first is a quantity to be shifted, and the second specifies the number of bit positions by which the first operand is to be shifted. The direction of the shift operation is controlled by the operator used.

Shift operators convert their operands to thirty-two-bit integers and return a result of the same type as the left operand.

The shift operators are listed in the following table.

Bitwise shift operators
Operator Description Example
Left shift
(<<)
This operator shifts the first operand the specified number of bits to the left. Excess bits shifted off to the left are discarded. Zero bits are shifted in from the right. 9<<2 yields 36, because 1001 shifted 2 bits to the left becomes 100100, which is 36.
Sign-propagating right shift (>>) This operator shifts the first operand the specified number of bits to the right. Excess bits shifted off to the right are discarded. Copies of the leftmost bit are shifted in from the left. 9>>2 yields 2, because 1001 shifted 2 bits to the right becomes 10, which is 2. Likewise, -9>>2 yields -3, because the sign is preserved.
Zero-fill right shift (>>>) This operator shifts the first operand the specified number of bits to the right. Excess bits shifted off to the right are discarded. Zero bits are shifted in from the left. 19>>>2 yields 4, because 10011 shifted 2 bits to the right becomes 100, which is 4. For non-negative numbers, zero-fill right shift and sign-propagating right shift yield the same result.

Toán tử logic

Toán tử logic thường được dùng với giá trị Boolean (kiểu logic); khi đó, chúng trả về giá trị Boolean. Tuy nhiên, toán tử &&|| thực tế trả về giá trị của một trong những toán hạng xác định, nên nếu hai toán tử này được dùng với giá trị không phải kiểu Boolean, chúng có thể trả về một giá trị không phải Boolean. Toán tử logic được mô tả trong bảng dưới.

Toán tử logic
Toán tử Cách dùng Mô tả
Logical AND (&&) expr1 && expr2 Trả về expr1 nếu nó có thể biến đổi thành false; ngược lại, trả về expr2. Như vậy, khi dùng với giá trị Boolean, && trả về true nếu cả hai toán hạng đều là true; ngược lại, trả về false.
Logical OR (||) expr1 || expr2 Trả về expr1 nếu nó có thể biến đổi thành true; ngược lại, trả về expr2. Vì vậy, khi dùng với giá trị Boolean, || trả về true nếu cả hai toán hạng đều là true; nếu cả hai false, trả về false.
Logical NOT (!) !expr Trả về false nếu toán hạng đứng ngay sau nó có thể biến đổi thành true; ngược lại, trả về true.

Ví dụ về các biểu thức có thể biến đổi thành false là những biểu thức khi thực thi trả về null, 0, NaN, chuỗi rỗng (""), hoặc undefined.

Sau đây là các ví dụ cho toán tử && (logical AND).

var a1 =  true && true;     // t && t trả về true
var a2 =  true && false;    // t && f trả về false
var a3 = false && true;     // f && t trả về false
var a4 = false && (3 == 4); // f && f trả về false
var a5 = 'Cat' && 'Dog';    // t && t trả về Dog
var a6 = false && 'Cat';    // f && t trả về false
var a7 = 'Cat' && false;    // t && f trả về false

Sau đây là các ví dụ cho toán tử || (logical OR).

var o1 =  true || true;     // t || t trả về true
var o2 = false || true;     // f || t trả về true
var o3 =  true || false;    // t || f trả về true
var o4 = false || (3 == 4); // f || f trả về false
var o5 = 'Cat' || 'Dog';    // t || t trả về Cat
var o6 = false || 'Cat';    // f || t trả về Cat
var o7 = 'Cat' || false;    // t || f trả về Cat

Sau đây là các ví dụ cho toán tử ! (logical NOT).

var n1 = !true;  // !t trả về false
var n2 = !false; // !f trả về true
var n3 = !'Cat'; // !t trả về false

Thực thi đoản-mạch

Vì các biểu thức logic được thực thi từ trái sang phải, ta có thể dùng chúng để thử tính "đoán-mạch" qua các quy định sau:

  • false && bất cứ gì là thực thi đoản-mạch ra false.
  • true || bất cứ gì là thực thi đoản-mạch ra true.

Quy định logic đảm bảo rằng các thực thi trên luôn đúng. Chú ý phần bất cứ gì trong các biểu thức trên không được thực thi, bởi vậy sẽ không xảy ra bất cứ tác dụng phụ nào.

Toán tử chuỗi

Ngoài toán tử so sánh, có thể dùng để so sánh chuỗi, toán tử ghép (+) ghép hai giá trị chuỗi lại với nhau, trả về một chuỗi mới là hợp của hai chuỗi cũ.

Chẳng hạn,

console.log('my ' + 'string'); // console logs the string "my string".

Toán tử gán rút gọn += cũng có thể dùng để ghép chuỗi.

Chẳng hạn,

var mystring = 'alpha';
mystring += 'bet'; // "alphabet" sẽ ghép với giá trị này trước khi gán vào mystring.

Toán tử điều kiện (ba ngôi)

Toán tử điều kiện là toán tử duy nhất của JavaScript cần tới ba toán hạng. Kết quả có thể là một trong hai giá trị tuỳ theo điều kiện. Cú pháp:

điều_kiện ? giá_trị_1 : giá_trị_2

Nếu điều_kiện trả về true, toán tử có giá trị giá_trị_1. Ngược lại toán tử có giá trị giá_trị_2. Bạn có thể dùng toán tử điều kiện ở bất cứ đâu như một toán tử bình thường.

Chẳng hạn,

var status = (age >= 18) ? 'adult' : 'minor';

Đoạn code này gán giá trị "adult" cho biến status nếu age lớn hơn hoặc bằng 18. Ngược lại, nó gán giá trị "minor" cho status.

Toán tử dấu phẩy

Toán tử dấu phẩy (,) đơn thuần tính toán cả hai giá trị toán hạng của nó và trả về giá trị của toán hạng cuối. Toán tử này được dùng chủ yếu trong vòng lặp for, để cho phép cập nhật nhiều biến cùng lúc sau mỗi lần thực hiện vòng lặp.

Chẳng hạn, nếu a là một mảng 2-chiều với 10 phần tử mỗi chiều, đoạn code sau dùng toán tử dấu phẩy để cập nhật hai biến cùng một lúc. Console in ra giá trị của các phần tử nằm trong đường chéo:

var x = [0,1,2,3,4,5,6,7,8,9]
var a = [x, x, x, x, x];

for (var i = 0, j = 9; i <= j; i++, j--)
  console.log('a[' + i + '][' + j + ']= ' + a[i][j]);

Toán tử một ngôi

Toán tử một ngôi là phép toán chỉ có duy nhất một toán hạng.

delete

Toán tử delete xoá một object, một thuộc tính của object, hoặc một phần tử ở chỉ mục xác định trong mảng. Cú pháp là:

delete objectName;
delete objectName.property;
delete objectName[index];
delete property; // chỉ được khi cài trong lệnh with

Với objectName là tên của object, property là thuộc tính đang tồn tại, và index là giá trị nguyên của chỉ mục tương ứng với vị trí của thuộc tính trong mảng.

Dạng thứ tư chỉ hoạt động khi được cài trong lệnh with, để xoá một thuộc tính khỏi object.

Bạn có thể dùng toán tử delete để xoá biến được khởi tạo ngầm nhưng không thể xoá được các biến được khởi tạo bằng lệnh var.

Nếu toán tử delete thành công, nó đặt thuộc tính hoặc phần tử đó thành undefined. Toán tử delete trả về true nếu phép toán khả thi; nó trả về false nếu phép toán bất khả thi.

x = 42;
var y = 43;
myobj = new Number();
myobj.h = 4;    // tạo thuộc tính h
delete x;       // trả về true (có thể xoá nếu khởi tạo ngầm)
delete y;       // trả về false (không thể xoá nếu khởi tạo bằng var)
delete Math.PI; // trả về false (không thể xoá thuộc tính tiền định nghĩa)
delete myobj.h; // trả về true (có thể xoá thuộc tính người dùng định nghĩa)
delete myobj;   // trả về true (có thể xoá nếu khợi tạo ngầm)
Xoá phần tử mảng

Khi bạn xoá một phần tử của mảng, chiều dài mảng không bị ảnh hưởng. Chẳng hạn, nếu bạn xoá a[3], a[4] vẫn là a[4]a[3] là undefined.

Khi toán tử delete loại bỏ một phần tử khỏi mảng, phần tử đó không còn tồn tại trong mảng. Trong ví dụ sau, trees[3] đã được loại bỏ bởi delete. Tuy nhiên, trees[3] vẫn có thể được trỏ tới và trả về undefined.

var trees = ['redwood', 'bay', 'cedar', 'oak', 'maple'];
delete trees[3];
if (3 in trees) {
  // sẽ không chạy vào đây
}

Nếu bạn muốn kiểm tra sự tồn tại của một phần tử trong mảng nhưng có giá trị là undefined, hãy dùng từ khoá undefined thay cho toán tử delete. Trong ví dụ tiếp sau đây, trees[3] được gán giá trị undefined, nhưng phần tử của mảng vẫn tồn tại:

var trees = ['redwood', 'bay', 'cedar', 'oak', 'maple'];
trees[3] = undefined;
if (3 in trees) {
  // sẽ chạy vào đây
}

typeof

Toán tử typeof có thể dùng theo cả hai cách dưới đây:

typeof operand
typeof (operand)

Toán tử typeof trả về một chuỗi ký tự thể hiện kiểu của toán hạng. operand có thể là chuỗi ký tự, biến, từ khoá, hoặc object cần xác định kiểu. Không bắt buộc phải thêm dấu ngoặc tròn.

Giả sử bạn có các biến sau:

var myFun = new Function('5 + 2');
var shape = 'round';
var size = 1;
var foo = ['Apple', 'Mango', 'Orange'];
var today = new Date();

Toán tử typeof trả về kết quả lần lượt cho từng biến:

typeof myFun;       // trả về "function"
typeof shape;       // trả về "string"
typeof size;        // trả về "number"
typeof foo;         // trả về "object"
typeof today;       // trả về "object"
typeof doesntExist; // trả về "undefined"

Với từ khoá truenull, toán tử typeof trả về kết quả sau:

typeof true; // trả về "boolean"
typeof null; // trả về "object"

Với số hoặc chuỗi ký tự, toán tử typeof trả về kết quả sau:

typeof 62;            // trả về "number"
typeof 'Hello world'; // trả về "string"

Với giá trị thuộc tính, toán tử typeof trả về kiểu dữ liệu mà thuộc tính đó bao hàm:

typeof document.lastModified; // trả về "string"
typeof window.length;         // trả về "number"
typeof Math.LN2;              // trả về "number"

Với phương thức hoặc hàm, toán tử typeof trả về kết quả như sau:

typeof blur;        // trả về "function"
typeof eval;        // trả về "function"
typeof parseInt;    // trả về "function"
typeof shape.split; // trả về "function"

Với các object tiền định nghĩa, toán tử typeof trả về kết quả như sau:

typeof Date;     // trả về "function"
typeof Function; // trả về "function"
typeof Math;     // trả về "object"
typeof Option;   // trả về "function"
typeof String;   // trả về "function"

void

Toán tử void operator có thể dùng theo cả hai cách dưới đây:

void (expression)
void expression

Toán tử void xác định biểu thực cần thực hiện mà không trả về giá trị nào. expression là một biểu thức JavaScript cần thực hiện. Dấu ngoặc tròn bao quanh expression là không bắt buộc, nhưng sẽ rất phong cách nếu dùng chúng.

Bạn có thể dùng toán tử void để xác định biểu thức cần thực thi trong một siêu liên kết. Biểu thức sẽ được thực hiện nhưng không văn bản hiện tại sẽ không tải lại tại chỗ.

Đoạn code sau tạo ra một siêu liên kết không thực hiện bất cứ điều gì khi có người dùng nhấn vào. Khi người dùng nhấn vào, void(0) thực hiện thành undefined, vốn không có hiệu ứng gì trong JavaScript.

<a href="javascript:void(0)">Click here to do nothing</a>

Đoạn code sẽ tiến hành hoàn tất mẫu đơn khi người dùng bấm vào siêu liên kết.

<a href="javascript:void(document.form.submit())">
Click here to submit</a>

Toán tử quan hệ

Toán tử quan hệ so sánh các toán hạng của nó và trả về giá trị Boolean tuỳ thuộc phép so sánh có true hay không.

in

Toán tử in trả về true nếu thuộc tính nhất định có trong object nhất định. Cú pháp là:

propNameOrNumber in objectName

với propNameOrNumber là chuỗi ký tự hoặc số đại diện cho tên của thuộc tính hoặc chỉ mục mảng, và objectName là tên của object.

Các ví dụ dưới đây chỉ ra vài cách dùng toán tử in.

// Arrays
var trees = ['redwood', 'bay', 'cedar', 'oak', 'maple'];
0 in trees;        // trả về true
3 in trees;        // trả về true
6 in trees;        // trả về false
'bay' in trees;    // trả về false (bạn phải xác định được chỉ mục của mảng,
                   // không phải giá trị tại vị trí chỉ mục đó)
'length' in trees; // trả về true (length là một thuộc tính của Array)

// object dựng sẵn
'PI' in Math;          // trả về true
var myString = new String('coral');
'length' in myString;  // trả về true

// object tự tạo
var mycar = { make: 'Honda', model: 'Accord', year: 1998 };
'make' in mycar;  // trả về true
'model' in mycar; // trả về true

instanceof

Toán tử instanceof trả về true nếu một object nhất định có kiểu của object nhất định. Cú pháp là:

objectName instanceof objectType

với objectName là tên của object để so sánh với objectType, và objectType là kiểu của object, như là Date hay Array.

Dùng instanceof khi bạn cần xác nhận kiểu của một object trong runtime (thời gian chạy). Chẳng hạn, khi bắt ngoại lệ, bạn có thể tìm tới từng ngoại lệ riêng biện tuỳ thuộc vào kiểu ngoại lệ được quăng (throw) ra.

Chẳng hạn, đoạn code dưới đây dùng instanceof để xác định xem liệu theDay có phải là một Date object hay không. Bởi vì theDay là một Date object, các lệnh trong sau điều kiện if được thực thi.

var theDay = new Date(1995, 12, 17);
if (theDay instanceof Date) {
  // lệnh sẽ được thực thi
}

Thứ tự thực hiện toán tử

Thứ tự thực hiện của toán tử xác định thứ tự thực hiện trong một biểu thức. Bạn có thể vượt quyền ưu tiên bằng cách dùng dấu ngoặc tròn.

Bảng sau chỉ ra thứ tự thực hiện toán tử, từ cao nhất tới thấp nhất.

Thứ tự thực hiện các toán tử
?Loại toán tử Individual operators
member . []
gọi / tạo mới instance () new
phủ định/tăng ! ~ - + ++ -- typeof void delete
nhân/chia * / %
cộng/trừ + -
dịch bit << >> >>>
quan hệ < <= > >= in instanceof
bằng == != === !==
bitwise-and &
bitwise-xor ^
bitwise-or |
logical-and &&
logical-or ||
điều kiện ?:
gán = += -= *= /= %= <<= >>= >>>= &= ^= |=
?dấu phẩy ,

Bảng thứ tự thực hiện chi tiết hơn có thể tìm được trong JavaScript Reference.

Biểu thức

Biểu thức là đơn vị code hợp lệ mà giải được ra một giá trị.

Mọi biểu thức đúng cú pháp đều trả về vài giá trị nào đó nhưng về mặt lý thuyết, có hai kiểu biểu thức: kèm tác dụng phụ (chẳng hạn: những biểu thức gán giá trị cho biến nào đó) và những biểu thức thực hiện gì đấy rồi trả về giá trị.

Biểu thức x = 7 là ví dụ cho kiểu thứ nhất. Biểu thức này dùng toán tử = để gán giá trị cho biến x. Tự biểu thức trả về 7.

Đoạn code 3 + 4 là ví dụ cho kiểu biểu thức thứ hai. Biểu thức này dùng toán tử + để thêm bốn vào ba mà không gán kết quả, bảy, cho một biến nào.

JavaScript có các loại biểu thức sau đây:

  • Số học: tính toán thành một số, chẳng hạn 3.14159. (Thường dùng với toán tử số học.)
  • Chuỗi ký tự: tính toán thành một chuỗi ký tự, chẳng hạn, "Fred" hoặc "234". (Thường dùng với toán tử chuỗi.)
  • Logic: tính toán thành true hoặc false. (Thường đi cùng với toán tử logic.)
  • Biểu thức nguyên thuỷ: Từ khoá căn bản và biểu thức chung trong JavaScript.
  • Biểu thức vế-trái: Giá trị bên trái là đích của phép gán.

Biểu thức nguyên thuỷ

Từ khoá căn bản và biểu thức chung trong JavaScript.

this

Dùng từ khoá this để trỏ đến object hiện tại. Tổng quát, this trỏ tới object đang gọi trong một phương thức. Có thể dùng this cùng với dấu chấm hoặc dấu ngoặc vuông:

this['propertyName']
this.propertyName

Giả sử hàm validate xác thực thuộc tính value của object, truyền vào cận trên và cận dưới của nó:

function validate(obj, lowval, hival) {
  if ((obj.value < lowval) || (obj.value > hival))
    console.log('Invalid Value!');
}

Bạn có thể gọi validate trong mỗi bộ xử lý sự kiện onChange trong form, dùng this để truyền vào phần tử của form, như trong ví dụ sau:

<p>Enter a number between 18 and 99:</p>
<input type="text" name="age" size=3 onChange="validate(this, 18, 99);">

Toán tử nhóm

Toán tử nhóm ( ) kiểm soát thứ tự thực hiện trong biểu thức. Chẳng hạn, bạn có thể cho phép nhân và chia thực hiện sau khi cộng và trừ.

var a = 1;
var b = 2;
var c = 3;

// thứ tự mặc định
a + b * c     // 7
// mặc định sẽ thực hiện như thế này
a + (b * c)   // 7

// giờ vượt thứ tự nào
// cộng trước rồi mới nhân  
(a + b) * c   // 9

// tương tự như
a * c + b * c // 9

Toán tử vế-trái

Giá trị bên trái là đích của phép gán.

new

Bạn có thể dùng toán tử new để tạo ra một instance thuộc kiểu object mà người-dùng-định-nghĩa hoặc một trong những kiểu object dựng-sẵn. Dùng new như sau:

var objectName = new objectType([param1, param2, ..., paramN]);

super

Từ khoá super được dùng để gọi hàm thuộc cha của object. Thường dùng bởi classes để gọi phương thức khởi tạo của lớp cha, chẳng hạn.

super([arguments]); // gọi phương thức khởi tạo của lớp cha.
super.functionOnParent([arguments]);

Toán tử Spread

Toán tử spread cho phép biểu thức mở rộng tại chỗ khi có nhiều tham số (khi gọi hàm) hoặc nhiều phần tử (với array literal).

Ví dụ: Nếu bạn có một mảng và muốn tạo một mảng mới với mảng cũ là một thành phần trong nó, cú pháp của array literal không bao giờ là đủ và bạn bắt buộc phải code chay, dùng tổ hợp push, splice, concat, vân vân. Với cú pháp spread, việc này súc tích hơn hẳn:

var parts = ['shoulders', 'knees'];
var lyrics = ['head', ...parts, 'and', 'toes'];

Tương tự, toán tử spread cũng hoạt động với lời gọi hàm:

function f(x, y, z) { }
var args = [0, 1, 2];
f(...args);

Document Tags and Contributors

Những người đóng góp cho trang này: mdnwebdocs-bot, PurpleLover
Cập nhật lần cuối bởi: mdnwebdocs-bot,