Boolean
=======

The **`Boolean`** object represents a truth value: `true` or `false`.

Description
-----------

### Boolean primitives and Boolean objects

Do not confuse the primitive `Boolean` values `true` and `false` with the `true` and `false` values of the `Boolean` object.

**Any** object, including a `Boolean` object whose value is `false`, evaluates to `true` when passed to a conditional statement. For example, the condition in the following `if` statement evaluates to `true`:


```js
const x = new Boolean(false);
if (x) {
  // this code is executed
}
```


This behavior does not apply to `Boolean` primitives. For example, the condition in the following `if` statement evaluates to `false`:


```js
const x = false;
if (x) {
  // this code is not executed
}
```


Do not use the `Boolean()` constructor with `new` to convert a non-boolean value to a boolean value — use `Boolean` as a function or a double NOT instead:


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


If you specify any object, including a `Boolean` object whose value is `false`, as the initial value of a `Boolean` object, the new `Boolean` object has a value of `true`.


```js
const myFalse = new Boolean(false); // initial value of false
const g = Boolean(myFalse); // initial value of true
const myString = new String("Hello"); // string object
const s = Boolean(myString); // initial value of 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 string coercion or number coercion, boolean coercion does not attempt to convert objects to primitives.

In other words, there are only a handful of values that get coerced to `false` — these are called falsy values. All other values 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 `Array.prototype.toString()`. Comparing strings and booleans results in both being 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 a new `Boolean` object.

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 Boolean objects with an initial value of false


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

### Creating Boolean objects with an initial value of true


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

Specifications
--------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-boolean-objects |

Browser compatibility
---------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

See also
--------

* Boolean
* Boolean primitives
* Boolean data type on Wikipedia