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

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

let age = 25;
let price = 99.99;

2. 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}!`;

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

let isActive = true;
let isOver18 = false;

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

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

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

let user = null;

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

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

7. 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

1. 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,
};

2. 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];

3. 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;
};

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

let today = new Date();

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

let pattern = /abc/;

6. 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');

7. 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.

Further reading

• JavaScript data types and data structures - MDN
• JavaScript guide: Data types
• Data types - javascript.info
• JavaScript data types