JavaScript is one of the most widely used programming languages in the world. Whether you're building web apps, writing backend logic, or automating small tasks, you will work with data.

To use data effectively, you must understand JavaScript’s data types.

In this guide, you’ll learn:

• What data types JavaScript supports

• The difference between primitive and non-primitive types

• How JavaScript stores and compares data

• Common pitfalls beginners face

• Practical examples for each type

Let’s get started.

---

What Are Data Types in JavaScript?

A data type describes the kind of value you’re working with.
JavaScript uses data types to determine how much memory to allocate, what operations you can perform, and how values behave during comparisons.

JavaScript has two major categories:

1. Primitive Data Types

2. Non-Primitive (Reference) Data Types

Let’s break these down.

---

Primitive Data Types in JavaScript

Primitive values are the simplest forms of data. They are immutable, meaning you cannot change them once created.
JavaScript has 7 primitive types:

1. String

2. Number

3. Boolean

4. Null

5. Undefined

6. Symbol

7. BigInt

---

1. String

A string represents text.

const name = "Madan";
const message = 'Hello World';
const sentence = `JavaScript is fun!`;

Strings can be written using " ", ' ', or backticks (template literals).

Use strings when you want to store words, sentences, or any text-based data.

---

2. Number

JavaScript uses the Number type for both integers and decimals.

const age = 20;
const price = 99.99;
const temp = -5;

JavaScript follows IEEE 754, which means numbers have limitations (like precision issues with decimals):

0.1 + 0.2;  // 0.30000000000000004

---

3. Boolean

A Boolean stores only two values: true or false.

const isLoggedIn = true;
const isAdmin = false;

Booleans are commonly used in conditions and comparisons.

---

4. Null

null represents an intentional absence of value.

let user = null;

You assign null manually when you want to say:

“This variable exists but has no value right now.”

---

5. Undefined

A variable becomes undefined when you do not assign a value.

let x;
console.log(x);  // undefined

JavaScript also returns undefined when accessing missing properties.

---

6. Symbol

Symbol creates unique values, often used as object keys.

const id = Symbol("userId");

Even if two symbols have the same description, they are always unique.

---

7. BigInt

BigInt handles numbers larger than the safe limit of normal JavaScript numbers.

const bigNumber = 123456789012345678901234567890n;

Use it when working with huge values such as cryptography or scientific calculations.

---

Non-Primitive Data Types in JavaScript

Non-primitive values are mutable and stored by reference.
There are two main non-primitive types:

1. Objects

2. Arrays (which are a type of object)

3. Functions (also objects)

---

1. Object

Objects store data in key–value pairs.

const user = {
  name: "Madan",
  age: 22,
  isMember: true
};

Objects let you model real-world entities.

---

2. Array

Arrays store lists of values in order.

const fruits = ["apple", "banana", "mango"];

They are perfect for collections of related data.

---

3. Function

A function itself is also a type of value.

function greet() {
  console.log("Hello!");
}

You use functions to build reusable logic.

---

Primitive vs Reference Types – The Key Difference

Primitive values are stored directly.

let a = 10;
let b = a;
a = 20;

console.log(b);  // 10

Reference values store a pointer to memory.

const obj1 = { age: 20 };
const obj2 = obj1;

obj1.age = 30;

console.log(obj2.age);  // 30

Changing one object affects the other because both variables point to the same memory location.

---

How to Check Data Types in JavaScript

You can use the typeof operator.

typeof 10;           // "number"
typeof "JS";         // "string"
typeof true;         // "boolean"
typeof undefined;    // "undefined"
typeof null;         // "object" (this is a known JavaScript quirk)
typeof {};           // "object"
typeof [];           // "object"
typeof function(){}; // "function"

Remember:

• Arrays and objects both return "object"

• Use Array.isArray() to check arrays

---

Common Beginner Mistakes (and How to Avoid Them)

1. Confusing null and undefined

• null: assigned by you

• undefined: assigned by JavaScript

2. Thinking numbers behave like math

Due to floating point issues:

0.1 + 0.2 !== 0.3

3. Forgetting that objects copy by reference

This causes unwanted side effects.

4. Assuming arrays have their own data type

Arrays are objects internally.

---

When to Use Each Type