Preview
Video Player
00:00
00:00
Instance Variables and Local Variables
4:54When using variables inside classes, only instance variables, which are prefixed with the `@` character, will be visible to all of the methods in the class. A variable that only exists inside of a code block or method is called a local variable. The whole concept is called scope.
When we create different variables inside
of a class,
0:00
not every method can see the variables
that we use.
0:03
If we wanna make a variable visible to
different methods inside of a class,
0:08
we call it an instance variable.
0:12
That means that the variable should be
visible to
0:15
the whole instance of the class.
0:18
If we want a variable that's only visible
inside of the method or
0:21
block that we're working with, that's
called a local variable, and
0:25
this whole concept is called the scope of
a variable.
0:29
Let's see how that works now using
Workspaces.
0:34
So, here's our Name class, and
0:38
let's talk a little bit about local versus
instance variables.
0:40
So, here we are in the full_name method,
and we also have full_name_with_title.
0:46
Let's go ahead and
0:51
pretend that we were creating a couple
different variables inside of this method.
0:53
So, let's say that we wanted to assemble
the first and middle name.
0:59
We could create a variable that says first
_and_middle_name.
1:05
We generally wouldn't do something like
this, but just follow along for a second.
1:10
[BLANK_AUDIO]
1:14
We now have access to this first
_and_middle_name variable right here.
1:21
So, what we could do is, I'm gonna comment
this out, and
1:26
we could say first_and_middle_name plus
space plus @last_name.
1:32
And that should still return the correct
item.
1:42
Now let's go ahead, get this out of here
for now.
1:46
So let's run this by typing ruby name.rb.
1:50
And it's printing the same thing, which is
what we wanted.
1:56
But we do not have access to this
first_and_middle_name variable
1:59
outside of this full_name method.
2:05
The only way that we would have access to
it
2:09
would be if we made it an instance
variable.
2:12
And we can see this if we use irb.
2:15
And we can do a shortcut to what I showed
you earlier where you type in load and
2:20
the path, and by typing irb -r name.rb.
2:25
Oops, looks like I forgot the path.
2:31
[BLANK_AUDIO]
2:33
Okay.
2:37
Now let me go ahead and create this name
variable.
2:39
[BLANK_AUDIO]
2:43
Now we can see printing out full_name
works when we call the method.
2:54
But if we were trying to call
first_and_middle_name,
2:59
this would not work.
3:02
[BLANK_AUDIO]
3:03
This doesn't work because it is just a
local variable.
3:06
[BLANK_AUDIO]
3:10
If we wanted to change it to an instance
variable, we would then have access to it.
3:13
Now, since we changed this file,
3:22
we're going to have to reload it into our
irb session.
3:24
Now let me go ahead and create a name
again.
3:30
[BLANK_AUDIO]
3:32
Now when we call first_and_middle_name,
3:44
we're getting this undefined method again
still.
3:47
And the reason is we haven't written an
attribute reader for it.
3:51
So let's go ahead and do that.
3:55
[BLANK_AUDIO]
3:56
And we'll reload this.
4:04
[BLANK_AUDIO]
4:05
And we can see that that's nil.
4:20
If we call full_name, it will have been
set when we called the full_name method.
4:23
And now we can see first_and_middle_name
is correct.
4:32
So, visibility of variables is something
very important to keep in mind,
4:37
and this is referred to as the scope of a
variable.
4:43
The scope, meaning where we are in the
method and what's visible variable-wise.
4:47