Understanding Clean Code: Functions ⚡
In software development, functions are the building blocks of any application. They are the primary way we structure our logic, encapsulate behavior, and divide complex tasks into manageable pieces.
However, not all functions are created equal. In Chapter 3 of Clean Code, the focus is on writing tasks that are small, focused, and do one thing well.
In this article, we'll dive into these principles and explore how to apply them in JavaScript.
?1. Small Functions: Less Is More
One core tenet of Clean Code is that functions should be small.
But what does "small" mean in this context? The author advocates for functions that are typically only a few lines long.
The idea is that a small function is easier to understand, test, and maintain.
Let's look at an example in JavaScript:
// Bad Example: A large, unfocused function
function processOrder(order) {
applyDiscount(order);
calculateShipping(order);
calculateTax(order);
generateInvoice(order);
sendConfirmationEmail(order);
updateInventory(order);
}
This function, while seemingly straightforward, does too much. Each of these tasks could and should be broken down into its own function.
// Good Example: Small, focused functions
function processOrder(order) {
applyDiscount(order);
calculateShipping(order);
calculateTax(order);
generateInvoice(order);
sendConfirmationEmail(order);
updateInventory(order);
}
function applyDiscount(order) {
// Discount logic
}
function calculateShipping(order) {
// Shipping calculation logic
}
function calculateTax(order) {
// Tax calculation logic
}
function generateInvoice(order) {
// Invoice generation logic
}
function sendConfirmationEmail(order) {
// Email sending logic
}
function updateInventory(order) {
// Inventory update logic
}
In the revised example, each function does one thing, making the code easier to read and maintain.
The processOrder function now serves as a high-level orchestrator, while smaller, more focused functions handle the details.
?2. Do One Thing
A function should do one thing and do it well. If you find yourself writing a function that performs multiple tasks, it's a sign that you should refactor it into smaller functions.
Here's an example:
// Bad Example: A function doing multiple things
function formatAndSendEmail(email, subject, message) {
const formattedMessage = `<html><body>${message}</body></html>`;
sendEmail(email, subject, formattedMessage);
}
While this function seems concise, it's doing two things: formatting the message and sending the email. Instead, break it down:
// Good Example: Functions doing one thing
function formatMessage(message) {
return `<html><body>${message}</body></html>`;
}
function sendFormattedEmail(email, subject, message) {
const formattedMessage = formatMessage(message);
sendEmail(email, subject, formattedMessage);
}
Now, each function has a single responsibility, which makes the code easier to test and reuse.
The formatMessage function can be tested independently of the email-sending logic.
?3. Avoid Side Effects
Functions should minimize side effects, meaning they shouldn't alter the state of the system in unexpected ways. Functions with side effects can be harder to debug and reason about.
Here's an example:
// Bad Example: A function with a side effect
let globalCounter = 0;
function incrementCounter() {
globalCounter++;
}
The incrementCounter function changes the global state, which can lead to bugs if not carefully managed.
A better approach is to return a new value and let the caller decide what to do with it:
// Good Example: Avoiding side effects
function incrementCounter(counter) {
return counter + 1;
}
globalCounter = incrementCounter(globalCounter);
By avoiding side effects, you make your functions more predictable and easier to work with.
?4. Single Level of Abstraction
Functions should operate at a single level of abstraction. Mixing different levels of detail within the same function can make it harder to understand.
For example:
// Bad Example: Mixed levels of abstraction
function getUserData(userId) {
const user = database.fetchUserById(userId); // Low-level
return `${user.firstName} ${user.lastName} (${user.email})`; // High-level
}
Here, the function mixes the low-level database fetch with the high-level formatting of user data.
It’s better to separate these concerns:
// Good Example: Single level of abstraction
function getUser(userId) {
return database.fetchUserById(userId);
}
function formatUserData(user) {
return `${user.firstName} ${user.lastName} (${user.email})`;
}
const user = getUser(userId);
const formattedUserData = formatUserData(user);
Now, each function operates at a single level of abstraction, making the code clearer and easier to maintain.
Conclusion ⚡
Writing clean functions is a cornerstone of writing maintainable code.
By keeping functions small, ensuring they do one thing, avoiding side effects, and maintaining a single level of abstraction, you can create code that is easier to read, understand, and maintain.
As you continue to hone your skills in JavaScript, keep these principles from Clean Code in mind to write functions that truly embody the art of simplicity and clarity.
The above is the detailed content of Understanding Clean Code: Functions ⚡. For more information, please follow other related articles on the PHP Chinese website!
Hot AI Tools
Undress AI Tool
Undress images for free
Undresser.AI Undress
AI-powered app for creating realistic nude photos
AI Clothes Remover
Online AI tool for removing clothes from photos.
Clothoff.io
AI clothes remover
Video Face Swap
Swap faces in any video effortlessly with our completely free AI face swap tool!
Hot Article
Hot Tools
Notepad++7.3.1
Easy-to-use and free code editor
SublimeText3 Chinese version
Chinese version, very easy to use
Zend Studio 13.0.1
Powerful PHP integrated development environment
Dreamweaver CS6
Visual web development tools
SublimeText3 Mac version
God-level code editing software (SublimeText3)
Advanced Conditional Types in TypeScript
Aug 04, 2025 am 06:32 AM
TypeScript's advanced condition types implement logical judgment between types through TextendsU?X:Y syntax. Its core capabilities are reflected in the distributed condition types, infer type inference and the construction of complex type tools. 1. The conditional type is distributed in the bare type parameters and can automatically split the joint type, such as ToArray to obtain string[]|number[]. 2. Use distribution to build filtering and extraction tools: Exclude excludes types through TextendsU?never:T, Extract extracts commonalities through TextendsU?T:Never, and NonNullable filters null/undefined. 3
Generate Solved Double Chocolate Puzzles: A Guide to Data Structures and Algorithms
Aug 05, 2025 am 08:30 AM
This article explores in-depth how to automatically generate solveable puzzles for the Double-Choco puzzle game. We will introduce an efficient data structure - a cell object based on a 2D grid that contains boundary information, color, and state. On this basis, we will elaborate on a recursive block recognition algorithm (similar to depth-first search) and how to integrate it into the iterative puzzle generation process to ensure that the generated puzzles meet the rules of the game and are solveable. The article will provide sample code and discuss key considerations and optimization strategies in the generation process.
How can you remove a CSS class from a DOM element using JavaScript?
Aug 05, 2025 pm 12:51 PM
The most common and recommended method for removing CSS classes from DOM elements using JavaScript is through the remove() method of the classList property. 1. Use element.classList.remove('className') to safely delete a single or multiple classes, and no error will be reported even if the class does not exist; 2. The alternative method is to directly operate the className property and remove the class by string replacement, but it is easy to cause problems due to inaccurate regular matching or improper space processing, so it is not recommended; 3. You can first judge whether the class exists and then delete it through element.classList.contains(), but it is usually not necessary; 4.classList
Vercel SPA routing and resource loading: Solve deep URL access issues
Aug 13, 2025 am 10:18 AM
This article aims to solve the problem of deep URL refresh or direct access causing page resource loading failure when deploying single page applications (SPAs) on Vercel. The core is to understand the difference between Vercel's routing rewriting mechanism and browser parsing relative paths. By configuring vercel.json to redirect all paths to index.html, and correct the reference method of static resources in HTML, change the relative path to absolute path, ensuring that the application can correctly load all resources under any URL.
Vercel Single Page Application (SPA) Deployment Guide: Solving Deep URL Asset Loading Issues
Aug 13, 2025 pm 01:03 PM
This tutorial aims to solve the problem of loading assets (CSS, JS, images, etc.) when accessing multi-level URLs (such as /projects/home) when deploying single page applications (SPAs) on Vercel. The core lies in understanding the difference between Vercel's routing rewriting mechanism and relative/absolute paths in HTML. By correctly configuring vercel.json, ensure that all non-file requests are redirected to index.html and correcting asset references in HTML as absolute paths, thereby achieving stable operation of SPA at any depth URL.
The Module Pattern in JavaScript: A Practical Guide
Aug 05, 2025 am 09:37 AM
ThemodulepatterninjavascriptsolvestheProbllobalscopepollutionandandandandandandandandandlackofencapsulation byusingClosuresandiifestocreatePrivat EvariaBlesandExPosonTrolledPublicapi; 1) IthidesInternal DataStusersandvalidatenamewithinacloslosloslosloslosloslus
Qwik: A Resumable Framework for Instant-Loading Web Apps
Aug 15, 2025 am 08:25 AM
Qwikachievesinstantloadingbydefaultthroughresumability,nothydration:1)TheserverrendersHTMLwithserializedstateandpre-mappedeventlisteners;2)Norehydrationisneeded,enablingimmediateinteractivity;3)JavaScriptloadson-demand,onlywhenuserinteractionoccurs;4
js add element to start of array
Aug 14, 2025 am 11:51 AM
In JavaScript, the most common method to add elements to the beginning of an array is to use the unshift() method; 1. Using unshift() will directly modify the original array, you can add one or more elements to return the new length of the added array; 2. If you do not want to modify the original array, it is recommended to use the extension operator (such as [newElement,...arr]) to create a new array; 3. You can also use the concat() method to combine the new element array with the original number, return the new array without changing the original array; in summary, use unshift() when modifying the original array, and recommend the extension operator when keeping the original array unchanged.
