In this lesson, you'll hone your understanding of conditionals and explore logical operators.

Logical Operators

The logical, `!`, operator is a prefix operator that negates, or reverses, the Boolean value of its operand. It returns `false` when the operand is `true`, and returns `true`, when the operand is `false`. 

Note that unlike the `&&` and `||` operators, the `!` operator acts on a single value.  

Assume we have the following variables that hold Boolean values. 

```swift 
let a = true
let b = false
```

Prepending the `!` operator to both values will result in the opposite Boolean:  

```swift 
print(!a) // Prints: false 
print(!b) // Prints: true 
```

The `!` operator can also be used to negate the value of an expression as long as that expression is contained within parentheses. The following example first executes the logic within the parentheses and then negates it.  

```swift 
print(!(true && false)) // Prints: true 
```

The resulting value will be `true` since `true && false` results in `false` and `!false` is `true`.  

Logical NOT Operator

Operators are special symbols used to assign, compare, combine, or simply, check values. 

Up until this point, we've worked with various operators supported by Swift including arithmetic operators (like `+` and `-`), comparison operators (like `>` and `<`), the assignment operator (`=`), and more. In this lesson, we'll explore another type of fundamental operators known as logical operators. 

_Logical operators_ determine a boolean result after combining or modifying `true` or `false` values. Swift supports the following logical operators:  

- `&&` (AND)
- `||` (OR)
- `!` (NOT) 

Take a look at the tables on the right for a preview of each operator's behavior. We'll explain each behavior in depth in the upcoming exercises. 

Truth tables for the AND, OR, and NOT operators. 

Introduction to Logical Operators

The logical, `&&`, operator evaluates two operands and returns a Boolean result. It returns `true` only when both operands are `true` and returns `false` when at least one operand is `false`.

`&&` is denoted by two ampersand symbols and translates to AND. 

The following truth table demonstrates all of the possible outcomes of an expression using `&&`.

Logical Expression | Result
--- | ---
true && true | true
true && false | false 
false && true | false
false && false | false 

<br>

Let's see the `&&` operator in action. Assume we're writing a program for an application that dims a screen by 25% in the evening time. We can set up the following `if`/`else` statement for this case:

```swift 
var time = 8 // PM 
var phoneInUse = true 
var brightness: Double

if time >= 8 && phoneInUse {
  brightness = 0.75 
} else {
  brightness = 1 
}

print(brightness) // Prints: 0.75
``` 

Notice how the brightness will be set to 75% only when `time >= 8` and `phoneInUse` are both `true`. Changing the value of `time` to be less than 8 or setting `phoneInUse` to `false`, would result in the brightness remaining the same. 

Logical AND Operator

Swift allows us to combine or chain logical operators, `&&`, `||`, and `!` in order to create longer, more complex compound expressions. 

Take a look at the following `if` statement that utilizes the `&&` and `||` operator in its condition: 

```swift 
let weekday = true 
let dayOff = false 
let weekend = false

if weekday && dayOff || weekend {
  print("Do something fun!") 
} else {
  print("Get some work done") 
}
// Prints: Get some work done
```

Combining the value of `weekday` and `dayOff` with the `&&` operator will result in `false`. This resulting value is then used to execute the expression `false` OR `weekend` which is `false`. Thus, the entire condition results in `false` and the second code block is executed. 

Note that when chaining Swift's logical operators, we must keep in mind the order in which execution happens. 

The `&&` operator has higher precedence over the `||` operator.  

This rule instructs our program to execute the expression containing the `&&` first, and then use that result to calculate the rest of the expression. 

For instance, rearranging the previous condition to... 

```swift 
weekend || weekday && dayOff 
``` 

would result in `weekday && dayOff` still executing first. 

Reference [this documentation](https://developer.apple.com/documentation/swift/swift_standard_library/operator_declarations) for more information about operator precedence in Swift.  

Combining Logical Operators

Excellent work! 👏 In this lesson, we've learned the following concepts:

- The logical `&&` operator translates to AND and returns `true` only when both operands are `true`. It returns `false` in all other cases.  
- The logical `||` operator translates to OR and returns `true` when either operands are `true`. When both operands are `false`, the logical expression evaluates to `false`. 
- The logical `!` operator translates to NOT and negates a Boolean value. 
- The `&&` operator has a higher precedence over the `||` operator. 
- Parentheses, `()`, may be used in a logical expression to control the order of operations and improve readability. 

Feel free to utilize the empty **Review.swift** file and output terminal on the right to hone your understanding of logical operators and practice writing Swift code!

Review 

Instead of relying on the compiler to set operator precedence, we can do so ourselves by wrapping a logical expression in parentheses, `()`. The use of parentheses also makes our code easier to read and interpret.

Assume the following logical expression with multiple logical operators: 

```swift
true || true && false && true 
```
 
The order of execution may seem unclear at first but following Swift's operator precedence rules, we achieve the Boolean outcome, `true`:

<img src="https://content.codecademy.com/courses/learn-swift/conditionals/Swift_LogicExpressions_1_v2.svg" alt="Diagram showing flow of operations of a logical expression without parentheses">


If we wanted more control of the evaluation of this expression, we can use parentheses to direct order of execution and improve the expression's readability:
 
```swift
(true || true) && (false && true) 
```

<img src="https://content.codecademy.com/courses/learn-swift/conditionals/Swift_LogicExpressions-06.svg" alt="Diagram showing flow of operations of a logical expression with parentheses">


Notice how although the expressions utilize the same operators, their outcomes are different. The presence of parentheses overrides Swift's operator precedence rules and dictates order of operations. 


Controlling Order of Execution 

The logical, `||`, operator evaluates two operands and returns a Boolean result. It returns `false` only when both operands are `false` and returns `true` when at least one operand is `true`.

`||` is denoted by two pipe symbols and translates to OR. 

The following truth table demonstrates all of the possible outcomes of an expression using `||`.

Logical Expression | Result
--- | ---
true &#124;&#124; true | true
true &#124;&#124; false | true 
false &#124;&#124; true | true
false &#124;&#124; false | false 

<br>

Take a look at the following example: 

```swift 
var snowing = false 
var raining = true

if snowing || raining {
 print("Wear waterproof shoes!")
}
```

If it is `snowing` OR `raining`, we recommend wearing waterproof shoes because in either scenario, your feet can get wet! Since `raining` is `true`, the condition will result in `true`, and the message `Wear waterproof shoes!` will get printed. 