The first method you should consider when creating a variable is the const keyword.

This is often the best choice for declaring variables.

Const is short for constant, meaning that the value of the variable shouldn't change

it should remain constant.

For example const pi is equal to 3.14159.

Const let's you protects variables from being overwritten by any stray assignments

in your code.

In other words, once you create a constant,

you can't give it another value.

Let me show you what I mean.

If you want to follow along you can open up the workspace on this page.

Open up pi.html, and as you can see we've assigned

a value of 3.1459 to the constant Pi.

Click on preview and navigate to pi.html.

Open up the developer tools and head over to the JavaScript console.

When we type pi, the value is logged.

Try to assign another value to pi.

We see we get an error type error assignment to a constant variable.

You will use constants frequently.

In fact, it should be your first choice when declaring variables.

You only use them to store numbers that shouldn't change while your program runs.

For example, tax rates, dimensions of user interface components, and

product prices are good examples.

And you'll use constants when your select an elements on a page, or

when you are assigning a function to a variable.

Any value can be assigned to a constant.

However, for a variable whose value will change during the life of the program,

const are a bad choice.

For example you wouldn't want to const to store a score of a game

since the score changes as the player plays the game.

In that case, you'll use the let keyword.

I'll show show you how that works in another video.

As I mentioned, constants help you fix problems

that can easily crop up in your JavaScript programs.

Let's take a look at a common problem that you'll run into.

If you want to follow along, open up the nam.html file in these video's workspace.

Here's a simple script with the variable name.

I'll preview this file and check in the console.

Notice that the console says Andrew.

That's the value of the name variable defined on line one.

The console then prints out Joe Craft,

which is logged by the create full name function.

Now that the programs run, what's the value of the name variable?

I'll just check that out in the console by writing name.

It's now Joe Craft.

Andrew is gone.

The variable has been overwritten by the function.

This is a simple scope issue.

The function is overwriting the name variable in the global scope.

It's a problem that can pop up and

can be difficult to catch, however const will help you spot the mistake.

Now when I preview this, the console spits out an error.

You can't change a value of a constant.

Because I used const, I can see that the simple mistake I made.

And I can go back into my script and fix it

Simply adding const before the name within the function keeps

that variable locked to the scope of the function.

It's no longer trying to reassign the name variable.

I'll preview this script one more time.

And no errors.

And I can log out name, and it's still Andrew.

Hooray, I'm not gone.