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
Tại sao?
// 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, 963 instead of 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, 965
Why? const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log(foo[0], bar[0]); // => 9, 963 is block-scoped rather than function-scoped like const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log(foo[0], bar[0]); // => 9, 960
const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log(foo[0], bar[0]); // => 9, 90
2. 3 Note that both const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log(foo[0], bar[0]); // => 9, 963 and const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log(foo[0], bar[0]); // => 9, 959 are block-scoped, whereas const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log(foo[0], bar[0]); // => 9, 960 is function-scoped
const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log(foo[0], bar[0]); // => 9, 94
In 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, 971 and const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log(foo[0], bar[0]); // => 9, 972 will produce a ReferenceError, while const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log(foo[0], bar[0]); // => 9, 973 contains the number. This is because const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log(foo[0], bar[0]); // => 9, 971 and const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log(foo[0], bar[0]); // => 9, 972 are block scoped, while const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log(foo[0], bar[0]); // => 9, 973 is scoped to the containing function
⬆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, 977
const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log(foo[0], bar[0]); // => 9, 92
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, 93
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, 978
const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log(foo[0], bar[0]); // => 9, 95
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, 978
Tại sao?
const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log(foo[0], bar[0]); // => 9, 97
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, 98
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, 980
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, 90
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, 981, chẳng hạn như const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log(foo[0], bar[0]); // => 9, 982, const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log(foo[0], bar[0]); // => 9, 983 và const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log(foo[0], bar[0]); // => 9, 984. dây dẫn. const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log(foo[0], bar[0]); // => 9, 985
Tại sao?
const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log(foo[0], bar[0]); // => 9, 91
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, 988 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, 989
const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log(foo[0], bar[0]); // => 9, 92
⬆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, 990
const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log(foo[0], bar[0]); // => 9, 93
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, 94
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, 991 để sao chép mảng
const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log(foo[0], bar[0]); // => 9, 95
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, 991 thay vì const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log(foo[0], bar[0]); // => 9, 993
const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log(foo[0], bar[0]); // => 9, 96
4. 5 Sử dụng const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log(foo[0], bar[0]); // => 9, 993 để 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, 97
4. 6 Sử dụng const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log(foo[0], bar[0]); // => 9, 993 thay vì trải rộng const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log(foo[0], bar[0]); // => 9, 991 để á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, 98
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, 997
const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log(foo[0], bar[0]); // => 9, 99
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 diệt
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, 998
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, 998
// bad var a = 1; var b = 2; // good const a = 1; const b = 2;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;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;03
Tạ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;06
Tại sao?
// bad var a = 1; var b = 2; // good const a = 1; const b = 2;7
⬆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 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 Wrap immediately invoked function expressions in parentheses. eslint. // 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 Never declare a function in a non-function block (// 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, etc). Assign the function to a variable instead. Browsers will allow you to do it, but they all interpret it differently, which is bad news bears. eslint. // bad var a = 1; var b = 2; // good const a = 1; const b = 2;11
7. 4 Note. ECMA-262 defines a // bad var a = 1; var b = 2; // good const a = 1; const b = 2;12 as a list of statements. A function declaration is not a statement
const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log(foo[0], bar[0]); // => 9, 900
7. 5 Never name a parameter // bad var a = 1; var b = 2; // good const a = 1; const b = 2;13. This will take precedence over the // bad var a = 1; var b = 2; // good const a = 1; const b = 2;13 object that is given to every function scope
const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log(foo[0], bar[0]); // => 9, 901
7. 6 Never use // bad var a = 1; var b = 2; // good const a = 1; const b = 2;13, opt to use rest syntax const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log(foo[0], bar[0]); // => 9, 991 instead. eslint. // bad var a = 1; var b = 2; // good const a = 1; const b = 2;17
Why? const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log(foo[0], bar[0]); // => 9, 991 is explicit about which arguments you want pulled. Plus, rest arguments are a real Array, and not merely Array-like like // bad var a = 1; var b = 2; // good const a = 1; const b = 2;13
const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log(foo[0], bar[0]); // => 9, 902
7. 7 Use default parameter syntax rather than mutating function arguments
const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log(foo[0], bar[0]); // => 9, 903
7. 8 Avoid side effects with default parameters
Why? They are confusing to reason about
const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log(foo[0], bar[0]); // => 9, 904
7. 9 Always put default parameters last. eslint. // bad var a = 1; var b = 2; // good const a = 1; const b = 2;20
const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log(foo[0], bar[0]); // => 9, 905
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;21
Tại sao?
const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log(foo[0], bar[0]); // => 9, 906
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;24
Tại sao?
const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log(foo[0], bar[0]); // => 9, 907
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;25
Tại sao?
const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log(foo[0], bar[0]); // => 9, 908
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;25
Tạ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, 909
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, 991 để 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;29
Tại sao?
const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log(foo[0], bar[0]); // => 9, 940
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, 941
⬆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;34
Tại sao?
Tại sao không?
const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log(foo[0], bar[0]); // => 9, 942
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, 943
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, 944
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;37
Tại sao?
const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log(foo[0], bar[0]); // => 9, 945
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;43
const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log(foo[0], bar[0]); // => 9, 946
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;44
const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log(foo[0], bar[0]); // => 9, 947
⬆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;46
Tại sao?
const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log(foo[0], bar[0]); // => 9, 948
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, 949
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, 920
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, 921
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;52
const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log(foo[0], bar[0]); // => 9, 922
9. 6 Avoid duplicate class members. dây dẫn. // bad var a = 1; var b = 2; // good const a = 1; const b = 2;53
Tại sao?
const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log(foo[0], bar[0]); // => 9, 923
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, 924
⬆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
Tại sao?
const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log(foo[0], bar[0]); // => 9, 925
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, 926
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, 927
10. 4 Only import from a path in one place. dây dẫn. // bad var a = 1; var b = 2; // good const a = 1; const b = 2;58
Tại sao?
const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log(foo[0], bar[0]); // => 9, 928
10. 5 Do not export mutable bindings. eslint. // bad var a = 1; var b = 2; // good const a = 1; const b = 2;59
Why? Mutation should be avoided in general, but in particular when exporting mutable bindings. While this technique may be needed for some special cases, in general, only constant references should be exported
const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log(foo[0], bar[0]); // => 9, 929
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;60
Tại sao?
const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log(foo[0], bar[0]); // => 9, 930
10. 7 Put all // bad var a = 1; var b = 2; // good const a = 1; const b = 2;56s above non-import statements. dây dẫn. // bad var a = 1; var b = 2; // good const a = 1; const b = 2;62
Why? Since // bad var a = 1; var b = 2; // good const a = 1; const b = 2;56s are hoisted, keeping them all at the top prevents surprising behavior
const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log(foo[0], bar[0]); // => 9, 931
10. 8 Multiline imports should be indented just like multiline array and object literals. dây dẫn. // bad var a = 1; var b = 2; // good const a = 1; const b = 2;64
Tại sao?
const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log(foo[0], bar[0]); // => 9, 932
10. 9 Disallow Webpack loader syntax in module import statements. dây dẫn. // bad var a = 1; var b = 2; // good const a = 1; const b = 2;65
Why? Since using Webpack syntax in the imports couples the code to a module bundler. 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;66
const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log(foo[0], bar[0]); // => 9, 933
10. 10 Do not include JavaScript filename extensions eslint. // bad var a = 1; var b = 2; // good const a = 1; const b = 2;67
Tại sao?
const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log(foo[0], bar[0]); // => 9, 934
⬆quay lại đầu trang
Iterators and Generators
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;71
Why? This enforces our immutable rule. 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ượng
const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log(foo[0], bar[0]); // => 9, 935
11. 2 Hiện tại không sử dụng máy phát điện
Tại sao?
11. 3 If you must use generators, or if you disregard our advice, make sure their function signature is spaced properly. 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, 936
⬆quay lại đầu trang
Đặc tính
12. 1 Use dot notation when accessing properties. dây dẫn. // bad var a = 1; var b = 2; // good const a = 1; const b = 2;89
const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log(foo[0], bar[0]); // => 9, 937
12. 2 Use bracket notation // bad var a = 1; var b = 2; // good const a = 1; const b = 2;90 when accessing properties with a variable
const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log(foo[0], bar[0]); // => 9, 938
12. 3 Use exponentiation operator // bad var a = 1; var b = 2; // good const a = 1; const b = 2;91 when calculating exponentiations. eslint. // bad var a = 1; var b = 2; // good const a = 1; const b = 2;92
const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log(foo[0], bar[0]); // => 9, 939
⬆quay lại đầu trang
Variables
13. 1 Always use const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log(foo[0], bar[0]); // => 9, 959 or const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log(foo[0], bar[0]); // => 9, 963 to declare variables. Not doing so will result in global variables. We want to avoid polluting the global namespace. Captain Planet warned us of that. eslint. // bad var a = 1; var b = 2; // good const a = 1; const b = 2;95 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, 950
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, 959 hoặc const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log(foo[0], bar[0]); // => 9, 963 cho mỗi biến hoặc phép gán. eslint. // bad var a = 1; var b = 2; // good const a = 1; const b = 2;99
Why? It’s easier to add new variable declarations this way, and you never have to worry about swapping out a const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log(foo[0], bar[0]); // => 9, 9000 for a const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log(foo[0], bar[0]); // => 9, 9001 or introducing punctuation-only diffs. You can also step through each declaration with the debugger, instead of jumping through all of them at once
const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log(foo[0], bar[0]); // => 9, 951
13. 3 Group all your const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log(foo[0], bar[0]); // => 9, 959s and then group all your const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log(foo[0], bar[0]); // => 9, 963s
Why? This is helpful when later on you might need to assign a variable depending on one of the previously assigned variables
const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log(foo[0], bar[0]); // => 9, 952
13. 4 Gán các biến ở nơi bạn cần, nhưng đặt chúng ở nơi hợp lý
Why? const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log(foo[0], bar[0]); // => 9, 963 and const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log(foo[0], bar[0]); // => 9, 959 are block scoped and not function scoped
const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log(foo[0], bar[0]); // => 9, 953
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, 9006
Tại sao?
const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log(foo[0], bar[0]); // => 9, 954
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, 9007, const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log(foo[0], bar[0]); // => 9, 9008). eslint const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log(foo[0], bar[0]); // => 9, 9009
Tạ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, 9010 thay vì const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log(foo[0], bar[0]); // => 9, 9011 hoặc const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log(foo[0], bar[0]); // => 9, 9012 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ạn
const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log(foo[0], bar[0]); // => 9, 955
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, 9013 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, 9014, 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, 9015
Tại sao?
const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log(foo[0], bar[0]); // => 9, 956
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, 9017
Tại sao? . Such variables take up space in the code and can lead to confusion by readers
const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log(foo[0], bar[0]); // => 9, 957
⬆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, 960 đượ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, 959 và const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log(foo[0], bar[0]); // => 9, 963 đượ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, 958
14. 2 Anonymous function expressions hoist their variable name, but not the function assignment
const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log(foo[0], bar[0]); // => 9, 959
14. 3 Named function expressions hoist the variable name, not the function name or the function body
const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log(foo[0], bar[0]); // => 9, 970
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, 971
Để 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, 9021 và const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log(foo[0], bar[0]); // => 9, 9022 thay vì const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log(foo[0], bar[0]); // => 9, 9023 và const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log(foo[0], bar[0]); // => 9, 9024. dây dẫn. const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log(foo[0], bar[0]); // => 9, 9025
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, 9027 và luôn tuân theo các quy tắc đơn giản này
- Objects evaluate to true
- 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, 972
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, 973
- 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, 9029 và const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log(foo[0], bar[0]); // => 9, 9030 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, 963, const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log(foo[0], bar[0]); // => 9, 959, const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log(foo[0], bar[0]); // => 9, 958 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, 9035
Tạ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, 9029 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, 974
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. eslint. const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log(foo[0], bar[0]); // => 9, 9039
const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log(foo[0], bar[0]); // => 9, 975
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, 9040
const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log(foo[0], bar[0]); // => 9, 976
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, 9041, const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log(foo[0], bar[0]); // => 9, 9042, and // bad var a = 1; var b = 2; // good const a = 1; const b = 2;91 since their precedence is broadly understood. 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, 9044 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, 9046
Why? This improves readability and clarifies the developer’s intention
const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log(foo[0], bar[0]); // => 9, 977
⬆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, 9047
const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log(foo[0], bar[0]); // => 9, 978
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, 9049, hãy đặt const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log(foo[0], bar[0]); // => 9, 9049 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, 9052
const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log(foo[0], bar[0]); // => 9, 979
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, 9049 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, 9057 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, 9061
const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log(foo[0], bar[0]); // => 9, 980
⬆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? . This also improves readability by making it easier to visually follow complex logic
const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log(foo[0], bar[0]); // => 9, 981
17. 2 Don't use selection operators in place of control statements
const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log(foo[0], bar[0]); // => 9, 982
⬆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, 9064 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, 983
18. 2 Sử dụng const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log(foo[0], bar[0]); // => 9, 9065 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, 984
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, 9066
const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log(foo[0], bar[0]); // => 9, 985
- 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, 9067 hoặc const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log(foo[0], bar[0]); // => 9, 9068 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, 9069 hoặc const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log(foo[0], bar[0]); // => 9, 9070
18. 5 Sử dụng const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log(foo[0], bar[0]); // => 9, 9071 để chú thích các vấn đề
const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log(foo[0], bar[0]); // => 9, 986
18. 6 Sử dụng const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log(foo[0], bar[0]); // => 9, 9072 để 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, 987
⬆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. eslint. const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log(foo[0], bar[0]); // => 9, 9073
const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log(foo[0], bar[0]); // => 9, 988
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;24
const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log(foo[0], bar[0]); // => 9, 989
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, 9077
const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log(foo[0], bar[0]); // => 9, 900
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, 9078
const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log(foo[0], bar[0]); // => 9, 901
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, 9079
const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log(foo[0], bar[0]); // => 9, 902
const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log(foo[0], bar[0]); // => 9, 903
const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log(foo[0], bar[0]); // => 9, 904
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, 9080 const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log(foo[0], bar[0]); // => 9, 9081
const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log(foo[0], bar[0]); // => 9, 905
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, 906
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, 9082
const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log(foo[0], bar[0]); // => 9, 907
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, 9083
const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log(foo[0], bar[0]); // => 9, 908
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, 9084
const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log(foo[0], bar[0]); // => 9, 909
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, 9085
const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log(foo[0], bar[0]); // => 9, 910
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, 9086
const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log(foo[0], bar[0]); // => 9, 911
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, 9014
Tại sao?
const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log(foo[0], bar[0]); // => 9, 912
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, 9088
const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log(foo[0], bar[0]); // => 9, 913
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, 9089
const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log(foo[0], bar[0]); // => 9, 914
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, 9090
const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log(foo[0], bar[0]); // => 9, 915
19. 17 Avoid spaces between functions and their invocations. dây dẫn. const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log(foo[0], bar[0]); // => 9, 9091
const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log(foo[0], bar[0]); // => 9, 916
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, 9092
const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log(foo[0], bar[0]); // => 9, 917
- 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, 9093
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, 9083
const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log(foo[0], bar[0]); // => 9, 918
⬆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, 9095
const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log(foo[0], bar[0]); // => 9, 919
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, 9096
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, 920
const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log(foo[0], bar[0]); // => 9, 921
⬆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, 9097
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, 922
Đọ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, 9098
const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log(foo[0], bar[0]); // => 9, 923
22. 3 số. Sử dụng const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log(foo[0], bar[0]); // => 9, 9099 để truyền kiểu và const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log(foo[0], bar[0]); // => 9, 9400 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, 9401 const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log(foo[0], bar[0]); // => 9, 9098
Tạ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, 953 hoặc const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log(foo[0], bar[0]); // => 9, 9405, nó được giả định là const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log(foo[0], bar[0]); // => 9, 9406 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, 9407 hoặc const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log(foo[0], bar[0]); // => 9, 9408, 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, 924
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, 9400 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, 925
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, 926
22. 6 Boolean. dây dẫn. const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log(foo[0], bar[0]); // => 9, 9098
const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log(foo[0], bar[0]); // => 9, 927
⬆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, 9411
const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log(foo[0], bar[0]); // => 9, 928
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, 9412
const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log(foo[0], bar[0]); // => 9, 929
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, 9413
const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log(foo[0], bar[0]); // => 9, 930
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, 9414
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, 931
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, 932
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, 933
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, 934
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, 935
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, 936
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, 959 (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, 959 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, 9418) 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, 937
⬆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, 9419 và const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log(foo[0], bar[0]); // => 9, 9420
const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log(foo[0], bar[0]); // => 9, 938
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, 951, hãy sử dụng const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log(foo[0], bar[0]); // => 9, 9422 hoặc const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log(foo[0], bar[0]); // => 9, 9423
const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log(foo[0], bar[0]); // => 9, 939
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, 9424 và const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log(foo[0], bar[0]); // => 9, 9425, 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, 940
⬆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, 941
thích hơn
const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log(foo[0], bar[0]); // => 9, 942
⬆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, 9426
const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log(foo[0], bar[0]); // => 9, 943
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, 944
- 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, 9427 hoặc parent > child const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log(foo[0], bar[0]); // => 9, 9428. jsPerf
26. 4 Sử dụng const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log(foo[0], bar[0]); // => 9, 9429 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, 945
⬆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 diệt
- 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
- Iterators and Generators
- 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, 9430 thay vì toàn cầu const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log(foo[0], bar[0]); // => 9, 9431. dây dẫn. const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log(foo[0], bar[0]); // => 9, 9432
Tại sao? . Nếu hành vi này là mong muốn, làm cho nó rõ ràng
const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log(foo[0], bar[0]); // => 9, 946
29. 2 Use const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log(foo[0], bar[0]); // => 9, 9434 instead of global const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log(foo[0], bar[0]); // => 9, 9435. eslint. const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log(foo[0], bar[0]); // => 9, 9432
Why? The global const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log(foo[0], bar[0]); // => 9, 9435 coerces non-numbers to numbers, returning true for anything that coerces to a finite number. If this behavior is desired, make it explicit
const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log(foo[0], bar[0]); // => 9, 947
⬆quay lại đầu trang
Testing
30. 1 Yup
const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log(foo[0], bar[0]); // => 9, 948
- 30. 2 No, but seriously
- Whichever testing framework you use, you should be writing tests
- Strive to write many small pure functions, and minimize where mutations occur
- Be cautious about stubs and mocks - they can make your tests more brittle
- We primarily use const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log(foo[0], bar[0]); // => 9, 9438 and const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log(foo[0], bar[0]); // => 9, 9439 at Airbnb. const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log(foo[0], bar[0]); // => 9, 9440 is also used occasionally for small, separate modules
- 100% test coverage is a good goal to strive for, even if it’s not always practical to reach it
- Whenever you fix a bug, write a regression test. A bug fixed without a regression test is almost certainly going to break again in the future
⬆quay lại đầu trang
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
⬆quay lại đầu trang
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
- Siêu anh hùng. 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
⬆quay lại đầu trang
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
- căn hộ. căn hộ/javascript
- Thường gán. ascribe/javascript
- Avant. avantcredit/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
- Bộ tộc Coeur d'Alene. 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. grooveshark/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. gậy đánh bóng
- 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. Ngang hàng/javascript
- Pier 1. Pier1/javascript
- Qotto. Qotto/javascript-style-guide
- React. phản ứng. org/docs/how-to-contribute. 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. stratodem/javascript
- SteelKiwi Development. steelkiwi/javascript
- StudentSphere. 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
⬆quay lại đầu trang
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
Hướng dẫn Hướng dẫn Phong cách JavaScript
- Reference
Chat With Us About JavaScript
- Find us on gitter
Contributors
- View Contributors
Giấy phép
(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
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