Learn how to create and use PHP associative arrays. 

Associative Arrays

PHP also lets us combine arrays. The union (`+`) operator takes two array operands and returns a new array with any unique keys from the second array appended to the first array. 

```php
$my_array = ["panda" => "very cute", "lizard" => "cute", "cockroach" => "not very cute"];
$more_rankings = ["capybara" => "cutest", "lizard" => "not cute", "dog" => "max cuteness"];
$animal_rankings = $my_array + $more_rankings;
```
The `$animal_rankings` we created above will have each of the _key=>value_ pairs from `$my_array`. In addition, it will contain the _key=>value_ pairs from `$more_rankings`: `"capybara"`=>`"cutest"` and `"dog"`=>`"max cuteness"`. However, since `"lizard"` is not a unique key, `$animal_rankings["lizard"]` will retain the value of `$my_array["lizard"]` (which is `"cute"`). 

The union operator can be a little tricky… consider the following union:

```php
$number_array = [8, 3, 7];

$string_array = ["first element", "second element", "third element"];

$union_array = $number_array + $string_array;
```
What values does `$union_array` hold? It has the elements `8`, `3`, and `7`. Since the two arrays being joined have identical keys (`0`, `1`, and `2`), no values from the second array, `$string_array`, are included in `$union_array`. 

Let's get some practice!


Joining Arrays

There are two ways to assign one variable to another: 
+ By value—this creates two variables that hold copies of the same value but remain independent entities.
+ By reference—this creates two variable names (aliases) which point to the same space in memory. They cannot be modified separately!

This remains true when dealing with array variables:
```php
$favorites = ["food"=>"pizza", "person"=>"myself", "dog"=>"Tadpole"];
$copy = $favorites;
$alias =& $favorites;
$favorites["food"] = "NEW!";

echo $favorites["food"]; // Prints: NEW!
echo $copy["food"]; // Prints: pizza
echo $alias["food"]; // Prints: NEW!
```
When passing arrays into functions, both built-in functions and those we write ourselves, we'll want to be conscious of whether the arrays are being passed by value or by reference. 

```php
function changeColor ($arr) 
{
  $arr["color"] = "red";	
}
$object = ["shape"=>"square", "size"=>"small", "color"=>"green"];
changeColor ($object);
echo $object["color"]; // Prints: green
```
Our function above doesn't accept its array argument by reference. Therefore, `$arr` is merely assigned a copy of the argument's value. This copy array is changed when the function is invoked, but that doesn't affect the original argument array (`$object`). To do that, we'd need to pass it by reference: 
```php
function reallyChangeColor (&$arr) 
{
  $arr["color"] = "red";	
}
$object = ["shape"=>"square", "size"=>"small", "color"=>"green"];
reallyChangeColor ($object);
echo $object["color"]; // Prints: red
```
Cool! Let's write some array functions!


Assign by Value or by Reference

As with ordered arrays, using `echo` to print an entire associative array is not very useful:

```php
$grades = [
    "Jane" => 98,
    "Lily" => 74,
    "Dan" => 88,
];

echo $grades; // Prints: Array
```
We can combine each of the values contained by the array into a single string and use `echo` to print that: 
```php
echo implode(", ", $grades); // Prints: 98, 74, 88 
```
A problem with this technique is that it only displays the values. We don't see the keys in the array or the relationships between the keys and values. To display this information, we can use the built-in `print_r()` function: 

```php
print_r($grades);
```
The above code will produce the following output:
```bash
Array
(
    [Jane] => 98
    [Lily] => 74
    [Dan] => 88
)
```
Let's print some associative arrays!


Printing Associative Arrays

The same syntax that adds new array elements can be used to change existing elements:
```php
$new_arr = ["first" => "I am first!", "second" => "I am second!"]; 

$new_arr["third"] = "I am third!";

echo $new_arr["third"]; // Prints: I am third!

$new_arr["third"] = "I am the *NEW* third!";

echo $new_arr["third"]; // Prints: I am the *NEW* third!
```
In the above code, we use the same syntax to add a _key=>value_ pair (`"third"` => `"I am third!"`) as we do to assign that key a new value (`"third"` => `"I am the *NEW* third!"`).

Since PHP will allow us to add a new _key=>value_ pair *or* change an existing value using exactly the same code, we'll need to use caution to avoid accidentally overwriting an existing value.

We can remove a _key=>value_ pair entirely using [the PHP `unset()` function](https://www.php.net/manual/en/function.unset.php). Note: if the key used doesn't exist in the array, then nothing happens. 

```php
$nums = ["one" => 1,"two"=> 2];

echo implode(", ", $nums); // Prints: 1, 2

unset($nums["one"]);

echo implode(", ", $nums); // Prints: 2
```

In the code above, we created an associative array with two _key => value_ pairs. We then removed the pair `"one"` => `1` using the `unset()` function. 

Let's practice changing and removing elements!


Changing and Removing Elements 

 _Associative arrays_ are collections of _key=>value_ pairs. The key in an associative array must be either a string or an integer. The values held can be any type. We use the `=>` operator to associate a key with its value. 
![key/value pairs](https://content.codecademy.com/courses/learn-javascript-objects/key%20value.svg)
We can think of keys as _pointing_ to their values since the key points the computer to the space in memory where the value is stored.  	

```php
$my_array = ["panda" => "very cute", "lizard" => "cute", "cockroach" => "not very cute"];
```
In the code above, we created an associative array using short array syntax. `$my_array` has three _key=>value_ pairs: 
+ The key `"panda"` points to the value `"very cute"`.
+ The key `"lizard"` points to the value `"cute"`.
+ The key `"cockroach"` points to the value `"not very cute"`.

We can also build associative arrays using the PHP `array()` function. 
```php
$about_me = array(
    "fullname" => "Aisle Nevertell",
    "social" => 123456789
);
```
In the code above, we created an associative array, `$about_me`, with two _key=>value_ pairs: 
+ The key `"fullname"` points to the value `"Aisle Nevertell"`.
+ The key `"social"` points to the value `123456789`.

Let's make some arrays!


You learned so much in this lesson! Let's review:

+ _Associative arrays_ are data structures in which string or integer _keys_ are associated with _values_.
+ We use the `=>` operator to associate a key with its value. `$my_array = ["panda"=>"very cute"]`
+ To print an array's keys and their values, we can use the `print_r()` function.
+ We access the value associated with a given key by using square brackets (`[ ]`). For example: `$my_array["panda"]` will return `"very cute"`.
+ We can assign values to keys using this same indexing syntax and the assignment operator (`=`): `$my_array["dog"] = "good cuteness";`
+ This same syntax can be used to change existing elements. `$my_array["dog"] = "max cuteness";`
+ We can remove a _key=>value_ pair entirely using the PHP `unset()` function.
+ Keys can be integers. In fact, ordered arrays are just arrays in which integer keys have been assigned to the values automatically. 
+ In PHP, associative arrays and ordered arrays are different uses of the same data type.
+ The union (`+`) operator takes two array operands and returns a new array with any unique keys from the second array appended to the first array.
+ When writing function with array parameters, we can pass the array by value or by reference depending on our intent. 

Awesome work!

Review

Associative arrays can use integers as keys, in addition to strings. 
```php
$num_array = [1000 => "one thousand", 100 => "one hundred", 600 => "six hundred"];
echo $num_array[1000]; // Prints: one thousand
```
When we build ordered arrays in PHP, the association with numerical keys to values is done for us automatically. The first element is associated with the key `0`, the second with `1`, and so on. But ordered arrays are still the same structure as associative arrays. We can mix and match:
```php
$ordered = [99, 1, 7, 8];
$ordered["special"] = "Cool!";
echo $ordered[3]; // Prints: 8
echo $ordered["special"]; // Prints: Cool!
``` 
When we add an element to an array without specifying a key (e.g. using `array_push()`), PHP will associate it with the "next" integer key. If no integer keys have been used, it will associate it with the key `0`, otherwise it will associate it one more than the largest integer used thus far. This behavior is the same whether the array is being used as an ordered array or an associative array. Let's look at an example:

```php
$num_array = [1000 => "one thousand", 100 => "one hundred", 600 => "six hundred"];
$num_array[] = "New Element in \$num_array";
echo $num_array[1001]; // Prints: New Element in $num_array

$animals_array = ["panda"=>"very cute", "lizard"=>"cute", "cockroach"=>"not very cute"];
array_push($animals_array, "New Element in \$animals_array");
echo $animals_array[0]; // Prints: New Element in $animals_array
```
Even though associative arrays and ordered arrays are technically the same, we recommend treating them as separate data types. Only use the empty square brackets syntax (or functions like `array_push()`) with ordered arrays. 

But, for now, let's break this rule a little to get used to the ins and outs of PHP arrays!


Numerical Keys

We can access the value that a given key points to by using square brackets (`[]`):

```php
$my_array = ["panda"=>"very cute", "lizard"=>"cute", "cockroach"=>"not very cute"];
echo $my_array["panda"]; // Prints: very cute
``` 
In the code above, we accessed the value `"very cute"` using its key, `"panda"`. 

To add new elements to an associative array, we use the assignment operator (`=`):
```php
$my_array["capybara"] = "cutest";
echo $my_array["capybara"]; // Prints: cutest
```
In the code above, we added a fourth key value pair to the array. We accessed the new value `"cutest"` using its key `"capybara"` and printed it using `echo`. 

The computer treats code between the square brackets as an expression, so that code will be evaluated before the array is accessed. This enables us to use variables, functions, and operators within the square brackets:

```php
$favorites = ["favorite_food"=>"pizza", "favorite_place"=>"my dreams", "FAVORITE_CASE"=>"CAPS", "favorite_person"=>"myself"];

echo  $favorites["favorite" . "_" . "food"]; 
// Prints: pizza

$key =  "favorite_place";
echo  $favorites[$key];  
// Prints: my dreams

echo $favorites[strtoupper("favorite_case")];
// Prints: CAPS
```

Let's access some elements!


Accessing and Adding Elements

Ordered arrays are awesome when we have data that lends itself to being collected into an ordered (indexed) list. But data can be collected and organized in lots of ways. 

Imagine we wanted a data structure to hold a bunch of information about ourself: our name, age, email address, birthday, social security number, and favorite food. We want all of these pieces of data in a single collection but not necessarily in any particular order. And it doesn’t make much sense to access these data items using indices, like in an ordered array. It would be hard to remember, for example, that index `0` corresponds to our name.
 

Time to meet another fundamental concept in computer science—the map. A _map_ associates keys with values. A key is a string or integer that we use to access a value (of any type). We could create a map with a key `"fullname"` that points to a value of `"Aisle Nevertell"`; this is much more understandable than associating the name with index `0`. Whenever we need to access a value, we'll be able to use the _associated_ key to find it. 

The PHP array type that we’ve been working with is actually implemented as a map! In a PHP ordered array, the index locations are the keys. But the PHP array type also enables us to build more traditional map-like structures where we assign meaningful keys to values (as opposed to indices). We call data structures like this _associative arrays_.
