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!
Top comments (0)