Clean Code Principles

Clean code is code that's easy to understand and easy to change. Here's how to write it.

Meaningful Names

Names should reveal intent:

// Bad
const d = new Date();
const x = users.filter(u => u.a > 18);

// Good
const currentDate = new Date();
const adultUsers = users.filter(user => user.age > 18);

Functions Should Do One Thing

// Bad - does too much
function processUser(user) {
 validateUser(user);
 saveToDatabase(user);
 sendWelcomeEmail(user);
 updateAnalytics(user);
}

// Good - single responsibility
function createUser(userData) {
 const user = validateUser(userData);
 return saveUser(user);
}

// Then compose
async function onUserSignup(userData) {
 const user = await createUser(userData);
 await sendWelcomeEmail(user);
 await trackSignup(user);
}

Keep Functions Small

If a function doesn't fit on your screen, it's too long.

// Break into smaller functions
function calculateOrderTotal(order) {
 const subtotal = calculateSubtotal(order.items);
 const tax = calculateTax(subtotal, order.taxRate);
 const shipping = calculateShipping(order.items, order.address);
 return subtotal + tax + shipping;
}

Avoid Comments - Write Self-Documenting Code

// Bad - comment explains what code does
// Check if user is an admin
if (user.role === 1) { ... }

// Good - code explains itself
const isAdmin = user.role === ROLES.ADMIN;
if (isAdmin) { ... }

DRY - Don't Repeat Yourself

// Bad - repetition
function validateEmail(email) {
 const regex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
 return regex.test(email);
}

function validateEmailField(email) {
 const regex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
 if (!regex.test(email)) throw new Error('Invalid email');
}

// Good - reuse
const EMAIL_REGEX = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;

function isValidEmail(email) {
 return EMAIL_REGEX.test(email);
}

function validateEmail(email) {
 if (!isValidEmail(email)) {
 throw new Error('Invalid email');
 }
}

Error Handling

Handle errors explicitly:

// Bad
try {
 doSomething();
} catch (e) {
 console.log(e);
}

// Good
try {
 await processPayment(order);
} catch (error) {
 logger.error('Payment failed', { orderId: order.id, error });
 throw new PaymentError('Payment processing failed', { cause: error });
}

The Boy Scout Rule

Leave code cleaner than you found it. Every commit should improve something.

Conclusion

Clean code takes practice. Review your code, get feedback, and continuously improve. Your team will thank you.