Essential JavaScript Coding Standards for Clean, Maintainable Code

Code is not only for machines but also for human readability and maintenance; in team collaboration, readability, maintainability, and consistency are crucial. For the flexible JavaScript language, coding standards are indispensable, and the following key guidelines are shared.

1. Naming Conventions

Use camelCase for variables and functions, PascalCase for class names, and UPPER_CASE_WITH_UNDERSCORES for constants.

// Good example
const MAX_COUNT = 10;
let userName = 'Alice';
function calculateTotal() {}
class UserProfile {}

// Bad example
let user_name = 'Alice';
function calculate_total() {}

2. Use Strict Mode

Add 'use strict' at the top of files to avoid common programming errors.

'use strict';

function doSomething() {
    // implementation
}

3. Variable Declarations

Prefer const, then let; avoid var. Ensure variables are declared before use.

// Good example
const PI = 3.14159;
let count = 1;

// Bad example
var name = 'John';

4. Code Indentation

Use a consistent indentation style, recommending 2 or 4 spaces (no tabs).

function example() {
    if (condition) {
        doSomething();
    }
}

5. Semicolon Usage

Terminate every statement with a semicolon to avoid issues with automatic semicolon insertion.

// Good example
let message = 'Hello';
console.log(message);

// Bad example
let message = 'Hello'
console.log(message)

6. String Usage

Prefer single quotes or backticks for consistency; use template literals for string concatenation.

// Good example
const name = 'John';
const greeting = `Hello, ${name}!`;

// Bad example
const name = "John";
const greeting = 'Hello, ' + name + '!';

7. Spacing Rules

Insert spaces around operators to improve readability.

8. Comment Guidelines

Add necessary comments for functions and complex logic, using JSDoc style.

9. Module Import/Export

Use ES6 module syntax and explicitly specify imported content.

10. Conditional Statements

Prefer ternary operators for simple if‑else cases; keep if‑else structures for complex logic.

11. Asynchronous Handling

Prefer async/await for asynchronous operations to improve readability.

12. Arrays and Objects

Use destructuring assignment and spread operators for concise code.

13. Error Handling

Use try‑catch blocks to handle potential errors and provide meaningful messages.

14. Function Guidelines

Functions should be short, follow the single‑responsibility principle, and have no more than three parameters; use an object parameter when more are needed.

15. Performance Considerations

Avoid creating functions inside loops; use debounce and throttle to control frequent operations.

// Good example
const debounced = debounce(() => {
    // handling logic
}, 300);

// Bad example
for (let i = 0; i < 1000; i++) {
    const handler = () => console.log(i);
}

Feel free to add more suggestions.