You learned previously that when a getter method is called, a property value

is computed and returned, but this value is not ever updated or stored anywhere.

A setter method, on the other hand, receives a value and

can perform logic on that value if need be.

Then it either updates an existing property with that value or

stores the value to a new property.

This is pretty confusing and complicated at first.

Don't worry if you're having trouble.

This is tough stuff and it can take awhile for new concepts to sink in.

When I'm learning a new concept, I spend a lot of time practicing the code and

reading about the topic online.

I found that being exposed to a topic from many different perspectives and

angles helps me understand things more deeply.

So I've included some things about getters and

setters that I find useful in the teacher's notes.

For this example,

we're going to add a setter method that sets an owner property for the pet class.

We'll start with a simple example to show the basic syntax and

get familiar with the concept, and in the next video we'll dive in deeper.

So back in our Pet.js file,

let's add a few lines under our existing getter method.

A setter method is created by typing the key word set followed by

the name of the property being set, which in our case is owner.

And then our usual parentheses and curly braces.

Setters always receive exactly one parameter.

The parameter is the value of the property that we'd like to set.

In this example, it will be the owner's name.

Inside our method,

we have to set an owner property equal to the parameter we passed in.

But there's a little snag.

The name of a property can never be the same as the name of a getter or

setter method.

This means we can't do this.

We have to create a property name that's different from

owner to hold the value of owner.

This is called a backing property.

And while we can name the backing property however we would like, convention dictates

to use the name of the setter function but with an underscore behind it.

Just like this.

While we're in our setter method, let's also add a console log.

When we set the owner property and run the file,

this will demonstrate that the setter function has actually been called.

Great.

So how do we use our setter method?

Move down to the end of the file and create a new line.

Type the name of the object who's owner property you want to set followed by a dot

and then the name of the setter method, which in this case is owner.

Add an equals sign and then the value of the owner's name.

You're probably thinking to yourself, this looks exactly like

setting a property value using dot notation, and you'd be right.

That's what's great about getter and setter methods.

They provide the syntactical simplicity of direct property access,

while simultaneously offering the flexibility of a method.

Great, we've set our owner property using a setter method.

Now let's try to access this property.

I'll create a new line and

log the owner property of the ernie object to the console.

Let's save and jump down to our console to run the file.

Well, we can see that out setter function was called, but

the value of the owner property is being output as undefined.

That's not great.

Why is that happening?

If you recall, the setter method is storing the value in a backing property.

In our case, that's actually _owner, not owner.

When we try to retrieve the value of owner by using ernie.owner, for example,

we get undefined, meaning the owner property has no assigned value.

To solve this, we've got to create a getter method called owner that returns

the value of the backing property.

I'll add that right before I set our method.

Awesome, now we have a way to access the owner property.

Let's try to run this again.

Great, you'll see that now it's outputting the value Ashley just like we

expect it to.

Awesome job.

In this example, our setter function didn't have any logic included.

In the next video, I'm going to show you an example of how adding logic to setter

functions can be used to simplify your coding process.