Heads up! To view this whole video, sign in with your Courses account or enroll in your free 7-day trial. Sign In Enroll
Preview
Start a free Courses trial
to watch this video
Class methods are used when a method needs to have functionality but it may not be tied to a specific instance of a class. The extend keyword in Ruby will mix behavior in to a class rather than instances of a class.
Code Samples
We've created a tracking module that creats an instances of something, pushes it on to an instances array, and then can find it in said array.
module Tracking
def create(name)
object = new(name)
instances.push(object)
return object
end
def instances
@instances ||= []
end
def find(name)
instances.find do |instance|
instance.name == name
end
end
end
From there, when we use the extend keyword, these methods will apply at the class level and not the instance level.
class Customer
extend Tracking
attr_accessor :name
def initialize(name)
@name = name
end
def to_s
"[#{@name}]"
end
end
Those methods now run at the class level and return instances of the class we just created:
puts "Customer.instances: %s" % Customer.instances.inspect
Output:
Customer.instances: []
Input:
puts "Customer.create: %s" % Customer.create("Jason")
Output:
Customer.create: [Jason]
Input:
puts "Customer.create: %s" % Customer.create("Kenneth")
Output:
Customer.create: [Kenneth]
Input:
puts "Customer.instances: %s" % Customer.instances.inspect
Output:
Customer.instances: [#<Customer:0x007f2b23eabc08 @name="Jason">, #<Customer:0x007f2b23eaba
f0 @name="Kenneth">]
Output:
puts "Customer.find('Jason'): %s" % Customer.find("Jason")
Output:
Customer.find('Jason'): [Jason]
Input:
puts "Customer.find('Mike'): %s" % Customer.find("Mike")
Output:
Customer.find('Mike'):
Related Discussions
Have questions about this video? Start a discussion with the community and Treehouse staff.
Sign upRelated Discussions
Have questions about this video? Start a discussion with the community and Treehouse staff.
Sign up
Now we're going to talk a little
bit about using the extend method.
0:00
We touched briefly
before on class methods.
0:05
Class methods are used when a method
needs to have functionality, but
0:08
it may not be tied to
a specific instance of a class.
0:13
It's much easier to understand if we
actually look at some code to see how
0:17
it works.
0:20
Let's go ahead and
see how that works now using WorkSpaces.
0:21
Okay so I have a WorkSpace right
here with another very simple class.
0:27
And this is just a customer class.
0:32
It has one attr_accessor for the name.
0:34
We initialize the class with the name and
set that instance variable.
0:37
And then the to_s method
just shows the name in brackets.
0:43
So now, what we're going to do
is create a module that will
0:48
track different customers.
0:52
And what I mean by that is, instead of
keeping track of every single instance of
0:54
a customer, we want to be able to
call Customer.create with a name.
0:59
And then that will be trackable
on the customer class.
1:06
So here's how we're going to do it.
1:11
Let's go ahead and
create a module called Tracking.
1:13
Now, the methods that we're going
to be writing in here are all
1:18
going to be appearing like a mix in.
1:23
However, since we're going to
be using the extend key word,
1:26
they will appear as class methods.
1:30
So first, let's go ahead and
1:33
create something which is
a method called instances.
1:35
And what this is gonna do
is return an empty array
1:41
the first time that we access it.
1:45
Now this array,
once we extend the class with this module,
1:48
will be available on the class.
1:53
Now that sounds a little bit strange, so
let's just go ahead and see how it works.
1:55
If we extend this with the Tracking
module, this isn't going to work yet.
1:59
Let's just see Customer.instances, and
2:06
this should return an array,
we'll just call inspect.
2:09
And actually, let's go ahead and
2:14
say Customer.instances and
use a format string.
2:16
And then put the output from that.
2:23
So now if we run extend.rb,
we can see we've got this empty array.
2:25
Now this array exists only
in the Customer class.
2:31
And we get to it by accessing this method.
2:35
So what this is going to do
is conditionally assign this
2:38
instances class variable at
this point to an empty array.
2:42
That will also return the array
that we just created or
2:46
it will just return the array
if it's already been created.
2:51
So now let's go ahead and
implement this create method on Customer.
2:56
And we're going to pass it one
argument which is the name.
3:02
Now we know any class that we
mix in this tracking module into
3:05
is going to have a name.
3:10
So what we're gonna do is say object,
is a new name.
3:14
Now what this is going to do
is call the initialize method
3:21
of the class that this was mixed into.
3:26
And return that and
assign it to this object method.
3:30
Then, we'll append that.
3:35
To the instances array and
return that variable.
3:41
So the reason we call this object
is because we don't know exactly
3:49
what kind of object is going to
come in to this tracking module.
3:53
All we know is that we're passing
the initialized method, the argument.
3:58
We append it to the array,
and then we return it.
4:03
So now, let's go ahead and
see how that works.
4:05
So, we'll just say Customer.create,
4:11
and then we will create
a customer called Jason.
4:16
And we'll do the same
thing again with Kenneth.
4:26
And then let's go ahead and
look at the instances.
4:31
Gonna clear my screen, and
run this one more time.
4:35
And you'll notice we've got no
customer instances here, and
4:38
then we properly create Jason and Kenneth.
4:42
And now this instances array
contains two different objects.
4:46
So this isn't super useful, but let's say
we wanted to find a certain customer.
4:53
What we could do is create this
method called find with the name.
4:57
And since it's an array,
we can just call instances.find.
5:04
And return the first name that matches
whatever it is we pass in to this
5:15
find method.
5:20
So let's see how that works.
5:23
We'll go ahead and try and find Jason.
5:26
Gonna clear my screen and run this again.
5:35
And you'll see that we get back Jason.
5:38
And lets go ahead and try and
find a name that doesn't exist.
5:42
And see what gets returned there,
and nothing gets returned.
5:50
So by calling extend and
passing in the module name,
5:56
instead of being mixed in
to instances of the class,
6:00
extend mixes in to the class
methods of the class.
6:04
It can be a little bit confusing.
6:11
Go ahead and
try it on your own now using WorkSpaces.
6:13
You need to sign up for Treehouse in order to download course files.
Sign upYou need to sign up for Treehouse in order to set up Workspace
Sign up