CYBER WEEK SALE: Get 50% off your Pro annual membership using code [CYBER23](https://www.codecademy.com/checkout?periods=year&plan_id=proGoldAnnualV2&discountCode=CYBER23)


Learn about storing data in ordered lists with the PHP ordered arrays data structure. 

Ordered Arrays

So far in our PHP programming, we've been thinking about individual pieces of data. We've seen how useful variables can be for holding a single value, for example. But as our programs grow more complicated, it's often useful to organize data into **collections** of elements, and to work with those collections as individual entities. 

For example, when we build a to-do list, each item on the list is one piece of data, but the collection of all of the elements together is also a meaningful object. To help us store and manipulate related elements of data together, programming languages employ _data structures_. 

One type of data structure fundamental to computer science is an _array_, a list of ordered, stored data. In PHP, we refer to this data structure as an _ordered array_. 

The location of an element in an array is known as its _index_. The elements in an ordered array are arranged in ascending numerical order starting with zero—the index of the first array element is 0, the index of the second is 1, and so on. 

Fun fact: Outside of programming, it's somewhat unusual to see a count that starts at 0 instead of 1, but there's a reason you'll see this in many programming languages. In the original implementation of the array data structure, the computer reserved side-by-side spots in memory for each element in an array, but it was too inefficient to keep track of all these memory locations. Therefore, the computer only stored the memory address of the very first element. The index was used to indicate how far away from the start of the array a given element was located. The first element of an array was zero spaces away from that stored address, hence it was at the 0th index. 


Introduction

In addition to using `array()`, we can also create an array by wrapping comma-separated elements in square brackets (`[ ]`). This feature is sometimes referred to as _short array syntax_, and more closely resembles what you might see in other programming languages.  

```php
$number_array = [0, 1, 2];
```
In the code above, we created the variable `$number_array` and assigned as its value an array containing the numbers `0`, `1`, and `2`. The number `0` is located at the 0th location index, the number `1` at the 1st, and the number `2` and the 2nd.

Let's compare using short array syntax with invoking the `array()` function:

```php
$string_array = array("first element", "second element");
$str_arr_short = ["first element", "second element"];

$mixed_array = array(1, "chicken", 78.2, "bubbles are crazy!");
$mix_arr_short = [1, "chicken", 78.2, "bubbles are crazy!"];
```
Here, regardless of which method we used, we got the same results.

When constructing arrays, we can also place each element on its own line to make it easier to read:
```php
$long_array = [
  1,
  2,
  3,
  4,
  5,
  6
];
```

Let's practice creating some short syntax arrays!


Creating Arrays with Short Syntax

We covered a lot in this lesson! Great job. Take a second to review everything you learned:

+ _Arrays_ are ordered collections of data that are a type of data structure fundamental to computer science. 
+ In PHP, we refer to this data structure as _ordered arrays_.
+ The location of an element in an array is known as its _index_. 
+ The elements in an ordered array are arranged in ascending numerical order starting with index zero.
+ We can construct ordered arrays with a built-in PHP function: `array()`.
+ We can construct ordered arrays with short array syntax, e.g. `[1,2,3]`.
+ We can print arrays using the built-in `print_r()` function or by converting them into strings using the `implode()` function.
+ We use square brackets (`[]`) to access elements in an array by their index.
+ We can add elements to the end of an array by appending square brackets (`[]`) to an array variable name and assigning the value with the assignment operator (`=`).
+ We can change elements in an array using array indexing and the assignment operator. 
+ The `array_pop()` function  removes the last element of an array.
+ The `array_push()` function adds elements to the end of an array.
+ The `array_shift()` function removes the first element of an array.
+ The `array_unshift()` function adds elements to the beginning of the array.
+ We can use chained square brackets (`[]`) to access and change elements within a nested array.

Review

We mentioned that arrays can hold elements of any type—this even includes other arrays! We can use chained operations to access and change elements within a nested array:

```php
$nested_arr = [[2, 4], [3, 9], [4, 16]];
$first_el = $nested_arr[0][0];
echo $first_el; // Prints: 2
```
Above, `$nested_arr` is an array with three array elements. The first, located at the 0th index, is the array `[2, 4]`. The expression `$nested_arr[0]` returns that array. We then index _that_ array's first element by appending an additional `[0]`. 

This can take practice to get used to. One helpful technique is to act like the computer; evaluate each part of the expression from left to right. By breaking down a complex expression into its simpler parts, it becomes easier to understand. Let's walk through a more complicated example together: 

```php
$very_nested = [1, "b", 33, ["cat", 6.1, [9, "LOST!", 6], "mouse"], 7.1];
``` 
We want to change the element which is currently `"LOST!"` to `"Found!"`. 
Let's breakdown the steps: 
+ We need the outermost array first: `$very_nested[3]` evaluates to the array `["cat", 6.1, [9, "LOST!", 6], "mouse"]`
+ Next we need the array located at the 2nd location index: `$very_nested[3][2]` evaluates to the array `[9, "LOST!", 6]`
+ And finally, the element we're looking for: `$very_nested[3][2][1]` evaluates to `"LOST!"`
```php
$very_nested[3][2][1] = "Found!";
``` 

Let's get some more practice with nested arrays!


Nested Arrays

Since arrays are a more complicated data type  than strings or integers, printing them is slightly more challenging. Using `echo` won't have the desired result:

```php
$number_array = [0, 1, 2];
echo $number_array; // Prints: Array
```
When we tried to use `echo` to print `$number_array`, it printed the word "Array" rather than the contents of the array. To print the contents of the array, we can use PHP built-in functions. The [built-in `print_r()` function](https://php.net/manual/en/function.print-r.php) outputs arrays in a human **r**eadable format:

```php
print_r($number_array);
```
This will output the array in the following format:
```
Array
(
    [0] => 0
    [1] => 1
    [2] => 2
)
```
If we merely want to print the elements in the array listed, we can convert the array into a string using the [built-in `implode()` function](https://www.php.net/manual/en/function.implode.php). The `implode()` function takes two arguments: a string to use between each element (the `$glue`), and the array to be joined together (the `$pieces`):
```php
echo implode(", ", $number_array);
```
This will output in the following format:
```
0, 1, 2 
```
Let's practice printing arrays!


Printing Arrays

We saw that `array_pop()` and `array_push()` deal exclusively with the end of the array (the index at the length of the array minus 1). PHP also provides functions for adding and removing elements from the beginning of an array (index `0`). 

The [`array_shift()` function](https://www.php.net/manual/en/function.array-shift.php) removes the first element of an array and returns that value. Each of the elements in the array will be *shifted* down an index. For example, the element that was previously at the 3rd index will now be located at the 2nd. 

```php
$adjectives = ["bad", "good", "great", "fantastic"];
$removed = array_shift($adjectives); 
echo $removed; //Prints: bad
echo implode(", ", $adjectives); // Prints: good, great, fantastic 
```
Just like `array_pop()`, `array_shift()` reduces the length of the array, and the deleted element is gone for good.

The [`array_unshift()` function](https://www.php.net/manual/en/function.array-unshift.php) takes an array as its first argument. The arguments that follow are elements to be added to the beginning of the array. It returns the new number of elements in the array. 

```php
$foods = ["pizza", "crackers", "apples", "carrots"];
$arr_len = array_unshift($foods, "pasta", "meatballs", "lettuce"); 
echo $arr_len; //Prints: 7
echo implode(", ", $foods); 
// Prints: pasta, meatballs, lettuce, pizza, crackers, apples, carrots
```
Let's practice!


Shifting and Unshifting

In the previous exercise, we learned how to add single array elements and to change array elements at a given index. PHP also provides us with built-in methods for removing array elements, and for adding many elements at once. 

The [`array_pop()` function](https://www.php.net/manual/en/function.array-pop.php) takes an array as its argument. It removes the last element of an array and returns the removed element. 

```php
$my_array = ["tic", "tac", "toe"];
array_pop($my_array); 
// $my_array is now ["tic", "tac"]
$popped = array_pop($my_array); 
// $popped is "tac"
// $my_array is now ["tic"]
```
Note that `array_pop()` doesn’t just set the last element to `NULL`. It actually removes it from the array, meaning that array's length will decrease by one (which we can verify using `count()`).

The [`array_push()` function](https://www.php.net/manual/en/function.array-push.php) takes an array as its first argument. The arguments that follow are elements to be added to the end of the array. `array_push()` adds each of the elements to the array and returns the new number of elements in the array. 

```php
$new_array = ["eeny"];
$num_added = array_push($new_array, "meeny", "miny", "moe"); 
echo $num_added; // Prints: 4
echo implode(", ", $new_array); // Prints: eeny, meeny, miny, moe 
```
Let's practice!


More Array Methods: Pushing and Popping

We can make adjustments to existing arrays—we don’t have to create a new array when we want our array to change.    

We add elements to the end of an array by taking the variable name and appending square brackets (`[]`), the assignment operator (`=`), and the element we want to add:

```php
$string_array = ["first element", "second element"];

$string_array[] = "third element";

echo implode(", ", $string_array); 
// Prints: first element, second element, third element 
```	
We can also reassign the individual elements in an array:

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

$string_array[0] = "NEW! different first element";

echo $string_array[0]; // Prints: NEW! different first element"
```
In the code above, we replaced the original string held in the array (`"first element"`) with a new string value: `"NEW! different first element"`.


Adding and Changing Elements

We can construct ordered arrays with a [built-in PHP function: `array()`](https://www.php.net/manual/en/function.array.php). 

The `array()` function returns an array. Each of the arguments with which the function was invoked becomes an element in the array (in the order they were passed in). 

Arrays are most useful when we store them in variables. We create an array variable the same way we create variables of other data types—with the assignment operator.


```php
$my_array = array(0, 1, 2);
```
In the code above, we constructed an array using the `array()` function which we captured with the `$my_array` variable.  `$my_array` is an array with three elements: `0` is located in the 0th index, `1` in the 1st, and `2` in the 2nd.

PHP arrays can store elements of any data type:
```php
$string_array = array("first element", "second element");
```
In the code above, `$string_array` holds two string elements. The string `"first element"` is located at the 0th location index, and the string `"second element"` is located at the 1st. 

PHP arrays can also store elements of multiple data types:
```php
$mixed_array = array(1, "chicken", 78.2, "bubbles are crazy!");
``` 
Above, `$mixed_array` holds four elements—some are strings while others are numbers. 

We can use the [built-in PHP `count()` function](https://www.php.net/manual/en/function.count.php) to get the number of elements in an array. This is especially useful as we work with larger and more complicated arrays:

```php
echo count($my_array); // Prints: 3
echo count($string_array); // Prints: 2
echo count($mixed_array); // Prints: 4
```

Let's create some arrays!


Creating Arrays with array()

The individual elements in an array can be accessed using the array variable's name, and the location index surrounded by square brackets (`[]`), for example:

```php
$my_array = ["tic", "tac", "toe"];

echo $my_array[1]; // Prints: tac
```
This process is sometimes referred to as _indexing_ an array. 

Remember the computer _evaluates_ variables it encounters (outside of assignment): it replaces them with the values they hold. Let's look at an example of indexing an array with a number variable:
```php
$num_var = 2;

$important_info = ["talking chicken", 181, "magnets?!", 99];

echo $important_info[$num_var]; // Prints: magnets?!
```

Let's practice accessing elements in arrays!
