PHP Strings and Variables

Awesome work! We've covered a lot of material in this lesson, so let's review:
- Strings are collections of text that the computer treats as a single piece of data. 
- A string can be any length and contain any letters, numbers, symbols, or spaces surrounded by quotation marks. 
- In order to include certain characters inside strings we have to use escape sequences.
- An _operator_ is a character that performs a task in our code.
- We can use the concatenation operator (`.`) to combine two strings into one. 
- Variables are a fundamental programming concept which allow us to easily reuse data in our code. 
- We declare a variable using the dollar sign (`$`) followed by the variable name and then use the assignment operator (`=`) to give it a value. 
- PHP has variable parsing which allows us to include variables directly in our strings. 
- Once a variable has been assigned, we can change its value. This is called reassignment. 
- We can create an alias for a variable, instead of just a copy, using the reference assignment operator (`=&`).
- Operations to the right of the assignment operator will be evaluated before assignment takes place.
- The concatenating assignment operator (`.=`) is a shorthand notation for reassigning a string variable to its current value appended with another string value.  

If that was a lot to take in, don't worry about memorizing everything right away. Remember that when you want to explore more about the language, <a href="http://php.net/manual/en/langref.php" target="_blank" rel="noopener noreferer">the documentation</a> is a great place to get comfortable exploring.


Review

Let's look at an example of creating a variable:

```php
$my_name = "Aisle Nevertell";
```
In the code above, we're actually doing two things with a single statement: we're _declaring_ a new variable by giving it the name `my_name`. We're also _assigning_ it the value `"Aisle Nevertell"`. The variable `$my_name` now holds the value `"Aisle Nevertell"`.

To declare a variable we use the dollar sign character (`$`) followed by our chosen variable name. The dollar sign is known as a _sigil_; it's a character that allows the computer to see quickly that something is a variable.  

To assign it a value we use another operator: the assignment operator (`=`) followed by the value we're assigning to the variable. 

Though it can occasionally be useful to separate these actions, we'll most often be declaring and assigning variables at the same time. 

![syntax diagram](https://content.codecademy.com/courses/php-strings-variables/PHP_m2l1e5.svg)

In PHP, variables names can contain numbers, letters, and underscores (`_`), but they have to start with either a letter or an underscore. Variable names are case sensitive, meaning that PHP will treat the variables `$my_example` and `$My_example` as two different variables.

One common convention when naming PHP variables is to use an underscore between words on variable names with more than one word in their name. This is known as _snake case_:
```php
$mood = ":)";
$favorite_food = "Red curry with eggplant";
```
Let's create some variables!

Creating Variables

The word variable comes from the latin variāre which means "to make changeable." This is an apt name because the value assigned to a variable can change. 

![gif of reassignment](https://content.codecademy.com/courses/php-strings-variables/PHPVariable_m2l1e8.gif)

The process of assigning a new value to a variable is called _reassignment_. We reassign a variable using the assignment operator on a variable that's already been declared:

```php
$favorite_food = "Red curry with eggplant";
echo $favorite_food; // Prints: Red curry with eggplant

// Reassign the value of $favorite_food to a new string
$favorite_food = "Pizza"; 
echo $favorite_food; // Prints: Pizza
```
It's often useful to create new variables assigned to the same value as an existing variable:

```php
$first_player_rank = "Beginner";
$second_player_rank = $first_player_rank; 
```
In the code above, we declared the variable `$first_player_rank` and assigned to it the string `"Beginner"`. Next, we declared  `$second_player_rank` and assigned it to `$first_player_rank`. 

This created a new variable (`$second_player_rank`) assigned the value `"Beginner"`. Notice how variables can be treated different depending on where they appear in code. During variable assignment or reassignment, the variable on the left of the assignment operator is treated as a variable (named storage for holding a value) while a variable on the right of the operator is treated as the value it stores. 



Variable Reassignment

When we create a variable assigned to another variable, the computer finds a new space in memory which it associates with the left operand, and it stores a copy of the right operand's value there. 

![GIF of assigning by value](https://content.codecademy.com/courses/php-strings-variables/PHPVariable_4_v3.gif)

This new variable holds  a *copy* of the value held by the original variable, but it's an independent entity; changes made to either variable won't affect the other:

```php
$first_player_rank = "Beginner"; 
$second_player_rank = $first_player_rank; 
echo $second_player_rank; // Prints: Beginner

$first_player_rank = "Intermediate"; // Reassign the value of $first_player_rank
echo $second_player_rank; // Still Prints: Beginner
```
We can also create an alias, or nickname, for a variable. Instead of a copy of the original variable's value, we create a new name which points to the same spot in memory. 

![GIF of assigning by reference](https://content.codecademy.com/courses/php-strings-variables/PHPVariable_5_v3.gif)

We use a different operator for this&mdash;the reference assignment operator (`=&`).

When we _assign by reference_ we're saying that the variable on the left of the operator should point, or _refer_, to the exact same data as the variable on the right. With assignment by reference, changes made to one variable will affect the other:

```php
$first_player_rank = "Beginner";
$second_player_rank =& $first_player_rank; 
echo $second_player_rank; // Prints: Beginner

$first_player_rank = "Intermediate"; // Reassign the value of $first_player_rank
echo $second_player_rank; // Prints: Intermediate
```
Ok, let's get some practice! 
  


Assign by Reference

We use quotation marks to indicate the start and end of a string. The quotation marks tell the computer that we want everything inside them to be treated as a single piece of data. But how do we include quotation marks inside a string? 

Consider the following string: `"She said "hi" to the dog."` 

In the code above, the quotes around "hi" are intended to be part of the string, but the computer will actually see two strings `"She said "` and `"  to the dog."` with `hi` in between. Since `hi` won't be recognized as valid PHP it will result in an error:

```php
echo "She said "hi" to the dog."; //syntax error, unexpected 'hi' (T_STRING)
```
In order to indicate which quotation marks the computer should view as instructions vs which it should view as simply characters, PHP allows for _escape sequences_. An escape sequence usually consists of a backslash (`\`) immediately followed by another character. 
```php
echo "She said \"hi\" to the dog."; // Prints: She said "hi" to the dog.
```
Quotation marks aren't the only symbol requiring an escape sequence. When we print multiple strings, PHP will print them to the same line by default: 
```php
echo "1. Go to gym";
echo "2. Cook dinner"; 
```
The code above will output `1. Go to gym2. Cook dinner`. To print the second string on a new line, we can use the newline escape sequence (`\n`):
```php
echo "1. Go to gym";
echo "\n2. Cook dinner"; 
/* Prints
1. Go to gym
2. Cook dinner
*/
```
You don't need to worry about other escape sequences yet, but if you'd like to see the full list you can find one in <a href="http://php.net/manual/en/language.types.string.php#language.types.string.syntax.double" target="_blank" rel="noopener noreferer">the PHP documentation</a>. 

Let's practice!


Escape Sequences

![illustration of string](https://content.codecademy.com/courses/php-strings-variables/PHP_m2l1e1.svg)

In everyday conversation, we use the word data to refer to any sort of information. This information is often a list of numbers, like a company's monthly expenses or statistics about an athlete's performance. However, in programming, data means something very specific. It's still information, but that information takes the form of a few specific types. 

The PHP language has different ways of handling different types of data. Which actions the computer can perform and how the computer stores the data in memory will vary based on the type. In this lesson, we'll be learning about the _string_ data type.

Strings are words or pieces of text that the computer treats as a single item. A string is a sequence of characters. It can be any length and contain any letters, numbers, symbols, or spaces surrounded by quotation marks. 

```php
echo "My first string"; // Prints: My first string
```
It's important to distinguish between strings and the rest of the code in a PHP program. Every part of a program is text, but strings are the parts we intend to keep as data—not as instructions to be executed by computer. In this lesson we're going to focus on strings wrapped in double quotation marks (if you're curious, you can check out  <a href="http://php.net/manual/en/language.types.string.php" target="_blank" rel="noopener noreferer">the official PHP documentation</a> to see other types of PHP strings). 

In later lessons, we'll be using PHP to create custom HTML documents enabling dynamic web pages. As we learn the basics, however, we'll be writing simple PHP only programs that run in the terminal. 

Let's make some strings!

Strings

Let's say I have a really long string in my program, and I'm going to need to use it multiple times. Do I have to type the string out every time I need to use it? The answer is "no". Variables are a fundamental programming concept designed to address this concern. With variables, we store values so that we can easily reuse them throughout a program. 

Before we can use variables in our code, we need to declare and assign them. 

 _Declaring_ a variable is the process of reserving a word, the _variable name_, which we'll be able to refer to in our code. It's good practice to name the variable in a way that describes the data it holds.

 _Assignment_ is the process of associating that variable name with a specific value so that everytime we use the variable's name the computer will grab that value.  

![gif of assigning a variable](https://content.codecademy.com/courses/php-strings-variables/PHP_m2l1e4n.gif)


cardboard boxes used to represent variables 

Variables

It can be useful to combine two strings together. This process is called _string concatenation_, and we can use the concatenation operator (`.`) to do this. 

An _operator_ is a character that performs a task in our code. The computer will take the string to the left of the concatenation operator, combine it with the string to the right, and return the resulting single string. Let's see an example of string concatenation:
```php
echo "one" . "two"; // Prints: onetwo
```
Notice how the string "onetwo" was printed. The computer won't make any assumptions for us—it will combine the strings exactly as they are without adding any spaces or line-breaks. If we want spaces, we'll have to add any spaces we want ourselves. Here we added a space to the string `"one "`:
```php
echo "one " . "two"; // Prints: one two
```
We can also combine, or chain, our operations to get a final result:

```php
echo "one" . " " . "two" . " " . "three"; // Prints: one two three
```
The concatenation operator takes two strings (the _operands_) and produces a string as a result (the return value). As we delve deeper into PHP, we'll learn about other kinds of operators. Most will take one or two operands, but there's even one that takes three. 

Let's join some strings together!


String Concatenation

In the last exercise, we saw how concatenating a number of strings and string variables got annoying. There's an easier way! 

PHP strings allow us to place variables directly into double quoted strings. These variables will be _parsed_ which means the computer will read the variables as the value they hold rather than see them as just a sequence of characters. 

```php
$dog_name = "Tadpole";
$favorite_food = "salmon";
$color = "brown";

echo "I have a $color dog named $dog_name and her favorite food is $favorite_food.";
// Prints: I have a brown dog named Tadpole and her favorite food is salmon.
```

PHP string parsing is incredibly useful. Whenever PHP sees a dollar sign (`$`) inside a string it will assume all the characters next to it (until it reaches a character that couldn't be included in a variable name) are a part of the variable name. 

Sometimes this can get complicated. Consider the following example:
```php
$toy = "frisbee";
echo "Alex likes playing with $toys";
```
The code above will cause an error. Why? The computer was looking for a variable `$toys` and couldn't find one. 

Fear not! PHP allows us to specifically indicate the variable name by wrapping it in curly braces to avoid any confusion. We'll include the dollar sign followed by the variable name wrapped in curly braces:
```php
$dog_name = "Tadpole";
$favorite_food = "treat";
$color = "brown";

echo "I have a ${color}ish dog named $dog_name and her favorite food is ${favorite_food}s.";
// Prints: I have a brownish dog named Tadpole and her favorite food is treats.
```
Let's have PHP do some variable parsing for us!


Variable Parsing

We can assign and reassign variables to the values that result from operations:

```php
$full_name = "Aisle" . " Nevertell";
echo $full_name; // Prints: Aisle Nevertell
```
During assignment, the computer will first evaluate everything to the right of the assignment operator and return a single value. 

In the code above, the computer will concatenate the strings `"Aisle"` and `" Nevertell"` into the value `"Aisle Nevertell"`. It will then assign this string as the value to the `$full_name` variable. 

This is true even for more complex operations:

```php
$full_name = "Aisle" . " " . "Nevertell" . " " . "Nomaderwat";
echo $full_name; // Prints: Aisle Nevertell Nomaderwat
```
One theme you may notice as you learn a programming language's syntax is that common actions that programmers need to do a lot often have a shortcut. Consider the following:
```php
$full_name = "Aisle";
$full_name = $full_name . " Nevertell";
echo $full_name; // Prints: Aisle Nevertell
```
In the code above, we have the variable `$full_name` assigned the value `"Aisle"`. We want to reassign `$full_name` to its current value appended with the string `" Nevertell"`.

Believe it or not, this is such a common task that PHP offers a shorthand notation, the concatenating assignment operator (`.=`). Let's compare the same action but using this alternate operator:

```php
$full_name = "Aisle";
$full_name .= " Nevertell";
echo $full_name; // Prints: Aisle Nevertell
```
It may seem funny to provide a shortcut to save just a few characters of typing, but when operations are performed often enough, those keystrokes can really add up. This syntax is also faster and easier to read which makes code easier to maintain. 

One important thing to note is that even though PHP is often flexible about whitespace, it is inflexible with the concatenating assignment operator&mdash;the `.` and `=` characters must not have any spaces or other whitespace characters between them. 

Let's practice!


Concatenating Assignment Operator

Once we've declared a variable and assigned a value to it, we can use it as many times as we want. We refer to a variable by using the dollar sign followed by the variable's name. 

```php
$favorite_food = "Red curry with eggplant, green beans, and peanuts";
echo $favorite_food; 
// Prints: Red curry with eggplant, green beans, and peanuts
``` 
Except during assignment, whenever the computer sees a variable in your code, it replaces the variable with the value assigned to that variable. 

```php
$dog_name = "Tadpole";
echo $dog_name; 
// Prints: Tadpole
```
Since the computer treats a variable just as if it were the value it holds, this means we can do operations on variables just as we would with any value of that type. 

```php
$dog_name = "Tadpole";
echo "My dog is named " . $dog_name; 
// Prints: My dog is named Tadpole
```
In the code above, we concatenated the string `"My dog is named "` to the value held by the `$dog_name ` variable (`"Tadpole"`). Let's look at another example that uses multiple variables:
```php
$dog_name = "Tadpole";
$favorite_food = "salmon";
$color = "brown";

echo "I have a " . $color . " dog named " . $dog_name . " and her favorite food is " . $favorite_food . ".";
// Prints: I have a brown dog named Tadpole and her favorite food is salmon.
```
Let's use some variables!
