Coding Standards

What is Coding Standards and Guidelines?

Good software development teams want their programmers to follow a clear and consistent way of writing code, called coding standards. Each organization usually creates its own standards and guidelines based on the type of software they build. It’s important for programmers to follow these standards, because code that doesn’t meet them can be rejected during a code review.

Purpose of Coding Standards:

• They make code written by different programmers look consistent.

• They improve readability, maintainability, and reduce complexity.

• They make it easier to reuse code and find errors.

• They encourage good programming practices and help programmers work more efficiently.

Example:

Copy

// Not Correct: vulnerable to injection
app.get('/user/:id', (req, res) => {
    const sql = `SELECT * FROM users WHERE id=${req.params.id}`;
    db.query(sql, (err, result) => res.send(result));
});

// Correct: safe parameterized query
app.get('/user/:id', (req, res) => {
    const sql = 'SELECT * FROM users WHERE id = ?';
    db.query(sql, [req.params.id], (err, result) => res.send(result));
});

Why: Using parameterized queries prevents SQL injection attacks, making the code secure.

1. Indentation & Formatting

Proper indentation and spacing make code readable and maintainable.

Wrapping Lines:

• Break lines after a comma or operator.

• Prefer higher-level breaks than lower-level breaks.

• Align new lines with the beginning of the previous expression.

White Spaces:

• Use Tabs for indentation, not spaces.

• Proper spacing makes code easier to read.

Blank Lines:

• Two blank lines between logical sections, class/interface definitions.

• One blank line between methods, properties, local variables, or logical sections inside a method.

Inter-term spacing:

• Single space after a comma or semicolon.

Table-like formatting:

• Align code logically for readability.

Example:

Copy

// Not Correct
const users=[{name:"John"},{name:"Jane"}];function add(a,b){return a+b}

// Correct
const users = [
	user = { name: "John" },
	user = { name: "Jane" }
];

function add(a, b) {
	return a + b;
}

Why: Proper formatting and spacing make code easy to scan, reducing mistakes and improving collaboration.

---

2. Inline Comments

All comments should be write by English

Internal Code Comments

• Single-line comments: Describe a single line or block.

• Multi-line comments: Explain complex logic in detail.

Documentation Comments

• All non-private classes, interfaces, methods, and properties should have documentation tags.

• These comments generate documentation automatically (e.g., JSDoc for Node.js).

Best Practices:

• Be concise but clear.

• Explain why, not what.

• Keep comments updated.

• Avoid redundancy.

• Use a consistent style.

Example:

Copy

// Not Correct
function multiply(a,b){return a*b} // multiply

// Correct
// Calculate the area of a rectangle
function calculateArea(width, height) {
	return width * height;
}

/**
 * Calculates total price including tax.
 * @param {number} price - base price
 * @param {number} taxRate - tax rate
 * @returns {number} total price
 */
function calculateTotal(price, taxRate) {
	return price + price * taxRate;
}

Why: Comments should explain the reasoning behind the code and make it understandable to others.

---

3. Global Variables Usage

• Minimize global variables to avoid conflicts and unintended side effects.

• Prefer constants or local variables inside functions or classes.

Example:

Copy

// Not Correct
var counter = 0;

// Correct
function incrementCounter() {
	let counter = 0; // local variable
	counter++;
}

Why: Using local variables prevents bugs caused by accidental overwrites in other parts of the program.

---

4. Naming Conventions

• Variables & functions: camelCase (userList, addUser)

• Classes: PascalCase (UserManager)

• Constants: UPPER_CASE (MAX_USERS)

• Avoid digits in variable names.

Example:

Copy

// Not Correct
const maxusers = 10;
class usermanager {}
let Users = [];
function adduser() {}

// Correct
const MAX_USERS = 10;
class UserManager {}
let users = [];
function addUser() {}

Why:

• Makes the purpose of variables and functions clear.

• Avoids confusion, improves readability, and makes it easy to locate files.

---

5. Structured Programming

• Break complex problems into smaller functions or modules.

• Each function should have a single responsibility.

• Use clear control flow structures.

Example:

Copy

// Not Correct
function processOrder(order) {
	validate(order); saveOrder(order); sendEmail(order); log(order);
}

// Correct
function validateOrder(order) { /*...*/ }
function saveOrder(order) { /*...*/ }
function sendOrderEmail(order) { /*...*/ }
function logOrder(order) { /*...*/ }

Why: Small functions are easier to test, maintain, and reuse in other parts of the project.

---

6. Error and Exception Handling

• Implement proper error handling.

• Use try-catch for exceptions.

• Avoid using exceptions for regular control flow.

Example:

Copy

// Not Correct
const result = divide(a, b);

// Correct
try {
	const result = divide(a, b);
} catch (err) {
	console.error("Error: Cannot divide by zero");
}

Why: Proper handling prevents crashes and makes debugging easier.

---

7. Coding Guidelines Summary

• Avoid difficult-to-read code.

• Follow language-specific style guides.

• Write well-documented, commented code.

• Use consistent spacing and line breaks.

• Keep functions small and modular.

• Conduct code reviews for quality.

• Avoid excessive use of third-party libraries.

• Never hard-code sensitive information.

---

8. Five Pillars of Code Quality

1. Readability

Copy

// Not Correct
const fn=u=>u.f+' '+u.l

// Correct
function getUserFullName(user) {
	return `${user.firstName} ${user.lastName}`;
}
// Why: Clear naming and readable format improves understanding

2. Maintainability

Copy

// Not Correct
function discount(price){return price*0.9}

// Correct
function calculateDiscount(price, rate = 0.1) {
	return price * (1 - rate);
}
// Why: Function is flexible and easier to modify

3. Reusability

Copy

// Not Correct
function sumTwoNumbers(a,b){return a+b}

// Correct
function sum(a, b) { return a + b; }
// Why: Can be reused in multiple contexts

4. Reliability

Copy

// Not Correct
function safeDivide(a,b){return a/b}

// Correct
function safeDivide(a, b) {
	if (b === 0) return null;
	return a / b;
}
// Why: Prevents runtime errors from invalid inputs

5. Performance Efficiency

Copy

// Not Correct
for(let i=0;i<arr.length;i++){}

// Correct
for(let i=0, len=arr.length; i<len; i++) {}
// Why: Avoids repeatedly accessing array length in the loop

---

9. Additional Node.js Guidelines

Version Control

Copy

# Not Correct
git commit -m "update"

# Correct
git checkout -b feature/login
git commit -m "feat: add login functionality"

Why: Clear commits make it easier to track changes and collaborate.

Testing

Copy

// Not Correct
test('sum test', ()=>{expect(sum(2,3)).toBe(5)})

// Correct
test('adds 2 + 3 to equal 5', () => {
	expect(sum(2, 3)).toBe(5);
});

Why: Proper test names describe the functionality and simplify debugging.

Security

Copy

// Not Correct
app.get('/user/:id', (req,res)=>{db.query(`SELECT * FROM users WHERE id=${req.params.id}`)})

// Correct
app.get('/user/:id', (req,res)=>{
	const sql = 'SELECT * FROM users WHERE id = ?';
	db.query(sql, [req.params.id], (err,result)=>res.send(result));
});

Why: Prevents SQL injection attacks and protects user data.

Documentation

Copy

# Not Correct
User module

# Correct
# User Module
Handles user registration, login, and profile updates

Why: Clear module documentation helps team members understand functionality quickly.

CI/CD

Copy

# Not Correct
steps:
- run: npm install
- run: npm build

# Correct
steps:
- run: npm install
- run: npm test
- run: npm build

Why: Running tests in CI ensures code quality before deployment.

Tools

Copy

# Not Correct
node app.js

# Correct
eslint src/**/*.js
prettier --write src/**/*.js

Why: Linting and formatting enforce consistent coding standards and prevent common errors.

---

10. ESLint configurations

1. No Console Logs

Config:

Copy

rules: {
  "no-console": ["error", { "allow": ["warn", "error"] }]
}

Code:

Copy

// Bad
console.log("Debugging...");

// Good
console.warn("This might be an issue.");
console.error("Something went wrong!");

Why: console.log often sneaks into production → messy logs + possible security leaks. Use warn/error (or a logger like winston) instead.

---

2. Semicolons

Config:

Copy

rules: {
  "semi": ["error", "always"]
}

Code:

Copy

// Bad
const name = "Alice"

// Good
const name = "Alice";

Why: Semicolons prevent Automatic Semicolon Insertion bugs, which can cause runtime errors.

---

3. Quotes

Config:

Copy

rules: {
  "quotes": ["error", "single"]
}

Code:

Copy

// Bad
const msg = "Hello world";

// Good
const msg = 'Hello world';

Why: Consistent quoting style improves readability and avoids unnecessary diffs.

---

4. Indentation

Config:

Copy

rules: {
  "indent": ["error", 2]
}

Code:

Copy

// Bad
if (true) {
     console.log("Too many spaces");
}

// Good
if (true) {
  console.log("Nice indentation");
}

Why: Consistent indentation makes code easier to scan and reduces confusion in nested logic.

---

5. Trailing Commas

Config:

Copy

rules: {
  "comma-dangle": ["error", "always-multiline"]
}

Code:

Copy

// Bad
const arr = [
  1,
  2
];

// Good
const arr = [
  1,
  2,
];

Why: Trailing commas make Git diffs cleaner when adding new items.

---

6. Curly Braces

Config:

Copy

rules: {
  "curly": ["error", "all"]
}

Code:

Copy

// Bad
if (isActive) doSomething();

// Good
if (isActive) {
  doSomething();
}

Why: Always using {} prevents hidden bugs when adding more statements later.

---

7. Strict Equality

Config:

Copy

rules: {
  "eqeqeq": ["error", "always"]
}

Code:

Copy

// Bad
if (userId == "5") {}

// Good
if (userId === "5") {}

Why: == does type coercion ("5" == 5 → true). === is strict → safer and less confusing.

---

8. No Unused Variables

Config:

Copy

rules: {
  "no-unused-vars": ["warn"]
}

Code:

Copy

// Bad
const temp = "Not used";

// Good
const user = "Alice";
console.log(user);

Why: Dead code makes projects harder to maintain and can hide bugs.

---

9. No Duplicate Imports

Config:

Copy

rules: {
  "no-duplicate-imports": "error"
}

Code:

Copy

// Bad
import fs from "fs";
import { readFile } from "fs";

// Good
import fs, { readFile } from "fs";

Why: Duplicate imports clutter the code and confuse readers.

---

10. No var, Prefer const

Config:

Copy

rules: {
  "no-var": "error",
  "prefer-const": "error"
}

Code:

Copy

// Bad
var count = 0;
let name = "Alice";

// Good
const count = 0;
let name = "Alice"; // only use let if value changes

Why:

• var has weird scoping issues (hoisting).

• const signals values that never change → safer.

---

11. Import Order

Config:

Copy

rules: {
  "import/order": ["error", {
    "groups": [["builtin", "external", "internal"]],
    "alphabetize": { "order": "asc", "caseInsensitive": true }
  }]
}

Code:

Copy

// Bad
import z from "./z";
import fs from "fs";
import a from "./a";

// Good
import fs from "fs";  // built-in
import a from "./a";  // local
import z from "./z";  // local

Why: Organized imports make dependencies easy to scan.

---

12. React Refresh Rule

Config:

Copy

rules: {
  "react-refresh/only-export-components": [
    "warn",
    { allowConstantExport: true }
  ]
}

Code:

Copy

// Bad
export const userId = 123;

// Good
export function App() {
  return <div>Hello</div>;
}

Why: Prevents exporting random values that break React Fast Refresh (hot reloading).