As you know, you can set inline styles on an HTML element with the style attribute.

The style set in this way override those set with external style sheets.

Just as we saw with other attributes,

inline styles can be set on an element with the style property.

However, unlike most other attributes, the style property itself is an object.

The properties on the style object represent the various CSS

properties we can set.

So let's look at this in the console.

Remember, the P variable is available here in the console.

And it's a reference to the description paragraph element

because it was declared earlier in app.js.

So let's have a look at its style property.

Over in the Console, I'll type p.style and

if you open this up, you can see all the style names.

So here's background, border, color, and so on.

And you'll notice that none of these styles are set.

But just looking at the paragraph,

it appears to have some styles applied to it, right?

Well, remember, these properties only refer to the elements in line styles.

Not any CSS rules that might be applied from a separate CSS document.

So as a result, you can't rely on these properties to know

how an element has been styled, unless you set them here yourself.

The style objects properties are generally used as setters and not getters for

this reason.

So let's try a few out, p.style.color =

'darkblue' changes the text color to dark blue.

And p.style.backgroundColor = 'lightblue'

changes the background color to light blue.

Now, one common use for setting style with JavaScript is to hide and

unhide elements on the page.

So let's set up a button that will toggle our description paragraph text field and

list in and out of view.

Switching over to index.html, let's add a button

below the first paragraph and give it an ID of toggle list.

And we'll make the button say, Hide list.

Then since we want to hide this paragraph text field button and list as one unit.

Let's wrap them in a div and give it the class list.

So now, over in app.js, let's select the button in div, we just created.

And I'm going to put my new constants at the top of the file to mirror where they

appear in the HTML.

The new button and div appear above the list.

So I'm going to declare these at the top of the file.

First, we'll say const toggleList =

document.getElementById('toggleList').

And right below const listDiv

= document.querySelector.

And then, we're going to query the class list.

You also notice, that I'm using two different selector methods here,

just for practice.

But in a real project, keeping it simple is probably a good idea.

So for example, if you've decided to use querySelector,

it might make sense to use it as often as possible throughout your code base.

Right now, we'll need to add a click event listener to the button.

So right below my constants say,

toggleList.addEventListener, Pass in click and a function.

So when the toggle button is clicked, we'll want to hide listdiv.

And we can do that by setting its display property to none.

So in the function, we'll type listDiv.style.display = none.

All right, so let's save this, go back to the browser, and refresh.

And clicking the button, we see the description paragraph and

list disappear, so great.

Clicking it again, though, we see that they don't come back.

So we'll need to do a little more work with the event listener to make our

toggle button completely functional.

Let's look at the code again.

So when this function runs, we want to show the list if it's hidden and

hide the list if it's visible.

So notice, I used the word if, so this is a perfect case to use a conditional.

So let's start by adding if and else statements to the function.

First, I'll say if.

ListDiv.style.display = 'block'.

And then, right below, we'll say, else listDiv.style.display = none.

So now, the function will either show or hide the list.

So what condition should the if statement check to decide which code block to run?

Well, let's use the div element's display property.

Since our function here is managing the inline display property,

we can rely on the value it returns.

So in the condition, I'll add

a listDiv.style.display

= none.

So now, if the display is none.

It will be set to block, otherwise, it will be set to none.

And let's just add a little more here.

So first, let's change the button's text depending on whether it's hiding or

showing the list.

We can use text content for this.

So the first in the if condition, we'll say,

toggleList.textContent = 'Hide list'.

Then inside else, we'll add toggleList.textContent

= 'show list', all right?

So let's save our file and try it out in the browser.

I'll go ahead and refresh the page.

And click the button and we can see that it works both ways now.

You can see that the button changes text to tell the user what it does, hide list,

and show list.

But there seems to be a problem.

Notice, how the list description paragraph is getting erased except for a colon.

That's kinda weird ,right?

Well, something is wrong with the code we've written.

The problem is a little tricky but can you figure out what's going on here?

Feel free to pause the video and figure out what the problem might be.

The colon is a clue.

Now, don't worry, if you didn't get on your own.

As I said, it was a tricky problem.

But remember, how I said the colon was the clue?

The problem turned out to be that both of our click event handlers, we're firing.

When we click the show and hide button.

So the second handler replaced the list description with

what was in the text input.

So if that input was blank, which it was.

The paragraph's text content was replaced with an empty string,

with a colon appended to it.

So in other words, it was replaced with just a colon.

So why were both handlers firing?

Well, remember, how query selector selects the first element it matches in the DOM?

When we added the show/hide button, above the other button.

That became the first button element in the DOM.

This constant of button that's declared here on line five

is being assigned to the wrong element.

So now, that we have two buttons on the page, this line should be more specific.

Better specificity reduces bugs but also helps make our code more readable.

Now, since the element we want to target has a class of description,

let's add that into the selector.

And while we're at it, let's add the class to the input, as well.

That will make it obvious, that these three declarations are grouped together,

just from reading the JavaScript, all right?

So now, let's switch back to the browser, refresh, and make sure it all works.

Great, it does.

All right, so in the next video,

we'll look at how we can create our own elements from scratch.