Ghi chú. hướng dẫn này giả định rằng bạn đang sử dụng Babel và yêu cầu bạn sử dụng babel-preset-airbnb hoặc tương đương. Nó cũng giả định rằng bạn đang cài đặt miếng chêm/polyfill trong ứng dụng của mình, với airbnb-browser-shims hoặc tương đương
Hướng dẫn này cũng có sẵn bằng các ngôn ngữ khác. xem phiên dịch
Hướng dẫn phong cách khác
Mục lục
các loại
1. 1 nguyên thủy. Khi bạn truy cập một kiểu nguyên thủy, bạn sẽ làm việc trực tiếp với giá trị của nó
29const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
30const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
31const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
32const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
33const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
34const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
const foo = 1; let bar = foo; bar = 9; console.log[foo, bar]; // => 1, 9
- Các biểu tượng không thể được điền đầy đủ một cách trung thực, vì vậy chúng không nên được sử dụng khi nhắm mục tiêu các trình duyệt/môi trường không hỗ trợ chúng nguyên bản
1. 2 khu phức hợp. Khi bạn truy cập một loại phức tạp, bạn sẽ làm việc trên một tham chiếu đến giá trị của nó
const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
⬆ quay lại đầu trang
Người giới thiệu
2. 1 Sử dụng
35 cho tất cả các tài liệu tham khảo của bạn; . dây dẫn.const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
37,const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
38const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
Tại sao?
2const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
2. 2 Nếu bạn phải chỉ định lại tài liệu tham khảo, hãy sử dụng
39 thay vìconst foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
36. dây dẫn.const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
41 jscs.const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
42const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
Tại sao?
9const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
2. 3 Lưu ý rằng cả
39 vàconst foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
35 đều có phạm vi khốiconst foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
2const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
⬆ 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.
47const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
4const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
3. 2 Sử dụng tên thuộc tính được tính toán khi tạo đối tượng có tên thuộc tính động
Tại sao?
5const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
3. 4 Sử dụng tốc ký giá trị thuộc tính. dây dẫn.
48 jscs.const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
49const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
Tại sao?
8const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
3. 5 Nhóm các thuộc tính tốc ký của bạn khi bắt đầu khai báo đối tượng của bạn
Tại sao?
9const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
3. 6 Chỉ trích dẫn các thuộc tính không hợp lệ. dây dẫn.
50 jscs.const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
51const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
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
2const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
3. 7 Không gọi trực tiếp các phương thức
52, chẳng hạn nhưconst foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
53,const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
54 vàconst foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
55const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
Tại sao?
0const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
3. 8 Ưu tiên toán tử trải rộng đối tượng trên
58 hơn đối tượng sao chép nông. Sử dụng toán tử nghỉ đối tượng để lấy một đối tượng mới với một số thuộc tính bị bỏ quaconst foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
1const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
⬆ quay lại đầu trang
Mảng
4. 1 Sử dụng cú pháp chữ để tạo mảng. dây dẫn.
59const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
2const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
4. 2 Sử dụng Array#push thay vì gán trực tiếp để thêm các mục vào một mảng
3const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
4. 3 Sử dụng dàn trải mảng
60 để sao chép mảngconst foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
4const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
4. 4 Để chuyển đổi một đối tượng dạng mảng thành một mảng, hãy sử dụng spread
60 thay vì Array. từconst foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
5const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
4. 5 Sử dụng Mảng. from thay vì spread
60 để á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
6const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
4. 6 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.
63const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
7const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
4. 7 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
8const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
⬆ 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.
64 jscs.const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
65const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
Tại sao?
9const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
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. jscs.
66const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
Tại sao?
20const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
⬆ quay lại đầu trang
Dây
6. 1 Sử dụng dấu nháy đơn
67 cho chuỗi. dây dẫn.const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
68 jscs.const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
69const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
21const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
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?
22const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
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.
70const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
71 jscs.const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
72const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
Tại sao?
23const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
- 6. 4 Không bao giờ sử dụng
73 trên một chuỗi, nó mở ra quá nhiều lỗ hổng. dây dẫn.const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
74const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
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.
75const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
Tại sao?
24const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
⬆ 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.
76 jscs.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
Tại sao? . Điều này gây hại cho khả năng đọc và bảo trì. Nếu bạn thấy rằng định nghĩa của một hàm đủ lớn hoặc phức tạp đến mức cản trở việc hiểu phần còn lại của tệp, thì có lẽ đã đến lúc giải nén nó vào mô-đun của riêng nó. Đừng quên đặt tên rõ ràng cho biểu thức, bất kể tên đó có được suy ra từ biến chứa hay không [điều này thường xảy ra trong các trình duyệt hiện đại hoặc khi sử dụng các trình biên dịch như Babel]. Điều này giúp loại bỏ bất kỳ giả định nào về ngăn xếp cuộc gọi của Lỗi. [Thảo luận]
25const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
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.
78 jscs.const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
79const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
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
26const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 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 [
80,const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
81, 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.const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
82const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
7. 4 Lưu ý. ECMA-262 định nghĩa một
83 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
27const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
7. 5 Không bao giờ đặt tên cho tham số
84. Điều này sẽ được ưu tiên hơn đối tượngconst foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
84 đượ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
28const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
7. 6 Không bao giờ sử dụng
84, 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
60. dây dẫn.const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
88const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
Tại sao? . Thêm vào đó, các đối số còn lại là một Mảng thực và không chỉ giống Mảng như
84const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
29const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
7. 7 Sử dụng cú pháp tham số mặc định thay vì thay đổi đối số hàm
90const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
7. 8 Tránh tác dụng phụ với thông số mặc định
Tại sao?
91const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
7. 9 Luôn đặt thông số mặc định cuối cùng
92const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
7. 10 Không bao giờ sử dụng hàm tạo Hàm để tạo một hàm mới. dây dẫn.
91const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
Tại sao?
93const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
7. 11 Khoảng cách trong chữ ký hàm. dây dẫn. ________ 092 ________ 093
Tại sao?
94const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
7. 12 Không bao giờ thay đổi tham số. dây dẫn.
94const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
Tại sao?
95const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
7. 13 Không bao giờ chỉ định lại các thông số. dây dẫn.
94const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
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
96const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
7. 14 Ưu tiên sử dụng toán tử trải rộng
60 để gọi các hàm biến thiên. dây dẫn.const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
98const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
Tại sao?
97const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
7. 15 Các hàm có chữ ký nhiều dòng hoặc lời gọi phải được thụt lề giống như mọi danh sách nhiều dòng khác trong hướng dẫn này. với mỗi mục trên một dòng, với dấu phẩy ở cuối mục cuối cùng. dây dẫn.
201const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
98const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
⬆ 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. Công ty cổ phần
202,const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
203.const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
204const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
Tại sao?
Tại sao không?
99const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
8. 2 Nếu thân hàm bao gồm một câu lệnh đơn lẻ trả về một biểu thức không có tác dụng phụ, hãy bỏ qua dấu ngoặc nhọn và sử dụng hàm trả về ngầm định. Nếu không, hãy giữ dấu ngoặc nhọn và sử dụng câu lệnh
206. dây dẫn. Công ty cổ phầnconst foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
207,const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
208.const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
209,const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
210const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
Tại sao? . Nó đọc tốt khi nhiều chức năng được xâu chuỗi lại với nhau
20const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
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?
21const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
8. 4 Nếu hàm của bạn nhận một đối số duy nhất và không sử dụng dấu ngoặc nhọn, hãy bỏ qua dấu ngoặc đơn. Mặt khác, 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. Ghi chú. cũng có thể chấp nhận luôn sử dụng dấu ngoặc đơn, trong trường hợp đó, hãy sử dụng tùy chọn “luôn luôn” cho eslint hoặc không bao gồm
209 cho jscs. dây dẫn.const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
207 jscs.const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
209const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
Tại sao?
22const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
8. 5 Tránh nhầm lẫn cú pháp hàm mũi tên [
214] với các toán tử so sánh [const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
215,const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
216]. dây dẫn.const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
217const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
23const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
⬆ quay lại đầu trang
Lớp & Constructor
9. 1 Luôn sử dụng
218. Tránh thao tác trực tiếp vớiconst foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
219const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
Tại sao?
24const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
9. 2 Sử dụng
221 để thừa kếconst foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
Tại sao?
25const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
9. 3 Phương thức có thể trả về
205 để 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
26const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
9. 4 Bạn có thể viết phương thức toString[] 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ụ
27const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
9. 5 Các lớp có hàm tạo mặc định nếu không được chỉ định. Hàm tạo trống hoặc hàm chỉ ủy quyền cho lớp cha là không cần thiết. dây dẫn.
224const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
28const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
9. 6 Tránh các thành viên lớp trùng lặp. dây dẫn.
225const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
Tại sao?
29const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
⬆ quay lại đầu trang
mô-đun
10. 1 Luôn sử dụng mô-đun [
226/______1227] 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ìnhconst foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
Tại sao?
40const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
10. 2 Không sử dụng nhập ký tự đại diện
Tại sao?
41const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
10. 3 Và không xuất trực tiếp từ một lần nhập
Tại sao?
42const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
- 10. 4 Chỉ nhập từ một đường dẫn ở một nơi. dây dẫn.
228const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
Tại sao?
43const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
- 10. 5 Không xuất các ràng buộc có thể thay đổi. dây dẫn.
229const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
Tại sao? . Mặc dù kỹ thuật này có thể cần thiết cho một số trường hợp đặc biệt, nhưng nói chung, chỉ nên xuất các tham chiếu cố định
44const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
- 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.
230const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
Tại sao?
45const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
- 10. 7 Đặt tất cả các
226 ở trên các câu lệnh không nhập khẩu. dây dẫn.const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
232const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
Tại sao?
46const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
10. 8 Nhập nhiều dòng phải được thụt lề giống như mảng nhiều dòng và đối tượng bằng chữ
Tại sao?
47const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
- 10. 9 Không cho phép cú pháp trình tải Webpack trong câu lệnh nhập mô-đun. dây dẫn.
234const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
Tại sao? . Thích sử dụng cú pháp trình tải trong
235const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
48const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
⬆ quay lại đầu trang
Trình vòng lặp và Trình tạo
11. 1 Không sử dụng vòng lặp. Thích các hàm bậc cao hơn của JavaScript thay vì các vòng lặp như
236 hoặcconst foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
237. dây dẫn.const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
238const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
239const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
Tạ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
240 /const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
241 /const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
242 /const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
243 /const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
244 /const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
245 /const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
246 / … để lặp lại các mảng vàconst foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
247 /const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
248 /const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
249 để 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
49const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
11. 2 Hiện tại không sử dụng máy phát điện
Tại sao?
11. 3 Nếu bạn phải sử dụng trình tạo hoặc nếu bạn bỏ qua lời khuyên của chúng tôi, hãy đảm bảo chữ ký chức năng của chúng được đặt đúng khoảng cách. dây dẫn.
250const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
Tại sao?
50const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
⬆ quay lại đầu trang
Đặc tính
12. 1 Sử dụng ký hiệu dấu chấm khi truy cập thuộc tính. dây dẫn.
257 jscs.const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
258const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
51const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
12. 2 Sử dụng ký hiệu ngoặc _______1259 khi truy cập các thuộc tính có biến
52const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
12. 3 Sử dụng toán tử lũy thừa
260 khi tính lũy thừa. dây dẫn.const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
261const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
53const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
⬆ quay lại đầu trang
Biến
13. 1 Luôn sử dụng
35 hoặcconst foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
39 để khai báo biến. Không làm như vậy sẽ dẫn đến các biến toàn cầu. Chúng tôi muốn tránh làm ô nhiễm không gian tên toàn cầu. Captain Planet đã cảnh báo chúng tôi về điều đó. dây dẫn.const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
264const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
37const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
54const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
13. 2 Sử dụng một khai báo
35 hoặcconst foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
39 cho mỗ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
268 jscs.const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
269const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
Tạ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
55const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
13. 3 Nhóm tất cả các
35 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
39 của bạnconst foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
Tại sao?
56const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
13. 4 Gán các biến ở nơi bạn cần, nhưng đặt chúng ở nơi hợp lý
Tại sao?
57const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
13. 5. Không gán chuỗi biến. dây dẫn.
276const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
Tại sao?
58const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
13. 6 Tránh sử dụng tăng và giảm đơn vị [++, –]. eslint
277const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
Tại sao? . Việc biến đổi các giá trị của bạn bằng các câu như
278 thay vìconst foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
279 hoặcconst foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
280 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
59const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
13. 7 Tránh ngắt dòng trước hoặc sau
281 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
282, 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
283const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
Tại sao?
80const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
⬆ quay lại đầu trang
cẩu
14. 1 khai báo
36 đượ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
35 vàconst foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
39 đượ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
81const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
14. 2 Biểu thức hàm ẩn danh nâng tên biến của chúng, nhưng không gán chức năng
82const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
14. 3 Biểu thức hàm được đặt tên kéo theo tên biến, không phải tên hàm hoặc thân hàm
83const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
14. 4 Khai báo hàm nâng tên của chúng và thân hàm
84const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
Để biết thêm thông tin, hãy tham khảo JavaScript Scoping & Hoisting của Ben Cherry
⬆ quay lại đầu trang
Toán tử so sánh & Bình đẳng
15. 2 Các câu điều kiện như câu lệnh
80 đánh giá biểu thức của chúng bằng cách sử dụng phép cưỡng chế 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
289 và luôn tuân theo các quy tắc đơn giản nàyconst foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
- 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
67, nếu không thì đúngconst foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
85const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
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ố
86const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
15. 5 Sử dụng dấu ngoặc nhọn để tạo các khối trong mệnh đề
291 vàconst foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
292 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
39,const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
35,const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
251 vàconst foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
218]. dây dẫn.const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
297const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
Tại sao? . Điều này gây ra vấn đề khi nhiều mệnh đề
291 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
87const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
15. 6 Các bộ ba không được lồng vào nhau và thường là các biểu thức một dòng. dây dẫn.
901const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
88const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
15. 7 Tránh những câu nói ngắn gọn không cần thiết. dây dẫn.
902const 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
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 [
903,const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
904,const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
252, &const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
906] vì quyền ưu tiên của chúng được hiểu rộng rãi. dây dẫn.const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
907const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
Tại sao?
90const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
⬆ quay lại đầu trang
khối
16. 1 Sử dụng dấu ngoặc nhọn với tất cả các khối nhiều dòng. dây dẫn.
908const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
91const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
16. 2 Nếu bạn đang sử dụng các khối nhiều dòng với
80 vàconst foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
910, hãy đặtconst foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
910 trên cùng một dòng với dấu ngoặc nhọn đóng của khốiconst foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
80 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
913 công ty cổ phần.const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
914const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
92const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
16. 3 Nếu khối
80 luôn thực thi câu lệnhconst foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
206, thì khốiconst foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
910 tiếp theo là không cần thiết. Mộtconst foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
206 trong một khốiconst foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
919 theo sau một khốiconst foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
80 có chứa mộtconst foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
206 có thể được tách thành nhiều khốiconst foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
80. dây dẫn.const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
923const 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
⬆ quay lại đầu trang
Tuyên bố kiểm soát
17. 1 Trong trường hợp câu lệnh kiểm soát của bạn [
80,const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
81, 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òngconst foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
Tại sao? . Điều này cũng cải thiện khả năng đọc bằng cách giúp dễ dàng theo dõi logic phức tạp một cách trực quan.
94const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
17. 2 Không sử dụng toán tử lựa chọn thay cho câu lệnh điều khiển
95const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
⬆ quay lại đầu trang
18. 1 Sử dụng
926 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
96const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
18. 2 Sử dụng
927 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
97const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
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.
928const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
98const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
- 18. 4 Đặt trước nhận xét của bạn bằng
929 hoặcconst foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
930 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à ________ 1931 hoặc ________ 1932const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
18. 5 Sử dụng
933 để 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
99const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
18. 6 Sử dụng
934 để chú thích các giải pháp cho các vấn đề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
⬆ quay lại đầu trang
Khoảng trắng
19. 1 Sử dụng tab mềm [ký tự dấu cách] được đặt thành 2 dấu cách. dây dẫn.
935 công ty cổ phần.const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
936const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
21const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
19. 2 Đặt 1 dấu cách trước dấu ngoặc nhọn. dây dẫn.
93 jscs.const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
938const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
22const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
19. 3 Đặt 1 dấu cách trước dấu ngoặc đơn mở trong các câu lệnh kiểm soát [
80,const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
81, 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
941 jscs.const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
942const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
23const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
19. 5 Kết thúc tệp bằng một ký tự dòng mới. dây dẫn.
943const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
24const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
25const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
26const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
19. 6 Sử dụng thụt đầu dòng khi tạo chuỗi phương thức dài [hơn 2 chuỗi phương thức]. Sử dụng dấu chấm ở đầu, nhấn mạnh rằng dòng này là lời gọi phương thức, không phải câu lệnh mới. dây dẫn. ________ 1944 ________ 1945
27const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
19. 7 Để trống một dòng sau các khối và trước câu lệnh tiếp theo. jscs.
946const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
28const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
19. 8 Đừng đệm các khối của bạn bằng các dòng trống. dây dẫn.
947 jscs.const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
948const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
29const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
19. 12 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.
282 jscs.const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
950const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
Tại sao?
00const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
⬆ quay lại đầu trang
dấu phẩy
20. 1 Dấu phẩy đứng đầu. Không. dây dẫn.
951 jscs.const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
952const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
01const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
20. 2 Dấu phẩy bổ sung. Chuẩn rồi. dây dẫn.
953 jscs.const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
954const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
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ũ
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
⬆ quay lại đầu trang
dấu chấm phẩy
21. 1 vâng. dây dẫn.
955 công ty cổ phần.const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
956const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
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ố
04const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
Đọ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.
957const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
05const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
22. 3 số. Sử dụng
958 để truyền kiểu vàconst foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
959 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
960const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
957const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
06const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
22. 4 Nếu vì bất kỳ lý do gì mà bạn đang làm điều gì đó hoang dã và
959 là nút thắ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
07const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
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
08const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
22. 6 Boolean. dây dẫn.
957const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
09const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
⬆ quay lại đầu trang
quy ước đặt tên
23. 1 Tránh tên có một chữ cái. Hãy mô tả với tên của bạn. dây dẫn.
964const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
10const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
23. 3 Chỉ sử dụng PascalCase khi đặt tên cho hàm tạo hoặc lớp. dây dẫn.
965 jscs.const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
966const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
11const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
23. 4 Không sử dụng dấu gạch dưới ở cuối hoặc ở đầu. dây dẫn. Công ty cổ phần
967.const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
968const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
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
12const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
23. 5 Không lưu tham chiếu đến
205. Sử dụng các chức năng mũi tên hoặc Hàm # liên kết. jscs.const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
970const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
13const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
23. 6 Tên tệp cơ sở phải khớp chính xác với tên xuất mặc định của nó
14const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
23. 7 Sử dụng camelCase khi bạn xuất hàm mặc định. Tên tệp của bạn phải giống với tên hàm của bạn
15const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
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
16const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
23. 9 Các từ viết tắt và viết tắt phải luôn được viết hoa hoặc viết thường
Tại sao?
17const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
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à
35 [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 đổiconst foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
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
35 thì sao? . Tuy nhiên, nó nên được sử dụng cho các hằng số đã xuấtconst foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
- Đối với các đối tượng đã xuất thì sao? . g.
973] và duy trì rằng tất cả các thuộc tính lồng nhau không thay đổiconst foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
18const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
- Còn tất cả các biến
⬆ 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 getVal[] và setVal[‘hello’]
19const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
24. 3 Nếu thuộc tính/phương pháp là một
31, hãy sử dụngconst foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
975 hoặcconst foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
976const 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
24. 4 Bạn có thể tạo các hàm get[] và set[] nhưng phải nhất quán
21const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
⬆ quay lại đầu trang
Sự kiện
25. 1 Khi đính kèm tải trọng dữ liệu vào các 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ì
22const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
thích hơn
23const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
⬆ quay lại đầu trang
jQuery
26. 2 Tra cứu bộ đệm jQuery
24const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
- 26. 3 Đối với các truy vấn DOM, hãy sử dụng Cascading
977 hoặc parent > childconst foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
978. jsPerfconst foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
26. 4 Sử dụng
979 với các truy vấn đối tượng jQuery có phạm viconst foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
25const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
⬆ quay lại đầu trang
Khả năng tương thích ECMAScript 5
⬆ 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+
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
980 thay vì toàn cầuconst foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
981. dây dẫn.const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
982const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
Tại sao? . Nếu hành vi này là mong muốn, làm cho nó rõ ràng
26const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
29. 2 Sử dụng
984 thay vì toàn cầuconst foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
985. dây dẫn.const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
982const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
Tại sao? . Nếu hành vi này là mong muốn, làm cho nó rõ ràng
27const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
⬆ quay lại đầu trang
thử nghiệm
30. 1 vâng
28const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
- 30. 2 Không, nhưng nghiêm túc
- Cho dù bạn sử dụng khung kiểm tra nào, bạn nên viết bài kiểm tra
- Cố gắng viết nhiều hàm thuần túy nhỏ và giảm thiểu nơi xảy ra đột biến
- Hãy thận trọng với sơ khai và giả - chúng có thể làm cho bài kiểm tra của bạn trở nên dễ vỡ hơn
- Chúng tôi chủ yếu sử dụng
988 vàconst foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
989 tại Airbnb.const foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
990 đôi khi cũng được sử dụng cho các mô-đun nhỏ, riêng biệtconst foo = [1, 2]; const bar = foo; bar[0] = 9; console.log[foo[0], bar[0]]; // => 9, 9
- Phạm vi kiểm tra 100% là một mục tiêu tốt để phấn đấu, ngay cả khi không phải lúc nào cũng thực tế để đạt được nó
- Bất cứ khi nào bạn sửa lỗi, hãy viết bài kiểm tra hồi quy. Một lỗi được sửa mà không kiểm tra hồi quy gần như chắc chắn sẽ lại bị hỏng trong tương lai
⬆ quay lại đầu trang
Màn biểu diễn
⬆ quay lại đầu trang
Tài nguyên
Học ES6+
Đọc này
Công cụ
Hướng dẫn phong cách khác
phong cách khác
Đọc thêm
Sách
Blog
Podcast
⬆ quay lại đầu trang
Trong thế giới hoang dã
Đây là danh sách các tổ chức đang sử dụng hướng dẫn phong cách này. Gửi cho chúng tôi yêu cầu kéo và chúng tôi sẽ thêm bạn vào danh sách
⬆ quay lại đầu trang
Dịch
Hướng dẫn phong cách này cũng có sẵn bằng các ngôn ngữ khác
Hướng dẫn Hướng dẫn Phong cách JavaScript
Trò chuyện với chúng tôi về JavaScript
người đóng góp
Giấy phép
[Giấy phép MIT]
Bản quyền [c] 2012 Airbnb
Theo đây, quyền được cấp miễn phí cho bất kỳ người nào có được bản sao của phần mềm này và các tệp tài liệu liên quan ['Phần mềm'], để xử lý Phần mềm mà không bị hạn chế, bao gồm nhưng không giới hạn các quyền sử dụng, sao chép, sửa đổi, hợp nhất
Thông báo bản quyền ở trên và thông báo cấp phép này sẽ được bao gồm trong tất cả các bản sao hoặc phần quan trọng của Phần mềm
PHẦN MỀM ĐƯỢC CUNG CẤP 'NGUYÊN TRẠNG', KHÔNG CÓ BẢO ĐẢM DƯỚI BẤT KỲ HÌNH THỨC NÀO, RÕ RÀNG HAY NGỤ Ý, BAO GỒM NHƯNG KHÔNG GIỚI HẠN CÁC BẢO ĐẢM VỀ KHẢ NĂNG BÁN ĐƯỢC, SỰ PHÙ HỢP CHO MỘT MỤC ĐÍCH CỤ THỂ VÀ SỰ 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