1. javascript
  2. /basics
  3. /data-types

A Beginner's Guide to Data Types in JavaScript


JavaScript, like many other programming languages, uses data types to define the kind of values that a variable can hold. Understanding data types is essential for writing efficient and effective code. In this article, we'll take a look at the different data types in JavaScript, and how to use the typeof operator to identify them.

Primitive Data Types in JavaScript

JavaScript has seven primitive data types:


Numbers can be integers or floating-point numbers. They can also be written in scientific notation. For example:

let age = 30;
let pi = 3.14;
let largeNum = 1e+12;


A sequence of characters. Strings can be written using single or double quotes. For example:

let name = "John";
let message = 'Hello, World!';


Boolean values can only be true or false. They are often used in conditional statements. For example:

let isStudent = true;
let isHappy = false;
if (isStudent) {
  console.log("You are a student");


A unique and immutable data type that can be used as an identifier for an object. For example:

let sym1 = Symbol("id");
let sym2 = Symbol("id");
console.log(sym1 === sym2); // false


Used to represent integers with arbitrary precision. It is denoted by appending "n" to the integer value. For example:

let big = 9007199254740991n;
console.log(big * big); // 81002880989318883660306659249961n


Represents the absence of a value or a variable that has been declared but not yet assigned a value. For example:

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


Represents a non-existent value. It's often used to indicate that an object has no value. For example:

let empty = null;
console.log(empty); // null

Object Types

JavaScript also has non-primitive data types, also known as object types, which are more complex and can contain multiple values. These include:

  • Object: a collection of key-value pairs, for example, {name: "John", age: 30}

  • Array: a list of items, for example, [1, 2, 3]

  • Function: a block of code that can be executed, for example, function add(a, b) {return a + b;}

  • Date: a specific point in time, for example, new Date()

  • RegExp: a regular expression, for example, /^[a-z]+$/

  • Error: an error object, for example, new Error("Invalidinput")

Here are some examples of non-primitive data types in use:

let person = {name: "John", age: 30}; // Object
let numbers = [1, 2, 3]; // Array
let add = function(a, b) {return a + b;}; // Function
let date = new Date(); // Date
let reg = /^[a-z]+$/; // RegExp
let error = new Error("Invalid input"); // Error

The typeof operator

To identify the type of a value or a variable, you can use the typeof operator. It returns a string indicating the type of the operand. For example:

console.log(typeof 42); // "number"
console.log(typeof "Hello, World!"); // "string"
console.log(typeof true); // "boolean"
console.log(typeof Symbol("id")); // "symbol"
console.log(typeof {name: "John", age: 30}); // "object"
console.log(typeof [1, 2, 3]); // "object"
console.log(typeof function add(a, b) {return a + b;}); // "function"
console.log(typeof new Date()); // "object"
console.log(typeof /^[a-z]+$/); // "object"
console.log(typeof undefined); // "undefined"
console.log(typeof null); // "object"
console.log(typeof error); // "object"

The typeof operator returns "object" for both objects and arrays, errors as well. To correctly identify if a value is an array, you can use the Array.isArray() method.

console.log(Array.isArray([1, 2, 3])); // true
console.log(Array.isArray({name: "John", age: 30})); // false


  • JavaScript has seven primitive data types: number, string, boolean, symbol, bigint, undefined and null.
  • JavaScript also has non-primitive data types, also known as object types, which include: object, array, function, date, and regular expressions.
  • The typeof operator can be used to identify the type of a value.
  • typeof returns "object" for both objects and arrays, use Array.isArray() method to correctly identify arrays.

Understanding how to identify and work with different types of data is a fundamental aspect of programming and will serve you as a foundation for more advanced concepts and techniques.