# Data Types in JavaScript

JavaScript, like any programming language, uses various data types to store and manipulate data. Understanding these data types is crucial for writing effective and bug-free code. In this article, you'll learn the different data types in JavaScript, how they work, and how you can use them in your programs.

## Basic Data Types

JavaScript has several basic (also called primitive) data types. These include:

### 1\. **Number**

The `Number` type represents both integer (whole) and floating-point (decimal) numbers. JavaScript uses the IEEE 754 standard for representing numbers, which means it can handle values in the range of approximately -2^53 to 2^53.

The code snippet below shows a positive integer, a decimal and a negative integer being assigned to different variables:

```javascript
let age = 25; // integer
let pi = 3.14; // floating-point number
let negative = -42; // negative number
```

### 2\. **String**

The `String` type is used for text. Strings are sequences of characters enclosed in single quotes (`' '`), double quotes (`" "`), or backticks (`` ` ` ``).

Examples:

```javascript
let greeting = "Hello, world!";
let name = 'Alice';
let template = `The sum is ${2 + 3}`; // Template literals allow embedded expressions
console.log(template); //output: The sum is 5
```

### 3\. **Boolean**

The `Boolean` type has only two values: `true` or `false`. It's commonly used in conditional statements and logical operations (you'll learn about conditional statements and logical operations in subsequent articles).

Examples:

```javascript
let isActive = true;
let isLoggedIn = false;
```

### 4\. **Undefined**

A variable that has been declared but not assigned a value has the type `undefined`.

Example:

```javascript
let myVar;
console.log(myVar); // Output: undefined
```

### 5\. **Null**

The `Null` type represents the intentional absence of any object value. `Null` simply means empty. It is often used to indicate that a variable should have no value.

Example:

```javascript
let empty = null;
```

### 6\. **Symbol**

Introduced in ECMAScript 6 (ES6), a `Symbol` is a unique and immutable (can't be altered) primitive value that can be used as the key of an object property.

Example:

```javascript
let sym = Symbol('description');
```

### 7\. **BigInt**

Also introduced in ES6, `BigInt` is used for very large integers that exceed the safe integer limit for the `Number` type (remember the `Number` data type only handle values in the range of approximately -2^53 to 2^53). You can create a `BigInt` by adding `n` to the end of an integer.

Example:

```javascript
let bigInt = 1234567890123456789012345678901234567890n;
```

## Complex Data Types

JavaScript also includes complex data types, primarily objects and arrays.

### 1\. **Object**

The `Object` type is a collection of properties. An object is created using curly braces `{}` and properties are key-value pairs. An object is an entity that contains properties describing that entity. In the example below, we have a person object with the following properties: name, age, and height.

Example:

```javascript
let person = {
  name: 'John',
  age: 30,
  height: '7cm'
};
```

### 2\. **Array**

An `Array` is a special type of object used for storing ordered collections of values. Arrays are created using square brackets `[]`. An array is similar to a set. It collection of elements/values that are similar.

Example:

```javascript
let numbers = [1, 2, 3, 4, 5];
let mixedArray = ['Hello', 42, true, null, {}];
```

You'll learn more about objects and arrays in future articles. For now, this is all you need to know.

## Type Conversion

JavaScript is a dynamically typed language, meaning variables can change types. This often involves type conversion, either implicitly (coercion) or explicitly.

### Implicit Conversion

JavaScript automatically converts types in certain operations.

In the first example below, JavaScript automatically converts the number `5` to a string `'5'` and then joins it with the other string `'5'` which results in the value `'55'`.

Example:

```javascript
let result = '5' + 5; // '55' (string)
let result2 = '5' - 2; // 3 (number)
```

### Explicit Conversion

You can explicitly convert types using functions like `String()`, `Number()`, and `Boolean()`.

Examples:

```javascript
let num = 10;
//converts the number to a string
let str = String(num); // '10'
//converts 0 to a boolean
let bool = Boolean(0); // false
//converts the string to a number
let n = Number('123'); // 123
```

## Checking Data Types

To check the type of a variable, use the `typeof` operator.

Examples:

```javascript
console.log(typeof 42); //output: 'number'
console.log(typeof 'Hello'); //output: 'string'
console.log(typeof true); //output: 'boolean'
console.log(typeof undefined); //output: 'undefined'
console.log(typeof null); //output: 'object' (this is actually a historical bug in JavaScript)
console.log(typeof Symbol('sym')); //output: 'symbol'
console.log(typeof 123n); //output: 'bigint'
console.log(typeof {name: 'Alice'}); //output: 'object'
console.log(typeof [1, 2, 3]); //output: 'object'
```

Understanding data types in JavaScript is fundamental to mastering the language. It is a very very important concept. Knowing the differences between these types and how to use them appropriately will help you write more efficient and effective code.

Practice working with these types and explore their behavior in different contexts to deepen your understanding. To master JavaScript, you need to practice regularly because practice makes perfect (though you might never be perfect at JavaScript, lol). That's a wrap! See you in the next one!

![](https://cdn.hashnode.com/res/hashnode/image/upload/v1720975059521/b3f5732f-38e5-4dce-b36e-854b98f577cd.png align="center")