Bộ lọc chữ cái javascript

2. 1 Sử dụng

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

bar[0] = 9;

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

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

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

bar[0] = 9;

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

61,

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

bar[0] = 9;

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

Why? This ensures that you can’t reassign your references, which can lead to bugs and difficult to comprehend code

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

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

2. 2 If you must reassign references, use

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

bar[0] = 9;

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

63 instead of

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

bar[0] = 9;

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

60. eslint.

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

bar[0] = 9;

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

Why?

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

bar[0] = 9;

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

63 is block-scoped rather than function-scoped like

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

bar[0] = 9;

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

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

bar[0] = 9;

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

2. 3 Note that both

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

bar[0] = 9;

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

63 and

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

bar[0] = 9;

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

59 are block-scoped, whereas

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

bar[0] = 9;

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

60 is function-scoped

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

bar[0] = 9;

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

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, 9

71 and

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

bar[0] = 9;

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

72 will produce a ReferenceError, while

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

bar[0] = 9;

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

73 contains the number. This is because

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

bar[0] = 9;

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

71 and

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

bar[0] = 9;

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

72 are block scoped, while

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

bar[0] = 9;

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

73 is scoped to the containing function

⬆back to top

Objects

3. 1 Use the literal syntax for object creation. eslint.

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

bar[0] = 9;

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

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

bar[0] = 9;

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

3. 2 Use computed property names when creating objects with dynamic property names
Why? They allow you to define all the properties of an object in one place
```
const foo = [1, 2];
const bar = foo;

bar[0] = 9;

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

3. 3 Use object method shorthand. eslint.

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

bar[0] = 9;

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

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

bar[0] = 9;

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

3. 4 Use property value shorthand. eslint.

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

bar[0] = 9;

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

Why? It is shorter and descriptive

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

bar[0] = 9;

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

3. 5 Group your shorthand properties at the beginning of your object declaration
Why? It’s easier to tell which properties are using the shorthand
```
const foo = [1, 2];
const bar = foo;

bar[0] = 9;

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

3. 6 Only quote properties that are invalid identifiers. eslint.

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

bar[0] = 9;

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

Why? In general we consider it subjectively easier to read. It improves syntax highlighting, and is also more easily optimized by many JS engines

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

bar[0] = 9;

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

3. 7 Do not call

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

bar[0] = 9;

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

81 methods directly, such as

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

bar[0] = 9;

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

82,

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

bar[0] = 9;

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

83, and

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

bar[0] = 9;

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

84. eslint.

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

bar[0] = 9;

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

Why? These methods may be shadowed by properties on the object in question - consider
const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9
86 - or, the object may be a null object (
const foo = [1, 2];
const bar = foo;

bar[0] = 9;

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

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

bar[0] = 9;

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

3. 8 Prefer the object spread syntax over

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

bar[0] = 9;

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

88 to shallow-copy objects. Use the object rest parameter syntax to get a new object with certain properties omitted. eslint.

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

bar[0] = 9;

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

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

bar[0] = 9;

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

⬆back to top

Arrays

4. 1 Use the literal syntax for array creation. eslint.

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

bar[0] = 9;

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

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

bar[0] = 9;

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

4. 2 Use Array#push instead of direct assignment to add items to an array

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

bar[0] = 9;

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

4. 3 Use array spreads

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

bar[0] = 9;

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

91 to copy arrays

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

bar[0] = 9;

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

4. 4 To convert an iterable object to an array, use spreads

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

bar[0] = 9;

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

91 instead of

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

bar[0] = 9;

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

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

bar[0] = 9;

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

4. 5 Use

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

bar[0] = 9;

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

93 for converting an array-like object to an array

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

bar[0] = 9;

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

4. 6 Use

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

bar[0] = 9;

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

93 instead of spread

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

bar[0] = 9;

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

91 for mapping over iterables, because it avoids creating an intermediate array

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

bar[0] = 9;

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

4. 7 Use return statements in array method callbacks. It’s ok to omit the return if the function body consists of a single statement returning an expression without side effects, following 8. 2. eslint.

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

bar[0] = 9;

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

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

bar[0] = 9;

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

4. 8 Use line breaks after open and before close array brackets if an array has multiple lines
```
// bad
var a = 1;
var b = 2;

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

⬆back to top

Destructuring

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

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9
```
98
Tại sao? . Việc lặp lại quyền truy cập đối tượng tạo ra nhiều mã lặp lại hơn, yêu cầu đọc nhiều hơn và tạo ra nhiều cơ hội mắc lỗi hơn. Destructuring objects also provides a single site of definition of the object structure that is used in the block, rather than requiring reading the entire block to determine what is used
```
// bad
var a = 1;
var b = 2;

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

5. 2 Use array destructuring. eslint.

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

bar[0] = 9;

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

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

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

5. 3 Use object destructuring for multiple return values, not array destructuring
Why? You can add new properties over time or change the order of things without breaking call sites
```
// bad
var a = 1;
var b = 2;

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

⬆back to top

Strings

6. 1 Use single quotes

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

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

00 for strings. eslint.

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

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

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

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

6. 2 Strings that cause the line to go over 100 characters should not be written across multiple lines using string concatenation
Why? Broken strings are painful to work with and make code less searchable
```
// bad
var a = 1;
var b = 2;

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

6. 3 When programmatically building up strings, use template strings instead of concatenation. eslint.

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

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

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

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

Why? Template strings give you a readable, concise syntax with proper newlines and string interpolation features

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

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

6. 4 Never use

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

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

04 on a string, it opens too many vulnerabilities. eslint.

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

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

6. 5 Do not unnecessarily escape characters in strings. eslint.

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

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

Why? Backslashes harm readability, thus they should only be present when necessary

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

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

⬆back to top

Functions

7. 1 Use named function expressions instead of function declarations. eslint.
```
// bad
var a = 1;
var b = 2;

// good
const a = 1;
const b = 2;
```
07
Why? Function declarations are hoisted, which means that it’s easy - too easy - to reference the function before it is defined in the file. This harms readability and maintainability. If you find that a function’s definition is large or complex enough that it is interfering with understanding the rest of the file, then perhaps it’s time to extract it to its own module. Don’t forget to explicitly name the expression, regardless of whether or not the name is inferred from the containing variable (which is often the case in modern browsers or when using compilers such as Babel). This eliminates any assumptions made about the Error’s call stack. (Discussion)
```
// bad
var a = 1;
var b = 2;

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

7. 2 Wrap immediately invoked function expressions in parentheses. dây dẫn.
```
// bad
var a = 1;
var b = 2;

// good
const a = 1;
const b = 2;
```
08
Why? An immediately invoked function expression is a single unit - wrapping both it, and its invocation parens, in parens, cleanly expresses this. Note that in a world with modules everywhere, you almost never need an 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;

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, 9

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, 9

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, 9

91 instead. eslint.

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

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

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

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9
91 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, 9

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, 9

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, 9

7. 9 Always put default parameters last. eslint.

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

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

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

bar[0] = 9;

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

7. 10 Never use the Function constructor to create a new function. eslint.

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

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

Why? Creating a function in this way evaluates a string similarly to
// bad
var a = 1;
var b = 2;

// good
const a = 1;
const b = 2;
04, which opens vulnerabilities

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

bar[0] = 9;

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

7. 11 Spacing in a function signature. eslint.

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

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

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

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

Why? Consistency is good, and you shouldn’t have to add or remove a space when adding or removing a name

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

bar[0] = 9;

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

7. 12 Never mutate parameters. eslint.

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

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

Why? Manipulating objects passed in as parameters can cause unwanted variable side effects in the original caller

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

bar[0] = 9;

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

7. 13 Never reassign parameters. eslint.

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

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

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, 9

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

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

bar[0] = 9;

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

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

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

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

Tại sao?

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

bar[0] = 9;

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

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

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

bar[0] = 9;

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

⬆back to top

Hàm mũi tên

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

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

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

33,

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

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

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, 9

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

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

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

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

bar[0] = 9;

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

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

bar[0] = 9;

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

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

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

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

Tại sao?

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

bar[0] = 9;

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

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

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

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

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

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

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

41,

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

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

42). dây dẫn.

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

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

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

bar[0] = 9;

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

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

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

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

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

bar[0] = 9;

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

⬆back to top

Lớp & Constructor

9. 1 Luôn sử dụng

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

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

45. Avoid manipulating

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

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

46 directly

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

// good
const a = 1;
const b = 2;
45 syntax is more concise and easier to reason about

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

bar[0] = 9;

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

9. 2 Use

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

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

48 for inheritance

Why? It is a built-in way to inherit prototype functionality without breaking
// bad
var a = 1;
var b = 2;

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

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

bar[0] = 9;

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

9. 3 Methods can return

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

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

35 to help with method chaining

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

bar[0] = 9;

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

9. 4 It’s okay to write a custom

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

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

51 method, just make sure it works successfully and causes no side effects

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

bar[0] = 9;

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

9. 5 Các lớp có hàm tạo mặc định nếu không được chỉ định. An empty constructor function or one that just delegates to a parent class is unnecessary. 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, 9
```
22

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

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

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

Tại sao?

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

bar[0] = 9;

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

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

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

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

bar[0] = 9;

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

⬆back to top

mô-đun

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

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

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

56/

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

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

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

Tại sao?

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

bar[0] = 9;

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

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

Tại sao?

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

bar[0] = 9;

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

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

Tại sao?

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

bar[0] = 9;

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

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

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

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

Tại sao?

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

bar[0] = 9;

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

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

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

bar[0] = 9;

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

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

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

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

Tại sao?

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

bar[0] = 9;

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

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

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

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

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

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

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

Tại sao?

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

bar[0] = 9;

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

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

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

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

Tại sao?

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

bar[0] = 9;

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

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

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

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

Tại sao? . Thích sử dụng cú pháp trình tải trong
// bad
var a = 1;
var b = 2;

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

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

bar[0] = 9;

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

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

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

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

Tại sao?

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

bar[0] = 9;

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

⬆back to top

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

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

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

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

68 hoặc

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

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

69. dây dẫn.

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

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

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

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

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

// 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, 9

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

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

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

bar[0] = 9;

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

⬆back to top

Đặc tính

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

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

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

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

bar[0] = 9;

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

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

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

bar[0] = 9;

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

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

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

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

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

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

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

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

bar[0] = 9;

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

⬆back to top

Biến

13. 1 Luôn sử dụng

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

bar[0] = 9;

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

59 hoặc

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

bar[0] = 9;

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

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

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

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

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

bar[0] = 9;

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

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

bar[0] = 9;

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

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

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

bar[0] = 9;

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

59 hoặc

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

bar[0] = 9;

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

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

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

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

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

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

bar[0] = 9;

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

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

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

bar[0] = 9;

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

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

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

bar[0] = 9;

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

63 của bạn

Tại sao?

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

bar[0] = 9;

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

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

Tại sao?

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

bar[0] = 9;

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

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

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

bar[0] = 9;

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

006

Tại sao?

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

bar[0] = 9;

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

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

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

bar[0] = 9;

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

007,

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

bar[0] = 9;

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

008). eslint

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

bar[0] = 9;

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

009

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, 9
010 thay vì
const foo = [1, 2];
const bar = foo;

bar[0] = 9;

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

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9
012 cũng sẽ mang tính biểu cảm hơn. Việc không cho phép các câu lệnh tăng và giảm đơn nguyên cũng ngăn bạn vô tình tăng trước/giảm trước các giá trị, điều này cũng có thể gây ra hành vi không mong muốn trong chương trình của bạn

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

bar[0] = 9;

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

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

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

bar[0] = 9;

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

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

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

bar[0] = 9;

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

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

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

bar[0] = 9;

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

015

Tại sao?

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

bar[0] = 9;

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

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

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

bar[0] = 9;

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

017

Tại sao? . Các biến như vậy chiếm không gian trong mã và có thể khiến người đọc nhầm lẫn

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

bar[0] = 9;

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

⬆back to top

cẩu

14. 1 khai báo

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

bar[0] = 9;

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

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

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

bar[0] = 9;

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

59 và

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

bar[0] = 9;

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

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

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

bar[0] = 9;

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

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

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

bar[0] = 9;

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

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

bar[0] = 9;

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

14. 4 Function declarations hoist their name and the function body

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

bar[0] = 9;

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

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

⬆back to top

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

15. 1 Sử dụng

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

bar[0] = 9;

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

021 và

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

bar[0] = 9;

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

022 thay vì

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

bar[0] = 9;

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

023 và

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

bar[0] = 9;

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

024. dây dẫn.

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

bar[0] = 9;

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

025

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

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

bar[0] = 9;

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

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

bar[0] = 9;

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

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

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

bar[0] = 9;

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

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

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

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

bar[0] = 9;

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

029 và

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

bar[0] = 9;

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

030 có chứa khai báo từ vựng (e. g.

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

bar[0] = 9;

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

63,

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

bar[0] = 9;

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

59,

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

bar[0] = 9;

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

58 và

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

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

45). dây dẫn.

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

bar[0] = 9;

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

035

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, 9
029 cố định nghĩa cùng một thứ

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

bar[0] = 9;

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

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

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

bar[0] = 9;

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

039

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

bar[0] = 9;

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

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

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

bar[0] = 9;

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

040

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

bar[0] = 9;

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

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

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

bar[0] = 9;

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

041,

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

bar[0] = 9;

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

042 và

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

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

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

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

bar[0] = 9;

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

044 và

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

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

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

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

bar[0] = 9;

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

046

Tại sao?

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

bar[0] = 9;

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

⬆back to top

khối

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

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

bar[0] = 9;

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

047

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

bar[0] = 9;

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

16. 2 If you’re using multiline blocks with

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

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

09 and

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

bar[0] = 9;

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

049, put

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

bar[0] = 9;

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

049 on the same line as your

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

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

09 block’s closing brace. dây dẫn.

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

bar[0] = 9;

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

052

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

bar[0] = 9;

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

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

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

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

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

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

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

36, thì khối

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

bar[0] = 9;

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

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

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

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

36 trong một khối

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

bar[0] = 9;

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

057 theo sau một khối

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

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

09 có chứa một

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

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

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

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

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

09. dây dẫn.

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

bar[0] = 9;

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

061

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

bar[0] = 9;

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

⬆back to top

Tuyên bố kiểm soát

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

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

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

bar[0] = 9;

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

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

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

bar[0] = 9;

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

⬆back to top

Bình luận

18. 1 Sử dụng

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

bar[0] = 9;

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

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

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

bar[0] = 9;

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

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

bar[0] = 9;

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

bar[0] = 9;

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

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

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

bar[0] = 9;

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

066

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

bar[0] = 9;

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

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

bar[0] = 9;

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

bar[0] = 9;

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

bar[0] = 9;

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

bar[0] = 9;

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

18. 5 Sử dụng

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

bar[0] = 9;

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

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

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

bar[0] = 9;

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

18. 6 Sử dụng

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

bar[0] = 9;

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

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

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

bar[0] = 9;

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

⬆back to top

Khoảng trắng

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

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

bar[0] = 9;

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

073

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

bar[0] = 9;

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

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

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

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

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

bar[0] = 9;

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

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

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

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

09,

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

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

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

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

bar[0] = 9;

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

077

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

bar[0] = 9;

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

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

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

bar[0] = 9;

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

078

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

bar[0] = 9;

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

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

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

bar[0] = 9;

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

079

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

bar[0] = 9;

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

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

bar[0] = 9;

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

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

bar[0] = 9;

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

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

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

bar[0] = 9;

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

080

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

bar[0] = 9;

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

081

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

bar[0] = 9;

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

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

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

bar[0] = 9;

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

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

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

bar[0] = 9;

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

082

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

bar[0] = 9;

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

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

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

bar[0] = 9;

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

083

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

bar[0] = 9;

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

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

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

bar[0] = 9;

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

084

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

bar[0] = 9;

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

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

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

bar[0] = 9;

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

085

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

bar[0] = 9;

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

19. 12 Add spaces inside curly braces. dây dẫn.

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

bar[0] = 9;

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

086

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

bar[0] = 9;

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

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

bar[0] = 9;

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

bar[0] = 9;

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

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

bar[0] = 9;

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

bar[0] = 9;

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

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

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

bar[0] = 9;

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

089

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

bar[0] = 9;

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

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

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

bar[0] = 9;

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

090

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

bar[0] = 9;

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

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

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

bar[0] = 9;

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

091

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

bar[0] = 9;

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

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

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

bar[0] = 9;

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

092

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

bar[0] = 9;

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

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

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

bar[0] = 9;

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

093

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

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

bar[0] = 9;

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

083

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

bar[0] = 9;

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

⬆back to top

dấu phẩy

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

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

bar[0] = 9;

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

095

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

bar[0] = 9;

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

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

bar[0] = 9;

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

bar[0] = 9;

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

bar[0] = 9;

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

⬆back to top

dấu chấm phẩy

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

bar[0] = 9;

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

bar[0] = 9;

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

⬆back to top

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

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

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

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

bar[0] = 9;

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

098

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

bar[0] = 9;

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

22. 3 số. Sử dụng

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

bar[0] = 9;

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

099 để truyền kiểu và

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

bar[0] = 9;

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

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

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

bar[0] = 9;

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

401

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

bar[0] = 9;

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

098

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, 9
53 hoặc
const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9
405, nó được giả định là
const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9
406 trừ khi số bắt đầu bằng cặp ký tự
const foo = [1, 2];
const bar = foo;

bar[0] = 9;

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

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9
408, trong trường hợp đó cơ số là 16 được giả định. Điều này khác với ECMAScript 3, chỉ đơn thuần là không khuyến khích (nhưng được phép) giải thích bát phân. Nhiều triển khai đã không áp dụng hành vi này kể từ năm 2013. Và, bởi vì các trình duyệt cũ hơn phải được hỗ trợ, hãy luôn chỉ định một cơ số

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

bar[0] = 9;

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

22. 4 If for whatever reason you are doing something wild and

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

bar[0] = 9;

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

400 is your bottleneck and need to use Bitshift for performance reasons, leave a comment explaining why and what you’re doing

const 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. Discussion. Largest signed 32-bit Int is 2,147,483,647
```
const foo = [1, 2];
const bar = foo;

bar[0] = 9;

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

22. 6 Boolean. eslint.

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

bar[0] = 9;

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

098

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

bar[0] = 9;

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

⬆back to top

Naming Conventions

23. 1 Avoid single letter names. Be descriptive with your naming. eslint.

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

bar[0] = 9;

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

411

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

bar[0] = 9;

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

23. 2 Use camelCase when naming objects, functions, and instances. eslint.

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

bar[0] = 9;

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

412

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

bar[0] = 9;

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

23. 3 Use PascalCase only when naming constructors or classes. eslint.

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

bar[0] = 9;

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

413

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

bar[0] = 9;

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

23. 4 Do not use trailing or leading underscores. eslint.
```
const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9
```
414
Why? JavaScript does not have the concept of privacy in terms of properties or methods. Although a leading underscore is a common convention to mean “private”, in fact, these properties are fully public, and as such, are part of your public API contract. This convention might lead developers to wrongly think that a change won’t count as breaking, or that tests aren’t needed. tl;dr. if you want something to be “private”, it must not be observably present
```
const foo = [1, 2];
const bar = foo;

bar[0] = 9;

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

23. 5 Don’t save references to

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

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

35. Use arrow functions or Function#bind

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

bar[0] = 9;

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

23. 6 A base filename should exactly match the name of its default export

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

bar[0] = 9;

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

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

bar[0] = 9;

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

23. 8 Use PascalCase when you export a constructor / class / singleton / function library / bare object

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

bar[0] = 9;

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

23. 9 Acronyms and initialisms should always be all uppercased, or all lowercased
Why? Names are for readability, not to appease a computer algorithm
```
const foo = [1, 2];
const bar = foo;

bar[0] = 9;

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

23. 10 You may optionally uppercase a constant only if it (1) is exported, (2) is a
```
const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9
```
59 (it can not be reassigned), and (3) the programmer can trust it (and its nested properties) to never change
Why? This is an additional tool to assist in situations where the programmer would be unsure if a variable might ever change. UPPERCASE_VARIABLES are letting the programmer know that they can trust the variable (and its properties) not to change
- What about all
```
const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9
```
  59 variables? - This is unnecessary, so uppercasing should not be used for constants within a file. It should be used for exported constants however
- What about exported objects? - Uppercase at the top level of export (e. g.
```
const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9
```
  418) and maintain that all nested properties do not change
```
const foo = [1, 2];
const bar = foo;

bar[0] = 9;

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

⬆back to top

Accessors

24. 1 Accessor functions for properties are not required

24. 2 Do not use JavaScript getters/setters as they cause unexpected side effects and are harder to test, maintain, and reason about. Instead, if you do make accessor functions, use

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

bar[0] = 9;

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

419 and

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

bar[0] = 9;

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

420

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

bar[0] = 9;

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

24. 3 If the property/method is a

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

bar[0] = 9;

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

51, use

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

bar[0] = 9;

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

422 or

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

bar[0] = 9;

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

423

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

bar[0] = 9;

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

24. 4 It’s okay to create

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

bar[0] = 9;

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

424 and

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

bar[0] = 9;

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

425 functions, but be consistent

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

bar[0] = 9;

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

⬆back to top

Events

25. 1 When attaching data payloads to events (whether DOM events or something more proprietary like Backbone events), pass an object literal (also known as a "hash") instead of a raw value. This allows a subsequent contributor to add more data to the event payload without finding and updating every handler for the event. Ví dụ, thay vì
```
const foo = [1, 2];
const bar = foo;

bar[0] = 9;

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

bar[0] = 9;

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

⬆back to top

jQuery

26. 1 Prefix jQuery object variables with a

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

bar[0] = 9;

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

426

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

bar[0] = 9;

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

26. 2 Cache jQuery lookups

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

bar[0] = 9;

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

26. 3 For DOM queries use Cascading

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

bar[0] = 9;

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

427 or parent > child

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

bar[0] = 9;

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

428. jsPerf

26. 4 Use

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

bar[0] = 9;

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

429 with scoped jQuery object queries

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

bar[0] = 9;

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

⬆back to top

ECMAScript 5 Compatibility

27. 1 Refer to Kangax’s ES5 compatibility table

⬆back to top

ECMAScript 6+ (ES 2015+) Styles

28. 1 This is a collection of links to the various ES6+ features

Hàm mũi tên
Classes
Object Shorthand
Object Concise
Object Computed Properties
Template Strings
Destructuring
Default Parameters
Lên đỉnh
Trải rộng mảng
Hãy để và Const
Toán tử lũy thừa
Trình vòng lặp và Trình tạo
mô-đun

28. 2 Không sử dụng các đề xuất TC39 chưa đạt đến giai đoạn 3
Tại sao? . Chúng tôi muốn sử dụng JavaScript và các đề xuất chưa phải là JavaScript

⬆back to top

Thư viện tiêu chuẩn

The Standard Library contains utilities that are functionally broken but remain for legacy reasons

29. 1 Sử dụng

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

bar[0] = 9;

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

430 thay vì toàn cầu

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

bar[0] = 9;

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

431. dây dẫn.

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

bar[0] = 9;

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

432

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, 9

29. 2 Sử dụng

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

bar[0] = 9;

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

434 thay vì toàn cầu

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

bar[0] = 9;

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

435. dây dẫn.

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

bar[0] = 9;

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

432

Why? The global
const foo = [1, 2];
const bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9
435 coerces non-numbers to numbers, returning true for anything that coerces to a finite number. If this behavior is desired, make it explicit

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

bar[0] = 9;

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

⬆back to top

Testing

30. 1 Yup

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

bar[0] = 9;

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

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, 9
```
  438 and
```
const foo = [1, 2];
const bar = foo;

bar[0] = 9;

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

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9
```
  440 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. Một lỗi được sửa mà không kiểm tra hồi quy gần như chắc chắn sẽ lại bị hỏng trong tương lai

⬆back to top

Màn biểu diễn

On Layout & Web Performance
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?

⬆back to top

Resources

Learning ES6+

Latest ECMA spec
ExploringJS
ES6 Compatibility Table
Comprehensive Overview of ES6 Features

Read This

Standard ECMA-262

Tools

Code Style Linters
- ESlint - Airbnb Style . eslintrc
- JSHint - Airbnb Style . jshintrc
Neutrino Preset - @neutrinojs/airbnb

Other Style Guides

Google JavaScript Style Guide
Google JavaScript Style Guide (Old)
jQuery Core Style Guidelines
Principles of Writing Consistent, Idiomatic JavaScript
StandardJS

Other Styles

Naming this in nested functions - Christian Johansen
Conditional Callbacks - Ross Allen
Popular JavaScript Coding Conventions on GitHub - JeongHoon Byun
Multiple var statements in JavaScript, not superfluous - Ben Alman

In the Wild

This is a list of organizations that are using this style guide. Send us a pull request and we'll add you to the list

123erfasst. 123erfasst/javascript
4Catalyzer. 4Catalyzer/javascript
Aan Zee. AanZee/javascript
Airbnb. airbnb/javascript
AloPeyk. AloPeyk
AltSchool. AltSchool/javascript
Apartmint. apartmint/javascript
Ascribe. ascribe/javascript
Avant. 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
Coeur d'Alene Tribe. www. cdatribe-nsn. gov
ComparaOnline. comparaonline/javascript
Compass Learning. compasslearning/javascript-style-guide
DailyMotion. dailymotion/javascript
DoSomething. DoSomething/eslint-config
Digitpaint digitpaint/javascript
Drupal. www. drupal. org
Ecosia. ecosia/javascript
Evernote. evernote/javascript-style-guide
Evolution Gaming. evolution-gaming/javascript
EvozonJs. evozonjs/javascript
ExactTarget. ExactTarget/javascript
Flexberry. Flexberry/javascript-style-guide
Gawker Media. gawkermedia
General Electric. GeneralElectric/javascript
Generation Tux. GenerationTux/javascript
GoodData. gooddata/gdc-js-style
GreenChef. greenchef/javascript
Grooveshark. grooveshark/javascript
Grupo-Abraxas. Grupo-Abraxas/javascript
Happeo. happeo/javascript
Honey. honeyscience/javascript
Chúng tôi thì sao. howaboutwe/javascript
HubSpot. HubSpot/javascript
Hyper. hyperoslo/javascript-playbook
InterCity Group. intercitygroup/javascript-style-guide
Jam3. Jam3/Javascript-Code-Conventions
JSSolutions. JSSolutions/javascript
Kaplan Komputing. kaplankomputing/javascript
KickorStick. kickorstick
Kinetica Solutions. kinetica/javascript
LEINWAND. LEINWAND/javascript
Lonely Planet. lonelyplanet/javascript
M2GEN. M2GEN/javascript
Mighty Spring. mightyspring/javascript
MinnPost. MinnPost/javascript
MitocGroup. MitocGroup/javascript
Muber. muber
National Geographic Society. natgeosociety
NullDev. NullDevCo/JavaScript-Styleguide
Nulogy. nulogy/javascript
Orange Hill Development. orangehill/javascript
Orion Health. orionhealth/javascript
Peerby. Peerby/javascript
Cầu tàu 1. Pier1/javascript
Qotto. Qotto/javascript-style-guide
Phản ứng. phản ứng. org/docs/cách đóng góp. html#style-guide
REI. reidev/js-style-hướng dẫn
Gợn sóng. hướng dẫn kiểu gợn sóng/javascript
Siêu thị của Sainsbury. jsainsburyplc
con chuồn chuồn. màn trập/javascript
nguồn. mã nguồn/javascript
Mức tải trọng. mức tải trọng
StratoDem Analytics. tầng lớp/javascript
ThépPhát triểnKiwi. thépkiwi/javascript
Sinh viênSphere. sinh viên/javascript
SwoopApp. swoopapp/javascript
SysGarage. sysgarage/javascript-style-guide
Syzygy Warszawa. syzygypl/javascript
Mục tiêu. mục tiêu/javascript
thổ địa. địa ngục
TheLadders. TheLadder/javascript
Mọt sách. thenerdery/javascript-tiêu chuẩn
Tomify. tomprats
traiti. traitify/eslint-config-traitify
Công nghệ T4R. Công nghệ T4R/javascript
đô thịSim. thành thị
VoxFeed. VoxFeed/javascript-style-guide
Phòng thu WeBox. weboxstudio/javascript
Weggo. Weggo/javascript
zillow. zillow/javascript
ZocDoc. ZocDoc/javascript

⬆back to top

Dịch

Hướng dẫn phong cách này cũng có sẵn bằng các ngôn ngữ khác

tiếng Bồ Đào Nha của người brazi. armoucar/javascript-style-guide
tiếng Bungari. borislavvv/javascript
tiếng Catalunya. fpmweb/javascript-style-guide
Tiếng Trung (Giản thể). lin-123/javascript
Truyền thống Trung Hoa). ghép hình/javascript
người Pháp. nmussy/javascript-style-guide
tiếng Đức. timofurrer/javascript-style-guide
người Ý. sinkswim/javascript-style-guide
tiếng Nhật. mitsuruog/javascript-style-guide
Hàn Quốc. ParkSB/javascript-style-guide
tiếng Nga. leonid lebedev/javascript-airbnb
người Tây Ban Nha. paolocarrasco/javascript-style-guide
tiếng Thái. lvarayut/javascript-style-guide
Thổ Nhĩ Kỳ. eraycetinay/javascript
tiếng Ukraina. Ivanzusko/javascript
Việt Nam. dangkyokhoang/javascript-style-guide

Hướng dẫn Hướng dẫn Phong cách JavaScript

Tài liệu tham khảo

Trò chuyện với chúng tôi về JavaScript

Tìm chúng tôi trên gitter

người đóng góp

Xem cộng tác viên

Giấy phép

(Giấy phép MIT)

Theo đây, quyền được cấp miễn phí cho bất kỳ người nào có được bản sao của phần mềm này và các tệp tài liệu liên quan ('Phần mềm'), để xử lý Phần mềm mà không bị hạn chế, bao gồm nhưng không giới hạn các quyền sử dụng, sao chép, sửa đổi, hợp nhất

Thông báo bản quyền ở trên và thông báo cấp phép này sẽ được bao gồm trong tất cả các bản sao hoặc phần quan trọng của Phần mềm

PHẦN MỀM ĐƯỢC CUNG CẤP 'NGUYÊN TRẠNG', KHÔNG CÓ BẢO ĐẢM DƯỚI BẤT KỲ HÌNH THỨC NÀO, RÕ RÀNG HAY NGỤ Ý, BAO GỒM NHƯNG KHÔNG GIỚI HẠN CÁC BẢO ĐẢM VỀ KHẢ NĂNG BÁN ĐƯỢC, TÍNH 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

⬆back to top

sửa đổi

Chúng tôi khuyến khích bạn rẽ nhánh hướng dẫn này và thay đổi các quy tắc để phù hợp với hướng dẫn phong cách của nhóm bạn. Dưới đây, bạn có thể liệt kê một số sửa đổi đối với hướng dẫn phong cách. Điều này cho phép bạn cập nhật định kỳ hướng dẫn phong cách của mình mà không phải xử lý xung đột hợp nhất

programming javascript

Bộ lọc chữ cái javascript

Objects

Arrays

Destructuring

Strings

Functions

Hàm mũi tên

Lớp & Constructor

mô-đun

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

Đặc tính

Biến

cẩu

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

khối

Tuyên bố kiểm soát

Bình luận

Khoảng trắng

dấu phẩy

dấu chấm phẩy

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

Naming Conventions

Accessors

Events

jQuery

ECMAScript 5 Compatibility

ECMAScript 6+ (ES 2015+) Styles

Thư viện tiêu chuẩn

Testing

Màn biểu diễn

Resources

In the Wild

Dịch

Hướng dẫn Hướng dẫn Phong cách JavaScript

Trò chuyện với chúng tôi về JavaScript

người đóng góp

Giấy phép

sửa đổi

Bài Viết Liên Quan

Quảng Cáo

Có thể bạn quan tâm

Toplist được quan tâm

Quảng cáo

Xem Nhiều

Quảng cáo

Chúng tôi

Điều khoản

Trợ giúp

Mạng xã hội