What are the various data types in JavaScript?

TL;DR

In JavaScript, data types can be categorized into primitive and non-primitive types:

Primitive data types

Number: Represents both integers and floating-point numbers.
String: Represents sequences of characters.
Boolean: Represents true or false values.
Undefined: A variable that has been declared but not assigned a value.
Null: Represents the intentional absence of any object value.
Symbol: A unique and immutable value used as object property keys. Read more in our deep dive on Symbols
BigInt: Represents integers with arbitrary precision.

Non-primitive (Reference) data types

Object: Used to store collections of data.
Array: An ordered collection of data.
Function: A callable object.
Date: Represents dates and times.
RegExp: Represents regular expressions.
Map: A collection of keyed data items.
Set: A collection of unique values.

The primitive types store a single value, while non-primitive types can store collections of data or complex entities.

Data types in JavaScript

JavaScript, like many programming languages, has a variety of data types to represent different kinds of data. The main data types in JavaScript can be divided into two categories: primitive and non-primitive (reference) types.

Primitive data types

Number: Represents both integer and floating-point numbers. JavaScript only has one type of number.

let age = 25;
let price = 99.99;

String: Represents sequences of characters. Strings can be enclosed in single quotes, double quotes, or backticks (for template literals).

let name = 'John Doe';
let greeting = 'Hello, world!';
let message = `Welcome, ${name}!`;

Boolean: Represents logical entities and can have two values: true or false.

let isActive = true;
let isOver18 = false;

Undefined: A variable that has been declared but not assigned a value is of type undefined.

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

Null: Represents the intentional absence of any object value. It is a primitive value and is treated as a falsy value.

let user = null;

Symbol: A unique and immutable primitive value, typically used as the key of an object property.

let sym1 = Symbol();
let sym2 = Symbol('description');

BigInt: Used for representing integers with arbitrary precision, useful for working with very large numbers.

let bigNumber = BigInt(9007199254740991);
let anotherBigNumber = 1234567890123456789012345678901234567890n;

Non-primitive (reference) data types

Object: It is used to store collections of data and more complex entities. Objects are created using curly braces {}.

let person = {
  name: 'Alice',
  age: 30,
};

Array: A special type of object used for storing ordered collections of data. Arrays are created using square brackets [].

let numbers = [1, 2, 3, 4, 5];

Function: Functions in JavaScript are objects. They can be defined using function declarations or expressions.

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

let add = function (a, b) {
  return a + b;
};

Date: Represents dates and times. The Date object is used to work with dates.

let today = new Date();

RegExp: Represents regular expressions, which are patterns used to match character combinations in strings.

let pattern = /abc/;

Map: A collection of keyed data items, similar to an object but allows keys of any type.

let map = new Map();
map.set('key1', 'value1');

Set: A collection of unique values.

let set = new Set();
set.add(1);
set.add(2);

Determining data types

JavaScript is a dynamically-typed language, which means variables can hold values of different data types over time. The typeof operator can be used to determine the data type of a value or variable.

console.log(typeof 42); // "number"
console.log(typeof 'hello'); // "string"
console.log(typeof true); // "boolean"
console.log(typeof undefined); // "undefined"
console.log(typeof null); // "object" (this is a historical bug in JavaScript)
console.log(typeof Symbol()); // "symbol"
console.log(typeof BigInt(123)); // "bigint"
console.log(typeof {}); // "object"
console.log(typeof []); // "object"
console.log(typeof function () {}); // "function"

Pitfalls

Type coercion

JavaScript often performs type coercion, converting values from one type to another, which can lead to unexpected results.

let result = '5' + 2; // '52' (string concatenation)
let difference = '5' - 2; // 3 (numeric subtraction)

In the first example, since strings can be concatenated with the + operator, the number is converted into a string and the two strings are concatenated together. In the second example, strings cannot work with the minus operator (-), but two numbers can be minused, so the string is first converted into a number and the result is the difference.