Did you ever want to build a web application? Perhaps you even started down that path in a language like Java or C#, when you realized that there was so much “climbing the mountain” that you had to do? Maybe you have heard about web services being all the rage, but thought they were too complicated to integrate into your web application. Or maybe you wondered how deploying web applications to the cloud works, but there was too much to set up just to get going. In this course, we will explore how to build web applications with the Ruby on Rails web application framework, which is geared towards rapid prototyping. Yes, that means building quickly! At the conclusion of this course, you will be able to build a meaningful web application and deploy it to the “cloud” using a Heroku PaaS (Platform as a Service). Best of all, it will almost feel effortless… Really! “But wait”, you will say, “there is no way that we can build a useful application if there is no database involved. You need the data for an application to be useful.” Great point! But what if… instead of getting the data from the database, we get it from the internet by tapping into one of the web services out there that readily provides data needed by our application? “Ok, but that’s probably very complicated”, you will say. Take this course and you will be pleasantly surprised at just how easy it is!
Modules
Loading...
From the course by Johns Hopkins University
Ruby on Rails: An Introduction
1524 оценки
Johns Hopkins University
1524 оценки
Course 1 of 6 in the Specialization Ruby on Rails Web Development
From the lesson
Introduction to Ruby
In this module, we will explore the different areas of the Ruby programming language.<p>We will start with the basics and continue with more advanced topics, such as arrays and hashes. We will also spend time exploring object oriented programming in Ruby, and finish the module by demonstrating how to perform unit testing.</p>
Meet the Instructors
Kalman HazinsAdjunct Professor, Graduate Computer Science
Whiting School of Engineering
[MUSIC]
Hi and welcome to lecture 12.
In this lecture, we'll discuss modules.
Modules as namespaces, modules as mixins.
We'll talk about built-in Ruby modules and
we'll also talk about the concept of require_relative.
So on the basic level, module really just a container.
It's a container for classes, methods or other modules even.
It's like a Class, but it cannot be instantiated.
So you cannot have an object of a specific module,
like you could have an object, obviously, of a class.
And modules are really used for two main purposes.
One, they use as a namespace or they use as a mix-in.
So to understand the idea of modules and namespace, a lot of languages.
For example, Java will have this idea of a package structure.
So you don't have a name collision between classes.
You will have, for example,
org.packageone.packagetwo and then the class at the end.
Ruby doesn't like having very deep structure, but it is obviously,
nice to have a way that the class names shouldn't collide.
So you shouldn't have a collision, so that's the idea of a namespace.
So for example, you could have a Match class, which makes sense to be part of
a Sports module and you could have a match class that's part of a Patterns module.
And these are completely separate, but
the way instantiate them is instead of just saying Match.new.
Because then you wouldn't know what Match it is, you put them inside a module.
And then you say, for example, module name Sports:: Match.new,
which refers to this class and Patterns::, which refers to this class.
Another way to use modules is as mixins and this is really cool.
So in OO, you have a concept called interfaces.
A lot of languages don't have that.
For example, Java will have a concept of interface.
Which basically, just means a contract requiring a certain group of classes that
abide by a certain contract, which defines what a class could do.
Mixins go a step beyond that, they actually provide a way to share code,
to share a mix-in,
which is why they are called mixins to share code between multiple classes.
Not only that, you could even include built-in modules like
Enumerable that do the hard work for you, as we're gonna see in a minute.
So to see a simple example of a module as a mix-in.
For example, you have modules that's called SayMyName,
which defines accessor, which is a set and a getter.
And just basically, defines a method that says print_name, which prints that name.
And then you can have a person class or
a company class that both include the module SayMyName,
which basically lets you include the functionality inside that module.
So now you could have a person, you could create a person and
then you could set the person name.
Wait a second, but a person doesn't have a name method.
That's okay, because a module does.
So you include the functionality of a module inside the person class.
Same thing with a company.
You include this functionality in a company.
So where it gets really interesting is that
you could include built-in modules from a Ruby itself.
So when we just cast arrays, I mentioned that arrays have methods like map,
select, reject, detect and so on.
So actually, the arrays themselves [INAUDIBLE] have those methods.
The array class includes the Enumerable module and
that's what gives it all the functionality.
And you can include this in your own class and all you have to do in this case for
the Enumerable Module is to provide implementation for
one method which is the each method.
Once you do that all the other functionality, like map, select and
other methods become available to you.
So let's see an example of this, where you would use this.
For example, let's say, you have a team.
And you have players on the team and you wanna write a Ruby
program that maybe selects a roster for some event.
So you would have a file called player.rb, which maybe would have a class player.
Now you could define multiple classes in the same file.
Ruby doesn't have anything against that, but
sometimes you might wanna define it as a separate files.
That's okay as well and
we'll see in a minute how to bring all those classes back into one place.
So you have a class player,
that maybe will have a name agent skill level getters.
And it will have a constructive that will initialize
the player with the name, age and a skill_level.
And then you can have a to_s method, which is basically your to string method,
which just says, what the player is?
And in this case, it's the (name): {Skill_level} (SL) skill level and
{age} for (AGE).
And then maybe in a different file somewhere, you'll have a Team class.
And the Team class will include the Enumerable module,
which as we gonna see in a minute, gives you a lot of functionality.
And all you have to do in order to be able to use this functionality
is defined in one method, which is each.
So the way you define this each method is you say, players.each,
loop through each element in the players array and yield player to a block.
Going back to the constructor, a team would just have a name.
Maybe a red team, blue team.
It will also have a setter and a getter for a name and players.
So players starts out as just being an empty array.
You could also add players using the splat functionality, which we discussed before.
And basically, all you're doing is you're just adding the array of players
that are passed then to your existent players, which starts out as nothing.
And then the to_s just prints some information about the team.
So maybe in the third place, you will have a regular file.
A regular .rb file and you could require_relative
the 'player' file and the 'team' file.
And require_relative, just basically means relative to this file, where those files?
So in different directory, you could use a path before player here.
So in this case, they're all in the same directory.
So you just say, require the 'player',
which is relative to this file in the same directory.
Require, 'team', so that brings a 'team' class as well and
we're gonna create a bunch of players.
So we're gonna create Bob, Mike, Scott and so on.
And then we're gonna create a team, let's say a Red team.
And we're call the add_players, which as you remember has a splat.
Which basically, let's you pass in all those players.
So now you have a red team with a whole bunch of players.
But now comes the cool part, because red team includes the Enumerable module.
You can all of a sudden, start doing interesting things with your team.
You could select all the players with a age range between 14 and 20.
Inclusive, because there are 2 dots and
you could reject any player who's skill level is less than 4.5.
And boom, you got your final result, which had the eligible players on the team.
This is real powerful.
We had them do a rhythm a code and then team class is really small.
But because we import the Enumerable module, we get lots of functionality.
In summary, modules allow you to mix-in useful code into other classes.
This could be Ruby modules or
this could be your own modules that maybe you wanna share.
And require_relative useful way of including other Ruby
files relative to the current Ruby file.
So this way, you don't have to put all 20 classes,
let's say that you're dealing with, in the same file.
You could, but at a certain point, you have a freedom to say that's too
much code in one file, I wanna go to a different file.
There's no restriction from a language point of view
of how many classes you could have in the same file.
But certainly at a certain point,
you might wanna think about splitting those files up.
Next, we'll talk about scope.
Ознакомьтесь с нашим каталогом
Присоединяйтесь бесплатно и получайте персонализированные рекомендации, обновления и предложения.
Coursera делает лучшее в мире образование доступным каждому, предлагая онлайн-курсы от ведущих университетов и организаций.
© Coursera Inc., 2018 Все права защищены.
