Đó là += hay =+ JavaScript?

Có bốn toán tử logic trong JavaScript.

if [1 || 0] { // works just like if[ true || false ]
  alert[ 'truthy!' ];
}

3 [HOẶC],

if [1 || 0] { // works just like if[ true || false ]
  alert[ 'truthy!' ];
}

4 [VÀ],

if [1 || 0] { // works just like if[ true || false ]
  alert[ 'truthy!' ];
}

5 [KHÔNG],

if [1 || 0] { // works just like if[ true || false ]
  alert[ 'truthy!' ];
}

6 [Kết hợp Nullish]. Ở đây chúng tôi đề cập đến ba toán tử đầu tiên, toán tử

if [1 || 0] { // works just like if[ true || false ]
  alert[ 'truthy!' ];
}

6 có trong bài viết tiếp theo

Mặc dù chúng được gọi là "logic", nhưng chúng có thể được áp dụng cho các giá trị thuộc bất kỳ loại nào, không chỉ boolean. Kết quả của họ cũng có thể thuộc bất kỳ loại nào

Hãy xem chi tiết

Toán tử “HOẶC” được biểu thị bằng hai ký hiệu đường thẳng đứng

result = a || b;

Trong lập trình cổ điển, logic OR chỉ có nghĩa là thao tác các giá trị boolean. Nếu bất kỳ đối số nào của nó là

if [1 || 0] { // works just like if[ true || false ]
  alert[ 'truthy!' ];
}

8, thì nó trả về

if [1 || 0] { // works just like if[ true || false ]
  alert[ 'truthy!' ];
}

8, nếu không thì nó trả về

let hour = 9;

if [hour < 10 || hour > 18] {
  alert[ 'The office is closed.' ];
}

0

Trong JavaScript, toán tử phức tạp hơn một chút và mạnh hơn. Nhưng trước tiên, hãy xem điều gì xảy ra với các giá trị boolean

Có bốn kết hợp hợp lý có thể

alert[ true || true ];   // true
alert[ false || true ];  // true
alert[ true || false ];  // true
alert[ false || false ]; // false

Như chúng ta có thể thấy, kết quả luôn là ________ 08 ngoại trừ trường hợp cả hai toán hạng đều là ________ 80

Nếu một toán hạng không phải là boolean, thì nó được chuyển đổi thành boolean để đánh giá

Chẳng hạn, số

let hour = 9;

if [hour < 10 || hour > 18] {
  alert[ 'The office is closed.' ];
}

3 được coi là

if [1 || 0] { // works just like if[ true || false ]
  alert[ 'truthy!' ];
}

8, số

let hour = 9;

if [hour < 10 || hour > 18] {
  alert[ 'The office is closed.' ];
}

5 là

let hour = 9;

if [hour < 10 || hour > 18] {
  alert[ 'The office is closed.' ];
}

0

if [1 || 0] { // works just like if[ true || false ]
  alert[ 'truthy!' ];
}

Hầu hết thời gian, OR

if [1 || 0] { // works just like if[ true || false ]
  alert[ 'truthy!' ];
}

3 được sử dụng trong câu lệnh

let hour = 9;

if [hour < 10 || hour > 18] {
  alert[ 'The office is closed.' ];
}

8 để kiểm tra xem có bất kỳ điều kiện nào trong số các điều kiện đã cho là

if [1 || 0] { // works just like if[ true || false ]
  alert[ 'truthy!' ];
}

8

Ví dụ

________số 8

Chúng ta có thể vượt qua nhiều điều kiện hơn

if [1 || 0] { // works just like if[ true || false ]
  alert[ 'truthy!' ];
}

1

Logic được mô tả ở trên hơi cổ điển. Bây giờ, hãy mang đến các tính năng “bổ sung” của JavaScript

Thuật toán mở rộng hoạt động như sau

Đưa ra nhiều giá trị OR'ed

if [1 || 0] { // works just like if[ true || false ]
  alert[ 'truthy!' ];
}

2

Toán tử OR

if [1 || 0] { // works just like if[ true || false ]
  alert[ 'truthy!' ];
}

3 thực hiện như sau

• Đánh giá các toán hạng từ trái sang phải
• Đối với mỗi toán hạng, chuyển đổi nó thành boolean. Nếu kết quả là

  if [1 || 0] { // works just like if[ true || false ]
    alert[ 'truthy!' ];
  }

  8 thì dừng và trả về giá trị ban đầu của toán hạng đó
• Nếu tất cả các toán hạng đã được đánh giá [i. e. tất cả đều là

  let hour = 9;
  
  if [hour < 10 || hour > 18] {
    alert[ 'The office is closed.' ];
  }

  0], trả về toán hạng cuối cùng

Một giá trị được trả về ở dạng ban đầu mà không cần chuyển đổi

Nói cách khác, một chuỗi OR

if [1 || 0] { // works just like if[ true || false ]
  alert[ 'truthy!' ];
}

3 trả về giá trị trung thực đầu tiên hoặc giá trị cuối cùng nếu không tìm thấy giá trị trung thực nào

Ví dụ

if [1 || 0] { // works just like if[ true || false ]
  alert[ 'truthy!' ];
}

7

Điều này dẫn đến một số cách sử dụng thú vị so với "OR thuần túy, cổ điển, chỉ có boolean"

1. Nhận giá trị trung thực đầu tiên từ danh sách các biến hoặc biểu thức

   Chẳng hạn, chúng ta có các biến

   if [1 || 0] { // works just like if[ true || false ]
     alert[ 'truthy!' ];
   }

   14,

   if [1 || 0] { // works just like if[ true || false ]
     alert[ 'truthy!' ];
   }

   15 và

   if [1 || 0] { // works just like if[ true || false ]
     alert[ 'truthy!' ];
   }

   16, tất cả đều là tùy chọn [i. e. có thể không được xác định hoặc có giá trị giả]

   Hãy sử dụng OR

   if [1 || 0] { // works just like if[ true || false ]
     alert[ 'truthy!' ];
   }

   3 để chọn cái có dữ liệu và hiển thị nó [hoặc

   if [1 || 0] { // works just like if[ true || false ]
     alert[ 'truthy!' ];
   }

   18 nếu không có gì được đặt]

   if [1 || 0] { // works just like if[ true || false ]
     alert[ 'truthy!' ];
   }

   3

   Nếu tất cả các biến là sai, thì

   if [1 || 0] { // works just like if[ true || false ]
     alert[ 'truthy!' ];
   }

   18 sẽ xuất hiện

2. đánh giá ngắn mạch

   Một tính năng khác của toán tử OR

   if [1 || 0] { // works just like if[ true || false ]
     alert[ 'truthy!' ];
   }

   3 được gọi là đánh giá "ngắn mạch"

   Điều đó có nghĩa là

   if [1 || 0] { // works just like if[ true || false ]
     alert[ 'truthy!' ];
   }

   3 xử lý các đối số của nó cho đến khi đạt đến giá trị trung thực đầu tiên và sau đó giá trị được trả về ngay lập tức mà không cần chạm vào đối số khác

   Tầm quan trọng của tính năng này trở nên rõ ràng nếu một toán hạng không chỉ là một giá trị mà còn là một biểu thức có tác dụng phụ, chẳng hạn như phép gán biến hoặc lệnh gọi hàm

   Trong ví dụ bên dưới, chỉ có thông báo thứ hai được in

   if [1 || 0] { // works just like if[ true || false ]
     alert[ 'truthy!' ];
   }

   7

   Ở dòng đầu tiên, toán tử OR

   if [1 || 0] { // works just like if[ true || false ]
     alert[ 'truthy!' ];
   }

   3 dừng đánh giá ngay khi nhìn thấy

   if [1 || 0] { // works just like if[ true || false ]
     alert[ 'truthy!' ];
   }

   8, vì vậy

   if [1 || 0] { // works just like if[ true || false ]
     alert[ 'truthy!' ];
   }

   24 không chạy

   Đôi khi, người ta sử dụng tính năng này để thực thi các lệnh chỉ khi điều kiện ở phần bên trái là sai

Toán tử AND được biểu diễn bằng hai dấu và

if [1 || 0] { // works just like if[ true || false ]
  alert[ 'truthy!' ];
}

4

if [1 || 0] { // works just like if[ true || false ]
  alert[ 'truthy!' ];
}

2

Trong lập trình cổ điển, AND trả về

if [1 || 0] { // works just like if[ true || false ]
  alert[ 'truthy!' ];
}

8 nếu cả hai toán hạng đều đúng và ngược lại là

let hour = 9;

if [hour < 10 || hour > 18] {
  alert[ 'The office is closed.' ];
}

0

alert[ true || true ];   // true
alert[ false || true ];  // true
alert[ true || false ];  // true
alert[ false || false ]; // false

0

Một ví dụ với

let hour = 9;

if [hour < 10 || hour > 18] {
  alert[ 'The office is closed.' ];
}

8

alert[ true || true ];   // true
alert[ false || true ];  // true
alert[ true || false ];  // true
alert[ false || false ]; // false

1

Cũng giống như với OR, bất kỳ giá trị nào cũng được phép làm toán hạng của AND

alert[ true || true ];   // true
alert[ false || true ];  // true
alert[ true || false ];  // true
alert[ false || false ]; // false

2

Đưa ra nhiều giá trị AND'ed

alert[ true || true ];   // true
alert[ false || true ];  // true
alert[ true || false ];  // true
alert[ false || false ]; // false

3

Toán tử AND

if [1 || 0] { // works just like if[ true || false ]
  alert[ 'truthy!' ];
}

4 thực hiện như sau

• Đánh giá các toán hạng từ trái sang phải
• Đối với mỗi toán hạng, chuyển đổi nó thành boolean. Nếu kết quả là

  let hour = 9;
  
  if [hour < 10 || hour > 18] {
    alert[ 'The office is closed.' ];
  }

  0, dừng lại và trả về giá trị ban đầu của toán hạng đó
• Nếu tất cả các toán hạng đã được đánh giá [i. e. tất cả đều trung thực], trả về toán hạng cuối cùng

Nói cách khác, AND trả về giá trị giả đầu tiên hoặc giá trị cuối cùng nếu không tìm thấy

Các quy tắc trên tương tự như OR. Sự khác biệt là AND trả về giá trị giả đầu tiên trong khi OR trả về giá trị trung thực đầu tiên

ví dụ

alert[ true || true ];   // true
alert[ false || true ];  // true
alert[ true || false ];  // true
alert[ false || false ]; // false

4

Chúng ta cũng có thể chuyển nhiều giá trị liên tiếp. Xem cách trả lại giá trị giả đầu tiên

alert[ true || true ];   // true
alert[ false || true ];  // true
alert[ true || false ];  // true
alert[ false || false ]; // false

5

Khi tất cả các giá trị là trung thực, giá trị cuối cùng được trả về

alert[ true || true ];   // true
alert[ false || true ];  // true
alert[ true || false ];  // true
alert[ false || false ]; // false

6

Ưu tiên của AND

if [1 || 0] { // works just like if[ true || false ]
  alert[ 'truthy!' ];
}

4 cao hơn OR

if [1 || 0] { // works just like if[ true || false ]
  alert[ 'truthy!' ];
}

3

Mức độ ưu tiên của toán tử AND

if [1 || 0] { // works just like if[ true || false ]
  alert[ 'truthy!' ];
}

4 cao hơn OR

if [1 || 0] { // works just like if[ true || false ]
  alert[ 'truthy!' ];
}

3

Vì vậy, mã

if [1 || 0] { // works just like if[ true || false ]
  alert[ 'truthy!' ];
}

75 về cơ bản giống như khi các biểu thức

if [1 || 0] { // works just like if[ true || false ]
  alert[ 'truthy!' ];
}

4 nằm trong ngoặc đơn.

if [1 || 0] { // works just like if[ true || false ]
  alert[ 'truthy!' ];
}

77

Đừng thay thế

let hour = 9;

if [hour < 10 || hour > 18] {
  alert[ 'The office is closed.' ];
}

8 bằng

if [1 || 0] { // works just like if[ true || false ]
  alert[ 'truthy!' ];
}

3 hoặc

if [1 || 0] { // works just like if[ true || false ]
  alert[ 'truthy!' ];
}

4

Đôi khi, mọi người sử dụng toán tử AND

if [1 || 0] { // works just like if[ true || false ]
  alert[ 'truthy!' ];
}

4 như một "cách viết ngắn gọn hơn cho

let hour = 9;

if [hour < 10 || hour > 18] {
  alert[ 'The office is closed.' ];
}

8"

Ví dụ

alert[ true || true ];   // true
alert[ false || true ];  // true
alert[ true || false ];  // true
alert[ false || false ]; // false

7

Hành động ở phần bên phải của

if [1 || 0] { // works just like if[ true || false ]
  alert[ 'truthy!' ];
}

4 sẽ chỉ thực hiện nếu đánh giá đạt đến nó. Đó là, chỉ khi

if [1 || 0] { // works just like if[ true || false ]
  alert[ 'truthy!' ];
}

34 là đúng

Vì vậy, về cơ bản chúng ta có một chất tương tự cho

alert[ true || true ];   // true
alert[ false || true ];  // true
alert[ true || false ];  // true
alert[ false || false ]; // false

8

Mặc dù, biến thể với

if [1 || 0] { // works just like if[ true || false ]
  alert[ 'truthy!' ];
}

4 có vẻ ngắn hơn, nhưng

let hour = 9;

if [hour < 10 || hour > 18] {
  alert[ 'The office is closed.' ];
}

8 rõ ràng hơn và có xu hướng dễ đọc hơn một chút. Vì vậy, chúng tôi khuyên bạn nên sử dụng mọi cấu trúc cho mục đích của nó. sử dụng

let hour = 9;

if [hour < 10 || hour > 18] {
  alert[ 'The office is closed.' ];
}

8 nếu chúng tôi muốn

let hour = 9;

if [hour < 10 || hour > 18] {
  alert[ 'The office is closed.' ];
}

8 và sử dụng

if [1 || 0] { // works just like if[ true || false ]
  alert[ 'truthy!' ];
}

4 nếu chúng tôi muốn AND

Toán tử boolean NOT được biểu thị bằng dấu chấm than

if [1 || 0] { // works just like if[ true || false ]
  alert[ 'truthy!' ];
}

5

Cú pháp khá đơn giản

alert[ true || true ];   // true
alert[ false || true ];  // true
alert[ true || false ];  // true
alert[ false || false ]; // false

9

Toán tử chấp nhận một đối số duy nhất và thực hiện như sau

1. Chuyển đổi toán hạng thành kiểu boolean.

   if [1 || 0] { // works just like if[ true || false ]
     alert[ 'truthy!' ];
   }

   71
2. Trả về giá trị nghịch đảo

Ví dụ

if [1 || 0] { // works just like if[ true || false ]
  alert[ 'truthy!' ];
}

0

Đôi khi NOT

if [1 || 0] { // works just like if[ true || false ]
  alert[ 'truthy!' ];
}

72 đôi khi được sử dụng để chuyển đổi một giá trị thành kiểu boolean

if [1 || 0] { // works just like if[ true || false ]
  alert[ 'truthy!' ];
}

1

Nghĩa là, cái đầu tiên KHÔNG chuyển đổi giá trị thành giá trị boolean và trả về giá trị nghịch đảo, và cái thứ hai KHÔNG đảo ngược lại giá trị đó. Cuối cùng, chúng tôi có một chuyển đổi giá trị đơn giản thành boolean

Có một cách dài dòng hơn một chút để làm điều tương tự – một hàm

if [1 || 0] { // works just like if[ true || false ]
  alert[ 'truthy!' ];
}

73 được tích hợp sẵn

if [1 || 0] { // works just like if[ true || false ]
  alert[ 'truthy!' ];
}

2

Mức độ ưu tiên của NOT

if [1 || 0] { // works just like if[ true || false ]
  alert[ 'truthy!' ];
}

5 là cao nhất trong tất cả các toán tử logic, vì vậy nó luôn thực thi trước, trước

if [1 || 0] { // works just like if[ true || false ]
  alert[ 'truthy!' ];
}

4 hoặc

if [1 || 0] { // works just like if[ true || false ]
  alert[ 'truthy!' ];
}

3

Là gì. = bằng JavaScript?

=== và == trong JavaScript là gì?

Tại sao lại sử dụng === trong JavaScript?

Thay thế của == và trong JavaScript là gì?