Skip to main content

How to Convert an Integer to a Boolean in JavaScript

Converting a number to a boolean value is a common operation in programming, especially when dealing with flags or values that represent "truthiness." In JavaScript, this conversion is governed by a simple rule: the number 0 is "falsy," while all other numbers (positive and negative) are "truthy."

This guide will teach you the most effective and readable methods for converting an integer to a boolean. We will cover the explicit Boolean() constructor and the concise double NOT (!!) operator.

The Core Concept: Truthy and Falsy Values​

In JavaScript, every value has an inherent boolean value. When a value is used in a boolean context (like an if statement), it is evaluated as either true or false.

For numbers, the rule is very simple:

  • 0 (and -0) is a falsy value.
  • All other numbers (e.g., 1, -1, 100, 0.5) are truthy values.

The goal of converting an integer to a boolean is to get the explicit true or false value that corresponds to its truthiness.

The Boolean() function is a constructor that, when called as a function, performs an explicit type conversion. It takes any value and returns its corresponding boolean equivalent.

For example, you have a number and you want to get its explicit boolean value.

// Problem: How to get the boolean equivalent of these numbers?
const count = 5;
const remaining = 0;

This is the most readable and self-documenting solution:

console.log(Boolean(5));    // Output: true
console.log(Boolean(-5));   // Output: true
console.log(Boolean(0));    // Output: false
console.log(Boolean(-0));   // Output: false
note

This is the recommended best practice because the Boolean() function name clearly communicates the intent of the code.

The Concise Method: The Double NOT (!!) Operator​

A very common and concise alternative is the double NOT (!!) operator. This is a shorthand that achieves the exact same result as the Boolean() constructor.

The logical NOT (!) operator coerces a value to a boolean and then inverts it. Using it twice inverts the value back to its original boolean state.

  • !5 -> !true -> false
  • !!5 -> !!true -> !false -> true

Solution:

console.log(!!5);    // Output: true
console.log(!!-5);   // Output: true
console.log(!!0);    // Output: false
console.log(!!-0);   // Output: false
note

While this is very common in many codebases, the Boolean() constructor is often preferred for its superior readability, especially for developers who may not be familiar with the !! idiom.

Why These Methods are Better Than Manual Comparison​

You could also convert a number to a boolean by comparing it to 0.

Example of the Manual Method:

const myNumber = 5;
const myBoolean = myNumber !== 0; // true

While this works for numbers, the Boolean() constructor and !! operator are more universal. They work on any data type, not just numbers, which makes them more versatile.

Boolean('hello'); // true
Boolean('');      // false
Boolean(null);    // false
note

For consistency, it's a good practice to use Boolean() for all explicit boolean conversions.

Conclusion​

For converting an integer to a boolean in JavaScript, the choice is clear and simple.

  • The Boolean(number) function is the recommended best practice. It is the most explicit, readable, and self-documenting method.
  • The double NOT operator (!!number) is a very common and concise alternative that achieves the exact same result.

Both methods correctly convert 0 to false and all other numbers to true, providing a reliable way to work with the "truthiness" of numerical values.

Table of Contents