“`html
Booleans: Simple, But Tricky!
Booleans. They seem so simple, right? Just true or false. What could possibly go wrong? Well, it turns out, a lot! After coding for many years, I’ve learned to be very careful when using them.
I’m John, by the way, and this is my take on how to handle Booleans. I even try to avoid them when I can! They can get confusing with all the negations and comparisons. But they’re also a fundamental part of programming, so we can’t just ignore them.
So, here are five rules I try to follow when I have to use Booleans. Let’s dive in!
Rule #1: Stay Positive!
When naming your Boolean variables, try to keep them positive. This means the variable should be true when something is happening or is working.
For example, it’s better to use UserIsAuthorized:
if (UserIsAuthorized) {
// Do something
}
Than something like !UserIsNotAuthorized:
if (!UserIsNotAuthorized) {
// Do something
}
It’s just easier to read and understand. Double negatives are confusing!
Lila: John, what’s a “double negative” in this case?
John: Good question, Lila! A double negative is like saying “not not allowed.” It’s confusing because “not allowed” means forbidden, but “not not allowed” means permitted! It’s the same with Booleans. Using “is not unauthorized” is harder to understand than simply saying “is authorized.”
Rule #2: Put Positive First
When you use an if...else statement, put the “positive” or “happy” scenario first. Our brains like to follow the happy path! It makes the code easier to read. Don’t do this:
if (!Authorized) {
// bad stuff
} else {
// good stuff
}
Instead, do this:
if (Authorized) {
// Things are okay
} else {
// Go away!!
}
It’s much easier to process because you don’t have to think about the “not” right away.
Rule #3: No Complex Expressions!
This one is about making your code super clear. Instead of putting a bunch of conditions all in one line, break them down into smaller, named variables.
Don’t do this:
if (user.age > 18 && user.isActive && !user.isBanned && user.subscriptionLevel >= 2) {
grantAccess();
}
Do this instead:
const isAdult = user.age > 18;
const hasAccess = !user.isBanned;
const isActive = user.isActive;
const isSubscriber = user.subscriptionLevel >= 2;
const canAccess = isAdult && hasAccess && isActive && isSubscriber;
if (canAccess) {
grantAccess();
}
See how much easier that is to read? It’s like showing your work in math class! It’s okay to be super obvious with these variable names, too:
const userHasJumpedThroughAllTheRequiredHoops = true;
Lila: What are “variables” and “expressions”, John?
John: Good question, Lila! Imagine a variable is like a labeled box where you can store a value. In this case, we’re storing whether a user is an adult or not. An expression is like a question you ask the computer. For example, “user.age > 18” is an expression that asks, “Is the user’s age greater than 18?” The computer answers with true or false, and that answer is stored in the variable.
Rule #4: Say No to Boolean Parameters
Boolean parameters can be confusing. A “parameter” is a value you pass into a function. Passing true or false into a function without context can make the code hard to understand.
Consider this:
saveUser(user, true, false); // ...the heck does this even mean?
What does true and false mean here? It’s not clear! Instead of using Booleans, consider using something called an “enum.”
Lila: What’s an “enum,” John?
John: An “enum,” short for enumeration, is like a list of named options. Imagine you have a set of colors: red, blue, and green. Instead of using numbers to represent them (like 1 for red, 2 for blue), you can give them names. That’s what an enum does! In our case, instead of using true or false, we can use enums like Send or DoNotSend for email options. This makes the code much clearer!
Here’s an example of using enums:
enum WelcomeEmailOption {
Send,
DoNotSend,
}
enum VerificationStatus {
Verified,
Unverified,
}
function saveUser(
user: User,
emailOption: WelcomeEmailOption,
verificationStatus: VerificationStatus
): void {
if (emailOption === WelcomeEmailOption.Send) {
sendEmail(user.email, 'Welcome!');
}
if (verificationStatus === VerificationStatus.Verified) {
user.verified = true;
}
// save user to database...
}
saveUser(newUser, WelcomeEmailOption.Send, VerificationStatus.Unverified);
See how much clearer that is? It’s almost like reading plain English!
Rule #5: Booleans are a Trap for Future Complexity
This rule is about planning ahead. Booleans can limit your options in the future. Enums are more flexible because you can easily add more options later.
Imagine you have a drink size system with only “small” and “large.” You might use a Boolean: IsSmallDrink. But what happens when you want to add a “medium” size? Suddenly, your Boolean is not enough! But if you had used an enum from the start:
enum DrinkSize {
Small,
Large
}
Adding “medium” is easy!
enum DrinkSize {
Small,
Medium,
Large
}
In Conclusion
Booleans are powerful and simple, and I remember when we didn’t even have them! But using them can be tricky. If you’re not careful, you can end up with confusing, hard-to-read code. So, tread carefully and think before you use a Boolean variable.
From my perspective, keeping things simple and readable is always worth the extra effort. It saves time and headaches in the long run!
Lila: As a beginner, this makes a lot of sense! I can see how things could get confusing quickly with all those “not”s and complex conditions. I’ll definitely try to use these rules when I start coding!
This article is based on the following original source, summarized from the author’s perspective:
Five rules for dealing with Booleans
“`