Các toán tử

Các đặc điểm chung của toán tử

Toán tử ép kiểu toán hạng của nó tới kiểu thích hợp

Nếu một toán tử nhận một toán hạng không có kiểu thích hợp, nó hiếm khi tạo ra ngoại lệ. Thay vì vậy, nó ép kiểu (tự động đổi kiểu) toán hạng thành kiểu thích hợp với nó. Cùng xét hai ví dụ.

Trước tiên, toán tử nhân chỉ làm việc với các số. Do đó, nó chuyển chuỗi thành số trước khi tính toán:

> '7' * '3'
21

Thứ hai, toán tử dấu ngoặc vuông ([ ]) dùng để truy cập giá trị thuộc tính của đối tượng chỉ có thể nhận toán hạng kiểu chuỗi hoặc symbol. Tất cả giá trị kiểu khác được ép kiểu thành chuỗi:

const obj = {};
obj['true'] = 123;

// Ép kiểu true thành 'true'
assert.equal(obj[true], 123);

Hầu hết toán tử chỉ làm việc với giá trị cơ sở

Hầu hết toán tử đều chỉ chấp nhận toán hạng có kiểu cơ sở. Nếu một toán hạng là đối tượng, nó thường bị ép kiểu thành kiểu cơ sở, ví dụ:

> [1,2,3] + [4,5,6]
'1,2,34,5,6'

Tại sao lại có kết quả trên? Toán tử cộng trước tiến ép kiểu toán hạng thành kiểu cơ sở:

> String([1,2,3])
'1,2,3'
> String([4,5,6])
'4,5,6'

Tiếp theo nối hai chuỗi lại với nhau:

> '1,2,3' + '4,5,6'
'1,2,34,5,6'

Toán tử cộng (+)

Toán tử cộng làm việc như sau trong JavaScript:

  • Trước tiên, nó chuyển đổi toán hạng thành kiểu cơ sở (nếu cần).
  • Sau đó chuyển tới một trong hai chế độ sau:
    • Chế độ chuỗi: Nếu có một giá trị cơ sở là chuỗi, toán tử còn lại cũng được chuyển thành chuỗi. Hai chuỗi được nối với nhau để tạo thành kết quả.
    • Chế độ số: Nếu không có giá trị cơ sở nào là chuỗi, chúng được chuyển thành số. Hai số được cộng với nhau để tạo thành kết quả.

Ví dụ về chế độ chuỗi:

> 'There are ' + 3 + ' items'
'There are 3 items'

Ví dụ về chế độ chuỗi:

> 4 + true
5

Toán tử gán

Toán tử gán đơn thuần

Toán tử gán đơn thuần được sử dụng để thay đổi nội dung của một biến hoặc một thuộc tính của đối tượng:

x = value;
obj.propKey = value;
arr[index] = value;

Toán tử gán kết hợp

Cho toán tử op, hai cách gán sau đây là tương đương:

myVar op= value
myVar = myVar op value

Chẳng hạn nếu op là toán tử + thì += làm việc như sau:

let str = '';
str += '<br>';
str += 'Hello!';
str += '</b>';

assert.equal(str, '<b>Hello!</b>');

Danh sách các toán tử gán kết hợp

  • Các toán tử số học:
    • +=
    • -=
    • *=
    • /=
    • %=
    • **=

+= cũng có thể dùng để nối chuỗi.

  • Các toán tử bit (ít sử dụng):
    • <<=
    • >>=
    • >>>=
    • &=
    • ^=
    • |=

Toán tử so sánh bằng

So sánh bằng không chặt (==!=)

Toán tử so sánh bằng không chặt == (!=) khi so sánh hai toán hạng sẽ tự động ép kiểu chúng về cùng một kiểu.

Các trường hợp sau khá dễ hiểu:

> '123' == 123
true
> false == 0 // false -> 0
true

Trường hợp sau khó hiểu hơn một chút:

> '' == 0 // '' -> 0
true

Các đối tượng được ép kiểu thành kiểu cơ sở khi và chỉ khi toán hạng kia là giá trị cơ sở:

> [1, 2, 3] == '1,2,3'
true
> ['1', '2', '3'] == '1,2,3'
true

Nếu cả hai toán hạng là đối tượng chúng chỉ bằng nhau nếu có cùng một tham chiếu:

> [1, 2, 3] == ['1', '2', '3']
false
> [1, 2, 3] == [1, 2, 3]
false

> const arr = [1, 2, 3];
> arr == arr
true

Cuối cùng, toán tử == xem undefined null bằng nhau:

> undefined == null
true

So sánh bằng chặt (===!==)

Toán tử so sánh bằng chặt không bao giờ ép kiểu. Hai giá trị chỉ bằng nhau nếu có cùng kiểu và giống nhau (về nội dung hoặc tham chiếu).

> false === 0
false
> '123' === 123
false

Một đối tượng chỉ bằng một giá trị khác, nếu giá trị này và đối tượng có cùng tham chiếu:

> [1, 2, 3] === '1,2,3'
false
> ['1', '2', '3'] === '1,2,3'
false

> [1, 2, 3] === ['1', '2', '3']
false
> [1, 2, 3] === [1, 2, 3]
false

> const arr = [1, 2, 3];
> arr === arr
true

Toán tử === không xem undefined null bằng nhau:

> undefined === null
false

So sánh với NaN

NaN là một giá trị đặc biệt không bằng bất cứ giá trị nào kể cả chính nó:

> NaN === NaN
false
> NaN == NaN
false

Do đó để kiểm tra một giá trị có là NaN không ta không thể dùng các toán tử ===== thông thường. Ta cần một phương thức đặc biệt là Object.is().

Phương thức này nhận hai đối số là hai giá trị cần so sánh:

> Object.is(123, 123)
true
> Object.is(123, '123')
false
> Object.is(NaN, NaN)
true

Các toán tử so sánh thứ tự

Toán tửTên
<Nhỏ hơn
<=Nhỏ hơn hoặc bằng
>Lớn hơn
>=Lớn hơn hoặc bằng

Các toán tử này làm việc với cả số và chuỗi:

> 5 >= 2
true
> 'bar' < 'foo'
true

Cần chú ý là: <=>= dựa trên so sánh bằng chặt.

Các toán tử khác

Toán tử dấu phảy

Toán tử dấu phảy (,) có hai toán hạng. Toán tử này chạy cả hai toán hạng nhưng trả về giá trị của toán hạng thứ hai.

> 'a', 'b'
'b'

Toán tử void

Toán tử void chỉ có một toán hạng. Nó chạy toán hạng này và không trả về giá trị nào (tức trả về undefined):

> void (3 + 2)
undefined