Khi toán tử được sử dụng với một chuỗi và một số javascript chuyển đổi giá trị số thành một chuỗi và thực hiện phép nối?

Có 3 cách nối chuỗi trong JavaScript. Trong hướng dẫn này, bạn sẽ tìm hiểu các cách khác nhau và sự đánh đổi giữa chúng

Toán tử let o = {x: 1}; let p = null; o && o.x // => 1: o is truthy, so return value of o.x p && p.x // => null: p is falsy, so return it and don't evaluate p.x3

Toán tử

let o = {x: 1};
let p = null;
o && o.x     // => 1: o is truthy, so return value of o.x
p && p.x     // => null: p is falsy, so return it and don't evaluate p.x

3 giống như bạn sử dụng để cộng hai số có thể được sử dụng để nối hai chuỗi

Bạn cũng có thể sử dụng

let o = {x: 1};
let p = null;
o && o.x     // => 1: o is truthy, so return value of o.x
p && p.x     // => null: p is falsy, so return it and don't evaluate p.x

5, trong đó

let o = {x: 1};
let p = null;
o && o.x     // => 1: o is truthy, so return value of o.x
p && p.x     // => null: p is falsy, so return it and don't evaluate p.x

6 là viết tắt của

let o = {x: 1};
let p = null;
o && o.x     // => 1: o is truthy, so return value of o.x
p && p.x     // => null: p is falsy, so return it and don't evaluate p.x

7

Nếu vế trái của toán tử

let o = {x: 1};
let p = null;
o && o.x     // => 1: o is truthy, so return value of o.x
p && p.x     // => null: p is falsy, so return it and don't evaluate p.x

3 là một chuỗi, JavaScript sẽ ép vế phải thành một chuỗi. Điều đó có nghĩa là an toàn khi nối các đối tượng, số,

let o = {x: 1};
let p = null;
o && o.x     // => 1: o is truthy, so return value of o.x
p && p.x     // => null: p is falsy, so return it and don't evaluate p.x

9 và

let o = {x: 1};
let p = null;
o && o.x     // => 1: o is truthy, so return value of o.x
p && p.x     // => null: p is falsy, so return it and don't evaluate p.x

0

Các toán tử

let o = {x: 1};
let p = null;
o && o.x     // => 1: o is truthy, so return value of o.x
p && p.x     // => null: p is falsy, so return it and don't evaluate p.x

3 và

let o = {x: 1};
let p = null;
o && o.x     // => 1: o is truthy, so return value of o.x
p && p.x     // => null: p is falsy, so return it and don't evaluate p.x

5 rất nhanh trên các công cụ JavaScript hiện đại, vì vậy không cần phải lo lắng về thứ gì đó như lớp StringBuilder của Java

let o = {x: 1}; let p = null; o && o.x // => 1: o is truthy, so return value of o.x p && p.x // => null: p is falsy, so return it and don't evaluate p.x31

Hàm

let o = {x: 1};
let p = null;
o && o.x     // => 1: o is truthy, so return value of o.x
p && p.x     // => null: p is falsy, so return it and don't evaluate p.x

31 tạo chuỗi mới từ việc ghép tất cả các phần tử trong mảng. Ví dụ

Tham số đầu tiên của

let o = {x: 1};
let p = null;
o && o.x     // => 1: o is truthy, so return value of o.x
p && p.x     // => null: p is falsy, so return it and don't evaluate p.x

33 được gọi là dấu tách. Theo mặc định, dấu phân cách là một dấu phẩy duy nhất

let o = {x: 1};
let p = null;
o && o.x     // => 1: o is truthy, so return value of o.x
p && p.x     // => null: p is falsy, so return it and don't evaluate p.x

34

Bạn có thể chuyển vào bất kỳ dấu phân cách nào bạn muốn. Dấu phân cách làm cho

let o = {x: 1};
let p = null;
o && o.x     // => 1: o is truthy, so return value of o.x
p && p.x     // => null: p is falsy, so return it and don't evaluate p.x

31 trở thành lựa chọn ưu tiên để nối các chuỗi nếu bạn thấy mình lặp đi lặp lại cùng một ký tự. Ví dụ: bạn có thể sử dụng

let o = {x: 1};
let p = null;
o && o.x     // => 1: o is truthy, so return value of o.x
p && p.x     // => null: p is falsy, so return it and don't evaluate p.x

36 làm dấu phân cách để nối một mảng các từ

Hoặc bạn có thể sử dụng

let o = {x: 1};
let p = null;
o && o.x     // => 1: o is truthy, so return value of o.x
p && p.x     // => null: p is falsy, so return it and don't evaluate p.x

37 để nối các đoạn URL lại với nhau

Dấu phân cách làm cho

let o = {x: 1};
let p = null;
o && o.x     // => 1: o is truthy, so return value of o.x
p && p.x     // => null: p is falsy, so return it and don't evaluate p.x

31 trở thành một cách rất linh hoạt để nối các chuỗi. Nếu bạn muốn kết hợp nhiều chuỗi với nhau, thông thường bạn nên sử dụng vòng lặp

let o = {x: 1};
let p = null;
o && o.x     // => 1: o is truthy, so return value of o.x
p && p.x     // => null: p is falsy, so return it and don't evaluate p.x

33 thay vì vòng lặp

let o = {x: 1};
let p = null;
o && o.x     // => 1: o is truthy, so return value of o.x
p && p.x     // => null: p is falsy, so return it and don't evaluate p.x

30 với

let o = {x: 1};
let p = null;
o && o.x     // => 1: o is truthy, so return value of o.x
p && p.x     // => null: p is falsy, so return it and don't evaluate p.x

3

Chuỗi JavaScript có phương thức

let o = {x: 1};
let p = null;
o && o.x     // => 1: o is truthy, so return value of o.x
p && p.x     // => null: p is falsy, so return it and don't evaluate p.x

32 tích hợp. Hàm

let o = {x: 1};
let p = null;
o && o.x     // => 1: o is truthy, so return value of o.x
p && p.x     // => null: p is falsy, so return it and don't evaluate p.x

32 nhận một hoặc nhiều tham số và trả về chuỗi đã sửa đổi. Các chuỗi trong JavaScript là bất biến, vì vậy

let o = {x: 1};
let p = null;
o && o.x     // => 1: o is truthy, so return value of o.x
p && p.x     // => null: p is falsy, so return it and don't evaluate p.x

32 không sửa đổi chuỗi tại chỗ

Nhược điểm của việc sử dụng

let o = {x: 1};
let p = null;
o && o.x     // => 1: o is truthy, so return value of o.x
p && p.x     // => null: p is falsy, so return it and don't evaluate p.x

32 là bạn phải chắc chắn rằng

let o = {x: 1};
let p = null;
o && o.x     // => 1: o is truthy, so return value of o.x
p && p.x     // => null: p is falsy, so return it and don't evaluate p.x

36 là một chuỗi. Bạn có thể chuyển tham số không phải chuỗi cho

let o = {x: 1};
let p = null;
o && o.x     // => 1: o is truthy, so return value of o.x
p && p.x     // => null: p is falsy, so return it and don't evaluate p.x

32, nhưng bạn sẽ nhận được TypeError nếu

let o = {x: 1};
let p = null;
o && o.x     // => 1: o is truthy, so return value of o.x
p && p.x     // => null: p is falsy, so return it and don't evaluate p.x

38

Hàm

let o = {x: 1};
let p = null;
o && o.x     // => 1: o is truthy, so return value of o.x
p && p.x     // => null: p is falsy, so return it and don't evaluate p.x

32 hiếm khi được sử dụng vì nó có nhiều trường hợp lỗi hơn toán tử

let o = {x: 1};
let p = null;
o && o.x     // => 1: o is truthy, so return value of o.x
p && p.x     // => null: p is falsy, so return it and don't evaluate p.x

3. Ví dụ: bạn sẽ gặp phải hành vi không mong muốn nếu gọi

let o = {x: 1};
let p = null;
o && o.x     // => 1: o is truthy, so return value of o.x
p && p.x     // => null: p is falsy, so return it and don't evaluate p.x

32 trên một giá trị xảy ra là một mảng. Bạn nên sử dụng

let o = {x: 1};
let p = null;
o && o.x     // => 1: o is truthy, so return value of o.x
p && p.x     // => null: p is falsy, so return it and don't evaluate p.x

3 thay vì

let o = {x: 1};
let p = null;
o && o.x     // => 1: o is truthy, so return value of o.x
p && p.x     // => null: p is falsy, so return it and don't evaluate p.x

32 trừ khi bạn có lý do chính đáng

Toán tử

if (a === b) stop();   // Invoke stop() only if a === b
(a === b) && stop();   // This does the same thing

6 có thể được hiểu ở ba cấp độ khác nhau. Ở cấp độ đơn giản nhất, khi được sử dụng với toán hạng boolean,

if (a === b) stop();   // Invoke stop() only if a === b
(a === b) && stop();   // This does the same thing

6 thực hiện phép toán AND Boolean trên hai giá trị. nó trả về

if (a === b) stop();   // Invoke stop() only if a === b
(a === b) && stop();   // This does the same thing

8 khi và chỉ khi cả toán hạng đầu tiên và toán hạng thứ hai của nó đều là

if (a === b) stop();   // Invoke stop() only if a === b
(a === b) && stop();   // This does the same thing

8. Nếu một hoặc cả hai toán hạng này là

if (a === b) stop();   // Invoke stop() only if a === b
(a === b) && stop();   // This does the same thing

0, nó sẽ trả về

if (a === b) stop();   // Invoke stop() only if a === b
(a === b) && stop();   // This does the same thing

0

if (a === b) stop();   // Invoke stop() only if a === b
(a === b) && stop();   // This does the same thing

6 thường được dùng như một từ kết hợp để nối hai biểu thức quan hệ

x === 0 && y === 0   // true if, and only if, x and y are both 0

Các biểu thức quan hệ luôn đánh giá bằng

if (a === b) stop();   // Invoke stop() only if a === b
(a === b) && stop();   // This does the same thing

8 hoặc

if (a === b) stop();   // Invoke stop() only if a === b
(a === b) && stop();   // This does the same thing

0, vì vậy khi được sử dụng như thế này, chính toán tử

if (a === b) stop();   // Invoke stop() only if a === b
(a === b) && stop();   // This does the same thing

6 trả về

if (a === b) stop();   // Invoke stop() only if a === b
(a === b) && stop();   // This does the same thing

8 hoặc

if (a === b) stop();   // Invoke stop() only if a === b
(a === b) && stop();   // This does the same thing

0. Các toán tử quan hệ có độ ưu tiên cao hơn

if (a === b) stop();   // Invoke stop() only if a === b
(a === b) && stop();   // This does the same thing

6 (và

let o = {x: 1};
let p = null;
o && o.x     // => 1: o is truthy, so return value of o.x
p && p.x     // => null: p is falsy, so return it and don't evaluate p.x

6), vì vậy các biểu thức như thế này có thể được viết một cách an toàn mà không cần dấu ngoặc đơn

Nhưng

if (a === b) stop();   // Invoke stop() only if a === b
(a === b) && stop();   // This does the same thing

6 không yêu cầu toán hạng của nó phải là giá trị boolean. Hãy nhớ lại rằng tất cả các giá trị JavaScript là “trung thực” hoặc “sai. ” (Xem §3. 4 để biết chi tiết. Các giá trị giả là

if (a === b) stop();   // Invoke stop() only if a === b
(a === b) && stop();   // This does the same thing

0,

let o = {x: 1};
let p = null;
o && o.x     // => 1: o is truthy, so return value of o.x
p && p.x     // => null: p is falsy, so return it and don't evaluate p.x

9,

if (a === b) stop();   // Invoke stop() only if a === b
(a === b) && stop();   // This does the same thing

0,

if (a === b) stop();   // Invoke stop() only if a === b
(a === b) && stop();   // This does the same thing

1,

if (a === b) stop();   // Invoke stop() only if a === b
(a === b) && stop();   // This does the same thing

2,

if (a === b) stop();   // Invoke stop() only if a === b
(a === b) && stop();   // This does the same thing

3 và

if (a === b) stop();   // Invoke stop() only if a === b
(a === b) && stop();   // This does the same thing

4. Tất cả các giá trị khác, bao gồm tất cả các đối tượng, là trung thực. ) Cấp độ thứ hai mà tại đó có thể hiểu

if (a === b) stop();   // Invoke stop() only if a === b
(a === b) && stop();   // This does the same thing

6 là toán tử Boolean AND cho các giá trị trung thực và giả. Nếu cả hai toán hạng là trung thực, toán tử trả về một giá trị trung thực. Mặt khác, một hoặc cả hai toán hạng phải là giả và toán tử trả về giá trị giả. Trong JavaScript, bất kỳ biểu thức hoặc câu lệnh nào mong đợi giá trị boolean sẽ hoạt động với giá trị true hoặc false, do đó, việc

if (a === b) stop();   // Invoke stop() only if a === b
(a === b) && stop();   // This does the same thing

6 không phải lúc nào cũng trả về

if (a === b) stop();   // Invoke stop() only if a === b
(a === b) && stop();   // This does the same thing

8 hoặc

if (a === b) stop();   // Invoke stop() only if a === b
(a === b) && stop();   // This does the same thing

0 không gây ra sự cố thực tế

Lưu ý rằng mô tả này nói rằng toán tử trả về “giá trị trung thực” hoặc “giá trị giả” nhưng không chỉ định giá trị đó là gì. Để làm được điều đó, chúng ta cần mô tả

if (a === b) stop();   // Invoke stop() only if a === b
(a === b) && stop();   // This does the same thing

6 ở cấp độ thứ ba và cấp độ cuối cùng. Toán tử này bắt đầu bằng cách đánh giá toán hạng đầu tiên của nó, biểu thức bên trái của nó. Nếu giá trị bên trái là sai, thì giá trị của toàn bộ biểu thức cũng phải là sai, vì vậy,

if (a === b) stop();   // Invoke stop() only if a === b
(a === b) && stop();   // This does the same thing

6 chỉ cần trả về giá trị bên trái và thậm chí không đánh giá biểu thức bên phải

Mặt khác, nếu giá trị bên trái là trung thực, thì giá trị chung của biểu thức phụ thuộc vào giá trị bên phải. Nếu giá trị bên phải là trung thực, thì giá trị tổng thể phải là trung thực và nếu giá trị bên phải là giả, thì giá trị tổng thể phải là giả. Vì vậy, khi giá trị bên trái là true, toán tử

if (a === b) stop();   // Invoke stop() only if a === b
(a === b) && stop();   // This does the same thing

6 sẽ đánh giá và trả về giá trị bên phải

let o = {x: 1};
let p = null;
o && o.x     // => 1: o is truthy, so return value of o.x
p && p.x     // => null: p is falsy, so return it and don't evaluate p.x

Điều quan trọng là phải hiểu rằng

if (a === b) stop();   // Invoke stop() only if a === b
(a === b) && stop();   // This does the same thing

6 có thể hoặc không thể đánh giá toán hạng bên phải của nó. Trong ví dụ mã này, biến

if (a === b) stop();   // Invoke stop() only if a === b
(a === b) && stop();   // This does the same thing

63 được đặt thành

let o = {x: 1};
let p = null;
o && o.x     // => 1: o is truthy, so return value of o.x
p && p.x     // => null: p is falsy, so return it and don't evaluate p.x

9 và biểu thức

if (a === b) stop();   // Invoke stop() only if a === b
(a === b) && stop();   // This does the same thing

65, nếu được đánh giá, sẽ gây ra TypeError. Nhưng mã sử dụng

if (a === b) stop();   // Invoke stop() only if a === b
(a === b) && stop();   // This does the same thing

6 theo cách thành ngữ để

if (a === b) stop();   // Invoke stop() only if a === b
(a === b) && stop();   // This does the same thing

65 chỉ được đánh giá nếu

if (a === b) stop();   // Invoke stop() only if a === b
(a === b) && stop();   // This does the same thing

63 là trung thực—không phải

let o = {x: 1};
let p = null;
o && o.x     // => 1: o is truthy, so return value of o.x
p && p.x     // => null: p is falsy, so return it and don't evaluate p.x

9 hoặc

if (a === b) stop();   // Invoke stop() only if a === b
(a === b) && stop();   // This does the same thing

0

Hành vi của

if (a === b) stop();   // Invoke stop() only if a === b
(a === b) && stop();   // This does the same thing

6 đôi khi được gọi là đoản mạch và đôi khi bạn có thể thấy mã cố tình khai thác hành vi này để thực thi mã có điều kiện. Ví dụ: hai dòng mã JavaScript sau đây có tác dụng tương đương

if (a === b) stop();   // Invoke stop() only if a === b
(a === b) && stop();   // This does the same thing

Nói chung, bạn phải cẩn thận bất cứ khi nào bạn viết một biểu thức có tác dụng phụ (gán, tăng, giảm hoặc gọi hàm) ở vế phải của

if (a === b) stop();   // Invoke stop() only if a === b
(a === b) && stop();   // This does the same thing

6. Những tác dụng phụ đó có xảy ra hay không phụ thuộc vào giá trị của vế trái

Mặc dù cách thức hoạt động của toán tử này hơi phức tạp, nhưng nó thường được sử dụng phổ biến nhất như một toán tử đại số Boolean đơn giản hoạt động trên các giá trị trung thực và sai lệch

Toán tử nào được sử dụng làm toán tử nối chuỗi trong JavaScript?

Lệnh nào trong JavaScript được sử dụng để chuyển đổi giá trị chuỗi thành giá trị số?

Điều gì xảy ra khi bạn thêm một số và một chuỗi trong JavaScript?

Chúng ta có thể nối chuỗi và số nguyên trong JavaScript không?