Learn how to write complex programs which can make decisions using boolean values, conditional statements, and comparison operators. 

Booleans and Comparison Operators

Woah! We covered a lot in this lesson. Good work. Let's review what we learned:
+ Conditionals make it possible for programs to decide how to react to a wide variety of situations.
+ `if` statements allow us to run a block of code **if** a condition is met. 
+ The boolean data type is either the value `TRUE` or `FALSE` and is the foundation of programmatic decision making.
+ We use `else` to include a block of code to run when the condition is not met. 
+ Comparison operators evaluate a relationship between two operands and return a boolean value.
 + The less than operator (`<`)
 + The less than or equal to operator (`<=`)
 + The greater than operator (`>`) 
 + The greater than or equal to operator (`>=`)
 + The Identical operator (`===`) 
 + The not identical operator `(!==)`
+ We can write conditionals with multiple `if` statements using the `elseif` construction.
+ Instead of using a series of `if` statements when we want to compare a value, expression, or variable against many different possible values and run different code depending on which it matches, we can use a `switch` statement.
+  The keyword `break` tells the computer to break out of the switch statement, without it, it will _fall through_ the rest of the switch executing all the code until it reaches a `break` or the end of the statement. 
+ A ternary operator (`?:`) is shorthand conditional operator. It takes three operands (a condition to check, an expression to return if the condition is `TRUE`, and an expression to return if the condition is `FALSE`). 
+ Any value or expression inside a condition will be converted to `TRUE` or `FALSE`. We consider values that will convert to `TRUE` to be _truthy_ and values that will convert to `FALSE` to be _falsy_. 
+ We can get user input from the terminal with the `readline()` function. 

That really is a lot... Take some time to practice and review! You're doing great.

Review

So far in our conditionals, we've been dealing with expressions that would evaluate to boolean values in any context. In practice, **any** value or expression in the condition will be **converted** to `TRUE` or `FALSE`. Take a look at the following real, working PHP code:
```php
if ("What's going on?"){
  echo "Let us explain…";
} 
// Prints: Let us explain…
```
In the above code, the condition checks the _truthiness_ of the string `"What's going on?"`. The computer converts this value to `TRUE` and therefore executes the code in the block. We sometimes refer to code that will be converted to `TRUE` as _truthy_ and code that will be converted to `FALSE` as _falsy_ since they aren't actually equivalent to those boolean values, but they will be treated as such in certain contexts. Most values and expressions are treated as truthy, so we'll focus on those that are falsy:
+ Empty strings 
+ `null`
+ an undefined or undeclared variable
+ an empty array
+ the number `0`
+ the string `"0"`

Let's see this in action:
```php
if ("") {
  echo "this will not print";
} elseif (null) {
  echo "this will not print";
} elseif ([]) {
  echo "this will not print";
} elseif (0) {
  echo "this will not print";
} elseif ("0") {
  echo "this will not print";
} else {
  echo "Finally!";
}
```
Since none of the conditions above hold truthy values, the code will print `Finally!`. 

This can be tricky, so let's get some practice with it. 


Truthy and Falsy

In the previous exercise, we taught you to use the keyword `break` after the block for each `case`. Without the  keyword `break`, not only will the first matching case's block run, but so will all the code in the subsequent cases! This is known as _fall through_. The keyword `break` tells the computer to **break** out of the switch statement, without it, it will **fall through** the rest of the `switch` executing all the code until it reaches a `break`, a `return`, or the end of the statement: 

```php
$letter = "a";
switch ($letter) {
  case "a":
    echo "a";
  case "b":
    echo "b";
  case "c":
    echo "c";
  case "d":
    echo "d";
}
```
The code above will output `abcd`. Only the first case (`case "a"`) actually matches the value of `$letter`, but since the above code doesn't have any `break`s all of the code in the `switch` will execute. Fall through may seem like a drag, but it can be useful when we want multiple cases to execute the same code:
```php
switch ($day_of_week) {
  case "Monday":
  case "Tuesday":
    echo "Just getting started!";
    break;
  case "Wednesday":
    echo "Humpday!";
    break;
  case "Thursday":
  case "Friday":
    echo "Almost the weekend!";
    break;
  case "Saturday":
  case "Sunday":
    echo "Enjoy!";
    break;
}
```
In the code above, we use fall through to our advantage by placing cases that should execute the same code next to each other and having them share a code block. So, for example, if `$day_of_week` has the value `"Monday"` or `"Tuesday"`, the string `"Just getting started!"` will be printed. 

It's ok if you don't find fall through useful in your own code. But knowing how to use it should remind you that it exists and that you need those `break`s! 


Switch Statements: Fall through

The outcomes of programs we've been writing so far have been predetermined. Unless we manually change our code, it will produce the same results each time it's run. But this isn't very realistic. Programs often receive unexpected inputs or results which is why we need conditionals. Conditionals allow us to write flexible programs that handle this variability. 

One common reason our programs need to be flexible is when they have user interaction. When we create a website, we don't know exactly when a user will press a button or exactly what text they'll input in a form. Writing programs that can handle unique user interaction is a big part of software development. 

User interaction isn't restricted to web development. We can enable user interaction in our terminal-based programs as well.

The [built-in `readline()` function](https://www.php.net/manual/en/function.readline.php) takes a string with which to prompt the user. It waits for the user to enter text into the terminal and returns that value as a string. 

```php
echo "Hi, I'm Aisle Nevertell. What's your name?\n";
$name = readline(">> ");
echo "\nNice to meet you, $name";
```
The code above prints, `Hi, I'm Aisle Nevertell. What's your name?`. Then, it prints `>> ` to the terminal to prompt the user to type and awaits their input which it will save in the `$name` variable. If the user entered `Alex`, for example, the program would next print `Nice to meet you, Alex` to the terminal. 

By incorporating in conditionals, we can take different actions depending on the user input:
```php
echo "\nWhat's your favorite color?\n";
$color = readline(">> ");
if ($color === "green"){
  echo "\nCool, that's my favorite too!";
} else {
  echo "\nOh, $color is nice, I guess…";
}
```
In the code above, we prompt the user to enter their favorite color. If they say our favorite color (green), we give one response, otherwise we give a different response. 

Let's practice!


User Input: readline()

We're going to learn about a specific type of conditional called an _if statement_. An if statement follows this basic structure:
```php
if (/*some condition*/) {
 // Do something...
}
```
The parentheses hold the condition we want the computer to check. **If** the condition is true, the code inside the code block (`{ }`) will run; if it's not true, the code will not run.  

The foundation of any conditional is the _boolean_ data type. A boolean can have one of two values: `TRUE` or `FALSE`. Note that these are the words without quotation marks—the string `"TRUE"` is not the same as the boolean value `TRUE`. These values are not case sensitive, but we follow the convention of making them uppercase. 

If we wanted to write code to approximate our hyperlink example from the previous exercise, we might write something like this:
```php
$is_clicked = TRUE;
if ($is_clicked) {
  $link_color = "purple";
  echo $link_color;
}
```
In the code above, we ask the computer to check the `$is_clicked` variable as the condition. If its value is `TRUE`, the value of `$link_color` will be assigned `"purple"` and printed. 

In the code above, were our condition **not** met, we'd skip over the code turning the link purple, but what should we do instead? **If** the link has been clicked, the color should be purple, otherwise it should be blue. We can include a block of code to run when the condition is not met with the keyword `else`:
```php
$is_clicked = FALSE;
if ($is_clicked) {
  $link_color = "purple";
  echo $link_color;
} else {
  $link_color = "blue";
  echo $link_color;
}
```
We changed the value of `$is_clicked` to `FALSE` so that the `if` block will not run. Rather, the `else` block will run and `blue` will be printed to the terminal. 

Let's make some conditionals!

If Statements

In this exercise we're going to learn a few more comparison operators and see how we can use them to compare more than just number values. 

The identical operator (`===`) will return `TRUE` if the left operand is the same as the right operand and `FALSE` if it's not:
```php
$num = 5;
$num === 5; // Evaluates to: TRUE
10 === 10; // Evaluates to: TRUE
$num === 20; // Evaluates to: FALSE
```
When we think about comparing two values, we'll need to think like a computer. Are `"hello"` and `"Hello"` the same? 
```php
$greeting = "hello";
$greeting === "hello"; // Evaluates to: TRUE
"hello" === "hel" . "lo";   // Evaluates to: TRUE
$greeting === "HELLO"; // Evaluates to: FALSE
```
The not identical operator (`!==`) will return `TRUE` if the two operators are different and `FALSE` if they're the same:
```php
$num = 5;
$num !== 5; // Evaluates to: FALSE
10 !== 10; // Evaluates to: FALSE
$num !== 20; // Evaluates to: TRUE

$greeting = "hello";
"hello" !== "hello"; // Evaluates to: FALSE
$greeting !== "HELLO"; // Evaluates to: TRUE
```
When looking through PHP code, you may encounter another operator—the equal operator (`==`). Like the identical operator, the equal operator will return `TRUE` if the left operand is the same as the right operand and `FALSE` if it's not. But the equal operator is less strict than the identical operator and can have some hard to predict results, so we prefer to only use the identical operator.  

Awesome. Let's practice!


Identical and Not Identical Operators

PHP offers a short-hand syntax to conditionally `return` a value. Before learning it, let's consider some example code: 
```php
$isClicked = FALSE;
if ( $isClicked ) {
  $link_color = "purple";
} else {
  $link_color = "blue";
}
```
In the code above, our condition checks the value of the `$isClicked` variable. If it's `TRUE` we assign `$link_color` to `"purple"`, otherwise we assign it the value `"blue"`. Our code is somewhat repetitive—the code in each code block is only slightly different. 

A ternary operator (`?:`) is another conditional operator. It takes three operands and returns a value: 
+ The first operand is a condition to check. This is followed by a question mark `?`.
+ The second operand is an expression to `return`  if the condition is `TRUE`. This is followed by a colon (`:`).
+ The third operand is an expression to `return` if the condition is `FALSE`. 

Let's see our previous example refactored with the ternary operator:
```php
$isClicked = FALSE;
$link_color = $isClicked ? "purple" : "blue";
```
The ternary operator allows us to write fewer lines of code while maintaining readability. 

Note that code in the expression will be executed, but the intended use of the ternary is to conditionally return a value _not_ to execute code.

Let's get some practice with the ternary operator! 


Ternary Operator

We often want to compare a value, expression, or variable against many different possible values and run different code depending on which it matches. We can use a series of `if`/`elseif` statements which use the identical operator (`===`) or we can use a `switch` statement—an alternate syntax.

We wrote some code with `if`/`elseif` statements to print a string based on a student's letter grade:
```php 
if ($letter_grade === "A"){
  echo "Terrific";
} elseif ($letter_grade === "B") {
  echo "Good";
} elseif ($letter_grade === "C") {
  echo "Fair";
} elseif ($letter_grade === "D") {
  echo "Needs Improvement";
} elseif ($letter_grade === "F") {
  echo "See me!";
} else {
  echo "Invalid grade"; 
}
```
Since this code involves a series of comparisons, it's ripe for a `switch` statement! Let's see it refactored with `switch`:
```php
switch ($letter_grade){
  case "A":
    echo "Terrific";
    break;
  case "B":
    echo "Good";
    break;
  case "C":
    echo "Fair";
    break;
  case "D":
    echo "Needs Improvement";
    break;
  case "F":
    echo "See me!";
    break;
  default:
    echo "Invalid grade"; 
}
```
We begin the keyword `switch` followed by the value (or expression) we'll be comparing—in this case, `$letter_grade`. We provide possible matches for the expression with the keyword `case`, the potential matching value, and the colon. For each `case`, we provide code that should run if that case matches. After each `case`, we include the keyword `break` to _break_ out of the `switch` statement. We can provide a `default` that should run if none of the provided cases match. 

A `switch` statement is a good example of code that might be preferable _not_ because it's shorter, but rather because it clearly indicates the purpose of the code; when looking at a `switch` statement we can quickly identify the important aspects of the code; this makes it easier to understand, extend, and debug.  


Switch Statement

So far, we've been writing conditionals that can only handle one condition. **If** that condition is met, we do one thing, otherwise we do something **else**. This only allows us one or two courses of action. But programs can be far more complex. 

Consider letter grades on a school assignment:
+ If the grade is less than 60, it's an F
+ Or else, if the grade is less than 70, it's a D. 
+ Or else, if the grade is less than 80, it's a C. 
+ Or else, if the grade is less than 90, it's a B. 
+ Or else, it's an A. 

We can write conditionals with multiple `if` statements using the `elseif` construction. The computer will continue through each condition until it finds a condition which is met or gets to the end—whichever comes first. 

Let's implement our letter grades example in code:

```php
$grade = 88;
if ($grade < 60) {
  echo "You got an F";
} elseif ($grade < 70) {
  echo "You got a D";
} elseif ($grade < 80) {
  echo "You got a C";
} elseif ($grade < 90) {
  echo "You got a B";
} else {
  echo "You got an A";
}
```
In the code above, `$grade` has a value of `88`. The computer will check each condition until one is met and run that block of code. When it gets to the condition `$grade < 90`, it evaluates to `TRUE`. That code block executes, and `You got a B` is logged to the terminal.

Notice that the order of our conditionals is important. The grade `55` would satisfy the condition `$grade < 90`, but it meets the condition intended for it, `$grade < 60` first. What if the `elseif` statements were in a different order?

```php
$grade = 55;
if ($grade < 90) {
  echo "You got a B";
} elseif ($grade < 80) {
  echo "You got a C";
} elseif ($grade < 70) {
  echo "You got a D";
} elseif ($grade < 60) {
  echo "You got an F";
} else {
  echo "You got an A";
}
```
The code above will output `You got a B` to the terminal since the computer will run the first `TRUE` condition. We need to take care when constructing our conditionals that they have the outcome we want. 

Note: you may encounter [the keywords `else if`](https://www.php.net/manual/en/control-structures.elseif.php) with a space separating the two words. In many situations, `else if` will work the same way as `elseif`. Since `elseif` works more universally, that's what we choose to use.   

Let's practice writing some `elseif` statements!


Elseif Statements

The condition, or _expression_, in an `if` statement can hold a boolean value—like `TRUE` or `FALSE`, a variable assigned to one of those values, or an expression that evaluates to `TRUE` or `FALSE`. 

Just as we can represent a value of five with `5` or with an expression that evaluates to five e.g. `3 + 2`, we can write expressions that evaluate to `TRUE` or `FALSE`. _Comparison operators_ evaluate a relationship between two operands and return a boolean value. 

The less than operator (`<`) will return `TRUE` if the left operand is less than the right operand and `FALSE` if it's not:
```php
1 < 10; // Evaluates to: TRUE
11 < 3; // Evaluates to: FALSE
```
The less than or equal to operator (`<=`) will return `TRUE` if the left operand is less than **or** equal to the right operand and `FALSE` if it's not:
```php
1 <= 10; // Evaluates to: TRUE
4 <= 4; // Evaluates to: TRUE
18 <= 2; // Evaluates to: FALSE
```
The greater than operator (`>`) will return `TRUE` if the left operand is greater than the right operand and `FALSE` if it's not. And the greater than or equal to operator (`>=`) will return `TRUE` if the left operand is greater than **or** equal to the right operand and `FALSE` if it's not:
```php
1 > 10; // Evaluates to: FALSE
11 > 3; // Evaluates to: TRUE
1 >= 10; // Evaluates to: FALSE
11 >= 11; // Evaluates to: TRUE
54 >= 10; // Evaluates to: TRUE
```
Let's practice writing conditionals using these operators!


Comparison Operators

Have you ever noticed that hyperlinks change color after you click them? **If** the link has been clicked, then the web browser renders it in purple, rather than blue. The programming concept that makes this possible is called _conditionals_. 

This might be a simple example, but conditionals underlie the complex behavior of computer programs from Gmail, to Mario games, to Microsoft Office.  Conditionals make it possible for programs to decide how to react to a wide variety of situations. 

But computers aren't intelligent—in order for them to make decisions they have to be programmed with a set of rules to follow. 

In this lesson, we'll explore how we write programs that can make decisions with conditionals.



A crossroads with one path for true and one path for false