Preview
Video Player
00:00
00:00
Write a Simple Module
3:35Writing a module is very similar to writing a class. Modules follow the same rules as classes and use CamelCase for naming. In this video, we're going to write the simplest possible module in Ruby.
Now let's go ahead and
write our first module.
0:00
Writing a module is very
similar to writing a class.
0:04
Modules follow the same rules as
classes and use camel case for naming.
0:07
When we create a module,
we use the Ruby keyword Module,
0:13
followed by the name of the module in
CamelCase and then the keyword end.
0:17
Let's see how that works
now using WorkSpaces.
0:23
Okay, so let's go ahead and
see how to write a Ruby Module.
0:27
Now I've gone ahead and
launched a new Ruby workspace.
0:32
So go ahead and
close this welcome markdown file.
0:37
Now over on the left side right click and
choose new file.
0:42
We're going to name this
simple_module.rb And
0:48
now, it will open up in
the main text editor.
0:53
Writing a module is just like
writing a class except instead of
0:58
using the class keyword, we use module, so
1:02
type in the module keyword and
then the name of the module that you want.
1:08
Now I'm going to call
this SimpleModule and
1:14
then press enter and write the word end.
1:18
Now let's go ahead and
see how this works inside of irb.
1:22
Click down into the console on the bottom
of the screen and type in irb.
1:26
Now we have to get our simple
module program loaded into irb.
1:32
We do that by typing load,
then a space, quote and
1:37
then the path to the simple module file.
1:42
Which is right here so type ./ and
then the name of the file,
1:45
which is simple_module.rb and
irb will return true.
1:49
So now you might wonder how
we access simple module.
1:56
Now we can't initialize it like a class.
1:59
So normally we could say class.new, but
2:02
we can't do that when we're
working with modules.
2:05
Just accessing it will
return SimpleModule.
2:09
So this doesn't do much right now, but
2:14
what we could do if we wanted
to was store a constant in here.
2:16
So lets say we wanted to return
the version of this SimpleModule.
2:21
We could create a constant called
VERSION and set that equal to 1.0.
2:27
Now constants are their own thing,
in Ruby kind of like modules,
2:35
they're written in all upper case,
and they can't be changed.
2:40
So once we type in this version here,
it's gonna be locked at 1.0.
2:44
Now since we've changed this file and
2:47
saved it,
we need to reload it into our irb session.
2:51
So I'm going to clear the screen and
in order to do that,
2:55
I'm going to press the up
arrow a couple of times
2:58
until that load statement
comes back up and there we go.
3:00
Now if we want to access
the version inside of this module,
3:04
we do that by typing SimpleModule, and
3:10
then two colons, and the word VERSION and
that will return 1.0.
3:13
When we access something using with
two colons, it's called the constant
3:19
resolution operator, and that's what we
use to access something inside of modules.
3:25
Try creating a module on your
own now using WorkSpaces.
3:31