JavaScript Boolean

A Boolean in JavaScript is a primitive logical data type that represents one of two binary states: true or false. It serves as the foundational mechanism for evaluating logical expressions and representing binary conditions in memory.

Instantiation and Syntax

Booleans can be instantiated using literal notation or the global Boolean() function.

// Literal assignment (Primitive)
const isActive = true;
const isComplete = false;

// Type casting using the Boolean() function (Primitive)
const hasValue = Boolean("Hello"); // true

Primitive vs. Wrapper Object

JavaScript distinguishes between the boolean primitive type and the Boolean object wrapper. Using the new keyword invokes the constructor and creates an object reference rather than a primitive value. This alters strict equality evaluation and memory allocation.

const primitiveBool = true;
const objectBool = new Boolean(true);

console.log(typeof primitiveBool); // "boolean"
console.log(typeof objectBool);    // "object"

console.log(primitiveBool === objectBool); // false

Note: Instantiating Booleans via the new Boolean() constructor is considered an anti-pattern. Because objects are inherently truthy, new Boolean(false) evaluates to true in a boolean context.

Type Coercion and Truthiness

When a non-boolean value is evaluated in a boolean context, JavaScript performs implicit type coercion. Values are categorized strictly as either “truthy” or “falsy”. There are exactly eight falsy values in JavaScript. If a value is not on this list, it evaluates to true.

// The 8 Falsy Values
Boolean(false);
Boolean(0);          // Number zero
Boolean(-0);         // Negative zero
Boolean(0n);         // BigInt zero
Boolean("");         // Empty string
Boolean(null);       // Absence of any object value
Boolean(undefined);  // Uninitialized variable
Boolean(NaN);        // Not a Number

All other values, including empty arrays, empty objects, and the string "false", are truthy.

// Truthy Examples
Boolean("false"); // true (non-empty string)
Boolean([]);      // true (object)
Boolean({});      // true (object)

Logical Operators and Boolean Casting

JavaScript logical operators (&&, ||, !) interact directly with boolean logic. While && and || return the value of one of their operands based on short-circuit evaluation, the logical NOT operator (!) always coerces its operand to a boolean primitive and inverts it. Applying the logical NOT operator twice (!!) is a standard syntactic shorthand for casting a value to a boolean primitive, functionally identical to calling Boolean().

// Logical NOT coerces to boolean and inverts
const inverted = !0; // true

// Double NOT casts to a boolean primitive
const castedString = !!"text"; // true
const castedNull = !!null;     // false

Tired of Poor JavaScript Skills? Fix That With Deep Grasping!Learn More

Functions

Methods

Constructors

Classes

Destructuring

Decorators

Modules

Accessors

Variables

Fields

Parameters

Error Handling

Control Flow

Statement Forms

Loops

Primitive Types

Comments

Access Operators

Spread Operators

Call Operators

Conditional Operators

Logical Operators

Equality Operators

Relational Operators

Arithmetic Operators

Assignment Operators

Update Operators

Unary Operators

Yield Operators

Bitwise Operators

Shift Operators

JavaScript Boolean

Instantiation and Syntax

Primitive vs. Wrapper Object

Type Coercion and Truthiness

Logical Operators and Boolean Casting

​Instantiation and Syntax

​Primitive vs. Wrapper Object

​Type Coercion and Truthiness

​Logical Operators and Boolean Casting

Instantiation and Syntax

Primitive vs. Wrapper Object

Type Coercion and Truthiness

Logical Operators and Boolean Casting