Everything you need to know about JS Variables
Tags: webdev, javascript, beginners, tutorial
Published: 2022-02-16 22:53:06

**One of the most important concepts in Javascript**, as with most programming languages, is the ability to define variables. A variable is a container of a value or data. Some types of variables can later be changed, based on logic we use in our code. Let's take a look at how variables work in Javascript.

##Defining Variables
There are two main types:

- **Constants** - these cannot be updated later, and contain constant data.
- **Variables** - as the name suggests, these can be changed.
We can define these two main types of variable in our code using the keywords let, var and const.

##Variables
The var is the original keyword was the first way to define variables introduced to Javascript. As with all other ways to define variables, var follows this pattern:

```javascript
var myVariable = 'some value';
```

Typically, in modern JS, we don't use var. However, it is subtly different from let and const, which we'll cover in this article. Above, the keyword var is used to say we are setting a variable called myVariable, and that the value of that variable is some value. Since we used quotation marks, Javascript will assume this is a string.

## Let
The let keyword is a new addition to Javascript. It is the same as var, with the only difference being it has block scope. We will cover logical statements and functions later, but this example may help to show what this means:

```javascript
let myVariable = 'some value';

if(myVariable == 'some value') {
    myVariable = 'some other value';
    // Within this 'block', myVariable now is equal to 'some other value'
}

// Outside the block, myVariable is equal to 'some value'
```

### Errors to watch out for!
**Note**: defining a variable with the same name twice will throw an error. The below code is invalid:

```javascript
let x = 'hello';
let x = 'goodbye';
// This will throw an error!
```
        
## Updating Variables
As we showed in the last example, we can update variables by simply referring to them again and changing their equal to value. This will only work for var and let, however, since const variables cannot be changed.

```javascript
let myVariable = 1; // myVariable is 1

myVariable = 2; // Now myVariable is 2
```

**Note**, if you try to define a variable twice with the same name, using var or let both times, Javascript will give you an error. You can only define a variable once, and after that, you must update it as shown above.

## Constants
Constants are defined using the const keyword. As mentioned before, these cannot be changed. They are defined in the same way as other variables, i.e.:

```javascript
const myConstant = 1;
```
The above refers to a constant which cannot be changed or updated.

## Dynamic Typing in Javascript
In other programming languages, it is necessary to define what type the variable is when defining it. In Javascript, the type is assumed based on how you enter the data. This is called dynamic typing. Some examples are shown below:

```javascript
let i = "1"; // this is a string, since we used quotation marks
let j = 1; // this is an int, since we used no quotation marks
let k = true; // this is boolean, since we used no quotation marks
let l = "true"; // this is a string, since we used quotation marks
```
As you can see, whether you use quotation marks or not can really affect your code. If you use quotation marks around a number, for example, it will be a string, and if you tried to add this "string" to a number later, it wouldn't work! So understanding these types is really important.

## Reserved words and case
When defining variables, case is important. As such name is different from NAme. We could therefore plausibly write the following, and have no errors:

```javascript
let naME = 'hello';
let NAme = 'goodbye';
```
**Note:** Variable Names cannot start with a number. You can use numbers, just not as the first letter.

## Reserved Keywords
There are a number of reserved keywords that you can't use in Javascript. They are all words you would use for other things in Javascript, like function, while, or let. [You can find a full list of reserved keywords here](https://fjolt.com/article/javascript-reserved-keywords). As such, the following code is invalid, and will throw an error:

```javascript
let while = 'hello';
let if = 'goodbye';
let let = 'no';
```
## Best Practices
Variables are used all over the place in Javascript and other coding languages. There are a few best practices, when we use variables, to make sure everyone reading your code understands what's going on.

- Name your variables something understandable - i.e. `colorOfBackground`, not `color`, or `firstName`, not `name`.
- Don't use special characters - support can vary for these - it's best to avoid.
- Use one naming format, and stick with it - decide on either `pothole_case_naming`, `camelCase`, or `CamelCase`, and name all of your variables that way for consistency.