Learn to build simple programs using operators. 

Operators

In computing, we work with lots of different forms of data. But the real fun comes when we can _do_ something with this data. 

In this lesson, we'll look at how we can write short computer programs using _operators_. 

Operators are different symbols that represent an _operation_, such as the plus sign (`+`) as a symbol for addition. Operations enable us to _process_ our data, to transform it into something else. 

You may already be familiar with operators and operations from other contexts. This lesson looks at different ways we can use operators in programming, including:

- Making calculations using _arithmetic_ operators.
- Comparing information using _comparison_ operators.
- Creating logical expressions using _logical_ (aka Boolean) operators.






Introduction

Think about the last time you needed to perform long division &mdash; did you write it out on paper or reach for a calculator? We can actually write computer programs that perform calculations for us. In fact, that was their original purpose! 

If we want to write a program that performs calculations, we need to use _arithmetic operators_. They include addition (`+`), subtraction (`-`), multiplication (`*`), and division (`/`). 

- _Addition_ adds an amount to a number: `2 + 3 = 5`
- _Subtraction_ takes away an amount from a number: `10 - 3 = 7`
- _Multiplication_ takes a number and repeats it a specified number of times: `5 * 2 = 10`
- _Division_ takes a number and divides it by another number: `15 / 3 = 5`

How does this work in real life? Let's say we need to buy some apples for the fruit salad recipe. The recipe calls for six apples, but we can only find bags of five. If we buy just enough bags for your recipe, how many extra apples will you have? 

Since one bag isn't enough, we need to buy two bags with five apples each, which would equal 10. Then, we'd subtract the six apples that we need for our recipe to find our answer: 
```js
apples = 5
my_apples = apples * 2 
answer = my_apples - 6
```
If we were to print out `answer`, it would equal `4`. 

You may notice that unlike in math class, we put the "answer" on the left-hand side of the equals sign, rather than to the right. That's because we're saving the value of our answer to a new variable! So, `apples`, `my_apples`, and `answer` are all variables. 

Using Operators to Make Calculations

As we saw, comparison operators allow us to examine the relationship of two values. But what if we're looking at more than two values? 

_Logical operators_, also known as boolean operators, evaluate multiple boolean expressions. Rather than determining if one relationship is true or false, it looks at several relationships by connecting them with logical operators and then determining the logic/validity of the overall expression.

Logical operators include:
- _AND_ &mdash; both expressions evaluate to true, so the final result is true:
  - `((4 > 1) AND (2 < 7)) ` is the same as `(TRUE AND TRUE)`. Evaluates to true. 
- *OR* &mdash; one of the expressions evaluates to true, so the final result is true: 
  - `((8 > 6) OR (3 > 6)) ` is the same as `(TRUE OR FALSE)`. Evaluates to true. 
- _NOT_ &mdash; an expression, no matter its logical value, evaluates to the opposite: 
  - `NOT (1 < 3)` evaluates to `NOT (TRUE)`. Evaluates to false.

The examples given are only a few of the outcomes that you can reach using logical operators. Using logical operators and boolean expressions enable us to handle different scenarios in our program. For example, what if we only had apples in our fridge? If a recipe asked for either apples OR pears, we could still make the recipe. But if a recipe requires both apples AND pears, we wouldn't be able to make it. 

Using Operators to Get Different Outcomes

Now that we know a bit about different operators, let's try writing our own expressions! 

As we've seen, we can use operators to change something's value, add other things to our program, to take them away, or to perform calculations. We can also use operators to compare statements or determine whether they are true or false. 

One important thing about operators when you program is that they may look different from language to language. That's because different programming languages have different _syntax_, or rules for how they are written.  

Putting it All Together

When writing a program, we often need to check if a value is correct or compare two values. 

_Comparison operators_ allow us to compare values and evaluate their relationship. Rather than evaluating to an integer, they evaluate to `true` or `false`, AKA boolean values. Expressions that evaluate to boolean values are known as _boolean expressions_. 

Comparison operators include:
-  Less than `<` &mdash; value to the left is **less than** the value to the right: `2 < 6`
- Greater than ` >` &mdash; value to the left is **more than** the value to the right: `14 > 5` 
- Equals `==` &mdash; value to the left is **equal to** the value to the right: `3 == 3`

Note: we use a double-equal sign to show that we're checking a value, rather than setting it equal to something, like we would with a variable. Some languages even use a triple-equal sign `===` to super-triple-check! 

There are two main instances where we use comparison operators:

**If we have an unknown quantity.** What if we knew that we needed a half pound of strawberries, but we didn't know the weight of each strawberry? We could weigh the strawberries and see if the total weight equals a half pound.

```js
strawberry_weight = ?
is (strawberry_weight == .5lb)? => true
```

**If we need to compare two known values.** If we're making a salad that's super citrusy, then we need to make sure we have more oranges than bananas. If that's false, I'll have to add more oranges. 

```js
bananas = 5
oranges = 3

is (oranges > bananas)? => false
```

Using Operators to Make Comparisons

Congrats! Now you know about different operators and how they can be used to build simple programs.

In this lesson, we learned:

- _Operators_ are symbols that represent different ways of modifying, comparing, and evaluating information.
- _Arithmetic operators_ are used to make calculations.
- _Comparison operators_ determine the relationship between two values, which results in a boolean.
- _Logical operators_ determine the logical state of multiple boolean values or expressions, which results in another boolean. 

Now that you know the building blocks of operators, how can you further combine them to write programs?