Những trường hợp toán tử ” khó đỡ” với JS

max() vs min()

Math.max() > Math.min()   // false

CHUYỆN GÌ VẬY? Max không lớn hơn min? KHÔNG nhưng nó có lý do của nó.

Theo định nghĩa Math.max ([value1 [, value2 [, …]]]) trả về số lớn nhất của số được gán. Tuy nhiên, khi không có đối số, nó sẽ trả về giá trị tối thiểu có thể ( minimum possible value ), đó là -Infinity.

Như bạn đã biết, Math.min () trả về Infinity khi không có đối số được cung cấp, ví dụ giá trị cao nhất có thể ( highest possible value )

Vì vậy, so sánh Math.max ()> Math.min () là không công bằng.

It’s not fair. – Infinity its way lower than Infinity.

0.1 + 0.2

0.1 + 0.2 === 0.3   // false

Đây không phải là vấn đề của JS để công bằng. Đây là floating point math.

Máy vi tính chỉ có thể lưu trữ các số nguyên, do đó, họ cần một số cách để đại diện cho số thập phân. Sự thể hiện này đi kèm với một mức độ không chính xác. Đó là lý do tại sao, rất thường xuyên, .1 + .2! = .3 – 0.300000000000004.com

Vấn đề nằm ở cách các máy lưu trữ các giá trị số (ví dụ sự biểu diễn nhị phân.) Trong trường hợp các giá trị số nguyên, chỉ những số nguyên có thể được biểu diễn bằng luỹ thừa của hai mới có thể đại diện chính xác.

Đối với rational numbers (như 0,1, là 1/10) chỉ các giá trị mà mẫu số có thể được biểu diễn bằng luỹ thừa của hai mới có thể đại diện chính xác.

Mặc dù 0.1 và 0.2 có thể được biểu diễn chính xác trong cơ sở 10 nhưng điều đó không đúng đối với cơ sở 2. Khi điều này xảy ra, máy của chúng tôi tạo ra một giá trị xấp xỉ giá trị thật sự (kết quả là một giá trị lặp ).

> 0.1.toString(2)
‘0.0001100110011001100110011001100110011001100110011001101’

> 0.2.toString(2)
‘0.001100110011001100110011001100110011001100110011001101’

Do đó, kết quả của 0,1 + 0,2 sẽ là một giá trị lặp.

Trong cơ sở 10, nó được viết là 0.30000000000000004

[ ] + {}

[] + {}     // ‘[object Object]’
{} + []     // 0

Toán + có những ý nghĩa khác nhau trong mỗi ví dụ.

Nó hoạt động như một toán tử bổ sung cho biểu thức [] + {}, và là toán tử một ngôi cho biểu thức {} + [].

Khi giải thích các biểu thức [ ] + { } JS xác định một bước bổ sung , nhưng trước khi thêm cả hai toán hạng, nó sẽ chuyển đổi chúng thành số nguyên thủy. Điều này được thực hiện bằng việc triển khai phương thức tĩnh .toString ().

Kết quả là chúng ta kết thúc với operation ” + ‘[object Object]’.

Chỉ ở giai đoạn này, JS biết rằng toán tử bổ sung + có mục đích nối chuỗi. Và giá trị cuối cùng của ‘[object Object]’ sẽ được trả về.

Tiếp theo!

Đối với biểu thức {} + [], toán tử đầu tiên là một cặp dấu ngoặc nhọn ( ví dụ một khối rỗng). Khối rỗng này có nghĩa là “không có gì để làm“. Do đó JS tiếp tục thực hiện biểu thức.

Khi đạt đến toán tử +, nó hoạt động như toán tử một ngôi bởi nó không có toán hạng trái. Bằng cận [ ] , nó được chuyển sang 0.

true + true

true + true === 2   // true
true – true === 0   // true
true === 1          // false

Ở đây, toán tử + hoạt động như một toán tử bổ sung và thêm cả hai toán hạng. Tuy nhiên trước khi nó có thể làm điều đó, nó cần phải chuyển đổi chúng thành ToNumber.

Theo định nghĩa, ToNumber trả về 1 nếu đối số đúng, 0 nếu đối số là sai.

Vì lý do này, biểu thức true + true của chúng ta dịch thành 1 + 1, nghĩa là 2.

1 < 2 < 3

1 < 2 < 3   // true
3 > 2 > 1   // false

Cảnh báo mâu thuẫn: Lại là cận ép

Ở đây, hãy cùng đi lại từng bước cho cả hai ví dụ:

1 <2 <3

  1. Bởi vì JS giải thích và thực hiện các biểu thức từ trái sang phải, nó sẽ chạy biểu thức 1 <2 đầu tiên, do đó “true” <3;
  2. Tiếp theo, cận ép, ToNumber (true) <3 có nghĩa là 1 <3;
  3. Trả lại “true” (vì 1 là thấp hơn 3);

3> 2> 1

  1. Bởi vì 3> 2 là “true” nên “true” > 1;
  2. ToNumber (true)> 1 chuyển thành 1> 1 ( lại khó hiểu 👌);
  3. Trả về “false” (vì 1 không lớn hơn 1);

‘5’ + 3

‘5’ + 3     // ’53’
‘5’ – 3     // 2

Theo định nghĩa, toán tử bổ sung thực hiện nối chuỗi hoặc bổ sung số.

Khi một trong số các toán hạng là một chuỗi, JS chuyển đổi toán hạng khác thành một chuỗi và trả về kết nối của cả hai. Trong trường hợp ‘5’ + 3, bởi vì toán hạng trái là một chuỗi, kết quả cuối cùng là việc nối cả hai ‘5’ và ToString (3) thành ’53’.

Toán tử trừ thực hiện một phép trừ với hai toán hạng.

Tuy nhiên, khi một toán tử không thuộc kiểu Number, nó sẽ được chuyển đổi ToNumber. Vì lý do đó, chuỗi ‘5’ được chuyển thành số 5 được trừ đi 3. Kết quả cuối cùng là 2.

Đánh giá của bạn

Nhận xét