HTML

Structure of content on the web

  • Web APIs

    Interfaces for building web applications

  • Learn
  • HTTP Observatory

    Scan a website for free

  • JavaScript
  • Standard built-in objects
  • Boolean.prototype.valueOf()
  • Inheritance
  • Function.prototype.call()
  • Function: displayName
  • Function.prototype.arguments
  • Function.prototype.caller
  • Instance methods
    1. Object.prototype.__defineGetter__()
    2. Object.prototype.__defineSetter__()
    3. Object.prototype.__lookupGetter__()
    4. Object.prototype.__lookupSetter__()
    5. Object.prototype.toLocaleString()
    6. Object.prototype.__proto__
    7. equality operators, and binary logical operators such as && and || return the values of the operands, which may or may not be boolean values.

      Boolean values are typically used in conditional testing, such as the condition for Array.prototype.filter().

      You would rarely need to explicitly convert something to a boolean value, as JavaScript does this automatically in boolean contexts, so you can use any value as if it's a boolean, based on its truthiness. You are also encouraged to use if (condition) and if (!condition) instead of if (condition === true) or if (condition === false) in your own code so you can take advantage of this convention. However, making sure that values representing conditions are always booleans can help clarify the intent of your code.

      js
      / Do this:
/ This always returns a boolean value
const isObject = (obj) => !!obj && typeof obj === "object";

/ Or this:
const isObject = (obj) => Boolean(obj) && typeof obj === "object";

/ Or this:
const isObject = (obj) => obj !== null && typeof obj === "object";

/ Instead of this:
/ This may return falsy values that are not equal to false
const isObject = (obj) => obj && typeof obj === "object";

      Boolean primitives and Boolean objects

      For converting non-boolean values to boolean, use Boolean as a function or use the double NOT operator. Do not use the Boolean() constructor with new.

      js
      const good = Boolean(expression);
const good2 = !!expression;
      js
      const bad = new Boolean(expression); / don't use this!

      This is because all objects, including a Boolean object whose wrapped value is false, are truthy and evaluate to true in places such as conditional statements. (See also the boolean coercion section below.)

      js
      if (new Boolean(true)) {
  console.log("This log is printed.");
}

if (new Boolean(false)) {
  console.log("This log is ALSO printed.");
}

const myFalse = new Boolean(false); / myFalse is a Boolean object (not the primitive value false)
const g = Boolean(myFalse); / g is true
const myString = new String("Hello"); / myString is a String object
const s = Boolean(myString); / s is true

      Warning: You should rarely find yourself using Boolean as a constructor.

      Boolean coercion

      Many built-in operations that expect booleans first coerce their arguments to booleans. The operation can be summarized as follows:

      • Booleans are returned as-is.
      • undefined turns into false.
      • null turns into false.
      • 0, -0, and NaN turn into false; other numbers turn into true.
      • 0n turns into false; other BigInts turn into true.
      • The empty string "" turns into false; other strings turn into true.
      • Symbols turn into true.
      • All objects become true.

      Note: A legacy behavior makes document.all return false when used as a boolean, despite it being an object. This property is legacy and non-standard and should not be used.

      Note: Unlike other type conversions like convert objects to primitives by calling user methods.

      In other words, there are only a handful of values that get coerced to false — these are called truthy values. A value's truthiness is important when used with logical operators, conditional statements, or any boolean context.

      There are two ways to achieve the same effect in JavaScript.

      • Double NOT: !!x negates x twice, which converts x to a boolean using the same algorithm as above.
      • The Boolean() function: Boolean(x) uses the same algorithm as above to convert x.

      Note that truthiness is not the same as being loosely equal to true or false.

      js
      if ([]) {
  console.log("[] is truthy");
}
if ([] == false) {
  console.log("[] == false");
}
/ [] is truthy
/ [] == false

      [] is truthy, but it's also loosely equal to false. It's truthy, because all objects are truthy. However, when comparing with false, which is a primitive, [] is also converted to a primitive, which is "" via converted to numbers, and they both become 0, so [] == false is true. In general, falsiness and == false differ in the following cases:

      • NaN, undefined, and null are falsy but not loosely equal to false.
      • "0" (and other string literals that are not "" but get coerced to 0) is truthy but loosely equal to false.
      • Objects are always truthy, but their primitive representation may be loosely equal to false.

      Truthy values are even more unlikely to be loosely equal to true. All values are either truthy or falsy, but most values are loosely equal to neither true nor false.

      Constructor

      Boolean()

      Creates Boolean objects. When called as a function, it returns primitive values of type Boolean.

      Instance properties

      These properties are defined on Boolean.prototype and shared by all Boolean instances.

      Boolean.prototype.constructor

      The constructor function that created the instance object. For Boolean instances, the initial value is the Boolean constructor.

      Instance methods

      Boolean.prototype.toString()

      Returns a string of either true or false depending upon the value of the object. Overrides the Object.prototype.toString() method.

      Boolean.prototype.valueOf()

      Returns the primitive value of the Boolean object. Overrides the Object.prototype.valueOf() method.

      Examples

      Creating false values

      js
      const bNoParam = Boolean();
const bZero = Boolean(0);
const bNull = Boolean(null);
const bEmptyString = Boolean("");
const bfalse = Boolean(false);

      Creating true values

      js
      const btrue = Boolean(true);
const btrueString = Boolean("true");
const bfalseString = Boolean("false");
const bSuLin = Boolean("Su Lin");
const bArrayProto = Boolean([]);
const bObjProto = Boolean({});

      Specifications

      Specification
      ECMAScript® 2026 Language Specification
      # sec-boolean-objects

      Browser compatibility

      See also