[MUSIC]

Hi, I'm Jason.

Let's start talking about arrays in Ruby.

So far, some basic types that we've learned about are strings and numbers.

Strings let us work with textual data in our programs, and

numbers with numerical data.

Let's say that we wanted to create a shopping list.

Inside of the shopping list,

our grocery items could be something like milk, eggs, and bread.

We could store that list in a string separated by commas.

Or we could use three different strings called something like item one,

item two, item three, and so on.

However, Ruby gives us a type specifically to work with that kind of data.

We could use an array.

An array is a container of data.

You can think of it as a list.

We could store all of our different grocery items inside of the array.

Arrays can store any type of thing that we have access to in Ruby.

Let's see how to make an array now using WorkSpaces.

So I have gone in and created a new Ruby workspace.

Now, over here in the console, going to drag this up.

And we're going to launch IRB by typing irb and press Enter.

Now let's go ahead and create our very first array.

We'll do that by typing the name of the variable,

in this case we'll say we wanna create a grocery list.

Now I'm going to type a space and the equals sign, another space, and

then capital a, y, a dot, and the word new.

This will create a new array, initialized to the variable called grocery list.

Now, right below, you'll see we have an equal sign, and

a greater than sign, which is going to be the return value.

And the return value is an open bracket, and then a closed bracket.

That's Ruby's sign for an array.

Now we can take a look at this grocery list item and it returns the same thing.

There’s another way that we can create an array.

And that is to use the brackets themselves.

So, we can type an open square bracket and then a closed square bracket and

we get the same thing.

Now this is useful, but

it’s not as useful as having a grocery list with items inside of it.

Lets go ahead and create a grocery list array with our items already in it.

So we'll put three items in here.

The way we add items to an array when creating it,

is to put the items inside of the brackets, separated by commas.

So right here, I've opened the bracket and will put the string milk, and

then we'll also add eggs and bread into this array.

Now we separate the items by a comma.

So in this case, we have milk as an item,

and then a comma, eggs, another comma, and bread.

We don't put a closing comma before the closing square bracket.

Now when we look at the grocery list, it has the same thing as an empty array,

except the items are inside.

Now we're not limited to just strings.

We could add numbers as well.

And you'll notice the numbers don't have quotes around them,

just like when we were working with strings and numbers by themselves.

Now another way to create an array, if we wanted to create an array of just strings,

we could use the %w syntax.

And then we don't have to surround our strings with quotes.

Now if we look at our grocery list, it has the same thing as if we did

surround it with quotes, and use the square bracket notation.

Another thing that we can do is use an uppercase W.

Now just like when we were printing things out with strings and

having them interpolated, using a capital W will allow us to do interpolation.

So I have assigned a variable called item equal to a string called milk.

Now, when I create this grocery list array, using a capital W,

item will be interpolated.

And the array comes back with a string of milk, another string of eggs, and

another string of bread.

Try both methods of creating arrays now, using WorkSpaces.