When writing code, one of the most overlooked yet critical aspects is naming.

The names we choose for variables, functions, classes, and other entities in our code can significantly impact readability, maintainability, and overall quality.

Chapter 2 of Clean Code delves into the art and science of choosing meaningful names, providing a set of guidelines that can help developers write code that is both expressive and understandable.

In this blog post, we’ll explore the key takeaways from this chapter, illustrating each concept with examples in JavaScript.

?1. Use Intention-Revealing Names

The names you choose should clearly convey the intent behind the variable, function, or class. The reader should be able to understand what the code does without needing additional context.

// Bad
let d; 

// Good
let daysUntilDeadline;

In the first example, d is vague and provides no context. The improved version, daysUntilDeadline, clearly indicates what the variable represents.

?2. Avoid Disinformation

Names should not be misleading. Avoid using names that might imply a different meaning than what the code actually does.

// Bad
let accountList = new Map();

// Good
let accountsMap = new Map();

Here, accountList could be misleading because it suggests a list (which is an ordered collection), whereas the actual data structure is a Map. Using accountsMap is more accurate.

?3. Make Meaningful Distinctions

If you need to differentiate between similar variables, functions, or classes, do so in a way that makes the distinction clear and meaningful.

// Bad
getUserInfo();
getUserData();

// Good
getUserProfile();
getUserSettings();

In the first example, getUserInfo and getUserData are too similar and don’t clearly convey their differences. The second example clarifies the distinction by naming the functions based on what they return.

?4. Use Pronounceable Names

Names should be easy to read and pronounce. This makes discussing the code with others more straightforward.

// Bad
let genymdhms;

// Good
let generationTimestamp;

genymdhms is a non-pronounceable name that would be difficult to remember or discuss. generationTimestamp, however, is clear and easy to say.

?5. Use Searchable Names

In larger codebases, it’s important to use names that are easy to search for. Avoid using single-letter names or overly abbreviated names.

// Bad
let e = document.getElementById('email');

// Good
let emailInputElement = document.getElementById('email');

e is not easily searchable, and it doesn’t convey what it represents. emailInputElement is more descriptive and easier to locate in the codebase.

?6. Avoid Encodings

Avoid including types, prefixes, or other encodings in your names. Let the name itself be descriptive enough.

// Bad
let phoneString;

// Good
let phoneNumber;

In this case, phoneString includes an unnecessary type encoding (String). phoneNumber is simpler and more direct.

?7. Class Names Should Be Nouns, Function Names Should Be Verbs

Classes represent objects or concepts, so their names should be nouns. Functions, on the other hand, represent actions, so their names should be verbs.

// Class names (Nouns)
class UserAccount {}
class ShoppingCart {}

// Function names (Verbs)
function calculateTotal() {}
function sendEmail() {}

This distinction helps in understanding the role of each element in your code.

?8. Avoid Mental Mapping

Don’t force the reader to translate a name into something more meaningful. The name should be self-explanatory.

// Bad
let n = 5; // Number of users

// Good
let userCount = 5;

n requires the reader to remember or deduce that it stands for the number of users, whereas userCount is immediately clear.

Conclusion ⚡

Choosing meaningful names is more than just a matter of style—it's a fundamental practice in writing clean, maintainable code.

By following the guidelines outlined in Chapter 2 of Clean Code, you can improve the readability of your JavaScript code and make it easier for others (and yourself) to understand and maintain.

Remember, the goal is to write code that communicates its purpose and logic, reducing the cognitive load on the reader.

The next time you name a variable, function, or class, consider the principles of meaningful naming and how they can contribute to cleaner, more effective code.

Happy Coding!