In the last video,

you learned about an important programming concept, the conditional statement.

Programmers use conditional statements to control the flow of their programs and

make them respond differently based on conditions inside the program.

The most important part of the statement is the condition itself.

It's a test that checks to see if something is either true or false.

For example, in this code the condition is spaceShips equal zero,

which breaks down to a simple question.

Is the value stored in the variable spaceShips equal to zero?

The answer is either yes or no.

If the answer is yes, the game is over and an alert dialogue appears.

As it turns out, all conditions, no matter how complex, end up with a simple yes or

no answer or, as computers like to think of it, true and false.

JavaScript provides lots of ways to test things.

We've seen the triple equals operator,

which is a way to test the equality of two things.

You can use that operator to see if the value a user

typed matches a particular string.

Or if the value in a variable is a particular number.

JavaScript provides other comparison operators to

help with conditional statements.

The greater than and less than symbols are great for comparing numeric values.

For example, you can make a game harder if the player's score is greater than 1,000.

Or, on the other hand, if a visitor is less than 18 years old you could

tell him to come back when he's older.

To get some practice understanding conditions let's look at

a few examples on the screen and you decide if the condition is true or false.

Three greater than two, this is true because three is a larger number than two.

100 greater than 100.

This is false because the two values are the same.

100 isn't greater than itself.

How about this.100 greater than or equal to 100.

This is true, because although the value on

the left isn't greater than the value on the right, it is equal to it.

Negative 12 less than zero.

This is true.

Because negative numbers are smaller than positive numbers or zero.

Okay, one more.

Apple less than bear.

The greater than and less than operators aren't limited to just numbers.

In this case, the comparison is true.

Because the first letter of the string on the left, the A in apple,

comes before the first letter of the second string, the B in bear.

That is A comes before B in the alphabet.

Letter strings will always come after number strings too.

That is if you compared a number and a letter, a number is less than a letter.

JavaScript provides two ways to test if values are equal.

The double equal sign is called the equality operator.

It lets you test if two values are the same, but it makes some allowances for

different types of values.

For example, three inside of quotes is a string.

And three without quotes is a number.

But if you use the double equal sign than the browser actually

converts the string to a number before comparing them, like this.

This comparison is true,

because the JavaScript interpreter converts the string to the number three.

And says that, yes, the number three is the same as the second number three.

The triple equal sign is called a strict equality operator.

It compares the type as well as the value.

In this case, the comparison is false, because one value is a string, and

the other is a number.

They aren't the same type of value, so they aren't equal.

It might seem like using the double equals operator is better,

since it seems more flexible.

However, professional JavaScript programmers tend to

use the triple equals operator.

And avoid the double equals.

Why? Because you

can get into some weird situations when using just the double equals operator.

Here's one example.

This is true.

Huh?

An empty string is equal to zero?

But if you use the strict equality operator the result is false.

What you'd expect.

In many cases the two equality operators work the same, but

there are a few cases like the one I just showed you where

the doubled equal sign will get you into a lot of trouble.

In this course I'll be using the strict or triple equals operator.

Let's look at a few examples using the strict equality operator.

This comparison is false.

Because the two numbers aren't equal.

This one is also false because those strings have different letters in them.

Whereas this one is true because those strings are the same.

But remember that java script is case sensitive so, this comparison is

false because the first string has all lower case and the second doesn't.

A lower case j isn't equal to an upper case J.

JavaScript also provides a way to test whether two values are not equal.

There's the basic not equal operator.

It's an exclamation mark followed by an equals sign.

The exclamation point is called a not operator so

exclamation equals is not equal to.

It's better to use the strict not equals.

That exclamation equals equals, for

the same reasons it's better to use the strict equality comparison operator.

Let's look at a few examples of the strict not equals operator.

This comparison is true because ten isn't equal to nine.

This is also true because the value on the left is a string and

the value on the right is a number.

So the types don't match.

This comparison is also true because the upper case R in

the first string isn't the same as the lower case r in the second string.

This comparison is false because the two numbers are the same.