Learn how to incorporate conditionals into your code! 

Conditionals

As we previously mentioned, we do things based on our present conditions. Like, if we're hungry, we'd get something to eat; if it's raining, we would carry an umbrella. 

How our actions follow the same:
1. If there's some condition
2. Take some action

Using Emojicode, we can add this decision making ability into our program using the `↪️` statement. This `↪️` checks a condition and if the condition evaluates to `👍`, it runs a block of code.

Take for instance:
```
↪️ 👍 🍇
  😀 🔤The condition is 👍🔤❗️
🍉

💭 Prints: The condition is 👍
```

Notice how we added the `👍` after the `↪️`. Then we follow up with a block of code using `🍇` and `🍉`. Inside the block of code, we added `😀❗️` to print out the string `🔤The condition is 👍🔤`. 

If we change the condition from `👍` to `👎` like so:

```
↪️ 👎 🍇
  😀 🔤The condition is 👍🔤❗️
🍉

💭 Nothing prints
```

Our code block doesn't run since our condition is `👎`. Therefore, we wouldn't get anything printed to the terminal. 

Let's create our own conditional to see it in action. 


The ↪️ Statement

Imagine a scenario where we're thirsty and want to drink some lemonade. But it turns out all the lemonade was sold out. If we followed our original plan exactly, we wouldn't get anything. But it's more realistic to have some backup plan. In this case, we could get something else to quench our thirst. 

Now let's bring it back to programming. Recall that the code in the previous exercise our code would only execute if the condition was true (`👍`). But there are many scenarios that we should have a backup plan ready for when the condition is false (`👎`). That's where the  `🙅` statement comes in.

`🙅` doesn't accept a condition and is added after a `↪️` statement. The `🙅`'s block of code executes if the previous condition(s) are all `👎` (stay tuned, we're going to cover multiple conditions soon in a later exercise!). Take a look at our code snippet:

```
👎 ➡️ 🖍🆕 isLemonadeInStock

↪️ isLemonadeInStock 🍇
  😀 🔤One glass of lemonade, please!🔤❗️
🍉
🙅 🍇
  😀 🔤Water, please!🔤❗️
🍉
```

Notice how our `↪️`'s condition is a variable `isLemonadeInStock`. That's right, we can use variables in our conditionals! `isLemonadeInStock` has a value of `👎`, so its code block doesn't run. Rather our `🙅` runs and then `Water, please!` is printed to the terminal. We can think of `🙅` as an _else_ statement, its code block runs when all else is `👎`. 

The 🙅 Statement

Consider the making of hard-boiled 🥚. We need both: boiling water and an egg. If even one ingredient is missing, we can't make it. So we should check for both conditions before we flex our culinary skills.

In programming, we also have to consider multiple conditions at the same time before executing code. That's where logical operators, like the `🤝` operator, become extremely useful. The `🤝` operator checks if two expressions are `👍` and returns a single `👌` value. If the first expression `👍` _AND_ the second expression is `👍`, then it returns `👍` &mdash; otherwise, it returns `👎`. 

Here's a table that shows the possible combinations of `👌` values in usage with `🤝`:

Expression | Evaluates to
--- | ---
`👍 🤝 👍`| `👍`
`👍 🤝 👎`| `👎`
`👍 🤝 👎`| `👎`
`👎 🤝 👎`| `👎`
      
Notice that only the first expression (`👍 🤝 👍`) evaluates to `👍`. 

Translating our 🥚 scenario to code, we get: 

```
👍 ➡️🖍 hasEgg 
👍 ➡️🖍 hasBoilingWater
↪️ hasEgg 🤝 hasBoilingWater 🍇
  😀 🔤We can make a hard-boiled 🥚!🔤❗️
🍉
🙅 🍇
  😀 🔤The conditions aren't right...🔤❗️
🍉

💭 Prints: We can make a hard-boiled 🥚!
```

Let's use the `🤝` in our own code! 


The 🤝 Logical Operator

Let's now expand the use of our conditionals to account for other types like: `🔤`, or `🔢`, or `💯`! But there's a question of, "how do we convert the types `🔤`,`🔢`, and `💯` to `👌` values?" Well, that's where the `🙌` comes in!

`🙌` compares two values, one on its left side and one on its right side, to see if they have the same value. The entire piece of code is an _expression_, we can think of expressions as code that evaluates to a value. In this case, the expression evaluates back to a `👍` or `👎` value.

Let's see a few examples: 

```
100 🙌 100      💭 Evaluates to: 👍
100 🙌 101      💭 Evaluates to: 👎
32.1 🙌 32      💭 Evaluates to: 👎
4.2 🙌 4.2      💭 Evaluates to: 👍
🔤A🔤 🙌 🔤A🔤 💭 Evaluates to: 👍
🔤A🔤 🙌 🔤B🔤 💭 Evaluates to: 👎
🔤A🔤 🙌 🔤a🔤 💭 Evaluates to: 👎 
```

Read through the examples and make sure you understand how the comparison works. Let's also take a look at the `🙌` usage in a conditional:

```
↪️ 🔤coke🔤 🙌 🔤pepsi🔤 🍇
  😀 🔤They're the same thing🔤❗️
🍉
🙅 🍇
  😀 🔤They're NOT the same🔤❗️
🍉
```

In the example above, our condition is the expression `🔤coke🔤 🙌 🔤pepsi🔤`. Since the strings are not the same, `they're NOT the same` is printed to the terminal. 

The 🙌 Operator

In Math class, we might have been asked to solve equations like:

```
2 * 6 + 10 / 2
```

If we read out our equation from left to right we might think that the answer is `11`. However, it's actually `17` because we have to follow a [specific order of operations](https://en.wikipedia.org/wiki/Order_of_operations). In the United States, there's a helpful mnemonic called [PEMDAS](https://en.wikipedia.org/wiki/Order_of_operations#Mnemonics) that helps us remember to the order:
1. `2 * 6`, which is `12` 
2. Then we have to divide! So `10 / 2` is `5`.
3. Lastly, we add `12` and `5` to get `17`! 

But wouldn't it be nice if someone put in parentheses to group together expressions for us to evaluate? That way we don't have to remember the specific ordering. Our neatly grouped expression would be:

```
(2 * 6) + (10 / 2)
```

The insertion of parentheses makes it clear which operations are done first. Emojicode also has its own [order of operations](https://www.emojicode.org/docs/reference/operators.html#operator-precedence) that determines the order in which expressions are evaluated. But, we can control the order using the emoji equivalent of parentheses, `( )`, `🤜 🤛`. When we translate our math equation to Emojicode, we get:

```
🤜 2 ✖️ 6 🤛 ➕ 🤜 10 ➗ 2 🤛
```

Using `🤜 🤛`, we make it clearer for which expressions go together and we decide the order of expressions. 




Grouping Expressions

So far we've only been able to check a single condition in our `↪️`/`🙅` statements. But, we actually check more conditions by using the `🙅↪️` statement.

Like the `↪️` that starts our conditionals, the `🙅↪️` accepts a condition and has a code block (`🍇`...`🍉`) that executes if the condition is `👍`. One or more `🙅↪️` statements can be added after the `↪️` statement.  The `🙅` statement will still be added at the very end as the default to run if the conditions for `↪️` and `🙅↪️` are all `👎`. 

Let's take a look at an example:

```
🔤yellow🔤 ➡️🖍🆕 trafficLight

↪️ trafficLight 🙌 🔤green🔤 🍇
  😀 🔤Go!!🔤❗️
🍉
🙅↪️ trafficLight 🙌 🔤yellow🔤 🍇
  😀 🔤Slow down...🔤❗️
🍉
🙅↪️ trafficLight 🙌 🔤red🔤 🍇
  😀 🔤Stop!🔤❗️
🍉
🙅 🍇
  😀 🔤This light's broken.🔤❗️
🍉

💭 Prints: Slow down...
```

In the example above, we included two `🙅↪️` statements. Each checked for different conditions. The first condition that evaluated to `👍` executed its code block, so `Slow down...` was printed to the terminal. Once a code block has executed, the rest of the statements don't run. If none of the conditions were `👍`, e.g. `trafficLight` had a value of `🔤brown🔤`, then `🙅`'s block runs. 


The 🙅↪️ Statement

We make decisions in everyday life based on conditions.

If we're tired, we might take a rest. If we're thirsty, we would find something to drink. If we're hungry, we grab something to eat. And if we want to be one with emojis 🧘‍♀️, we learn Emojicode.

We can mimic the same type of decision making in our code using conditionals. _Conditionals_ take an expression, which is code that evaluates to determine a value, and checks if it is `👍` or `👎`. 

If it's `👍`, we can tell our program to do one thing &mdash; we can even account for `👎` to do another. 

As we write more complex programs, conditionals allow us to address multiple scenarios and make our programs more robust. 





Introduction to Conditionals

In addition to `🙌` operator, Emojicode also offers other comparison operators to expand our use cases!

Here's a list of the comparison operators:

Operator | Operation
--- | ---
◀️ | Less than
▶️ | Greater than
◀️🙌 | Less than or equal to
▶️🙌 | Greater than or equal to
    

Like the `🙌` operator, the listed operators all compare two values and returns a `👍` or `👎` value. For example:

```
2 ◀️ 5 💭 👍
```

We can read the expression above as a question, "is `2` less than `5`?" Since the answer is yes, then `👍` is returned. Below are a few more examples to read through to understand the use of comparison operators:

```
4 ◀️ 4         💭 👎
10 ▶️ 5        💭 👍
10.6 ◀️🙌 10.6 💭 👍
3.14 ▶️🙌 4    💭 👎
```

Once you're ready, tackle the steps in this exercise!  





Comparison Operators

Another helpful logical operator is the `👐` operator.

The `👐` operator also checks two expressions and returns a `👌` value. The major difference is that the `👐` operator returns `👍` so long as a single expression is `👍`.

Here's the table of expression combinations: 

Expression | Evaluates to
--- | ---
`👍 👐 👍`| `👍`
`👍 👐 👎`| `👍`
`👍 👐 👎`| `👍`
`👎 👐 👎`| `👎`
      
From the table above, we see that the only expression that returns `👎` is when both values are `👎`, (`👎 👐 👎`). 

Let's look over a code snippet using `👐`:

```
👍 ➡️🖍 hasUmbrella 
👎 ➡️🖍 hasRaincoat
↪️ hasUmbrella 👐 hasRaincoat 🍇
  😀 🔤Walking in the rain is fun!🔤❗️
🍉
🙅 🍇
  😀 🔤Let's stay inside🔤❗️
🍉

💭 Prints: Walking in the rain is fun!
```

Notice, `hasUmbrella` has a value of `👍`, while `hasRaincoat` has a value of `👎`. Our condition checks `hasUmbrella 👐 hasRaincoat`. As long as either `hasUmbrella` _OR_ `hasRaincoat`  is `👍`, it returns `👍`. Since `Walking in the rain is fun!` was printed, we can confirm that our condition returned `👍`. 



The 👐 logical Operator

Great job getting through Emojicode's conditionals!

In this lesson we went over:
* The `↪️` statement accepts a condition and executes a code block if the condition is `👍`.
* The `🙅` statement provides a default code block to run if no other conditions are `👍`.
* `🙌` is used to check if two values are equal. 
* Other comparison operators, `◀️`, `▶️`, `◀️🙌`, `▶️🙌` compare the value of two numbers. 
* The `🙅↪️` statement is used to check additional conditions and executes a code block if its condition is `👍`.
* The `🤝` logical operator checks that two expressions are both `👍`.
* The `👐` logical operator that at least one of two expressions is `👍`.
* We can group together expressions using `🤜 🤛`. 

🎉🥳 That's a lot! A round of 👏 for you! 

