Đúng + đúng trong JavaScript

Chào. Tôi là Brandon. Tôi đã tạo codeburst. io và tôi viết các bài viết và hướng dẫn về JavaScript để giúp những người mới bắt đầu hiểu rõ hơn về hoạt động bên trong của Phát triển Web. Nếu bạn có bất kỳ câu hỏi nào về bài viết, hãy để lại nhận xét và tôi sẽ liên hệ lại với bạn hoặc tìm tôi trên twitter @brandonmorelli. Cuối cùng, khi bạn đã sẵn sàng thực sự đi sâu vào Phát triển Web, hãy xem các Khóa học Tốt nhất để Học Phát triển Web Full Stack

Làm thế nào để theo cùng

Nó sắp trở nên kỳ lạ - và bạn sẽ muốn đi theo tôi. Bạn có thể mở Bảng điều khiển dành cho nhà phát triển Chrome của mình bằng. [Các cửa sổ. Ctrl + Shift + J] [Mac. Cmd + Tùy chọn + J]. Điều này sẽ cho phép bạn nhập tất cả các mã sau vào trình duyệt của mình để bạn có thể xem trong thời gian thực những gì đang xảy ra…

3 + true == 4

Tôi cũng không đùa. Trong JavaScript, khi toán tử cộng được đặt giữa number và boolean, thì boolean được chuyển đổi thành number

Nếu bạn nhớ lại bài viết JavaScript Showdown của tôi, false == 0 và true == 1. Với suy nghĩ này,

'1' + 1 + 1
   '11' + 1
       '111'

0 được chuyển đổi thành

'1' + 1 + 1
   '11' + 1
       '111'

1 và do đó chúng tôi nhận được câu trả lời là

'1' + 1 + 1
   '11' + 1
       '111'

2

đúng + sai

Điều này tuân theo logic tương tự như ví dụ trên. Khi toán tử cộng được đặt giữa hai

'1' + 1 + 1
   '11' + 1
       '111'

3, thì

'1' + 1 + 1
   '11' + 1
       '111'

3 được chuyển thành

'1' + 1 + 1
   '11' + 1
       '111'

5. Do đó,

'1' + 1 + 1
   '11' + 1
       '111'

6 được chuyển đổi thành

'1' + 1 + 1
   '11' + 1
       '111'

7 và chúng tôi nhận được câu trả lời là

'1' + 1 + 1
   '11' + 1
       '111'

8

‘4’ + 8

Điều gì xảy ra khi chúng tôi thêm một số

'1' + 1 + 1
   '11' + 1
       '111'

9 vào một số thực tế number?

Theo logic này. 3 + true === 44 trở thành 3 + true === 45 và chúng tôi nhận được câu trả lời là 3 + true === 46

đúng + '4'

Tương tự như ví dụ trên, JavaScript sẽ chuyển đổi giá trị boolean thành giá trị

'1' + 1 + 1
   '11' + 1
       '111'

9 và nối. Điều này trở thành 3 + true === 49 và kết quả là 3 + true == 40

1 + 1 + ‘1’

Thứ tự các hoạt động là quan trọng. Trong trường hợp này, JavaScript đánh giá 3 + true == 41 đầu tiên trước mọi thứ khác. 3 + true == 42 bằng 3 + true == 43. Sau đó, chúng tôi tiếp tục và thêm vào giá trị

'1' + 1 + 1
   '11' + 1
       '111'

9 của 3 + true == 45. Phép nối xảy ra và kết quả là 3 + true == 46

Đây là chuỗi sự kiện

1 + 1 + '1'
  2   + '1'
       '21'

'1' + 1 + 1

Điều gì thay đổi khi chúng ta có giá trị chuỗi đầu tiên thay vì cuối cùng?

'1' + 1 + 1
   '11' + 1
       '111'

3 + true == 47. Vì vậy, trong trường hợp này, chúng tôi còn lại một chuỗi dài 3 + true == 48

-‘69’ + 69

Điều gì sẽ xảy ra nếu chúng ta cố gắng phủ định một

'1' + 1 + 1
   '11' + 1
       '111'

9 và sau đó thêm một number? . Tuy nhiên, sự phủ định thay đổi mọi thứ

Dấu trừ trước number2 là một toán tử trừ đơn nguyên sẽ thực sự chuyển đổi

'1' + 1 + 1
   '11' + 1
       '111'

9 thành number và làm cho nó trở thành số âm. Do đó, phương trình của chúng ta trở thành number5 bằng với number6

-‘giddy up’ + 409

Điều gì sẽ xảy ra nếu toán tử trừ đơn nguyên của chúng ta đứng trước một chuỗi không thể chuyển đổi thành số?

Bạn làm được rồi

Làm tốt lắm. Tôi hy vọng bạn thích bài viết của tôi. Tôi xuất bản một vài bài viết và hướng dẫn mỗi tuần, vui lòng nhập email của bạn vào đây nếu bạn muốn được thêm vào danh sách email hàng tuần của tôi

Bảng 4. Chuyển đổi giá trị thành booleans.

> Boolean['abc']
true
> Boolean[[]]
true
> Boolean[{}]
true

8

> Boolean['abc']
true
> Boolean[[]]
true
> Boolean[{}]
true

1

if [x] {
  // x is truthy
}

if [!x] {
  // x is falsy
}

if [x] {
  // x is truthy
} else {
  // x is falsy
}

const result = x ? 'truthy' : 'falsy';

0

> Boolean['abc']
true
> Boolean[[]]
true
> Boolean[{}]
true

1boolean

> Boolean['abc']
true
> Boolean[[]]
true
> Boolean[{}]
true

3 [no change]number

if [x] {
  // x is truthy
}

if [!x] {
  // x is falsy
}

if [x] {
  // x is truthy
} else {
  // x is falsy
}

const result = x ? 'truthy' : 'falsy';

3

if [x] {
  // x is truthy
}

if [!x] {
  // x is falsy
}

if [x] {
  // x is truthy
} else {
  // x is falsy
}

const result = x ? 'truthy' : 'falsy';

4

> Boolean['abc']
true
> Boolean[[]]
true
> Boolean[{}]
true

1,

if [x] {
  // x is truthy
}

if [!x] {
  // x is falsy
}

if [x] {
  // x is truthy
} else {
  // x is falsy
}

const result = x ? 'truthy' : 'falsy';

6

if [x] {
  // x is truthy
}

if [!x] {
  // x is falsy
}

if [x] {
  // x is truthy
} else {
  // x is falsy
}

const result = x ? 'truthy' : 'falsy';

4

> Boolean['abc']
true
> Boolean[[]]
true
> Boolean[{}]
true

1Other numbers

if [x] {
  // x is truthy
}

if [!x] {
  // x is falsy
}

if [x] {
  // x is truthy
} else {
  // x is falsy
}

const result = x ? 'truthy' : 'falsy';

4

> Boolean['abc']
true
> Boolean[[]]
true
> Boolean[{}]
true

2bigint

if [x] {
  // x is truthy
}

if [!x] {
  // x is falsy
}

if [x] {
  // x is truthy
} else {
  // x is falsy
}

const result = x ? 'truthy' : 'falsy';

3

if [x] {
  // x is truthy
}

if [!x] {
  // x is falsy
}

if [x] {
  // x is truthy
} else {
  // x is falsy
}

const result = x ? 'truthy' : 'falsy';

4

> Boolean['abc']
true
> Boolean[[]]
true
> Boolean[{}]
true

1Other numbers

if [x] {
  // x is truthy
}

if [!x] {
  // x is falsy
}

if [x] {
  // x is truthy
} else {
  // x is falsy
}

const result = x ? 'truthy' : 'falsy';

4

> Boolean['abc']
true
> Boolean[[]]
true
> Boolean[{}]
true

2string

if [obj.prop !== undefined] {
  // obj has property .prop
}

6

if [x] {
  // x is truthy
}

if [!x] {
  // x is falsy
}

if [x] {
  // x is truthy
} else {
  // x is falsy
}

const result = x ? 'truthy' : 'falsy';

4

> Boolean['abc']
true
> Boolean[[]]
true
> Boolean[{}]
true

1Other strings

if [x] {
  // x is truthy
}

if [!x] {
  // x is falsy
}

if [x] {
  // x is truthy
} else {
  // x is falsy
}

const result = x ? 'truthy' : 'falsy';

4

> Boolean['abc']
true
> Boolean[[]]
true
> Boolean[{}]
true

2symbol

> Boolean['abc']
true
> Boolean[[]]
true
> Boolean[{}]
true

2objectAlways

> Boolean['abc']
true
> Boolean[[]]
true
> Boolean[{}]
true

2

15. 2 Giá trị giả và trung thực

Khi kiểm tra điều kiện của câu lệnh

if [obj.prop] {
  // obj has property .prop
}

3, vòng lặp

if [obj.prop] {
  // obj has property .prop
}

4 hoặc vòng lặp

if [obj.prop] {
  // obj has property .prop
}

5, JavaScript hoạt động khác với mong đợi của bạn. Lấy ví dụ, điều kiện sau

Trong nhiều ngôn ngữ lập trình, điều kiện này tương đương với

Tuy nhiên, trong JavaScript, nó tương đương với

if [Boolean[value] === true] {}

Nghĩa là, JavaScript kiểm tra xem

if [obj.prop] {
  // obj has property .prop
}

6 có phải là

> Boolean['abc']
true
> Boolean[[]]
true
> Boolean[{}]
true

2 khi được chuyển đổi thành boolean hay không. Loại kiểm tra này phổ biến đến mức các tên sau đây đã được giới thiệu

• Một giá trị được gọi là truey nếu nó là

  > Boolean['abc']
  true
  > Boolean[[]]
  true
  > Boolean[{}]
  true

  2 khi được chuyển đổi thành boolean
• Một giá trị được gọi là falsy nếu nó là

  > Boolean['abc']
  true
  > Boolean[[]]
  true
  > Boolean[{}]
  true

  1 khi được chuyển đổi thành boolean

Mỗi giá trị là trung thực hoặc sai. tbl tư vấn. , chúng ta có thể tạo một danh sách đầy đủ các giá trị giả

• > Boolean['abc']
  true
  > Boolean[[]]
  true
  > Boolean[{}]
  true

  8

• if [x] {
    // x is truthy
  }
  
  if [!x] {
    // x is falsy
  }
  
  if [x] {
    // x is truthy
  } else {
    // x is falsy
  }
  
  const result = x ? 'truthy' : 'falsy';

  0
• Boolean.

  > Boolean['abc']
  true
  > Boolean[[]]
  true
  > Boolean[{}]
  true

  1
• số.

  if [x] {
    // x is truthy
  }
  
  if [!x] {
    // x is falsy
  }
  
  if [x] {
    // x is truthy
  } else {
    // x is falsy
  }
  
  const result = x ? 'truthy' : 'falsy';

  3,

  if [x] {
    // x is truthy
  }
  
  if [!x] {
    // x is falsy
  }
  
  if [x] {
    // x is truthy
  } else {
    // x is falsy
  }
  
  const result = x ? 'truthy' : 'falsy';

  6
• Bigint.

  if [obj.prop] {
    // obj has property .prop
  }

  5
• Chuỗi.

  if [obj.prop !== undefined] {
    // obj has property .prop
  }

  6

Tất cả các giá trị khác [bao gồm tất cả các đối tượng] là trung thực

> Boolean['abc']
true
> Boolean[[]]
true
> Boolean[{}]
true

15. 2. 1 Kiểm tra tính trung thực và giả dối

if [x] {
  // x is truthy
}

if [!x] {
  // x is falsy
}

if [x] {
  // x is truthy
} else {
  // x is falsy
}

const result = x ? 'truthy' : 'falsy';

Toán tử điều kiện được sử dụng ở dòng cuối cùng được giải thích

Bài tập. chân thật

if [obj.prop] {
  // obj has property .prop
}

7

15. 3 Kiểm tra sự tồn tại dựa trên sự thật

Trong JavaScript, nếu bạn đọc thứ gì đó không tồn tại [e. g. , một tham số bị thiếu hoặc một thuộc tính bị thiếu], kết quả là bạn thường nhận được _______17_______8. Trong những trường hợp này, việc kiểm tra sự tồn tại tương đương với việc so sánh một giá trị với

> Boolean['abc']
true
> Boolean[[]]
true
> Boolean[{}]
true

8. Ví dụ: đoạn mã sau kiểm tra xem đối tượng

function func[x] {
  if [!x] {
    throw new Error['Missing parameter x'];
  }
  // ···
}

0 có thuộc tính

function func[x] {
  if [!x] {
    throw new Error['Missing parameter x'];
  }
  // ···
}

1 không

if [obj.prop !== undefined] {
  // obj has property .prop
}

Do

> Boolean['abc']
true
> Boolean[[]]
true
> Boolean[{}]
true

8 bị sai, chúng tôi có thể rút ngắn kiểm tra này thành

if [obj.prop] {
  // obj has property .prop
}

15. 3. 1 Cạm bẫy. kiểm tra sự tồn tại dựa trên sự trung thực là không chính xác

Kiểm tra sự tồn tại dựa trên tính xác thực có một cạm bẫy. chúng không chính xác lắm. Xem xét ví dụ trước đây

if [obj.prop] {
  // obj has property .prop
}

Phần thân của câu lệnh

if [obj.prop] {
  // obj has property .prop
}

3 bị bỏ qua nếu

• function func[x] {
    if [!x] {
      throw new Error['Missing parameter x'];
    }
    // ···
  }

  4 bị thiếu [trong trường hợp đó, JavaScript trả về

  > Boolean['abc']
  true
  > Boolean[[]]
  true
  > Boolean[{}]
  true

  8]

Tuy nhiên, nó cũng bị bỏ qua nếu

• function func[x] {
    if [!x] {
      throw new Error['Missing parameter x'];
    }
    // ···
  }

  4 là

  > Boolean['abc']
  true
  > Boolean[[]]
  true
  > Boolean[{}]
  true

  8

• function func[x] {
    if [!x] {
      throw new Error['Missing parameter x'];
    }
    // ···
  }

  4 là bất kỳ giá trị giả nào khác [

  if [x] {
    // x is truthy
  }
  
  if [!x] {
    // x is falsy
  }
  
  if [x] {
    // x is truthy
  } else {
    // x is falsy
  }
  
  const result = x ? 'truthy' : 'falsy';

  0,

  if [x] {
    // x is truthy
  }
  
  if [!x] {
    // x is falsy
  }
  
  if [x] {
    // x is truthy
  } else {
    // x is falsy
  }
  
  const result = x ? 'truthy' : 'falsy';

  3,

  if [obj.prop !== undefined] {
    // obj has property .prop
  }

  6, v.v. ]

Trong thực tế, điều này hiếm khi gây ra vấn đề, nhưng bạn phải nhận thức được cạm bẫy này

15. 3. 2 Trường hợp sử dụng. là một tham số được cung cấp?

Kiểm tra tính trung thực thường được sử dụng để xác định xem người gọi hàm có cung cấp tham số hay không

function func[x] {
  if [!x] {
    throw new Error['Missing parameter x'];
  }
  // ···
}

Về mặt tích cực, mô hình này được thiết lập và ngắn. Nó ném lỗi chính xác cho

> Boolean['abc']
true
> Boolean[[]]
true
> Boolean[{}]
true

8 và

if [x] {
  // x is truthy
}

if [!x] {
  // x is falsy
}

if [x] {
  // x is truthy
} else {
  // x is falsy
}

const result = x ? 'truthy' : 'falsy';

0

Về mặt tiêu cực, có một cạm bẫy đã đề cập trước đó. mã cũng đưa ra lỗi cho tất cả các giá trị giả khác

Một cách khác là kiểm tra

> Boolean['abc']
true
> Boolean[[]]
true
> Boolean[{}]
true

8

if [x === undefined] {
  throw new Error['Missing parameter x'];
}

15. 3. 3 Trường hợp sử dụng. một tài sản tồn tại?

Kiểm tra tính trung thực cũng thường được sử dụng để xác định xem một tài sản có tồn tại hay không

function readFile[fileDesc] {
  if [!fileDesc.path] {
    throw new Error['Missing property: .path'];
  }
  // ···
}
readFile[{ path: 'foo.txt' }]; // no error

Mẫu này cũng được thiết lập và có thông báo trước. nó không chỉ ném nếu thuộc tính bị thiếu mà còn nếu thuộc tính tồn tại và có bất kỳ giá trị giả nào

Nếu bạn thực sự muốn kiểm tra xem thuộc tính có tồn tại hay không, bạn phải sử dụng

if [Boolean[value] === true] {}

0

15. 4 Toán tử có điều kiện [

if [x === undefined] {
  throw new Error['Missing parameter x'];
}

6]

Toán tử điều kiện là phiên bản biểu thức của câu lệnh

if [obj.prop] {
  // obj has property .prop
}

3. Cú pháp của nó là

if [Boolean[value] === true] {}

1

Nó được đánh giá như sau

• Nếu

  if [x === undefined] {
    throw new Error['Missing parameter x'];
  }

  8 là trung thực, hãy đánh giá và trả lại

  if [x === undefined] {
    throw new Error['Missing parameter x'];
  }

  9
• Nếu không, hãy đánh giá và trả về

  function readFile[fileDesc] {
    if [!fileDesc.path] {
      throw new Error['Missing property: .path'];
    }
    // ···
  }
  readFile[{ path: 'foo.txt' }]; // no error

  0

Toán tử điều kiện còn được gọi là toán tử bậc ba vì nó có ba toán hạng

ví dụ

if [Boolean[value] === true] {}

2

Đoạn mã sau chứng minh rằng bất kỳ nhánh nào trong hai nhánh “then” và “else” được chọn thông qua điều kiện, thì chỉ nhánh đó được đánh giá. Các chi nhánh khác không phải là

if [Boolean[value] === true] {}

3

15. 5 Toán tử logic nhị phân. Và [

function readFile[fileDesc] {
  if [!fileDesc.path] {
    throw new Error['Missing property: .path'];
  }
  // ···
}
readFile[{ path: 'foo.txt' }]; // no error

1], Hoặc [

function readFile[fileDesc] {
  if [!fileDesc.path] {
    throw new Error['Missing property: .path'];
  }
  // ···
}
readFile[{ path: 'foo.txt' }]; // no error

2]

Các toán tử logic nhị phân

function readFile[fileDesc] {
  if [!fileDesc.path] {
    throw new Error['Missing property: .path'];
  }
  // ···
}
readFile[{ path: 'foo.txt' }]; // no error

3 và

function readFile[fileDesc] {
  if [!fileDesc.path] {
    throw new Error['Missing property: .path'];
  }
  // ···
}
readFile[{ path: 'foo.txt' }]; // no error

4 là bảo toàn giá trị và đoản mạch

15. 5. 1 Giữ gìn giá trị

Bảo toàn giá trị có nghĩa là toán hạng được hiểu là phép toán luận nhưng được trả về không thay đổi

if [Boolean[value] === true] {}

4

15. 5. 2 Đoản mạch

Đoản mạch có nghĩa là nếu toán hạng đầu tiên đã xác định kết quả, thì toán hạng thứ hai không được đánh giá. Toán tử duy nhất khác trì hoãn việc đánh giá các toán hạng của nó là toán tử có điều kiện. Thông thường, tất cả các toán hạng được đánh giá trước khi thực hiện một thao tác

Ví dụ: logic And [

function readFile[fileDesc] {
  if [!fileDesc.path] {
    throw new Error['Missing property: .path'];
  }
  // ···
}
readFile[{ path: 'foo.txt' }]; // no error

3] không đánh giá toán hạng thứ hai của nó nếu toán hạng đầu tiên là sai

if [Boolean[value] === true] {}

5

Nếu toán hạng đầu tiên là true,

function readFile[fileDesc] {
  if [!fileDesc.path] {
    throw new Error['Missing property: .path'];
  }
  // ···
}
readFile[{ path: 'foo.txt' }]; // no error

6 được thực thi

if [Boolean[value] === true] {}

6

15. 5. 3 Hợp lý và [

function readFile[fileDesc] {
  if [!fileDesc.path] {
    throw new Error['Missing property: .path'];
  }
  // ···
}
readFile[{ path: 'foo.txt' }]; // no error

1]

Biểu thức

function readFile[fileDesc] {
  if [!fileDesc.path] {
    throw new Error['Missing property: .path'];
  }
  // ···
}
readFile[{ path: 'foo.txt' }]; // no error

8 [“

function readFile[fileDesc] {
  if [!fileDesc.path] {
    throw new Error['Missing property: .path'];
  }
  // ···
}
readFile[{ path: 'foo.txt' }]; // no error

9 And

if [Boolean[value] === true] {}

00”] được đánh giá như sau

1. Đánh giá

   function readFile[fileDesc] {
     if [!fileDesc.path] {
       throw new Error['Missing property: .path'];
     }
     // ···
   }
   readFile[{ path: 'foo.txt' }]; // no error

   9
2. Là kết quả sai?
3. Mặt khác, đánh giá

   if [Boolean[value] === true] {}

   00 và trả về kết quả

Nói cách khác, hai biểu thức sau gần như tương đương

ví dụ

if [Boolean[value] === true] {}

7

15. 5. 4 Hợp lý Hoặc [______82_______4]

Biểu thức

if [Boolean[value] === true] {}

04 [“

function readFile[fileDesc] {
  if [!fileDesc.path] {
    throw new Error['Missing property: .path'];
  }
  // ···
}
readFile[{ path: 'foo.txt' }]; // no error

9 Or

if [Boolean[value] === true] {}

00”] được đánh giá như sau

1. Đánh giá

   function readFile[fileDesc] {
     if [!fileDesc.path] {
       throw new Error['Missing property: .path'];
     }
     // ···
   }
   readFile[{ path: 'foo.txt' }]; // no error

   9
2. Kết quả có đúng sự thật không?
3. Mặt khác, đánh giá

   if [Boolean[value] === true] {}

   00 và trả về kết quả

Nói cách khác, hai biểu thức sau gần như tương đương

ví dụ

if [Boolean[value] === true] {}

8

15. 5. 4. 1 Trường hợp sử dụng kế thừa cho logic Hoặc [

function readFile[fileDesc] {
  if [!fileDesc.path] {
    throw new Error['Missing property: .path'];
  }
  // ···
}
readFile[{ path: 'foo.txt' }]; // no error

4]. cung cấp giá trị mặc định

ECMAScript 2020 đã giới thiệu toán tử kết hợp nullish [

if [Boolean[value] === true] {}

10] cho các giá trị mặc định. Trước đó, logic Or đã được sử dụng cho mục đích này

Điều gì là đúng sự thật trong JavaScript?

Đúng == Đúng trong JavaScript?

Sự khác biệt giữa true và true trong JavaScript là gì?

true[] là một hàm. true là giá trị boolean .

Làm cách nào để kiểm tra điều kiện thực trong JavaScript?

Câu lệnh if/else thực thi một khối mã nếu một điều kiện cụ thể là đúng. Nếu điều kiện là sai, một khối mã khác có thể được thực thi. Câu lệnh if/else là một phần của Câu lệnh "Có điều kiện" của JavaScript, được sử dụng để thực hiện các hành động khác nhau dựa trên các điều kiện khác nhau.