Boolean operators like and and or are very useful for

testing multiple conditions in one statement.

For example, in a browser based game,

you could test if the time had run out or the player had to use all their lives.

If either were true the game would end.

Likewise with the and operator.

It makes sure that multiple conditions are true before

evaluating the entire conditional statement to be true.

Simple programmers use boolean operators to perform what's

called the Short Circuit.

It's basically a way to optimize code by stopping the evaluation of an expression

as soon as an outcome is known.

It's often used to quickly assign a value or execute code.

Let's take a look at some examples.

Open up the workspace on this page to follow along or

feel free to follow along in your local environment.

Lets start by looking out the result of a boolean and operates its of the console.

This will log out to be true, because both expressions evaluate to true.

Let's run this to be sure.

Great, now let's replace the second expression with the string.

For example, cow.

Now what do you think will happen?

A string with a length greater than zero can evaluate to true because it's truthy.

So will this print true?

Let's try it.

It printed cow.

That's because the operator actually returns

a second value if the first one is truthy.

Let’s add another boolean and with the string chicken.

Running that, we get chicken, because all operants

are truthy.

Now let’s change cow to false.

If we run that, we get false back, that's because the JavaScript's

interpreter starts with the leftmost expression and then moves right.

If any of the operands are falsey the first falsey operant is returned.

And any operants that follow aren’t considered.

So the interpreter never even considers this string chicken in this case.

Everything after the false is short-circuited.

We can see this By putting a statement as one of the operants.

Let's remove consul.log at the beginning and

instead use it in the final operand logging chicken from that.

When we're on this now, false is returned and the log method is never called.

This behavior allows us to check a condition and then run code only if it's

true, replicating an if block in one concise line of code.

Let's just replace false with cow again.

And let's make sure, we'll run, both the preceding operands are truthy.

Now when we want it again, the log method is executed and

this string chicken appears.

Let's look at the boolean or operator now.

It returns the first truth value it finds as it reads from left to right.

Let's replace our two && operators with | |.

And let's look the expression.

In this case, the first expression is truthy because three is equal to three and

the equality operator returns a boolean value.

So we see true is logged.

If we change one of the threes to four what do you think will happen?

Cow is the first truth value that the interpreter

comes to so it's returned is an important note however

if all of the values of falsely the last one is still returned.

If we change cow to false, and chicken to zero, and

run it, zero is logged.

You wouldn't want to replicate a complex branching condition

using logical operators in this way.

If else and switch statements are better for

multiple branches, but let me show you a few ways short circuiting can be useful.

For example, let's say we have a function named is adult,

that we want to use to return true or

false Based on a number passed into the function.

If the number represents an age, and is greater than or

equal to 18, we want to return true.

If no number is passed into the function,

the number is less than 18 we want it to return false.

You could write the function with an if else statement like this.

The condition here is checking both the age exists of the first part before the &&

and that the age is equal to or greater than 18.

You could rewrite this much more concisely using short circuiting.

Let me run this in the console and

to see will get a false value undefined when none number is past in.

Let's change it to 15 now, which is less than 18.

So false is returned.

33 Which is greater than 18 and true is logged.

A common way you will see short circuiting done is to assign a default value.

Let's write a simple function to illustrate this called count to 5.

It takes a single argument called start.

This will be the starting value, then we'll create a loop for counting up to 5.

And it logs out the value of i each time it goes through the loop.

Let's run this with 2 to see it in action.

it works as expected.

Now what if we call this function with no arguments.

It prints nothing, because dots isn't defined and

then the loop condition is false at the beginning.

What if we want to set a default value for start so

it still counts from say one even if it's called without an argument.

We can do this by short circuiting.

Now if start is undefined it will be falsey.

Say the second value will be assigned to starts.

Otherwise starts will be assigned the value it already contains.

Let's run this function once again with two.

And it works.

And then again with no arguments.

This seems to work well.

However there is a problem.

What if we want to start at zero?

If we pass this in, it will be falsey.

And one will be assigned to starts.

So it's impossible to start the count at zero.

This is why you have to be careful when you use the or

operator to assign a default value.

While it can be used in a lot of circumstances,

it can't really be used when a valid value can be considered falsey.

You'll probably see the or operator a lot

being used to assign a default value in older code.

EXMAScript 2015 introduced default parameters to functions

making using short circuiting less useful.

The new 2015 syntax also

doesn't suffer from the issue of evaluating zero as a false value.

To assign a default value in 2015 you can just assign the value.

To the parameter in the function declaration.

If you're interested in default parameters,

check out the teacher's notes for further reading.

We've now seen how to use short circuiting to assign values.

Let see a quick example of one using a statement.

Lets say we have a function that greets someone if the name is provided.

If name is provided the second operant will be evaluated,

printing the greeting to the console.

Let's run this now to see if nothing happens.

Good, it doesn't.

Now let's apply a name say, Sam.

[SOUND] Now the second operant is evaluated and

the message is printed to the console.

Short circuit evaluation is not as good as replicating if else as it is

with just plain old if statements.

And like the ternary operator, you'll want to reserve its use to times when

it's very easy to tell what your code is trying to accomplish for

someone arriving fresh to the project.

Generally, you'll probably want to avoid this in favor of the if statement

which is usually much easier to read and understand.

Now you know a little bit more about the options

that you have when adding logic to your programs.

Have fun programming!