TypeScript - Boolean: A Beginner's Guide to Truth and Falsehood in Programming

Hello there, future coding superstar! Are you ready to dive into the fascinating world of booleans in TypeScript? Don't worry if you've never written a line of code before – we're going to start from the very beginning and take this journey together. By the end of this tutorial, you'll be a boolean master, able to wield true and false like a programming wizard!

What is a Boolean?

Before we jump into the nitty-gritty, let's talk about what a boolean actually is. In programming, a boolean is a data type that can have only two values: true or false. It's like a light switch – it's either on or off, with no in-between.

Imagine you're asking your friend if they want to go to the movies. Their answer can only be "Yes" (true) or "No" (false). That's exactly how booleans work in programming!

Syntax: How to Write Booleans in TypeScript

In TypeScript, writing a boolean is as simple as typing true or false. Here's an example:

let isHappy: boolean = true;
let isSad: boolean = false;

In this code, we've created two variables: isHappy and isSad. The isHappy variable is set to true, while isSad is set to false.

Type Annotations: Telling TypeScript What to Expect

You might have noticed the : boolean part in our previous example. This is called a type annotation. It's like putting a label on a box to tell everyone what's inside. When we write : boolean, we're telling TypeScript, "Hey, this variable is going to be a boolean!"

Here's another example:

let isRaining: boolean;
isRaining = true;
// isRaining = "Yes"; // This would cause an error!

In this case, we've declared isRaining as a boolean, but we haven't given it a value yet. Later, we assign true to it, which is perfectly fine. However, if we tried to assign a string like "Yes" to it, TypeScript would throw an error because "Yes" is not a boolean value.

Truthy and Falsy Values: When Non-Booleans Act Like Booleans

Now, here's where things get interesting! In TypeScript (and JavaScript), some non-boolean values can be treated as if they were booleans. We call these "truthy" and "falsy" values.

• Falsy values include: false, 0, '' (empty string), null, undefined, and NaN.
• Everything else is considered truthy.

Let's see this in action:

if (1) {
    console.log("1 is truthy!");
}

if ("") {
    console.log("This won't be printed because an empty string is falsy.");
}

In this example, the first if statement will run because 1 is truthy, but the second one won't because an empty string is falsy.

Converting a Non-Boolean Value to Boolean

Sometimes, you might want to convert a non-boolean value to a boolean. There are a couple of ways to do this:

1. Using the Boolean() function:

let num = 5;
let boolValue = Boolean(num);
console.log(boolValue); // Outputs: true

2. Using the double negation operator (!!):

let str = "Hello";
let boolValue = !!str;
console.log(boolValue); // Outputs: true

Both of these methods will convert truthy values to true and falsy values to false.

Boolean Operations: Combining Booleans

Now that we know how to create booleans, let's learn how to work with them. There are three main boolean operations:

1. AND (&&): Returns true if both operands are true.
2. OR (||): Returns true if at least one operand is true.
3. NOT (!): Reverses the boolean value.

Let's see these in action:

let isAdult = true;
let hasLicense = false;

console.log(isAdult && hasLicense); // false
console.log(isAdult || hasLicense); // true
console.log(!isAdult); // false

In this example, isAdult && hasLicense is false because while isAdult is true, hasLicense is false. isAdult || hasLicense is true because at least one of them (isAdult) is true. !isAdult is false because it's the opposite of true.

Conditional Expressions with Booleans

Booleans are often used in conditional statements to make decisions in our code. Here's an example:

let age: number = 20;
let canVote: boolean = age >= 18;

if (canVote) {
    console.log("You can vote!");
} else {
    console.log("Sorry, you're too young to vote.");
}

In this code, we're checking if age is greater than or equal to 18. If it is, canVote will be true, and the person can vote. If not, canVote will be false, and they can't vote.

TypeScript Boolean vs boolean

You might sometimes see Boolean (with a capital B) in TypeScript code. This refers to the Boolean object, which is different from the primitive boolean type we've been using.

let primitiveBoolean: boolean = true;
let objectBoolean: Boolean = new Boolean(true);

In general, it's recommended to use the primitive boolean type unless you have a specific reason to use the Boolean object.

Boolean Properties and Methods

While the primitive boolean type doesn't have any properties or methods, the Boolean object does. Here are a few:

Property/Method	Description
Boolean.prototype.toString()	Returns "true" or "false"
Boolean.prototype.valueOf()	Returns the primitive value of the Boolean object

Here's how you might use these:

let boolObj = new Boolean(true);
console.log(boolObj.toString()); // Outputs: "true"
console.log(boolObj.valueOf()); // Outputs: true

And there you have it! You've just completed a whirlwind tour of booleans in TypeScript. Remember, booleans might seem simple, but they're the building blocks of logic in programming. Every time you use an if statement or a loop, you're working with booleans behind the scenes.

As you continue your programming journey, you'll find booleans popping up everywhere. They're like the secret agents of the programming world – small, discreet, but incredibly powerful. So the next time someone asks you "true or false?", you can smile, knowing you understand the deep, existential implications of that question in the world of programming.

Keep practicing, stay curious, and remember: in the world of booleans, there's no maybe – only true or false. Happy coding!

Credits: Image by storyset