2. 1 Use
const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 959 for all of your references; avoid using
const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 960. eslint.
const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 961,
const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 962
Why? This ensures that you can’t reassign your references, which can lead to bugs and difficult to comprehend code
// bad var a = 1; var b = 2; // good const a = 1; const b = 2;
2. 2 If you must reassign references, use
const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
63 instead ofconst foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
60. eslint.const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
65Why?
const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
63 is block-scoped rather than function-scoped likeconst foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
60const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
0
2. 3 Note that both
const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
63 andconst foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
59 are block-scoped, whereasconst foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
60 is function-scopedconst foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
4In the above code, you can see that referencing
const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
71 andconst foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
72 will produce a ReferenceError, whileconst foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
73 contains the number. This is becauseconst foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
71 andconst foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
72 are block scoped, whileconst foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
73 is scoped to the containing function
⬆back to top
Objects
3. 1 Use the literal syntax for object creation. eslint.
const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
77const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
2
3. 2 Use computed property names when creating objects with dynamic property names
Why? They allow you to define all the properties of an object in one place
const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
3
3. 3 Use object method shorthand. eslint.
const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
78const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
5
3. 4 Use property value shorthand. eslint.
const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
78Why? It is shorter and descriptive
const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
7
3. 5 Group your shorthand properties at the beginning of your object declaration
Why? It’s easier to tell which properties are using the shorthand
const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
8
3. 6 Only quote properties that are invalid identifiers. eslint.
const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
80Why? In general we consider it subjectively easier to read. It improves syntax highlighting, and is also more easily optimized by many JS engines
const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
0
3. 7 Do not call
const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
81 methods directly, such asconst 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, andconst foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
84. eslint.const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
85Why? These methods may be shadowed by properties on the object in question - consider
const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
86 - or, the object may be a null object [const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
87]const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
1
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. Use the object rest parameter syntax to get a new object with certain properties omitted. eslint.const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
89const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
2
⬆back to top
Arrays
4. 1 Use the literal syntax for array creation. eslint.
const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
90const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
3
4. 2 Use Array#push instead of direct assignment to add items to an array
const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
4
4. 3 Use array spreads
const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
91 to copy arraysconst foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
5
4. 4 To convert an iterable object to an array, use spreads
const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
91 instead ofconst foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
93const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
6
4. 5 Use
const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
93 for converting an array-like object to an arrayconst foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
7
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ộngconst 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 gianconst foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
8
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
97const 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 dấu ngoặc mảng mở và trước khi đóng nếu mảng có nhiều dòng
// bad var a = 1; var b = 2; // good const a = 1; const b = 2;
0
⬆back to top
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
98Tại sao? . Repeating object access creates more repetitive code, requires more reading, and creates more opportunities for mistakes. Destructuring objects also provides a single site of definition of the object structure that is used in the block, rather than requiring reading the entire block to determine what is used
// bad var a = 1; var b = 2; // good const a = 1; const b = 2;
1
5. 2 Use array destructuring. eslint.
const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
98// bad var a = 1; var b = 2; // good const a = 1; const b = 2;
2
5. 3 Use object destructuring for multiple return values, not array destructuring
Why? You can add new properties over time or change the order of things without breaking call sites
// bad var a = 1; var b = 2; // good const a = 1; const b = 2;
3
⬆back to top
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;
01// bad var a = 1; var b = 2; // good const a = 1; const b = 2;
4
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;
02// bad var a = 1; var b = 2; // good const a = 1; const b = 2;
03Tại sao?
// bad var a = 1; var b = 2; // good const a = 1; const b = 2;
6
- 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;
05
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;
06Tại sao?
// bad var a = 1; var b = 2; // good const a = 1; const b = 2;
7
⬆back to top
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;
07Tạ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 quá 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 chính 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;
08Tạ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ệnhconst foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
00
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ăngconst foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
01
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ơiconst 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;
17Tại sao? . Ngoài ra, các đối số còn lại là một Mảng thực và không chỉ giống Mảng như
// bad var a = 1; var b = 2; // good const a = 1; const b = 2;
13const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
02
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
03
7. 8 Tránh tác dụng phụ với thông số mặc định
Tại sao?
const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
04
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;
20const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
05
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;
21Tại sao?
const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
06
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;
23// bad var a = 1; var b = 2; // good const a = 1; const b = 2;
24Tại sao?
const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
07
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;
25Tại sao?
const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
08
7. 13 Never reassign parameters. dây dẫn.
// bad var a = 1; var b = 2; // good const a = 1; const b = 2;
25Tại sao? . Nó cũng có thể gây ra các vấn đề tối ưu hóa, đặc biệt là trong V8
const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
09
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 đổi. dây dẫn.// bad var a = 1; var b = 2; // good const a = 1; const b = 2;
29Tại sao?
const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
40
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;
32const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
41
⬆back to top
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;
34Tại sao?
Tại sao không?
const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
42
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;
38Tạ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;
37Tại sao?
const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
45
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;
43const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
46
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;
44const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
47
⬆back to top
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;
46Tại sao?
const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
48
9. 2 Sử dụng
// bad var a = 1; var b = 2; // good const a = 1; const b = 2;
48 để thừa kếTại sao?
const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
49
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ứcconst foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
20
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
21
9. 5 Classes have a default constructor if one is not specified. 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;
52const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
22
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;
53Tại sao?
const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
23
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;
55const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
24
⬆back to top
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ìnhTại sao?
const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
25
10. 2 Không sử dụng nhập ký tự đại diện
Tại sao?
const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
26
10. 3 Và không xuất trực tiếp từ một lần nhập
Tại sao?
const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
27
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;
58Tại sao?
const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
28
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;
59Tạ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;
60Tại sao?
const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
30
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;
62Tại sao?
const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
31
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ữ. eslint.
// bad var a = 1; var b = 2; // good const a = 1; const b = 2;
64Tại sao?
const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
32
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;
65Tại sao? . Thích sử dụng cú pháp trình tải trong
// bad var a = 1; var b = 2; // good const a = 1; const b = 2;
66const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
33
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;
67Tại sao?
const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
34
⬆back to top
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;
70// bad var a = 1; var b = 2; // good const a = 1; const b = 2;
71Tại sao? . Xử lý các hàm thuần túy trả về giá trị dễ lý luận hơn các tác dụng phụ
Sử dụng
// 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;
73 /// bad var a = 1; var b = 2; // good const a = 1; const b = 2;
74 /// bad var a = 1; var b = 2; // good const a = 1; const b = 2;
75 /// bad var a = 1; var b = 2; // good const a = 1; const b = 2;
76 /// bad var a = 1; var b = 2; // good const a = 1; const b = 2;
77 /// bad var a = 1; var b = 2; // good const a = 1; const b = 2;
78 /. để lặp lại các mảng và// bad var a = 1; var b = 2; // good const a = 1; const b = 2;
79 /// bad var a = 1; var b = 2; // good const a = 1; const b = 2;
80 /// bad var a = 1; var b = 2; // good const a = 1; const b = 2;
81 để tạo các mảng để bạn có thể lặp lại các đối tượngconst foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
35
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;
82Tại sao?
const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
36
⬆back to top
Đặ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;
89const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
37
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
38
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;
92const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
39
⬆back to top
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ặcconst 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 đó. eslint.// bad var a = 1; var b = 2; // good const a = 1; const b = 2;
95const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
61const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
50
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ặcconst 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;
99Tại sao? . Bạn cũng có thể duyệt qua từng khai báo bằng trình gỡ lỗi, thay vì xem qua tất cả chúng cùng một lúc
const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
51
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ácconst foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
63 của bạnTại sao?
const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
52
13. 4 Gán các biến ở nơi bạn cần, nhưng đặt chúng ở nơi hợp lý
Tại sao?
const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
53
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
006Tại sao?
const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
54
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]. eslintconst foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
009Tại sao? . Việc biến đổi các giá trị của bạn bằng các câu như
const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
010 thay vìconst foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
011 hoặcconst foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
012 cũng sẽ mang tính biểu cảm hơn. Việc không cho phép các câu lệnh tăng và giảm đơn nguyên cũng ngăn bạn vô tình tăng trước/giảm trước các giá trị, điều này cũng có thể gây ra hành vi không mong muốn trong chương trình của bạnconst foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
55
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ạmconst 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. eslintconst foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
015Tại sao?
const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
56
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
017Tại sao? . Các biến như vậy chiếm không gian trong mã và có thể khiến người đọc nhầm lẫn
const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
57
⬆back to top
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áoconst 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ànconst foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
58
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
59
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
71Để biết thêm thông tin, hãy tham khảo JavaScript Scoping & Hoisting của Ben Cherry
⬆back to top
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ượngconst 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
73
- 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.const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
63,const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
59,const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
58 và// bad var a = 1; var b = 2; // good const a = 1; const b = 2;
45]. dây dẫn.const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
035Tại sao? . Điều này gây ra vấn đề khi nhiều mệnh đề
const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
029 cố định nghĩa cùng một thứconst foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
74
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
039const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
75
15. 7 Tránh những câu nói ba hoa 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
040const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
76
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 đặtconst 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
046Tại sao?
const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
77
⬆back to top
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
047const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
78
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 đặtconst 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
052const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
79
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ốiconst 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ốiconst 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
061const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
80
⬆back to top
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òngTạ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
82
⬆back to top
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òngconst foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
83
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ốiconst 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
066const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
85
- 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ặcconst 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 được 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ặcconst 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
86
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
87
⬆back to top
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
073const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
88
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;
24const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
89
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
077const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
00
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
078const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
01
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
079const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
02const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
03const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
04
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
080const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
081const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
05
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
06
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
082const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
07
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
083const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
08
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
084const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
09
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
085const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
10
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
086const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
11
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
014Tạ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
088const 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
089const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
14
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
090const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
15
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
091const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
16
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
092const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
17
- 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
083const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
18
⬆back to top
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
095const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
19
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
096Tạ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
20const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
21
⬆back to top
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
097Tạ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
⬆back to top
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
098const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
23
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
401const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
098Tại sao? . Khoảng trắng hàng đầu trong chuỗi bị bỏ qua. Nếu cơ số là
const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
53 hoặcconst foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
405, nó được giả định làconst foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
406 trừ khi số bắt đầu bằng cặp ký tựconst foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
407 hoặcconst foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
408, trong trường hợp đó cơ số là 16 được giả định. Điều này khác với ECMAScript 3, chỉ đơn thuần là không khuyến khích [nhưng được phép] giải thích bát phân. Nhiều triển khai đã không áp dụng hành vi này kể từ năm 2013. Và, bởi vì các trình duyệt cũ hơn phải được hỗ trợ, hãy luôn chỉ định một cơ sốconst foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
24
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àmconst 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
098const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
27
⬆back to top
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
411const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
28
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
412const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
29
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
413const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
30
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
414Why? JavaScript does not have the concept of privacy in terms of properties or methods. 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. if you want something to be “private”, it must not be observably present
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. Use arrow functions or Function#bindconst foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
32
23. 6 A base filename should exactly match the name of its default export
const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
33
23. 7 Use camelCase when you export-default a function. Your filename should be identical to your function’s name
const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
34
23. 8 Use PascalCase when you export a constructor / class / singleton / function library / bare object
const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
35
23. 9 Acronyms and initialisms should always be all uppercased, or all lowercased
Why? Names are for readability, not to appease a computer algorithm
const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
36
23. 10 You may optionally uppercase a constant only if it [1] is exported, [2] is a
const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
59 [it can not be reassigned], and [3] the programmer can trust it [and its nested properties] to never changeWhy? This is an additional tool to assist in situations where the programmer would be unsure if a variable might ever change. UPPERCASE_VARIABLES are letting the programmer know that they can trust the variable [and its properties] not to change
- What about all
const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
59 variables? - This is unnecessary, so uppercasing should not be used for constants within a file. It should be used for exported constants however - What about exported objects? - Uppercase at the top level of export [e. g.
const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
418] and maintain that all nested properties do not change
const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
37- What about all
⬆back to top
Accessors
- 24. 1 Accessor functions for properties are not required
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. Instead, if you do make accessor functions, use
const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
419 andconst foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
420const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
38
24. 3 If the property/method is a
const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
51, useconst foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
422 orconst foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
423const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
39
24. 4 It’s okay to create
const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
424 andconst foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
425 functions, but be consistentconst foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
40
⬆back to top
Sự kiện
25. 1 When attaching data payloads to events [whether DOM events or something more proprietary like Backbone events], pass an object literal [also known as a "hash"] instead of a raw value. This allows a subsequent contributor to add more data to the event payload without finding and updating every handler for the event. For example, instead of
const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
41prefer
const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
42
⬆back to top
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
426const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
43
26. 2 Cache jQuery lookups
const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
44
- 26. 3 For DOM queries use Cascading
const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
427 or parent > childconst foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
428. jsPerf
26. 4 Use
const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
429 with scoped jQuery object queriesconst foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
45
⬆back to top
ECMAScript 5 Compatibility
- 27. 1 Refer to Kangax’s ES5 compatibility table
⬆back to top
ECMAScript 6+ [ES 2015+] Styles
- 28. 1 This is a collection of links to the various ES6+ features
- Hàm mũi tên
- Classes
- Object Shorthand
- Object Concise
- Object Computed Properties
- Template Strings
- hủy hoại
- Default Parameters
- Rest
- Array Spreads
- Let and Const
- Exponentiation Operator
- Trình vòng lặp và Trình tạo
- mô-đun
28. 2 Do not use TC39 proposals that have not reached stage 3
Why? They are not finalized, and they are subject to change or to be withdrawn entirely. We want to use JavaScript, and proposals are not JavaScript yet
⬆back to top
Thư viện tiêu chuẩn
The Standard Library contains utilities that are functionally broken but remain for legacy reasons
29. 1 Use
const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
430 instead of globalconst foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
431. eslint.const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
432Why? The global
const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
431 coerces non-numbers to numbers, returning true for anything that coerces to NaN. Nếu hành vi này là mong muốn, làm cho nó rõ ràngconst foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
46
29. 2 Use
const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
434 instead of globalconst foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
435. eslint.const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
432Why? The global
const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
435 coerces non-numbers to numbers, returning true for anything that coerces to a finite number. If this behavior is desired, make it explicitconst foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
47
⬆back to top
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
48
- 30. 2 Không, nhưng nghiêm túc
- Whichever testing framework you use, you should be writing tests
- 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ó
- Whenever you fix a bug, write a regression test. 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
⬆back to top
Performance
- Về Bố cục và Hiệu suất Web
- String vs Array Concat
- Try/Catch Cost In a Loop
- Bang Function
- jQuery Find vs Context, Selector
- innerHTML vs textContent for script text
- Long String Concatenation
- Are JavaScript functions like
// 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, and// bad var a = 1; var b = 2; // good const a = 1; const b = 2;
74 optimized for traversing arrays? - Loading
⬆back to top
Resources
Learning ES6+
- Latest ECMA spec
- ExploringJS
- ES6 Compatibility Table
- Comprehensive Overview of ES6 Features
Read This
- Standard ECMA-262
Tools
- Code Style Linters
- ESlint - Airbnb Style . eslintrc
- JSHint - Airbnb Style . jshintrc
- Neutrino Preset - @neutrinojs/airbnb
Other Style Guides
- Google JavaScript Style Guide
- Google JavaScript Style Guide [Old]
- jQuery Core Style Guidelines
- Principles of Writing Consistent, Idiomatic JavaScript
- StandardJS
Other Styles
- Naming this in nested functions - Christian Johansen
- Conditional Callbacks - Ross Allen
- Popular JavaScript Coding Conventions on GitHub - JeongHoon Byun
- Multiple var statements in JavaScript, not superfluous - Ben Alman
Further Reading
- Understanding JavaScript Closures - Angus Croll
- Basic JavaScript for the impatient programmer - Dr. Axel Rauschmayer
- You Might Not Need jQuery - Zack Bloom & Adam Schwartz
- ES6 Features - Luke Hoban
- Frontend Guidelines - Benjamin De Cock
Books
- JavaScript. The Good Parts - Douglas Crockford
- JavaScript Patterns - Stoyan Stefanov
- Pro JavaScript Design Patterns - Ross Harmes and Dustin Diaz
- High Performance Web Sites. Essential Knowledge for Front-End Engineers - Steve Souders
- Maintainable JavaScript - Nicholas C. Zakas
- JavaScript Web Applications - Alex MacCaw
- Pro JavaScript Techniques - John Resig
- Smashing Node. js. JavaScript Everywhere - Guillermo Rauch
- Secrets of the JavaScript Ninja - John Resig and Bear Bibeault
- Human JavaScript - Henrik Joreteg
- Superhero. js - Kim Joar Bekkelund, Mads Mobæk, & Olav Bjorkoy
- JSBooks - Julien Bouquillon
- Third Party JavaScript - Ben Vinegar and Anton Kovalyov
- Effective JavaScript. 68 Specific Ways to Harness the Power of JavaScript - David Herman
- Eloquent JavaScript - Marijn Haverbeke
- You Don’t Know JS. ES6 & Beyond - Kyle Simpson
Blogs
- JavaScript Weekly
- JavaScript, JavaScript
- Bocoup Weblog
- Adequately Good
- NCZOnline
- Perfection Kills
- Ben Alman
- Dmitry Baranovskiy
- nettuts
Podcasts
- JavaScript Air
- JavaScript Jabber
⬆back to top
In the Wild
This is a list of organizations that are using this style guide. Send us a pull request and we'll add you to the list
- 123erfasst. 123erfasst/javascript
- 4Catalyzer. 4Catalyzer/javascript
- Aan Zee. AanZee/javascript
- Airbnb. airbnb/javascript
- AloPeyk. AloPeyk
- AltSchool. AltSchool/javascript
- Apartmint. apartmint/javascript
- Ascribe. ascribe/javascript
- Avant. tín dụng tiên phong/javascript
- Axept. axept/javascript
- Billabong. billabong/javascript
- Bisk. bisk
- Bonhomme. bonhommeparis/javascript
- Brainshark. brainshark/javascript
- CaseNine. CaseNine/javascript
- Cerner. Cerner
- Chartboost. ChartBoost/javascript-style-guide
- Coeur d'Alene Tribe. www. cdatribe-nsn. gov
- ComparaOnline. comparaonline/javascript
- Compass Learning. compasslearning/javascript-style-guide
- DailyMotion. dailymotion/javascript
- DoSomething. DoSomething/eslint-config
- Digitpaint digitpaint/javascript
- Drupal. www. drupal. org
- Ecosia. ecosia/javascript
- Evernote. evernote/javascript-style-guide
- Evolution Gaming. evolution-gaming/javascript
- EvozonJs. evozonjs/javascript
- ExactTarget. ExactTarget/javascript
- Flexberry. Flexberry/javascript-style-guide
- Gawker Media. gawkermedia
- General Electric. GeneralElectric/javascript
- Generation Tux. GenerationTux/javascript
- GoodData. gooddata/gdc-js-style
- GreenChef. greenchef/javascript
- Grooveshark. rãnh/javascript
- Grupo-Abraxas. Grupo-Abraxas/javascript
- Happeo. happeo/javascript
- Honey. honeyscience/javascript
- How About We. howaboutwe/javascript
- HubSpot. HubSpot/javascript
- Hyper. hyperoslo/javascript-playbook
- InterCity Group. intercitygroup/javascript-style-guide
- Jam3. Jam3/Javascript-Code-Conventions
- JSSolutions. JSSolutions/javascript
- Kaplan Komputing. kaplankomputing/javascript
- KickorStick. kickorstick
- Kinetica Solutions. kinetica/javascript
- LEINWAND. LEINWAND/javascript
- Lonely Planet. lonelyplanet/javascript
- M2GEN. M2GEN/javascript
- Mighty Spring. mightyspring/javascript
- MinnPost. MinnPost/javascript
- MitocGroup. MitocGroup/javascript
- Muber. muber
- National Geographic Society. natgeosociety
- NullDev. NullDevCo/JavaScript-Styleguide
- Nulogy. nulogy/javascript
- Orange Hill Development. orangehill/javascript
- Orion Health. orionhealth/javascript
- Peerby. Peerby/javascript
- Pier 1. Pier1/javascript
- Qotto. Qotto/javascript-style-guide
- React. reactjs. org/docs/how-to-contribute. html#style-guide
- REI. reidev/js-style-guide
- Ripple. ripple/javascript-style-guide
- Sainsbury’s Supermarkets. jsainsburyplc
- Shutterfly. shutterfly/javascript
- Sourcetoad. sourcetoad/javascript
- Mức tải trọng. mức tải trọng
- StratoDem Analytics. stratodem/javascript
- SteelKiwi Development. steelkiwi/javascript
- Sinh viênSphere. studentsphere/javascript
- SwoopApp. swoopapp/javascript
- SysGarage. sysgarage/javascript-style-guide
- Syzygy Warsaw. syzygypl/javascript
- Target. target/javascript
- Terra. terra
- TheLadders. TheLadders/javascript
- The Nerdery. thenerdery/javascript-standards
- Tomify. tomprats
- Traitify. traitify/eslint-config-traitify
- T4R Technology. T4R-Technology/javascript
- UrbanSim. urbansim
- VoxFeed. VoxFeed/javascript-style-guide
- WeBox Studio. weboxstudio/javascript
- Weggo. Weggo/javascript
- Zillow. zillow/javascript
- ZocDoc. ZocDoc/javascript
⬆back to top
Translation
This style guide is also available in other languages
- Brazilian Portuguese. armoucar/javascript-style-guide
- Bulgarian. borislavvv/javascript
- Catalan. fpmweb/javascript-style-guide
- Chinese [Simplified]. lin-123/javascript
- Chinese [Traditional]. jigsawye/javascript
- French. nmussy/javascript-style-guide
- German. timofurrer/javascript-style-guide
- Italian. sinkswim/javascript-style-guide
- Japanese. mitsuruog/javascript-style-guide
- Korean. ParkSB/javascript-style-guide
- Russian. leonidlebedev/javascript-airbnb
- Spanish. paolocarrasco/javascript-style-guide
- Thai. lvarayut/javascript-style-guide
- Turkish. eraycetinay/javascript
- Ukrainian. ivanzusko/javascript
- Vietnam. dangkyokhoang/javascript-style-guide
The JavaScript Style Guide Guide
- Reference
Chat With Us About JavaScript
- Find us on gitter
Contributors
- View Contributors
License
[The MIT License]
Copyright [c] 2012 Airbnb
Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files [the 'Software'], to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions
The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software
THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE
⬆back to top
Amendments
We encourage you to fork this guide and change the rules to fit your team’s style guide. 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