A condition in a conditional statement is really just a question with a yes or

no answer.

In JavaScript, we say that the condition evaluates to either true or false.

True and False have a specific meaning in JavaScript, they're called Booleans.

And along with strings and

numbers, they represent a third type of value or data type in JavaScript.

Though they have an unusual name, Booleans are simple.

Remember, a Boolean value can be only one of two possible values,

true or false, that's it.

There will be times where you'll want to ask your program yes/no questions,

then run different code based on those answers.

Let's have a look at some examples.

This time open the booleans.js inside your js folder and

update the script tag in index.html so that it points to booleans.js.

In JavaScript programming, the two possible Boolean values are represented by

the keywords, true and false.

Because all conditions return a true or false value,

you can see how these two keywords work by using them in this if/else statement.

If I type true inside the condition and refresh the browser,

The condition is true displays in the console.

Now, if I type false inside the condition,

The condition is false appears.

Notice that there are no quotation marks around the words true or false.

They're not strings, they each represent a specific type of value, a Boolean value,

so quotes should not go around them.

You can assign a Boolean value to a variable,

just like you can assign a string or a number to a variable.

This is a common way to keep track of a certain condition throughout a program.

For example, let's see how we can use a Boolean value in a number guessing game.

First, declare a new variable using the let keyword named

correctGuess, and set it to the Boolean value false.

When the number guessing game begins, the player hasn't yet guessed anything, so

we'll say that the guess is false.

The value of this variable will only change if the player gets the correct

answer.

And notice how we're using the let keyword here because we expect the value of

correct guests to change.

Next, declare a variable named number to store the number two guess.

You can set it to any number between 1 and 10, I'll set it to 6.

Then let's declare one more variable named guess.

To store the answer, the user types into a prompt dialogue,

which will instruct the user to guess a number between 1 and 10.

Next, below the guests variable,

let's write a conditional statement that changes the correct guess

variable from false to true if the user guessed the correct number.

Type, if guess === number,

run the code inside these curly braces or code block.

If the number the user typed into the prompt dialog exactly

matches the number stored in the number variable,

we're going to change the value of the correct guess variable from false to true.

If the player guesses wrong, the variable isn't changed, it remains false.

Now, there's one detail we need to address in the condition.

You learned that the value returned by the prompt method is a string.

So notice how in the condition,

we're comparing a number value with a string value.

For example, even if the user types 6, the program will compare

the number 6 inside quotes with the actual number value 6.

And this is always going to return false, because we're using the strict equality

operator, and the game will not work as expected.

So for the sake of this example,

we need to convert the string value returned by prompt to a number of value.

The quickest way to do this is by adding a plus symbol or

the unary plus operator just before the guests variable like this,

make sure that there is no space between the plus and the variable.

So now, this ensures that we're comparing two number values.

It may seem a little strange, but

don't worry too much about this operator for now.

You're going to learn a whole lot more about converting strings to numbers and

working with number values in a later course.

For now, I've posted more information about the unary plus operator and

the teachers notes with this video.

Finally, let's update the conditional statements below to check the current

value of the correctGuess variable and put a message that matches the condition.

First, the if statement will check if the value of correctGuess is true.

If it's true, then log the message, You guessed the number.

Else, if the value is false,

then print a different message that reveals the random number.

I'll use a template literal to insert the value

of the number variable Into the message, Sorry,

the number was ${number} and that's it.

Before running it, let's step through this code line by line.

First, we declare a variable with the Boolean value false.

Next, we store the number to guess in a variable named number.

We then open a dialog box and ask the user to supply a number,

which we store in the variable guess.

Then the program tests the user's response.

If the user supplied the same number stored in guess,

then the correct guest variable changes to true.

If the player didn't however, then the variable stays the same, it's false.

Then we have a second conditional statement that says,

if the value in correctGuess is true, then print a winning message to the console.

However, if the value is false, then reveal the number.

All right, let's see it in action.

I'll save the file, refresh the browser.

If I type, say, 8 into the prompt dialog,

the console displays, Sorry, the number was 6.

Refresh the page to try again, this time I'll type 6 and

see the message, You guessed the number, good.

You can also simplify the code in this if/else statement.

Remember that all conditions are either true or false,

that is, the test condition produces a Boolean value.

Since we're already storing either true or false in the correctGuess variable,

we don't need to use the strict equality operator at all.

In other words, this is the same as this.

And as you can see,

the number guessing game still works in the same way as before.

There are other ways you might write this number guessing game,

without having to use two separate conditional statements.

I use this approach to teach you how Booleans get evaluated and

change the flow of a program when used in conditional statements.