[MUSIC] Let's now discuss arrays. These are the most common data structure in Ruby programs, so we can't do too much more Ruby programming without them. And as well see in In the next segment they're also an excellent vehicle for seeing how Ruby supports higher order programming and functional programming styles. So, there's lots of special syntax, and many provided methods for the array class. You'll probably want to consult the documentation to find things that you're interested in. We'll just scratch the surface here and show you some of the possibilities. What an array is, is basically something that holds any number of other objects, and is indexed by some number. So, you can get the third element, or the fifth element, or the zeroth element, and their special syntax to get the Ith element, where A is some array object. You write i in brackets after the a, that just sends the message to a that you want the Ith element. And you can set the ith element with the corresponding center method, where you write a[i] = e. Now, arrays are common in many programming languages, this is the common syntax for them. But compared to other languages, Ruby's arrays are much more flexible and dynamic, they let you do almost anything. Almost nothing you can do with an array is actually an error, they just come up with some sensible thing to do, and as a result, arrays can be used for almost anything in Ruby, any kind of data structure. Even though they might not be the most efficient thing, often in small scripts or simple programs, people prefer the convenience and flexibility, over the sort of efficiency and error detection of arrays and other programming languages. So, mostly what I'll do now is just show you a whole bunch of examples using IRB, so that we get the hang of it. So, first of all, you can make an array with just comma separated values inside of brackets. So A is now a variable that holds the array with four elements, where the second element is seven and the zeroth element is three. Like in most programming languages, arrays start counting their index positions from zero. So if you say a[4], that's not actually in the array. In many languages you'd get an array balance error for this, but Ruby just gives you back to nil object, and the same what happened if we ask for the thousandth element of the array. If you ask for the size of the array, you get the number of elements currently in it, that is four. Let's see, you would probably think that -1 would return nil since that's clearly outside the balance of the array. But no, Ruby interprets negative indices of just counting from the current end of the array. So I minus one will return nine, and I minus two will return seven, whereas I minus four will return three, and I minus five will return nil, and so on. So, we can also update array elements, so if we say, a [1] = 6, now if we print out the array, we see that indeed, six is in the first index position. What if you assign to something outside the bounds, surely, this is an error, right? Nope, it's happy to assign to that, and what's even stranger is we now have an index four and an index five. You'll see that it filled in enough array entries with nil objects in order to make room for that 14 we added to the sixth position. So, if I assigned to the 1000th position, I would now have an array with 1,001 entries in it. Okay, so indeed, if you now ask a.size, you see that the length, the size is now seven. We're in a dynamically typed language, so we can put absolutely anything in this array. How about putting a string in a[3]? We could put an instance of any class, any kind of object, into our array, and that will work just fine. As I mentioned, there's lots of operations and methods to find on arrays. We've even defined some of the arithmetic operators on arrays in ways that you might imagine is reasonable. So, for example, if I take an array like a, and I add to it another array, that just appends things on to the end. So b is, in fact, let's see, I guess ninth element array, which is different than a, which is still this seventh element array. I can't possibly show you everything you can do with arrays, but here's one that I discovered which is kind of nice. The pipe operator takes two arrays and returns an array containing the elements of either, like plus, but it removes it any duplicates. So, in fact, you get back an array here that just has three elements three, two, and one, because any other elements would be duplicated in the result. Okay, so that kind of shows you the flexibility of arrays. Now, let see how we can use them for all sorts of things. So, given that arrays are so flexible, there's no reason for separate tuples in Ruby. If you want to tuple just use an array. So, here's a three element tuple that is false, the string high and seven, and you can get the last thing out of it with triple bracket two. So this is a perfectly good tuple, so why would you do anything else? But, more than that, arrays also can have sizes that are growing, or shrinking, or chosen dynamically. So let me show you a different way to make an array, not on this line but the next one. Here I just want to emphasize that we could have some number X that could be computed at run time. So x is 20 from some arbitrary computation, and then you can say array.new(x), and you get an array of length 20. Now, if you wanted to initialize the elements, you can do that with blocks. This is the subject of the next segment, but here's a different version that's also an array of 20 elements, but there all initialized to zero. Or, you can even make different elements initialized to different things. Here's a 20 element array of zero minus one minus two up to, or I guess, down to minus 19. So, arrays can be tuples, they can be things of arbitrary size, what else could they be? Well, it turns out they make perfectly good stacks. So a stack is something with operations push and pop, where things are popped in last in first out order. These are ubiquitous in computer science, we saw call stacks earlier in the course. So, if we just take our old array a here, it turns out that all arrays have a method push, which pushes, which adds an element to the right side. So you see, I just pushed five under the right there, I could push seven, and now if I pop, I get a seven back and array a no longer has that seven. I could pop again, and I would get a five, I could pop again, I would get a 14, and now my array is shorter. So, I'm essentially using an array as a stack, and Ruby's arrays are so flexible, why would you define your own stack, when you can just use these push and pop methods? So, if we can do stacks can we use queues? So, a queue is like a stack except instead of things coming off in the reverse order that they're put on, they're taking off the same order they're put on. So it is like queueing up, the person who gets in line first gets served first in properly functioning queue. So, I still have this a, I could push 11, that will put things on the right. The way to pull something off the left, off the beginning is the shift operator. It's called shift, because when I say a.shift, like pop, I get one of the array elements back, here at three, but everything's been shifted over. And indeed now, a[0] is not three anymore, it's six, and a[1] is seven, and if I shift again, then a[1] is the string hi. So, if i use a combination of push and shift, I have a queue. I could also put things on the front of the line. So if you want to skip ahead to the front of the line, you could unshift with 19, and now my array indeed has a 19 on the front, and if I do a shift, I get the 19 out. So, arrays support all of these things. So now that we've sen that they're that flexible, you can put things on the front, on the back, you can slice them, you can dice them, you can grow them, you can shrink them, let's talk about aliasing. So, arrays are objects, so our previous discussion of aliasing still applies. If I say something like d = a, then d is this array, and a is this array, and as we'll see in just a second, they are aliases. But if I did something like e = a + this empty array, well the plus operation always returns a new array. So e has all the same contents, but e is not aliased with a and d. So, let me show that to you, d[0] is seven. If I now assign into a[0] six, then d[0] is now six, a[0] is now six, but e[0] is seven. So, that's our aliasing story, always nice to have a short example to show what is an alias and what is not. Let me just show you a few more things to wrap things up. There's tons more to learn about arrays, let me show you one more array. How about two, four, six, eight, ten, twelve, fourteen. So, it turns out, what if you wanted part of this array. So there's these things called array slices. So you could say, I want elements two through four, and you would get back a new array with six, eight, ten, and twelve. Which is, let's see, elements two, three, four. I'm surprised that, I see, it starts at element two, and it gives me four elements. So that's fine. Here is something a little stranger, you can actually assign this way. When you assign in, you don't have to put the same number of elements. So after I do this, f is shorter, I replace six, eight, ten, and twelve with one, and one. Showing yet again, that arrays are this very flexible data structure. They're really an arbitrary mapping from numeric indices to values, and that's how you have to think of them. Finally, the most common thing to do with a collection of data, is to do something to all of them, map over them, do a reduce over them, see if something is true of any of them. And that's really what the next segment is about, but to give you little precursor that you really can do things with arrays. Here's a little array with four elements, and I could say to each of them, let's print i times i, and I have to explain the next segment what this means, but there it did actually print all of them. And of course, I can do that with any array, for example, f. So that's your flexibility over arrays. You'll have to consult the documentation to find more methods in general. If you can think of a general method over arrays there probably lots of people would want not just you, it's probably already to find in the library, and it's a good idea to look it up. Other than that, remember that arrays can be good for tuples, lists, stacks, queues, and what are called arrays and other programming languages, and will continue to use them for the rest of our study of Ruby.
