The Data Types of Javascript
Tags: javascript, beginners, webdev
Published: 2021-06-11 20:32:26

Javascript has evolved into one of the most robust languages. Before javascript was just mainly focused on adding some interactivity to the web, but now we are able to build mobile application with React Native, backend with Node.js and even desktop applications with Electron. To take advantage of all this functionality we need to make sure we have our basic Javascript fundamentals down. Today I want to talk about the different data types in Javascript. 

## Primitive vs Non-Primitive
There are two main categories data types fall into with javascript. You have primitive and non-primitive. Why is this important? Depending on its category will determine how javascript stores and references the information. A primitive data types stores a single value and are passed by value. A non-primitive data type can store multiple values and are passed by reference. 


##Primitive

To clear things up, a primitive data type are things like boolean, strings, and numbers. Being passed by value means if you assign one variable the value of a different variable it stores just the value. Example: `let x=“hi”` `let y=x`. y is assigned ‘hi’. In background when y is assigned x, Javascript takes 'hi' and creates a new space in memory to reference. This keeps x and y separated from each other.

![primitive being passed by value](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/t3luttk1ia7o5sunctpa.png)

###String
A string is a group of characters inside of quotes. Javascript lets you use both single and double quotes.
```javascript
let str = ‘hi there’
let str2=“I have 2 dogs”
```

###Number
This represents a number and can be assigned with or without decimals. They are 64-bit floating point values and have a limit to how big a number can be.
```javascript
let num = 3
let num2 = 3.3
```

###BigInt
This is used to store numbers larger than what the number data type can hold. 
```javascript
let bigNum = 87956239487562934765239847562398745638974562983745623987456
```

###Boolean
Conditional values of true and false. You can set variables to a boolean value or you can also compare and that will return a boolean value. 
```javascript
let bol = true
let num = 3
num === 3 //return true
num === 33 //return false
```

### Undefined
This is when you declare a variable but never assign it a value. Javascript will automatically assign it an undefined value. 
```javascript
let x; //value of x is undefined
let y = undefined //same as declaring without assigning value = undefined
```

###Null
Represents a non-existent or invalid value.

###Symbol
Used to store an anonymous and unique value. This a new data type that was introduced with ES6.
```javascript
let sym = Symbol(‘unique’)
```

## Non-primitive
 Non-primitive data types are things like arrays and objects. They can hold multiple values inside of them. Being passed by reference means that if you assign a non-primitive data type to a variable it actually stores the location of the original variable and not the value. This can lead to some tricky errors to fix if not managed correctly. Example `let x=[1,2,3]` and `let y=x`. In the example we are not assigning y the value of [1,2,3] like we would for a primitive data type. We are actually assigning it x. In the background when we assign `y=x` Javascripts looks for the location in memory that represents x. It will then assign that location to y. This means if we make any changes to x it will also reflect in y.  

![Non-Primitive being passed by reference](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/2aho7hfu17gaqksuywqe.png)


###Object
Stores a collection of data. If the data type is non-primitive it will always an object type in javascript. 
```javascript
let obj = {name: ‘Tripp’, dogDad: true}
let arr = [1,2,3,4]
```

I hope you found this quick summary of data types in Javascript useful. They are pretty straight forward but if not managed correctly can lead to some tricky errors to debug.