[As described below, this is Part C of a 3-part course. Participants should complete Parts A and B first -- Part C "dives right in" and refers often to material from Part A and Part B.] This course is an introduction to the basic concepts of programming languages, with a strong emphasis on functional programming. The course uses the languages ML, Racket, and Ruby as vehicles for teaching the concepts, but the real intent is to teach enough about how any language “fits together” to make you more effective programming in any language -- and in learning new ones. This course is neither particularly theoretical nor just about programming specifics -- it will give you a framework for understanding how to use language constructs effectively and how to design correct and elegant programs. By using different languages, you will learn to think more deeply than in terms of the particular syntax of one language. The emphasis on functional programming is essential for learning how to write robust, reusable, composable, and elegant programs. Indeed, many of the most important ideas in modern languages have their roots in functional programming. Get ready to learn a fresh and beautiful way to look at software and how to have fun building it. The course assumes some prior experience with programming, as described in more detail in the first module of Part A. Part B assumes successful completion of Part A. The course is divided into three Coursera courses: Part A, Part B, and Part C. As explained in more detail in the first module of Part A, the overall course is a substantial amount of challenging material, so the three-part format provides two intermediate milestones and opportunities for a pause before continuing. The three parts are designed to be completed in order and set up to motivate you to continue through to the end of Part C. Week 1 of Part A has a more detailed list of topics for all three parts of the course, but it is expected that most course participants will not (yet!) know what all these topics mean.
Arrays
Loading...
From the course by University of Washington
Programming Languages, Part C
196 ratings
From the lesson
Section 8 and Homework 6 (First Module with Ruby)
Let's get started programming with Ruby, including learning about Ruby's variant of (almost) function closures and the "inheritance and overriding" that is the essence of object-oriented programming. The welcome message has a few additional comments about "what makes Ruby different" and how to approach the (rather different) homework assignment, so let's get started...
Meet the Instructors
Dan GrossmanProfessor
Computer Science & Engineering
>> [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 we'll see 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 when 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 there's special syntax to get the i-th
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 i-th element.
And you can set the i-th element with the corresponding center method, where you
write a bracket i equals 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 in error detection of arrays in 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 7, and the zeroth element is 3.
Like in most programming languages, arrays start counting their index positions from
zero. So, if you say a sub 4, that's not
actually in the array. In many languages, you'll get an array
bounds error for this. But Ruby just gives you back the nil
object. And the same would happen if we asked 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 minus 1 would return nil, since that's
clearly outside the bounds of the array, but no Ruby interprets negative indices of
just counting from the current end of the array.
So, i minus 1 will return 9. And i minus 2 will return 7.
Whereas, i minus 4 will return 3. And i minus 5 will return nil, and so on.
So, we can also update array elements. So if we a, say a sub 1 equals 6.
Now, if we print out the array. We see that, indeed, 6 is in the first
index position. What if you assign 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 a
fourth b a 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 assign to the 1000th position, I
would now have an array with 1001 entries in it, okay?
So, indeed if you now ask a dot size, you see that the length, the size is now 7.
We're in a dynamically-typed language, so we can put absolutely anything in this
array. How about putting a string in a sub 3?
We can 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 define some of the arithmetic
operators on arrays in, 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 onto the end. So, b is in fact now this let's see I
guess 9 element array, which is different than a, which is still the 7th 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 any duplicates.
So, in fact, you get back an array here that just has three elements, 3, 2 and 1,
because any other elements would be duplicated in the result.
Okay, so that kind of shows you the flexibility of arrays.
Now let's 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. Let's, if you want to tuple then just use
an array, right? So here's a 3-element tuple that, you
know, is false. Just string hi and 7, and you can get the
last thing out of it with triple bracket 2.
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 on 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 of x.
Alright? 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 they're all initialized to 0.
Or you can even make different elements initialized to different things.
Here's a 20 element array of 0 minus 1, minus 2, 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'll see I just pushed 5 onto the
right there, I could push 7. And now if I pop, I get a 7 back and an
array no longer, a no longer has that 7. I could pop again, and I would get a 5.
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 stacks 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 taken off in the same order they're put on.
So, it is like queuing up. The person who gets in line first, gets
served first in a properly functioning queue.
So, I still have this a. I could push 11.
That would 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, a 3. But everything's been shifted over.
And indeed, now, a sub 0 is not 3 anymore, it's 6.
And a sub 1 is 7. And if I shift again, then a sub 1 is the
string high. 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 can 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 seen 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 equals 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 equals a plus 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.
Alright? So, d bracket zero is 7.
Alright? If I now assign into a sub 0, 6.
Then d sub 0 is now 6, a sub 0 is now 6. But e sub 0 is 7.
So that's is 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 2, 4, 6, 8, 10, 12 14, okay?
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 2 through 4 and you would get back a new
array with 6, 8, 10 and 12 which is, let's see elements 2, 3, 4.
I'm surprised that oh, it's, I see, it starts at element 2 and it gives me 4
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 6, 8, 10 and 12 with 1 and 1.
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's true of any of them, and
that's really what the next segment is about.
But to give you a 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 put
a, let's print i times i. And I have to explain in the next segment
what this means, but there did actually print all them.
And, of course, I could do this 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 that probably lots of people would want, not just you, it's
probably already defined in the library, and it's a good idea to go look it up.
Other than that, remember that arrays can be good for tuples, lists, stacks, queues,
and what are called arrays in other programming languages.
And we'll continue to use them for the rest of our study of Ruby.
Explore our Catalog
Join for free and get personalized recommendations, updates and offers.
Coursera provides universal access to the world’s best education,
partnering with top universities and organizations to offer courses online.
© 2018 Coursera Inc. All rights reserved.
