Learn how to use the list data type to store and edit ordered data.

Lists

Congratulations! Now you've learned about another data type known as a list. 

- A _list_ is an ordered sequence of information
- You can access an item in a list by using its _index_ position
- You can _append_ items to the end of the list or _insert_ them in the middle
- You can also _remove_ an item from the end or middle of a list


Lists: Review

We're also able to remove items from a list. 

Similar to adding items, we can modify lists by taking off the last item, or we can use indexing to select a specific item and remove it from the list. 

```js
myList = ['apple', 'banana', 'pear']

// removes 'pear' from myList and returns 'pear'
myList.pop() 

// now, myList == ['apple', 'banana']
```
This line of code will take away the last item from our list, keeping our sequence intact. But we can also remove items from the middle of our list:


```js
myList = ['apple', 'banana', 'pear']

myList.splice(1, 1) // removes 'banana' from myList and returns 'banana'

// now, myList == ['apple', 'pear']
```

Removing Items from a List

Lists _order_ items so that they're in a specific sequence. For example the comic strip, as a list, stores frames in a specific order. Without an order, the story wouldn’t make sense!

This idea of sequence is important because it tells us that each value has a specific position in the list. The position of value in a list is known as its _index_. You can think of an index like an address - it's what we use to locate an item in a list. 

List indices (the plural of index) are numbers. Usually, lists will start their index at 0 and then add one for each value. So if you want to select the first item in the list, make sure to remember to use 0 in order to do so!

![list_indices](https://content.codecademy.com/programs/code-foundations-path/bop-iii/lists/array_slice.svg)

Knowing an item's index allows us to select a value from a list and do something with it, like save it to a variable. It can also be useful in modifying a list, whether by adding something or removing it. 

Accessing List Items

After a list is created, we're able to add things to it.  

When we add things to the end of an existing list, we say that we're _appending_ them to the end. Imagine we're trying out different endings for our comic strip. We can try adding different frames to our current narrative and see which one we like the best.

```js
myList = ['apple', 'banana', 'pear']

myList.push('orange') // the .push command is JavaScript's implementation for appending an item to the end of a list

// now, myList == ['apple', 'banana', 'pear', 'orange']
```


In addition to adding things to the end of a list, we can also insert items in the existing list. We do so by using the index number for where we want to position our new value. 


```js
myList = ['apple', 'banana', 'pear']

myList.splice(1, 0, 'mango') // make 'mango' the second item in the list

// now, myList = ['apple', 'mango', 'banana', 'pear']

```
In this line of code, we inserted the string `'mango'` at the index 1 position.
But it's important to be careful - adding something in the middle of a pre-existing list, or adding it to the beginning of a list, will alter the indices for all the following items. Notice that 'banana' was in the second position and is now in the third.

In JavaScript, we can edit lists with commands like `.splice` and `.pop`. You don’t need to memorize these commands – the important part is that you understand the ways in which lists can be edited!


Adding Items to a List

Great! Now that you know all about lists, let's write some code. 

There are many ways to create lists and they can change depending on what language you are programming in. Here's an example of a list in JavaScript that contains three items:

```js
myList = ['apple', 'banana', 'pear']
```

In JavaScript, lists are created by defining a name for the list (such as `myList`), then setting it equal to a set of brackets `[]`. If there's nothing in between the brackets, the list is empty. But `myList` has three items in between brackets `[]`, each separated by a comma `,`:
- `'apple'`
- `'banana'`
- `'pear'`

You may have noticed that those were all _strings_. We can also put other data types in a list, including numbers and boolean values. We can even put other lists in a list!

To select an item from the list, we use the following syntax:
```js
// the following line will return 'apple'
myList[0]
```

Where `myList` is the name of the list we are selecting from and `[0]` is the first item in the list. As we may remember, the first item is at the 0th index. So this code would grab the string, `'apple'`. 

Let's look at another example using the following list:

```js
colors = ['red', 'yellow', 'green', 'blue']
```

To select the third item in the list, we would write `colors[2]`: 
```js
// the following line will return 'green'
colors[2]
```

We could also save this selection to a variable, so we can use it later in our code:

```js
// now myFavoriteColor is equal to 'green'
myFavoriteColor = colors[2]
```

Lists: Putting it Together

When we start writing more complex programs, we'll start working with more pieces of data. But data can get messy real fast if we're not careful. 

To keep our data tidy, we'll want to use _data structures_. Data structures are formats that we can use to keep track of our data in an organized fashion.

_Lists_ are one very basic data structure. Programmers use lists as a container to store multiple pieces of information that relate to each other in some way. Like a list of the presidents of the US, types of cheeses in alphabetical order, and the finishing positions of runners in a race.
 
What makes lists special is that they order our data in a specific, linear sequence.

Since our values are kept in order, it allows us to easily find the information we're looking for; otherwise, we'd have a huge jumbled mess of data!


In this lesson, we're going to cover:
- Accessing an item from a list
- Adding an item to a list
- Removing an item from a list
