C sang javascript

2. 1 Sử dụng

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

59 cho tất cả các tài liệu tham khảo của bạn; . dây dẫn.

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

61,

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

// bad
var a = 1;
var b = 2;

// good
const a = 1;
const b = 2;

2. 2 Nếu bạn phải chỉ định lại tài liệu tham khảo, hãy sử dụng

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

63 thay vì

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

60. dây dẫn.

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

2. 3 Lưu ý rằng cả

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

63 và

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

59 đều ở phạm vi khối, trong khi

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

60 là phạm vi chức năng

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

Trong đoạn mã trên, bạn có thể thấy rằng việc tham chiếu

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

71 và

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

72 sẽ tạo ra ReferenceError, trong khi

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

73 chứa số. Điều này là do

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

71 và

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

72 nằm trong phạm vi khối, trong khi

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

73 nằm trong phạm vi hàm chứa

⬆quay lại đầu trang

Các đối tượng

3. 1 Sử dụng cú pháp theo nghĩa đen để tạo đối tượng. dây dẫn.

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

3. 2 Sử dụng tên thuộc tính được tính toán khi tạo đối tượng có tên thuộc tính động
Tại sao?
```
const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9
```
3

3. 3 Sử dụng tốc ký phương thức đối tượng. dây dẫn.

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

3. 4 Sử dụng tốc ký giá trị thuộc tính. dây dẫn.

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

3. 5 Nhóm các thuộc tính tốc ký của bạn khi bắt đầu khai báo đối tượng của bạn
Tại sao?
```
const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9
```
8

3. 6 Chỉ trích dẫn các thuộc tính không hợp lệ. dây dẫn.
```
const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9
```
80
Tại sao? . Nó cải thiện khả năng làm nổi bật cú pháp và cũng được nhiều công cụ JS tối ưu hóa dễ dàng hơn
```
const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9
```
0

3. 7 Không gọi trực tiếp các phương thức

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

81, chẳng hạn như

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

82,

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

83 và

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

84. dây dẫn.

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

3. 8 Ưu tiên cú pháp trải rộng đối tượng trên

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

88 hơn đối tượng sao chép nông. Sử dụng cú pháp tham số phần còn lại của đối tượng để nhận một đối tượng mới với các thuộc tính nhất định bị bỏ qua. dây dẫn.

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

⬆quay lại đầu trang

Mảng

4. 1 Sử dụng cú pháp chữ để tạo mảng. dây dẫn.

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

4. 2 Sử dụng Array#push thay vì gán trực tiếp để thêm các mục vào một mảng

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

4. 3 Sử dụng dàn trải mảng

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

91 để sao chép mảng

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

4. 4 Để chuyển đổi một đối tượng có thể lặp lại thành một mảng, hãy sử dụng chênh lệch

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

91 thay vì

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

4. 5 Sử dụng

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

93 để chuyển đổi một đối tượng dạng mảng thành một mảng

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

4. 6 Sử dụng

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

93 thay vì trải rộng

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

91 để ánh xạ qua các lần lặp, vì nó tránh tạo mảng trung gian

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

4. 7. Sử dụng câu lệnh return trong gọi lại phương thức mảng. Có thể bỏ qua phần trả về nếu thân hàm bao gồm một câu lệnh trả về một biểu thức mà không có tác dụng phụ, sau 8. 2. dây dẫn.
```
const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9
```
97
```
const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9
```
9

4. 8 Sử dụng dấu ngắt dòng sau khi mở và trước khi đóng dấu ngoặc mảng nếu một mảng có nhiều dòng
```
// bad
var a = 1;
var b = 2;

// good
const a = 1;
const b = 2;
```
0

⬆quay lại đầu trang

hủy hoại

5. 1 Sử dụng phá hủy đối tượng khi truy cập và sử dụng nhiều thuộc tính của một đối tượng. dây dẫn.
```
const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9
```
98
Tại sao? . Việc lặp lại quyền truy cập đối tượng tạo ra nhiều mã lặp lại hơn, yêu cầu đọc nhiều hơn và tạo ra nhiều cơ hội mắc lỗi hơn. Phá hủy các đối tượng cũng cung cấp một trang định nghĩa duy nhất về cấu trúc đối tượng được sử dụng trong khối, thay vì yêu cầu đọc toàn bộ khối để xác định những gì được sử dụng.
```
// bad
var a = 1;
var b = 2;

// good
const a = 1;
const b = 2;
```
1

5. 2 Sử dụng phá hủy mảng. dây dẫn.

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

// bad
var a = 1;
var b = 2;

// good
const a = 1;
const b = 2;

5. 3 Sử dụng phá hủy đối tượng cho nhiều giá trị trả về, không phá hủy mảng
Tại sao?
```
// bad
var a = 1;
var b = 2;

// good
const a = 1;
const b = 2;
```
3

⬆quay lại đầu trang

Dây

6. 1 Sử dụng dấu nháy đơn

// bad
var a = 1;
var b = 2;

// good
const a = 1;
const b = 2;

00 cho chuỗi. dây dẫn.

// bad
var a = 1;
var b = 2;

// good
const a = 1;
const b = 2;

// bad
var a = 1;
var b = 2;

// good
const a = 1;
const b = 2;

6. 2 Các chuỗi khiến dòng vượt quá 100 ký tự không nên được viết trên nhiều dòng bằng cách nối chuỗi
Tại sao?
```
// bad
var a = 1;
var b = 2;

// good
const a = 1;
const b = 2;
```
5

6. 3 Khi xây dựng chuỗi theo chương trình, hãy sử dụng chuỗi mẫu thay vì nối. dây dẫn.

// bad
var a = 1;
var b = 2;

// good
const a = 1;
const b = 2;

// bad
var a = 1;
var b = 2;

// good
const a = 1;
const b = 2;

// bad
var a = 1;
var b = 2;

// good
const a = 1;
const b = 2;

6. 4 Không bao giờ sử dụng

// bad
var a = 1;
var b = 2;

// good
const a = 1;
const b = 2;

04 trên một chuỗi, nó mở ra quá nhiều lỗ hổng. dây dẫn.

// bad
var a = 1;
var b = 2;

// good
const a = 1;
const b = 2;

6. 5 Không thoát các ký tự trong chuỗi một cách không cần thiết. dây dẫn.

// bad
var a = 1;
var b = 2;

// good
const a = 1;
const b = 2;

// bad
var a = 1;
var b = 2;

// good
const a = 1;
const b = 2;

⬆quay lại đầu trang

Chức năng

7. 1 Sử dụng biểu thức hàm được đặt tên thay vì khai báo hàm. dây dẫn.
```
// bad
var a = 1;
var b = 2;

// good
const a = 1;
const b = 2;
```
07
Tại sao? . Điều này gây hại cho khả năng đọc và bảo trì. Nếu bạn thấy rằng định nghĩa của một hàm đủ lớn hoặc phức tạp đến mức cản trở việc hiểu phần còn lại của tệp, thì có lẽ đã đến lúc giải nén nó vào mô-đun của riêng nó. Đừng quên đặt tên rõ ràng cho biểu thức, bất kể tên đó có được suy ra từ biến chứa hay không (điều này thường xảy ra trong các trình duyệt hiện đại hoặc khi sử dụng các trình biên dịch như Babel). Điều này giúp loại bỏ bất kỳ giả định nào về ngăn xếp cuộc gọi của Lỗi. (Thảo luận)
```
// bad
var a = 1;
var b = 2;

// good
const a = 1;
const b = 2;
```
8

7. 2 Gói các biểu thức hàm được gọi ngay lập tức trong ngoặc đơn. dây dẫn.
```
// bad
var a = 1;
var b = 2;

// good
const a = 1;
const b = 2;
```
08
Tại sao? . Lưu ý rằng trong một thế giới có các mô-đun ở khắp mọi nơi, bạn hầu như không bao giờ cần IIFE
```
// bad
var a = 1;
var b = 2;

// good
const a = 1;
const b = 2;
```
9

7. 3 Không bao giờ khai báo một chức năng trong một khối không có chức năng (
```
// bad
var a = 1;
var b = 2;

// good
const a = 1;
const b = 2;
```
09,
```
// bad
var a = 1;
var b = 2;

// good
const a = 1;
const b = 2;
```
10, v.v.). Thay vào đó, hãy gán chức năng cho một biến. Các trình duyệt sẽ cho phép bạn làm điều đó, nhưng tất cả chúng đều diễn giải nó theo cách khác nhau, đó là tin xấu. dây dẫn.
```
// bad
var a = 1;
var b = 2;

// good
const a = 1;
const b = 2;
```
11

7. 4 Lưu ý. ECMA-262 định nghĩa một

// bad
var a = 1;
var b = 2;

// good
const a = 1;
const b = 2;

12 là một danh sách các câu lệnh. Một khai báo hàm không phải là một câu lệnh

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

7. 5 Không bao giờ đặt tên cho tham số

// bad
var a = 1;
var b = 2;

// good
const a = 1;
const b = 2;

13. Điều này sẽ được ưu tiên hơn đối tượng

// bad
var a = 1;
var b = 2;

// good
const a = 1;
const b = 2;

13 được cung cấp cho mọi phạm vi chức năng

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

7. 6 Không bao giờ sử dụng

// bad
var a = 1;
var b = 2;

// good
const a = 1;
const b = 2;

13, thay vào đó hãy chọn sử dụng cú pháp nghỉ ngơi

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

91. dây dẫn.

// bad
var a = 1;
var b = 2;

// good
const a = 1;
const b = 2;

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

7. 7 Sử dụng cú pháp tham số mặc định thay vì thay đổi đối số hàm

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

7. 8 Tránh tác dụng phụ với thông số mặc định

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

7. 9 Luôn đặt thông số mặc định cuối cùng. dây dẫn.

// bad
var a = 1;
var b = 2;

// good
const a = 1;
const b = 2;

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

7. 10 Không bao giờ sử dụng hàm tạo Hàm để tạo một hàm mới. dây dẫn.

// bad
var a = 1;
var b = 2;

// good
const a = 1;
const b = 2;

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

7. 11 Khoảng cách trong chữ ký hàm. dây dẫn.

// bad
var a = 1;
var b = 2;

// good
const a = 1;
const b = 2;

// bad
var a = 1;
var b = 2;

// good
const a = 1;
const b = 2;

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

7. 12 Không bao giờ thay đổi tham số. dây dẫn.

// bad
var a = 1;
var b = 2;

// good
const a = 1;
const b = 2;

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

7. 13 Không bao giờ chỉ định lại các thông số. dây dẫn.

// bad
var a = 1;
var b = 2;

// good
const a = 1;
const b = 2;

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

7. 14 Ưu tiên sử dụng cú pháp trải rộng

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

91 để gọi các hàm biến thiên. dây dẫn.

// bad
var a = 1;
var b = 2;

// good
const a = 1;
const b = 2;

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

7. 15 Các hàm có chữ ký nhiều dòng hoặc lời gọi phải được thụt lề giống như mọi danh sách nhiều dòng khác trong hướng dẫn này. với mỗi mục trên một dòng, với dấu phẩy ở cuối mục cuối cùng. dây dẫn.
```
// bad
var a = 1;
var b = 2;

// good
const a = 1;
const b = 2;
```
32
```
const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9
```
41

⬆quay lại đầu trang

Hàm mũi tên

8. 1 Khi bạn phải sử dụng một chức năng ẩn danh (như khi chuyển một lệnh gọi lại nội tuyến), hãy sử dụng ký hiệu chức năng mũi tên. dây dẫn.

// bad
var a = 1;
var b = 2;

// good
const a = 1;
const b = 2;

33,

// bad
var a = 1;
var b = 2;

// good
const a = 1;
const b = 2;

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

8. 2 Nếu thân hàm bao gồm một câu lệnh đơn lẻ trả về một biểu thức không có tác dụng phụ, hãy bỏ qua dấu ngoặc nhọn và sử dụng hàm trả về ngầm định. Nếu không, hãy giữ dấu ngoặc nhọn và sử dụng câu lệnh
```
// bad
var a = 1;
var b = 2;

// good
const a = 1;
const b = 2;
```
36. dây dẫn.
```
// bad
var a = 1;
var b = 2;

// good
const a = 1;
const b = 2;
```
37,
```
// bad
var a = 1;
var b = 2;

// good
const a = 1;
const b = 2;
```
38
Tại sao? . Nó đọc tốt khi nhiều chức năng được xâu chuỗi lại với nhau
```
const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9
```
43

8. 3 Trong trường hợp biểu thức kéo dài trên nhiều dòng, hãy đặt nó trong dấu ngoặc đơn để dễ đọc hơn
Tại sao?
```
const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9
```
44

8. 4 Luôn bao gồm các dấu ngoặc đơn xung quanh các đối số để rõ ràng và nhất quán. dây dẫn.

// bad
var a = 1;
var b = 2;

// good
const a = 1;
const b = 2;

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

8. 5 Tránh nhầm lẫn cú pháp hàm mũi tên (

// bad
var a = 1;
var b = 2;

// good
const a = 1;
const b = 2;

40) với các toán tử so sánh (

// bad
var a = 1;
var b = 2;

// good
const a = 1;
const b = 2;

41,

// bad
var a = 1;
var b = 2;

// good
const a = 1;
const b = 2;

42). dây dẫn.

// bad
var a = 1;
var b = 2;

// good
const a = 1;
const b = 2;

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

8. 6 Thực thi vị trí của các thân hàm mũi tên với trả về ngầm định. dây dẫn.

// bad
var a = 1;
var b = 2;

// good
const a = 1;
const b = 2;

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

⬆quay lại đầu trang

Lớp & Constructor

9. 1 Luôn sử dụng

// bad
var a = 1;
var b = 2;

// good
const a = 1;
const b = 2;

45. Tránh thao tác trực tiếp với

// bad
var a = 1;
var b = 2;

// good
const a = 1;
const b = 2;

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

9. 2 Sử dụng

// bad
var a = 1;
var b = 2;

// good
const a = 1;
const b = 2;

48 để thừa kế

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

9. 3 Phương thức có thể trả về

// bad
var a = 1;
var b = 2;

// good
const a = 1;
const b = 2;

35 để giúp xâu chuỗi phương thức

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

9. 4 Bạn có thể viết một phương thức

// bad
var a = 1;
var b = 2;

// good
const a = 1;
const b = 2;

51 tùy chỉnh, chỉ cần đảm bảo rằng nó hoạt động thành công và không gây tác dụng phụ

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

9. 5 Các lớp có hàm tạo mặc định nếu không được chỉ định. Hàm tạo trống hoặc hàm chỉ ủy quyền cho lớp cha là không cần thiết. dây dẫn.

// bad
var a = 1;
var b = 2;

// good
const a = 1;
const b = 2;

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

9. 6 Tránh các thành viên lớp trùng lặp. dây dẫn.

// bad
var a = 1;
var b = 2;

// good
const a = 1;
const b = 2;

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

9. 7 Các phương thức lớp nên sử dụng
```
// bad
var a = 1;
var b = 2;

// good
const a = 1;
const b = 2;
```
35 hoặc được tạo thành một phương thức tĩnh trừ khi thư viện hoặc khung bên ngoài yêu cầu sử dụng các phương thức không tĩnh cụ thể. Là một phương thức thể hiện nên chỉ ra rằng nó hoạt động khác nhau dựa trên các thuộc tính của người nhận. dây dẫn.
```
// bad
var a = 1;
var b = 2;

// good
const a = 1;
const b = 2;
```
55
```
const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9
```
24

⬆quay lại đầu trang

mô-đun

10. 1 Luôn sử dụng mô-đun (

// bad
var a = 1;
var b = 2;

// good
const a = 1;
const b = 2;

56/

// bad
var a = 1;
var b = 2;

// good
const a = 1;
const b = 2;

57) trên hệ thống mô-đun không chuẩn. Bạn luôn có thể dịch mã sang hệ thống mô-đun ưa thích của mình

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

10. 2 Không sử dụng nhập ký tự đại diện

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

10. 3 Và không xuất trực tiếp từ một lần nhập

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

10. 4 Chỉ nhập từ một đường dẫn ở một nơi. dây dẫn.

// bad
var a = 1;
var b = 2;

// good
const a = 1;
const b = 2;

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

10. 5 Không xuất các ràng buộc có thể thay đổi. dây dẫn.
```
// bad
var a = 1;
var b = 2;

// good
const a = 1;
const b = 2;
```
59
Tại sao? . Mặc dù kỹ thuật này có thể cần thiết cho một số trường hợp đặc biệt, nhưng nói chung, chỉ nên xuất các tham chiếu cố định
```
const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9
```
29

10. 6 Trong các mô-đun có một lần xuất, ưu tiên xuất mặc định hơn xuất có tên. dây dẫn.

// bad
var a = 1;
var b = 2;

// good
const a = 1;
const b = 2;

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

10. 7 Đặt tất cả các

// bad
var a = 1;
var b = 2;

// good
const a = 1;
const b = 2;

56 ở trên câu lệnh không nhập khẩu. dây dẫn.

// bad
var a = 1;
var b = 2;

// good
const a = 1;
const b = 2;

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

10. 8 Nhập nhiều dòng phải được thụt lề giống như mảng nhiều dòng và đối tượng bằng chữ. dây dẫn.

// bad
var a = 1;
var b = 2;

// good
const a = 1;
const b = 2;

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

10. 9 Không cho phép cú pháp trình tải Webpack trong câu lệnh nhập mô-đun. dây dẫn.

// bad
var a = 1;
var b = 2;

// good
const a = 1;
const b = 2;

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

10. 10 Không bao gồm phần mở rộng tên tệp JavaScript eslint.

// bad
var a = 1;
var b = 2;

// good
const a = 1;
const b = 2;

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

⬆quay lại đầu trang

Trình vòng lặp và Trình tạo

11. 1 Không sử dụng vòng lặp. Thích các hàm bậc cao hơn của JavaScript thay vì các vòng lặp như

// bad
var a = 1;
var b = 2;

// good
const a = 1;
const b = 2;

68 hoặc

// bad
var a = 1;
var b = 2;

// good
const a = 1;
const b = 2;

69. dây dẫn.

// bad
var a = 1;
var b = 2;

// good
const a = 1;
const b = 2;

// bad
var a = 1;
var b = 2;

// good
const a = 1;
const b = 2;

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

11. 2 Hiện tại không sử dụng máy phát điện
Tại sao?

11. 3 Nếu bạn phải sử dụng trình tạo hoặc nếu bạn bỏ qua lời khuyên của chúng tôi, hãy đảm bảo chữ ký chức năng của chúng được đặt đúng khoảng cách. dây dẫn.
```
// bad
var a = 1;
var b = 2;

// good
const a = 1;
const b = 2;
```
82
Tại sao?
```
const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9
```
36

⬆quay lại đầu trang

Đặc tính

12. 1 Sử dụng ký hiệu dấu chấm khi truy cập thuộc tính. dây dẫn.

// bad
var a = 1;
var b = 2;

// good
const a = 1;
const b = 2;

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

12. 2 Sử dụng ký hiệu ngoặc _______490 khi truy cập các thuộc tính có biến

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

12. 3 Sử dụng toán tử lũy thừa

// bad
var a = 1;
var b = 2;

// good
const a = 1;
const b = 2;

91 khi tính lũy thừa. dây dẫn.

// bad
var a = 1;
var b = 2;

// good
const a = 1;
const b = 2;

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

⬆quay lại đầu trang

Biến

13. 1 Luôn sử dụng

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

59 hoặc

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

63 để khai báo biến. Không làm như vậy sẽ dẫn đến các biến toàn cầu. Chúng tôi muốn tránh làm ô nhiễm không gian tên toàn cầu. Captain Planet đã cảnh báo chúng tôi về điều đó. dây dẫn.

// bad
var a = 1;
var b = 2;

// good
const a = 1;
const b = 2;

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

13. 2 Sử dụng một khai báo

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

59 hoặc

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

63 cho mỗi biến hoặc phép gán. dây dẫn.

// bad
var a = 1;
var b = 2;

// good
const a = 1;
const b = 2;

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

13. 3 Nhóm tất cả các

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

59 của bạn và sau đó nhóm tất cả các

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

63 của bạn

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

13. 4 Gán các biến ở nơi bạn cần, nhưng đặt chúng ở nơi hợp lý

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

13. 5. Không gán chuỗi biến. dây dẫn.

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

006

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

13. 6 Tránh sử dụng số tăng và giảm đơn vị (

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

007,

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

008). eslint

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

009

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

13. 7 Tránh ngắt dòng trước hoặc sau

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

013 trong bài tập. Nếu bài tập của bạn vi phạm

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

014, hãy bao quanh giá trị trong dấu ngoặc. eslint

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

015

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

13. 8 Không cho phép các biến không sử dụng. dây dẫn.

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

017

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

⬆quay lại đầu trang

cẩu

14. 1 khai báo

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

60 được nâng lên đầu phạm vi chức năng kèm theo gần nhất của chúng, nhiệm vụ của chúng không. Khai báo

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

59 và

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

63 được ban phước với một khái niệm mới gọi là Vùng chết tạm thời (TDZ). Điều quan trọng là phải biết tại sao typeof không còn an toàn

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

14. 2 Biểu thức hàm ẩn danh nâng tên biến của chúng, nhưng không gán chức năng

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

14. 3 Biểu thức hàm được đặt tên kéo theo tên biến, không phải tên hàm hoặc thân hàm
```
const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9
```
70

14. 4 Khai báo hàm nâng tên của chúng và thân hàm

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

Để biết thêm thông tin, hãy tham khảo JavaScript Scoping & Hoisting của Ben Cherry

⬆quay lại đầu trang

Toán tử so sánh & Bình đẳng

15. 1 Sử dụng

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

021 và

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

022 thay vì

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

023 và

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

024. dây dẫn.

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

025

15. 2 Các câu lệnh có điều kiện như câu lệnh
```
// bad
var a = 1;
var b = 2;

// good
const a = 1;
const b = 2;
```
09 đánh giá biểu thức của chúng bằng cách ép buộc với phương pháp trừu tượng
```
const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9
```
027 và luôn tuân theo các quy tắc đơn giản này
- Các đối tượng đánh giá là đúng
- Không xác định đánh giá sai
- Null đánh giá là sai
- Booleans đánh giá giá trị của boolean
- Các số đánh giá là sai nếu +0, -0 hoặc NaN, nếu không thì đúng
- Các chuỗi đánh giá là sai nếu một chuỗi rỗng
```
// bad
var a = 1;
var b = 2;

// good
const a = 1;
const b = 2;
```
  00, nếu không thì đúng
```
const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9
```
72

15. 3 Sử dụng phím tắt cho phép toán luận, nhưng so sánh rõ ràng cho chuỗi và số

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

15. 4 Để biết thêm thông tin, hãy xem Chân lý bình đẳng và JavaScript của Angus Croll

15. 5 Sử dụng dấu ngoặc nhọn để tạo các khối trong mệnh đề

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

029 và

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

030 có chứa khai báo từ vựng (e. g. ________ 063, ________ 059, ________ 058 và ________ 445). dây dẫn.

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

035

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

15. 6 Các bộ ba không được lồng vào nhau và thường là các biểu thức một dòng. dây dẫn.

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

039

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

15. 7 Tránh những câu nói ngắn gọn không cần thiết. dây dẫn.

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

040

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

15. 8 Khi trộn các toán tử, hãy đặt chúng trong ngoặc đơn. Ngoại lệ duy nhất là các toán tử số học tiêu chuẩn.

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

041,

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

042 và

// bad
var a = 1;
var b = 2;

// good
const a = 1;
const b = 2;

91 vì quyền ưu tiên của chúng được hiểu rộng rãi. Chúng tôi khuyên bạn nên đặt

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

044 và

// bad
var a = 1;
var b = 2;

// good
const a = 1;
const b = 2;

84 trong ngoặc đơn vì mức độ ưu tiên của chúng có thể không rõ ràng khi chúng được trộn lẫn. dây dẫn.

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

046

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

⬆quay lại đầu trang

khối

16. 1 Sử dụng dấu ngoặc nhọn với tất cả các khối nhiều dòng. dây dẫn.

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

047

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

16. 2 Nếu bạn đang sử dụng các khối nhiều dòng với

// bad
var a = 1;
var b = 2;

// good
const a = 1;
const b = 2;

09 và

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

049, hãy đặt

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

049 trên cùng một dòng với dấu ngoặc nhọn đóng của khối

// bad
var a = 1;
var b = 2;

// good
const a = 1;
const b = 2;

09 của bạn. dây dẫn.

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

052

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

16. 3 Nếu một khối

// bad
var a = 1;
var b = 2;

// good
const a = 1;
const b = 2;

09 luôn thực thi một câu lệnh

// bad
var a = 1;
var b = 2;

// good
const a = 1;
const b = 2;

36, thì khối

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

049 tiếp theo là không cần thiết. Một

// bad
var a = 1;
var b = 2;

// good
const a = 1;
const b = 2;

36 trong một khối

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

057 theo sau một khối

// bad
var a = 1;
var b = 2;

// good
const a = 1;
const b = 2;

09 có chứa một

// bad
var a = 1;
var b = 2;

// good
const a = 1;
const b = 2;

36 có thể được tách thành nhiều khối

// bad
var a = 1;
var b = 2;

// good
const a = 1;
const b = 2;

09. dây dẫn.

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

061

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

⬆quay lại đầu trang

Tuyên bố kiểm soát

17. 1 Trong trường hợp tuyên bố kiểm soát của bạn (
```
// bad
var a = 1;
var b = 2;

// good
const a = 1;
const b = 2;
```
09,
```
// bad
var a = 1;
var b = 2;

// good
const a = 1;
const b = 2;
```
10, v.v. ) quá dài hoặc vượt quá độ dài dòng tối đa, mỗi điều kiện (được nhóm) có thể được đưa vào một dòng mới. Toán tử logic nên bắt đầu dòng
Tại sao? . Điều này cũng cải thiện khả năng đọc bằng cách giúp dễ dàng theo dõi logic phức tạp một cách trực quan.
```
const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9
```
81

17. 2 Không sử dụng toán tử lựa chọn thay cho câu lệnh điều khiển

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

⬆quay lại đầu trang

Bình luận

18. 1 Sử dụng

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

064 cho nhận xét nhiều dòng

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

18. 2 Sử dụng
```
const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9
```
065 cho nhận xét một dòng. Đặt nhận xét một dòng trên một dòng mới phía trên chủ đề của nhận xét. Đặt một dòng trống trước nhận xét trừ khi nó nằm trên dòng đầu tiên của khối
```
const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9
```
84

18. 3 Bắt đầu tất cả các nhận xét bằng khoảng trắng để dễ đọc hơn. dây dẫn.

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

066

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

18. 4 Đặt trước nhận xét của bạn bằng
```
const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9
```
067 hoặc
```
const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9
```
068 giúp các nhà phát triển khác nhanh chóng hiểu được liệu bạn đang chỉ ra một vấn đề cần xem xét lại hay nếu bạn đang đề xuất một giải pháp cho vấn đề cần được triển khai. Những nhận xét này khác với các nhận xét thông thường vì chúng có thể thực hiện được. Các hành động là
```
const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9
```
069 hoặc
```
const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9
```
070

18. 5 Sử dụng

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

071 để chú thích các vấn đề

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

18. 6 Sử dụng

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

072 để chú thích các giải pháp cho vấn đề

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

⬆quay lại đầu trang

Khoảng trắng

19. 1 Sử dụng tab mềm (ký tự dấu cách) được đặt thành 2 dấu cách. dây dẫn.

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

073

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

19. 2 Đặt 1 dấu cách trước dấu ngoặc nhọn. dây dẫn.

// bad
var a = 1;
var b = 2;

// good
const a = 1;
const b = 2;

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

19. 3 Đặt 1 dấu cách trước dấu ngoặc đơn mở trong câu lệnh kiểm soát (

// bad
var a = 1;
var b = 2;

// good
const a = 1;
const b = 2;

09,

// bad
var a = 1;
var b = 2;

// good
const a = 1;
const b = 2;

10, v.v. ). Không đặt khoảng trắng giữa danh sách đối số và tên hàm trong lời gọi hàm và khai báo. dây dẫn.

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

077

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

19. 4 Tắt các toán tử có dấu cách. dây dẫn.

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

078

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

19. 5 Kết thúc tệp bằng một ký tự dòng mới. dây dẫn.

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

079

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

19. 6 Sử dụng thụt đầu dòng khi tạo chuỗi phương thức dài (hơn 2 chuỗi phương thức). Sử dụng dấu chấm ở đầu, nhấn mạnh rằng dòng này là lời gọi phương thức, không phải câu lệnh mới. dây dẫn.

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

080

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

081

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

19. 7 Để trống một dòng sau các khối và trước câu lệnh tiếp theo

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

19. 8 Đừng đệm các khối của bạn bằng các dòng trống. dây dẫn.

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

082

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

19. 9 Không sử dụng nhiều dòng trống để đệm mã của bạn. dây dẫn.

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

083

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

19. 10 Không thêm khoảng trắng bên trong dấu ngoặc đơn. dây dẫn.

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

084

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

19. 11 Không thêm dấu cách trong ngoặc. dây dẫn.

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

085

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

19. 12 Thêm khoảng trắng bên trong dấu ngoặc nhọn. dây dẫn.

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

086

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

19. 13 Tránh các dòng mã dài hơn 100 ký tự (bao gồm cả khoảng trắng). Ghi chú. như trên, các chuỗi dài được miễn quy tắc này và không được chia nhỏ. dây dẫn.
```
const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9
```
014
Tại sao?
```
const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9
```
12

19. 14 Yêu cầu khoảng cách nhất quán bên trong mã thông báo khối mở và mã thông báo tiếp theo trên cùng một dòng. Quy tắc này cũng thực thi khoảng cách nhất quán bên trong mã thông báo khối gần và mã thông báo trước đó trên cùng một dòng. dây dẫn.
```
const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9
```
088
```
const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9
```
13

19. 15 Tránh dấu cách trước dấu phẩy và yêu cầu khoảng trắng sau dấu phẩy. dây dẫn.

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

089

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

19. 16 Thực thi khoảng cách bên trong dấu ngoặc thuộc tính được tính. dây dẫn.

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

090

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

19. 17 Tránh khoảng trắng giữa các hàm và lời gọi của chúng. dây dẫn.

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

091

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

19. 18 Thực thi khoảng cách giữa các khóa và giá trị trong các thuộc tính chữ của đối tượng. dây dẫn.

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

092

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

19. 19 Tránh dấu cách ở cuối dòng. dây dẫn.

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

093

19. 20 Tránh nhiều dòng trống, chỉ cho phép một dòng mới ở cuối tệp và tránh một dòng mới ở đầu tệp. dây dẫn.

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

083

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

⬆quay lại đầu trang

dấu phẩy

20. 1 Dấu phẩy đứng đầu. Không. dây dẫn.

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

095

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

20. 2 Dấu phẩy bổ sung. Chuẩn rồi. dây dẫn.
```
const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9
```
096
Tại sao? . Ngoài ra, các trình chuyển mã như Babel sẽ loại bỏ dấu phẩy ở cuối bổ sung trong mã được chuyển mã, điều đó có nghĩa là bạn không phải lo lắng về vấn đề dấu phẩy ở cuối trong các trình duyệt cũ
```
const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9
```
20
```
const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9
```
21

⬆quay lại đầu trang

dấu chấm phẩy

21. 1 vâng. dây dẫn.
```
const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9
```
097
Tại sao? . Tuy nhiên, ASI chứa một vài hành vi lập dị và mã của bạn sẽ bị hỏng nếu JavaScript hiểu sai ngắt dòng của bạn. Các quy tắc này sẽ trở nên phức tạp hơn khi các tính năng mới trở thành một phần của JavaScript. Việc chấm dứt rõ ràng các câu lệnh của bạn và định cấu hình trình nói dối của bạn để bắt các dấu chấm phẩy bị thiếu sẽ giúp bạn không gặp phải sự cố
```
const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9
```
22
Đọc thêm

⬆quay lại đầu trang

Loại đúc và ép buộc

22. 1 Thực hiện ép kiểu ở đầu câu lệnh

22. 2 dây. dây dẫn.

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

098

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

22. 3 số. Sử dụng

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

099 để truyền kiểu và

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

400 luôn có cơ số để phân tích chuỗi. dây dẫn.

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

401

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

098

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

22. 4 Nếu vì bất kỳ lý do gì mà bạn đang làm điều gì đó hoang dã và
```
const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9
```
400 là nút cổ chai của bạn và cần sử dụng Bitshift vì lý do hiệu suất, hãy để lại nhận xét giải thích lý do và việc bạn đang làm
```
const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9
```
25

22. 5 lưu ý. Hãy cẩn thận khi sử dụng các hoạt động bitshift. Các số được biểu diễn dưới dạng giá trị 64 bit, nhưng các thao tác dịch chuyển bit luôn trả về số nguyên 32 bit (nguồn). Bitshift có thể dẫn đến hành vi không mong muốn đối với các giá trị số nguyên lớn hơn 32 bit. Thảo luận. Int 32 bit có chữ ký lớn nhất là 2.147.483.647
```
const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9
```
26

22. 6 Boolean. dây dẫn.

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

098

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

⬆quay lại đầu trang

quy ước đặt tên

23. 1 Tránh tên có một chữ cái. Hãy mô tả với tên của bạn. dây dẫn.

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

411

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

23. 2 Sử dụng camelCase khi đặt tên đối tượng, chức năng và phiên bản. dây dẫn.

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

412

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

23. 3 Chỉ sử dụng PascalCase khi đặt tên cho hàm tạo hoặc lớp. dây dẫn.

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

413

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

23. 4 Không sử dụng dấu gạch dưới ở cuối hoặc ở đầu. dây dẫn.
```
const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9
```
414
Tại sao? . Mặc dù dấu gạch dưới ở đầu là một quy ước phổ biến có nghĩa là “riêng tư”, trên thực tế, các thuộc tính này hoàn toàn công khai và do đó, là một phần trong hợp đồng API công khai của bạn. Quy ước này có thể khiến các nhà phát triển nghĩ sai rằng một thay đổi sẽ không được tính là vi phạm hoặc không cần kiểm tra. tl;dr. nếu bạn muốn một cái gì đó là "riêng tư", nó không được hiện diện rõ ràng
```
const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9
```
31

23. 5 Không lưu tham chiếu đến

// bad
var a = 1;
var b = 2;

// good
const a = 1;
const b = 2;

35. Sử dụng các chức năng mũi tên hoặc Hàm # liên kết

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

23. 6 Tên tệp cơ sở phải khớp chính xác với tên xuất mặc định của nó

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

23. 7 Sử dụng camelCase khi bạn xuất hàm mặc định. Tên tệp của bạn phải giống với tên hàm của bạn
```
const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9
```
34

23. 8 Sử dụng PascalCase khi bạn xuất hàm tạo/lớp/đơn/thư viện hàm/đối tượng trần
```
const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9
```
35

23. 9 Các từ viết tắt và viết tắt phải luôn luôn là chữ hoa hoặc chữ thường
Tại sao?
```
const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9
```
36

23. 10 Bạn chỉ có thể tùy ý viết hoa một hằng số nếu nó (1) được xuất, (2) là
```
const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9
```
59 (không thể gán lại nó) và (3) lập trình viên có thể tin tưởng nó (và các thuộc tính lồng nhau của nó) sẽ không bao giờ thay đổi
Tại sao? . UPPERCASE_VARIABLES đang cho lập trình viên biết rằng họ có thể tin tưởng biến (và các thuộc tính của nó) sẽ không thay đổi
- Còn tất cả các biến
```
const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9
```
  59 thì sao? . Tuy nhiên, nó nên được sử dụng cho các hằng số đã xuất
- Đối với các đối tượng đã xuất thì sao? . g.
```
const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9
```
  418) và duy trì rằng tất cả các thuộc tính lồng nhau không thay đổi
```
const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9
```
37

⬆quay lại đầu trang

phụ kiện

24. 1 Chức năng truy cập cho các thuộc tính không bắt buộc

24. 2 Không sử dụng trình getters/setters JavaScript vì chúng gây ra tác dụng phụ không mong muốn và khó kiểm tra, bảo trì và lý do hơn. Thay vào đó, nếu bạn tạo các hàm truy cập, hãy sử dụng

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

419 và

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

420

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

24. 3 Nếu thuộc tính/phương pháp là một

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

51, hãy sử dụng

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

422 hoặc

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

423

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

24. 4 Bạn có thể tạo các hàm

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

424 và

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

425, nhưng phải nhất quán

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

⬆quay lại đầu trang

Sự kiện

25. 1 Khi đính kèm tải trọng dữ liệu vào sự kiện (dù là sự kiện DOM hay thứ gì đó độc quyền hơn như sự kiện Xương sống), hãy chuyển một đối tượng theo nghĩa đen (còn được gọi là "hàm băm") thay vì giá trị thô. Điều này cho phép người đóng góp tiếp theo thêm nhiều dữ liệu hơn vào tải trọng sự kiện mà không cần tìm và cập nhật mọi trình xử lý cho sự kiện. Ví dụ, thay vì
```
const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9
```
41
thích hơn
```
const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9
```
42

⬆quay lại đầu trang

jQuery

26. 1 Biến đối tượng jQuery có tiền tố với một

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

426

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

26. 2 Tra cứu bộ đệm jQuery

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

26. 3 Đối với các truy vấn DOM, hãy sử dụng Cascading

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

427 hoặc parent > child

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

428. jsPerf

26. 4 Sử dụng

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

429 với các truy vấn đối tượng jQuery có phạm vi

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

⬆quay lại đầu trang

Khả năng tương thích ECMAScript 5

27. 1 Tham khảo bảng tương thích ES5 của Kangax

⬆quay lại đầu trang

Kiểu ECMAScript 6+ (ES 2015+)

28. 1 Đây là tập hợp các liên kết đến các tính năng khác nhau của ES6+

Hàm mũi tên
Các lớp học
đối tượng tốc ký
đối tượng ngắn gọn
Thuộc tính tính toán đối tượng
Chuỗi mẫu
hủy hoại
Thông số mặc định
Lên đỉnh
Trải rộng mảng
Hãy để và Const
Toán tử lũy thừa
Trình vòng lặp và Trình tạo
mô-đun

28. 2 Không sử dụng các đề xuất TC39 chưa đạt đến giai đoạn 3
Tại sao? . Chúng tôi muốn sử dụng JavaScript và các đề xuất chưa phải là JavaScript

⬆quay lại đầu trang

Thư viện tiêu chuẩn

Thư viện tiêu chuẩn chứa các tiện ích bị hỏng chức năng nhưng vẫn tồn tại vì lý do cũ

29. 1 Sử dụng

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

430 thay vì toàn cầu

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

431. dây dẫn.

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

432

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

29. 2 Sử dụng

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

434 thay vì toàn cầu

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

435. dây dẫn.

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

432

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

⬆quay lại đầu trang

thử nghiệm

30. 1 vâng

const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

30. 2 Không, nhưng nghiêm túc
- Cho dù bạn sử dụng khung kiểm tra nào, bạn nên viết bài kiểm tra
- Cố gắng viết nhiều hàm thuần túy nhỏ và giảm thiểu nơi xảy ra đột biến
- Hãy thận trọng với sơ khai và giả - chúng có thể làm cho bài kiểm tra của bạn trở nên dễ vỡ hơn
- Chúng tôi chủ yếu sử dụng
```
const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9
```
  438 và
```
const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9
```
  439 tại Airbnb.
```
const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9
```
  440 đôi khi cũng được sử dụng cho các mô-đun nhỏ, riêng biệt
- Phạm vi kiểm tra 100% là một mục tiêu tốt để phấn đấu, ngay cả khi không phải lúc nào cũng thực tế để đạt được nó
- Bất cứ khi nào bạn sửa lỗi, hãy viết bài kiểm tra hồi quy. Một lỗi được sửa mà không kiểm tra hồi quy gần như chắc chắn sẽ lại bị hỏng trong tương lai

⬆quay lại đầu trang

Màn biểu diễn

Về Bố cục và Hiệu suất Web
Chuỗi so với mảng Concat
Thử/Nắm bắt chi phí trong một vòng lặp
chức năng bang
jQuery Tìm so với Ngữ cảnh, Bộ chọn
InternalHTML so với textContent cho văn bản tập lệnh
Nối chuỗi dài

Các hàm JavaScript như

// bad
var a = 1;
var b = 2;

// good
const a = 1;
const b = 2;

72,

// bad
var a = 1;
var b = 2;

// good
const a = 1;
const b = 2;

77 và

// bad
var a = 1;
var b = 2;

// good
const a = 1;
const b = 2;

74 có được tối ưu hóa để duyệt qua các mảng không?

Đang tải

⬆quay lại đầu trang

Tài nguyên

Học ES6+

Thông số kỹ thuật ECMA mới nhất
Khám pháJS
Bảng tương thích ES6
Tổng quan toàn diện về các tính năng của ES6

Đọc này

Tiêu chuẩn ECMA-262

Công cụ

Mã phong cách Linters
- ESlint - Phong cách Airbnb. eslintrc
- JSHint - Phong cách Airbnb. jshintrc
Đặt trước Neutrino - @neutrinojs/airbnb

Hướng dẫn phong cách khác

Hướng dẫn kiểu Google JavaScript
Hướng dẫn kiểu Google JavaScript (Cũ)
Nguyên tắc phong cách cốt lõi của jQuery
Nguyên tắc viết JavaScript nhất quán, thành ngữ
tiêu chuẩnJS

phong cách khác

Đặt tên này trong các hàm lồng nhau - Christian Johansen
Gọi lại có điều kiện - Ross Allen
Quy ước mã hóa JavaScript phổ biến trên GitHub - JeongHoon Byun
Nhiều câu lệnh var trong JavaScript, không thừa - Ben Alman

Đọc thêm

Hiểu về JavaScript Closures - Angus Croll
JavaScript cơ bản cho lập trình viên thiếu kiên nhẫn - Dr. Axel Rauschmayer
Bạn có thể không cần jQuery - Zack Bloom & Adam Schwartz
Tính năng ES6 - Luke Hoban
Nguyên tắc giao diện người dùng - Benjamin De Cock

Sách

JavaScript. Những Phần Tốt - Douglas Crockford
Mẫu JavaScript - Stoyan Stefanov
Mẫu thiết kế JavaScript chuyên nghiệp - Ross Harmes và Dustin Diaz
Trang web hiệu suất cao. Kiến Thức Cần Thiết Cho Kỹ Sư Front-End - Steve Souders
JavaScript có thể duy trì - Nicholas C. Zakas
Ứng dụng web JavaScript - Alex MacCaw
Kỹ thuật JavaScript chuyên nghiệp - John Resig
đập vỡ nút. js. JavaScript ở mọi nơi - Guillermo Rauch
Bí mật của Ninja JavaScript - John Resig và Bear Bibeault
JavaScript của con người - Henrik Joreteg
Siêu anh hùng. js - Kim Joar Bekkelund, Mads Mobæk, & Olav Bjorkoy
JSBooks - Julien Bouquillon
JavaScript của bên thứ ba - Ben Vinegar và Anton Kovalyov
JavaScript hiệu quả. 68 cách cụ thể để khai thác sức mạnh của JavaScript - David Herman
JavaScript hùng hồn - Marijn Haverbeke
Bạn không biết JS. ES6 & Hơn thế nữa - Kyle Simpson

Blog

JavaScript hàng tuần
JavaScript, JavaScript
Blog Bocoup
Đủ tốt
NCZTrực tuyến
Sự hoàn hảo giết chết
Ben Alman
Dmitry Baranovsky
quả óc chó

Podcast

Không khí JavaScript
Jabber JavaScript

⬆quay lại đầu trang

Trong thế giới hoang dã

Đây là danh sách các tổ chức đang sử dụng hướng dẫn phong cách này. Gửi cho chúng tôi yêu cầu kéo và chúng tôi sẽ thêm bạn vào danh sách

123erfast. 123erfasst/javascript
4bộ xúc tác. 4Catalyzer/javascript
Aan Zee. AanZee/javascript
Airbnb. airbnb/javascript
AloPeyk. AloPeyk
trường thay thế. AltSchool/javascript
căn hộ. căn hộ/javascript
Thường gán. gán/javascript
tiên phong. tín dụng tiên phong/javascript
axept. axept/javascript
Billabong. hóa đơn/javascript
Canh tôm cua. canh tôm cua
Bonhomme. bonhommeparis/javascript
cá mập. brainshark/javascript
CaseNine. CaseNine/javascript
Cerner. Cerner
tăng biểu đồ. ChartBoost/javascript-style-guide
Bộ tộc Coeur d'Alene. www. cdatribe-nsn. chính phủ
So sánh trực tuyến. so sánh trực tuyến/javascript
học la bàn. hướng dẫn sử dụng la bàn/javascript-style-guide
chuyển động hàng ngày. dailymotion/javascript
Làm việc gì đó. DoS Something/eslint-config
Digitpaint Digitpaint/javascript
drupal. www. drupal. tổ chức
hệ sinh thái. sinh thái/javascript
Evernote. evernote/javascript-style-guide
Trò chơi tiến hóa. tiến hóa-chơi game/javascript
EvozonJs. evozonjs/javascript
Mục tiêu chính xác. Mục tiêu chính xác/javascript
dâu dẻo. Flexberry/javascript-style-guide
truyền thông gawker. gawkermedia
điện tổng hợp. Điện tổng hợp/javascript
Tux thế hệ. Thế hệTux/javascript
dữ liệu tốt. gooddata/gdc-js-style
đầu bếp xanh. đầu bếp xanh/javascript
rãnh. rãnh/javascript
Grupo-Abraxas. Grupo-Abraxas/javascript
Happeo. happeo/javascript
Mật ong. khoa học mật ong/javascript
Chúng tôi thì sao. howaboutwe/javascript
HubSpot. HubSpot/javascript
siêu. hyperoslo/javascript-playbook
Nhóm liên thành phố. intercitygroup/javascript-style-guide
mứt3. Jam3/Javascript-Code-Conventions
JSSolutions. JSSolutions/javascript
Máy tính Kaplan. kaplankomputing/javascript
KickorStick. gậy đánh bóng
giải pháp động học. động học/javascript
LEINWAND. LEINWAND/javascript
Hành tinh cô đơn. hành tinh cô đơn/javascript
M2GEN. M2GEN/javascript
Mùa xuân hùng vĩ. hùng mạnh/javascript
TrinPost. TrinPost/javascript
MitocNhóm. Nhóm Mitoc/javascript
Muber. người chăn bò
Hội Địa lý Quốc gia. xã hội tự nhiên
NullDev. NullDevCo/JavaScript-Styleguide
Nuology. nulogy/javascript
Phát triển Đồi Cam. màu cam/javascript
Sức khỏe Orion. orionhealth/javascript
ngang hàng. Ngang hàng/javascript
Cầu tàu 1. Cầu tàu1/javascript
Qotto. Qotto/javascript-style-guide
Phản ứng. phản ứng. org/docs/cách đóng góp. html#style-guide
REI. reidev/js-style-hướng dẫn
Gợn sóng. hướng dẫn kiểu gợn sóng/javascript
Siêu thị của Sainsbury. jsainsburyplc
con chuồn chuồn. màn trập/javascript
nguồn. mã nguồn/javascript
Mức tải trọng. mức tải trọng
StratoDem Analytics. tầng lớp/javascript
ThépPhát triểnKiwi. thépkiwi/javascript
Sinh viênSphere. sinh viên/javascript
SwoopApp. swoopapp/javascript
SysGarage. sysgarage/javascript-style-guide
Syzygy Warszawa. syzygypl/javascript
Mục tiêu. mục tiêu/javascript
thổ địa. địa ngục
những cái thang. TheLadder/javascript
Mọt sách. thenerdery/javascript-tiêu chuẩn
Tomify. tomprats
traiti. traitify/eslint-config-traitify
Công nghệ T4R. Công nghệ T4R/javascript
đô thịSim. thành thị
VoxFeed. VoxFeed/javascript-style-guide
Phòng thu WeBox. weboxstudio/javascript
Weggo. Weggo/javascript
zillow. zillow/javascript
ZocDoc. ZocDoc/javascript

⬆quay lại đầu trang

Dịch

Hướng dẫn phong cách này cũng có sẵn bằng các ngôn ngữ khác

tiếng Bồ Đào Nha của người brazi. armoucar/javascript-style-guide
tiếng Bungari. borislavvv/javascript
tiếng Catalunya. fpmweb/javascript-style-guide
Tiếng Trung (Giản thể). lin-123/javascript
Truyền thống Trung Hoa). ghép hình/javascript
người Pháp. nmussy/javascript-style-guide
tiếng Đức. timofurrer/javascript-style-guide
người Ý. sinkswim/javascript-style-guide
tiếng Nhật. mitsuruog/javascript-style-guide
Hàn Quốc. ParkSB/javascript-style-guide
tiếng Nga. leonid lebedev/javascript-airbnb
người Tây Ban Nha. paolocarrasco/javascript-style-guide
tiếng Thái. lvarayut/javascript-style-guide
Thổ Nhĩ Kỳ. eraycetinay/javascript
tiếng Ukraina. Ivanzusko/javascript
Việt Nam. dangkyokhoang/javascript-style-guide

Hướng dẫn Hướng dẫn Phong cách JavaScript

Tài liệu tham khảo

Trò chuyện với chúng tôi về JavaScript

Tìm chúng tôi trên gitter

người đóng góp

Xem cộng tác viên

Giấy phép

(Giấy phép MIT)

Theo đây, quyền được cấp miễn phí cho bất kỳ người nào có được bản sao của phần mềm này và các tệp tài liệu liên quan ('Phần mềm'), để xử lý Phần mềm mà không bị hạn chế, bao gồm nhưng không giới hạn các quyền sử dụng, sao chép, sửa đổi, hợp nhất

Thông báo bản quyền ở trên và thông báo cấp phép này sẽ được bao gồm trong tất cả các bản sao hoặc phần quan trọng của Phần mềm

PHẦN MỀM ĐƯỢC CUNG CẤP 'NGUYÊN TRẠNG', KHÔNG CÓ BẢO ĐẢM DƯỚI BẤT KỲ HÌNH THỨC NÀO, RÕ RÀNG HAY NGỤ Ý, BAO GỒM NHƯNG KHÔNG GIỚI HẠN CÁC BẢO ĐẢM VỀ KHẢ NĂNG BÁN ĐƯỢC, SỰ PHÙ HỢP CHO MỘT MỤC ĐÍCH CỤ THỂ VÀ KHÔNG VI PHẠM. TRONG BẤT KỲ TRƯỜNG HỢP NÀO TÁC GIẢ HOẶC NGƯỜI GIỮ BẢN QUYỀN SẼ KHÔNG CHỊU TRÁCH NHIỆM PHÁP LÝ VỀ BẤT KỲ KHIẾU NẠI, THIỆT HẠI HOẶC TRÁCH NHIỆM PHÁP LÝ KHÁC NÀO, DÙ TRONG MỘT HÀNH ĐỘNG HỢP ĐỒNG, NGOẠI TỆ HOẶC CÁCH NÀO KHÁC, PHÁT SINH TỪ, NGOÀI HOẶC LIÊN QUAN ĐẾN PHẦN MỀM HOẶC VIỆC SỬ DỤNG HOẶC CÁC GIAO DỊCH KHÁC TRONG

⬆quay lại đầu trang

sửa đổi

Chúng tôi khuyến khích bạn rẽ nhánh hướng dẫn này và thay đổi các quy tắc để phù hợp với hướng dẫn phong cách của nhóm bạn. Dưới đây, bạn có thể liệt kê một số sửa đổi đối với hướng dẫn phong cách. Điều này cho phép bạn cập nhật định kỳ hướng dẫn phong cách của mình mà không phải xử lý xung đột hợp nhất

programming javascript

C sang javascript

Các đối tượng

Mảng

hủy hoại

Dây

Chức năng

Hàm mũi tên

Lớp & Constructor

mô-đun

Trình vòng lặp và Trình tạo

Đặc tính

Biến

cẩu

Toán tử so sánh & Bình đẳng

khối

Tuyên bố kiểm soát

Bình luận

Khoảng trắng

dấu phẩy

dấu chấm phẩy

Loại đúc và ép buộc

quy ước đặt tên

phụ kiện

Sự kiện

jQuery

Khả năng tương thích ECMAScript 5

Kiểu ECMAScript 6+ (ES 2015+)

Thư viện tiêu chuẩn

thử nghiệm

Màn biểu diễn

Tài nguyên

Trong thế giới hoang dã

Dịch

Hướng dẫn Hướng dẫn Phong cách JavaScript

Trò chuyện với chúng tôi về JavaScript

người đóng góp

Giấy phép

sửa đổi

Bài Viết Liên Quan

Quảng Cáo

Có thể bạn quan tâm

Toplist được quan tâm

Quảng cáo

Xem Nhiều

Quảng cáo

Chúng tôi

Điều khoản

Trợ giúp

Mạng xã hội