What are the data types in JavaScript?
JavaScript has eight data types that can be divided into two main categories: primitive types and reference types (objects). Understanding these data types is fundamental to working effectively with JavaScript.
Primitive Data Types
JavaScript has seven primitive data types:
1. String
Represents textual data enclosed in single quotes, double quotes, or backticks (template literals).
const name = "Rahul";
const greeting = 'Hello';
const message = `${greeting}, ${name}!`; // Template literal (ES6)
// String methods
console.log(name.length); // 5
console.log(name.toUpperCase()); // "RAHUL"
console.log(name.charAt(0)); // "R"
console.log(name.indexOf("h")); // 22. Number
Represents both integer and floating-point numbers.
const integer = 42;
const float = 3.14;
const negative = -10;
const exponent = 2.5e6; // 2,500,000
const binary = 0b1010; // 10 in decimal
const octal = 0o744; // 484 in decimal
const hex = 0xFF; // 255 in decimal
// Special numeric values
const infinity = Infinity;
const negInfinity = -Infinity;
const notANumber = NaN; // Result of invalid calculations
// Number methods
console.log(Number.isInteger(42)); // true
console.log(Number.isNaN(NaN)); // true
console.log((3.14159).toFixed(2)); // "3.14"3. BigInt
Represents integers with arbitrary precision (introduced in ES2020).
const bigNumber = 9007199254740991n; // n suffix creates a BigInt
const anotherBig = BigInt("9007199254740991");
// BigInt operations
console.log(bigNumber + 1n); // 9007199254740992n
console.log(bigNumber * 2n); // 18014398509481982n
// Cannot mix with Number type without explicit conversion
// console.log(bigNumber + 1); // TypeError
console.log(Number(bigNumber) + 1); // 90071992547409924. Boolean
Represents a logical entity with two values: true and false.
const isActive = true;
const isComplete = false;
// Truthy and falsy values
console.log(Boolean(0)); // false
console.log(Boolean("")); // false
console.log(Boolean(null)); // false
console.log(Boolean(undefined)); // false
console.log(Boolean(NaN)); // false
console.log(Boolean(1)); // true
console.log(Boolean("hello")); // true
console.log(Boolean({})); // true
console.log(Boolean([])); // true5. Undefined
Represents a variable that has been declared but not assigned a value.
let variable;
console.log(variable); // undefined
console.log(typeof variable); // "undefined"
// Function parameters that aren't provided are undefined
function test(param) {
console.log(param); // undefined if not provided
}
test();6. Null
Represents the intentional absence of any object value.
const empty = null;
console.log(empty); // null
console.log(typeof null); // "object" (this is a historical bug in JavaScript)
// Checking for null
console.log(empty === null); // true7. Symbol
Represents a unique and immutable value, often used as object property keys (introduced in ES6).
const id = Symbol("id");
const anotherId = Symbol("id");
console.log(id === anotherId); // false, each Symbol is unique
// Using Symbols as object keys
const user = {
name: "Priya",
[id]: 12345 // Symbol as a property key
};
console.log(user[id]); // 12345
console.log(Object.keys(user)); // ["name"], Symbols are not enumerableReference Data Type: Object
All non-primitive types in JavaScript are objects:
8. Object
Represents a collection of key-value pairs and more complex entities.
// Object literal
const person = {
firstName: "Rahul",
lastName: "Sharma",
age: 28,
greet() {
return `Hello, I'm ${this.firstName}`;
}
};
console.log(person.firstName); // "Rahul"
console.log(person["lastName"]); // "Sharma"
console.log(person.greet()); // "Hello, I'm Rahul"Common Object Sub-types
Arrays
Arrays are objects used for storing ordered collections.
const fruits = ["Apple", "Banana", "Cherry"];
console.log(fruits[0]); // "Apple"
console.log(fruits.length); // 3
// Array methods
fruits.push("Date"); // Add to end
fruits.pop(); // Remove from end
fruits.unshift("Apricot"); // Add to beginning
fruits.shift(); // Remove from beginning
fruits.splice(1, 1, "Blueberry"); // Replace elementsFunctions
Functions in JavaScript are first-class objects.
// Function declaration
function add(a, b) {
return a + b;
}
// Function expression
const subtract = function(a, b) {
return a - b;
};
// Arrow function (ES6)
const multiply = (a, b) => a * b;
console.log(add(5, 3)); // 8
console.log(typeof add); // "function"Date
Object for working with dates and times.
const now = new Date();
const specific = new Date("2023-01-15T12:30:00");
console.log(now.toISOString());
console.log(specific.getFullYear()); // 2023
console.log(specific.getMonth()); // 0 (January is 0)RegExp
Object for pattern matching with regular expressions.
const pattern = /^\d{3}-\d{2}-\d{4}$/;
const ssn = "123-45-6789";
console.log(pattern.test(ssn)); // trueMap
Object for storing key-value pairs with any type of keys (ES6).
const userRoles = new Map();
userRoles.set("Rahul", "Admin");
userRoles.set("Priya", "Editor");
console.log(userRoles.get("Rahul")); // "Admin"
console.log(userRoles.has("Priya")); // true
console.log(userRoles.size); // 2Set
Object for storing unique values of any type (ES6).
const uniqueNumbers = new Set([1, 2, 3, 3, 4, 4, 5]);
console.log(uniqueNumbers.size); // 5 (duplicates removed)
console.log(uniqueNumbers.has(3)); // trueType Checking in JavaScript
Using typeof Operator
console.log(typeof "Hello"); // "string"
console.log(typeof 42); // "number"
console.log(typeof true); // "boolean"
console.log(typeof undefined); // "undefined"
console.log(typeof null); // "object" (historical bug)
console.log(typeof {}); // "object"
console.log(typeof []); // "object" (arrays are objects)
console.log(typeof function(){}); // "function"
console.log(typeof Symbol()); // "symbol"
console.log(typeof 42n); // "bigint"More Precise Type Checking
// For arrays
console.log(Array.isArray([])); // true
console.log(Array.isArray({})); // false
// For null
console.log(value === null); // true if value is null
// For NaN
console.log(Number.isNaN(NaN)); // true
console.log(Number.isNaN("string")); // false (unlike global isNaN())
// For finite numbers
console.log(Number.isFinite(42)); // true
console.log(Number.isFinite(Infinity)); // falseType Coercion
JavaScript performs automatic type conversion when operations involve different types.
Implicit Coercion
console.log("5" + 3); // "53" (number coerced to string)
console.log("5" - 3); // 2 (string coerced to number)
console.log("5" * "3"); // 15 (strings coerced to numbers)
console.log(true + 1); // 2 (true coerced to 1)
console.log(false + 1); // 1 (false coerced to 0)
console.log(5 + undefined); // NaN (undefined coerced to NaN)Explicit Coercion
// To String
console.log(String(42)); // "42"
console.log(String(true)); // "true"
console.log(String(null)); // "null"
console.log(String(undefined)); // "undefined"
console.log((123.45).toString()); // "123.45"
// To Number
console.log(Number("42")); // 42
console.log(Number("42px")); // NaN
console.log(Number(true)); // 1
console.log(Number(false)); // 0
console.log(Number(null)); // 0
console.log(Number(undefined)); // NaN
console.log(parseInt("42px", 10)); // 42
console.log(parseFloat("3.14")); // 3.14
// To Boolean
console.log(Boolean(0)); // false
console.log(Boolean("")); // false
console.log(Boolean("hello")); // true
console.log(Boolean(42)); // true
console.log(!!42); // true (shorthand for Boolean())Primitive vs. Reference Types
Value Comparison
Primitives are compared by value:
let a = 5;
let b = 5;
console.log(a === b); // trueObjects are compared by reference:
let obj1 = { value: 5 };
let obj2 = { value: 5 };
console.log(obj1 === obj2); // false (different references)
let obj3 = obj1;
console.log(obj1 === obj3); // true (same reference)Mutability
Primitives are immutable:
let name = "Rahul";
name[0] = "K"; // No effect
console.log(name); // "Rahul" (unchanged)Objects are mutable:
let user = { name: "Rahul" };
user.name = "Karan";
console.log(user.name); // "Karan" (changed)Interview Tips
- Understand the difference between primitive and reference types
- Be able to explain type coercion and its implications
- Know how to properly check types in JavaScript
- Understand that
typeof nullreturns “object” (a historical bug) - Be familiar with ES6 data types like Symbol, Map, and Set
- Understand how primitive values are immutable while objects are mutable
- Be prepared to discuss the differences between
==and===operators in relation to types
Test Your Knowledge
Take a quick quiz to test your understanding of this topic.