Everything You Should Know About Javascript Variables
Tags: javascript, tutorial, webdev, beginners
Published: 2019-10-16 16:02:42

# Front Matter

I'm a firm believer in [deliberate practice](https://jamesclear.com/deliberate-practice-theory) and also the idea that the best way to learn something is to teach it. This article will focus solely on javascript variables. We'll go over things like types, coercion, scope, hoisting and some style choices.

Really, this is just an excuse to make more title cards. I do it all for the graphics.

![Laughing Lion](https://media.giphy.com/media/bOvFrUeeHz2zC/giphy.gif)

# Video

If you prefer to watch, instead of read, check out the companion video!

{% youtube _3th_0JN-mc %}

{% youtube xYYsLyep0Ho %}

# What is a variable?

First things first, let's get a good definition.

> A variable is a named location for storing a value. That way an unpredictable value can be accessed through a predetermined name. - MDN

Think of it as a placeholder. 

When you say to yourself, "I need to remember all this information later, but I only want to remember one word"...that's a variable!

![See, I suffer from short-term memory loss.](https://media.giphy.com/media/VhXhoqn3DJt8Q/source.gif)

## Types

JS is a dynamically typed language, so we generally don't have to worry about assigning the type of data that is being stored in that variable. However, knowing the types makes debugging a lot easier.

> Variables don't have types, but the values in them do. These types define intrinsic behavior of the values. - Kyle Simpson

JavaScript defines seven built-in types:

- null
- undefined
- boolean
- number
- string
- object
- symbol -- added in ES6!

**Note:** All of these types except object are called "primitives".

> In JavaScript, a primitive (primitive value, primitive data type) is data that is not an object and has no methods. - MDN

### null

> Represents the intentional absence of any object value - MDN

`null` is something you (the human) use to purposefully say, this variable has no value.

![I'm not worthless!](https://media.giphy.com/media/ZjlOfaQjp3KWA/source.gif)

**General Usage**

Consistent way of returning from a function that doesn't yield results:
```js
    function return3 (value) {
    	if(value === 3) { return value }
    	else { return null }
    }
    
    return3(2) // null
```
If we didn't tell it to return `null`, it would return `undefined`.

### undefined

Defines a variable that does not have a value. In other words, the JS Engine is aware that a variable exists, but it has no value. This may seem similar to `null` but they are different. The main difference is that `null` is a defined value, whereas `undefined` is not. For a great article about this specific topic, check [this out](https://codeburst.io/javascript-null-vs-undefined-20f955215a2).
```js
    let b;
    console.log(b) // undefined
```
### boolean

Simple true or false
```js
    let falseVariable = false
```
### number

The number in JS differs from other programming languages that define what type of number, e.g. float, integer, etc. Instead, JS uses the double-precision 64-bit floating point format (IEEE 754). That means you don't have to worry about the type of number when declaring it. Just declare away!
```js
    let four = 4;
    let fiveish = 5.1;
    console.log(four + fiveish) // 9.1
```
**General Usage**

A value you expect to do something computational with, e.g. math.

### string

A sequence of characters. For example, this sentence.
```js
    let someString = "I'm a string!"
```
**General Usage**

Storing information to display to the user.

### object

> An object initializer is a comma-delimited list of zero or more pairs of property names and associated values of an object, enclosed in curly braces ({}). - MDN
```js
    let car = {
    	color: "red",
    	miles: 400,
    }
    
    console.log(car.color) //red
```
**General Usage**

Everything. Which, is only partially a joke. I use JS objects to pass data around in an application.

**A note about the Array**

Technically speaking, an Array is an object. If you don't believe me run this in the console:
```js
    typeof [1,2,3] === "object";
```
However, as Kyle Simpson notes:

> It's most appropriate to think of them (arrays) also as a "subtype" of object (see Chapter 3), in this case with the additional characteristics of being numerically indexed (as opposed to just being string-keyed like plain objects) and maintaining an automatically updated .length property.

### symbol -- added in ES6!

Unique Identifiers. No two symbols will ever be the same. Useful as object keys, in large data structures.

Avoid Naming collisions

Gotta be honest, I haven't used this in the real world, so maybe someone has a good example to share! However, I found a really good overview of symbols [here](https://www.keithcirkel.co.uk/metaprogramming-in-es6-symbols/).

### Bonus!

**undeclared**

Undeclared means that the variable you are trying to access is not available in the scope, which we'll talk about in length in a minute. The error you will see is `ReferenceError: x is not defined` .

# Declaring variables

There are three different ways to declare a variable in Javascript. We're going to talk about all three: `var` , `let`  and `const` .

## var vs const vs let

It's been a minute since `const` and `let` were standardized into the JS Spec (2295360 as of the minute I'm writing this).

**var**

Old school way of defining a variable in JS. It was king of the block for a long time, until it's much more specific brothers came long.

- can be changed
- scoped globally or locally to an entire function regardless of block scope.

**let**

- can be changed.
- scoped to the block.
- let variables are not initialized until their definition is evaluated. - MDN

**const**

- cannot be changed after instantiation.
- scoped to the block.

**when to use let vs const**

There are two camps about how to approach when to use what.

1. I don't trust anyone
    1. This method says, use `const` first for every variable. If the need comes along that you need to change a variable after it's been declared, change it to `let`.
2. I trust myself
    1. This method says, use `let` for everything. If the need comes along that you need to make sure a variable can't be changed, change it to `const`.

Moral of the story here:

- Don't use var anymore. If you're worried about compatibility in browsers, it has 94% global compatibility. If that still isn't good enough (there are some edge cases), you probably should use Babel to poly-fill other things anyways.

# Coercion

What if I told you that you could change the past.

![You gotta put your past behind you.](https://media.giphy.com/media/UYi82ItuXD3gs/source.gif)

Check it out.
```js
    let threeString = "3";
    let threeNum = 3;
```
They look different right? One is obviously a `number` and one obviously a `string` .

If we do this, you'd expect it to throw an error:
```js
    let sum = threeString + threeNum
```
But it doesn't! JS "coerces" `threeString` into a number so it can do math. Thanks JS...I think? In this scenario, it's probably fine. However, you can run into issues if you are trying to evalute an expressions "truthy-ness". Check out [this article](https://www.freecodecamp.org/news/js-type-coercion-explained-27ba3d9a2839/) for an even DEEPER dive.

# Scope

Scope in Javascript refers to:

> The current context of execution. - MDN

This means different things depending on whether we are talking about the old school `var` or the new school `const` / `let` . Scope comes in two flavors: local and global.

## Global

Global scope is anything at the top level of the file.
```js
    var globalVar = "I'm global!"
    let globalLet = "I'm also global!"
    const globalConst = "I'm global too!"
    
    function someFunction() {
    	console.log(globalVar); // I'm global!
    	console.log(globalLet); // I'm also global!
    	console.log(globalConst); // I'm global too!
    }
```
## Local

The definition of local scope changes slightly, depending on whether you are talking about `var` or `let`/`const`.

### var (functional scope)

A `var` statement when called within a function, is available anywhere in that function. For example:
```js
    function someFunction() {
    	if(true) {
    		var localScope = "Yo! Call me!"
    		console.log(localScope) // "Yo! Call me!"      
    	}
    	console.log(localScope) // "Yo! Call me!"
    }
```
As long as it's within that function, it's available to be called.

### let and const (block scope)

The new kids on the block `let` and `const` are **BLOCK** scoped, which means they are only available within the block they are in. 

Examples of blocks are: **if**/**switch** statements, **for**/**while** loops. Or, as described expertly in [this article](https://dev.to/sandy8111112004/javascript-introduction-to-scope-function-scope-block-scope-d11):

> Generally speaking, whenever you see {curly brackets}, it is a block.

Using the same example:
```js
    function someFunction() {
    	if(true) {
    		let localScope = "Yo! Call me!"
    		console.log(localScope) // "Yo! Call me!"      
    	}
    	console.log(localScope) // Uncaught ReferenceError: localScope is not defined
    }
```
# Hoisting

Per the MDN docs:

> Because variable declarations (and declarations in general) are processed before any code is executed, declaring a variable anywhere in the code is equivalent to declaring it at the top. This also means that a variable can appear to be used before it's declared. This behavior is called "hoisting", as it appears that the variable declaration is moved to the top of the function or global code.

More simply put:

> all declarations, both variables and functions, are processed first, before any part of your code is executed. - Kyle Simpson

When a `var` statement is hoisted to the top of the context, it is assigned a value of `undefined` . 
```js
    hoistedVar = "I've been hoisted!";
    var hoistedVar;
    
    console.log(hoistedVar) // I've been hoisted!
```
What better way to understand it than using Tyler McGinnis' amazing [Javascript Visualizer](https://tylermcginnis.com/javascript-visualizer/)! As you can see, both variables are given a value of `undefined` as soon the Creation phase starts. This allows the compiler to assign the value of "I've been Hoisted" to the value when it parses through the code during execution.

![Hoisting in action](https://thepracticaldev.s3.amazonaws.com/i/dnq3kmphjbyu1bm4bjex.gif))

## Let and Const Caveat

`let` and `const` are not hoisted in the same way that `var` is. `var` is initialized as `undefined` when they are hoisted. `let` and `const` remain uninitialized until the statement is evaluated by the compiler. Thanks, [Bergi](https://stackoverflow.com/questions/31219420/are-variables-declared-with-let-or-const-not-hoisted-in-es6), for the insight.

Therefore, using the same example:
```js
    hoistedVar = "I've been hoisted!";
    let hoistedVar;
    
    console.log(hoistedVar) // Uncaught ReferenceError: 
    												//Cannot access 'hoistedVar' before initialization
```
# Style Choices

![Stylish Timon](https://media.giphy.com/media/bEDFKJQIw9kFa/giphy.gif)

## Casing

When you declare variables, there's a bunch of different options. The style is up to you, but just keep it consistent.

### **Camel Casing (Dromedary)**
```js
    let camelCasedVar = "Im camel cased"
```
This is used for common variables throughout my applications.

### **Camel Casing (Pascal)**
```js
    let PascalCasedVar = "Im Pascal cased"
```
I use Pascal casing for Classes or Components.

### **Snake Case**
```js
    let snake_case_var = "Sssssnake case"
```
This method is pretty common in PhP, for whatever reason, but I haven't seen it much in JS land. I don't really like it anyways, so I don't use it anymore.

### **Kebab-case**
```html
    <input id="kebab-case-input">
```
According to [StackOverflow](https://stackoverflow.com/questions/11273282/whats-the-name-for-hyphen-separated-case), this convention is known colloquially as kebab-case. While this method can't be used by JS, it is a common convention in HTML. I try to avoid it for reasons mentioned below.

### What I use

I typically use camel casing, for everything (CSS, JS, HTML). For one, it seems to be pretty standard about the JS world, but also because it makes writing out selectors a little cleaner/consistent. 

Consider the example below:
```html
    <form action="/" id="form">
      <input type="text" id="kebab-case">
      <input type="text" id="camelCase">
      <button type="submit">Submit</button>
    </form>
```
```js
    // When we submit form data, we can access it via the event parameter.  
    let form = document.getElementById("form")
    form.addEventListener("submit", function(event) {
        event.preventDefault();
    
    		// if we use hyphens, we have to use brackets/quotes to get the value
        const kebabInput = event.target["kebab-case"].value
    
    		// if we use anything without special characters, we can use dot notation
        const camelInput = e.target.camelCase.value
    }, false)
```
I think this makes for cleaner code, but I'll leave that up to you to debate.

## What do I call this variable?

Now that you know where you're going to be able to access it, and whether you can change it or not, it's time to name it! If you're like me, it takes a good five minutes to settle on a variable name. Over the years, I've come across some helpful tips to avoid that wasted time. The most important one:

> Name it what it is.

Wow, what great advice. 

![Rafiki](https://media.giphy.com/media/H3BDRHV1p14fC/giphy.gif)

I know it sounds simple, but just think about what exact information is going to be held in this variable and what you're going to do with it. Try to avoid using single character variables like `i`, `e` or `p`. Use whole words. If your text editor is any good, it'll autocomplete those for you anyways. 

### Reserved Words

Just a note, there are a bunch of reserved words in JS. For instance: `abstract`, `var` and `boolean`. You can check them all out [here](https://www.w3schools.com/js/js_reserved.asp).

# Final Thoughts

Wow, we made it to the end. Congratulations! Honestly, there is a lot of information here. We talked all about types, hoisting, coercion, and threw in some ES6 for flavor. There's no way we covered it all.

Did I miss anything? What other topics should we explore together?

Leave a comment below!

As always, happy coding!

![Lion King Walking Montage](https://media.giphy.com/media/ycKlfboAj3k2s/source.gif)

# Resources

## Paid Courses

[ES6 for Everyone](https://es6.io/)

## Free

[Carbon](https://carbon.now.sh/)

[Eloquent JavaScript](https://eloquentjavascript.net/)

[Var, let and const- what's the difference?](https://dev.to/sarah_chima/var-let-and-const--whats-the-difference-69e)

[https://tylermcginnis.com/var-let-const/](https://tylermcginnis.com/var-let-const/)

[https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/var](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/var)

[https://www.tutorialspoint.com/javascript/javascript_variables.htm](https://www.tutorialspoint.com/javascript/javascript_variables.htm)

[https://blog.sessionstack.com/how-javascript-works-memory-management-how-to-handle-4-common-memory-leaks-3f28b94cfbec](https://blog.sessionstack.com/how-javascript-works-memory-management-how-to-handle-4-common-memory-leaks-3f28b94cfbec)