JavaScript Logical NOT

The logical NOT (!) is a unary operator that evaluates its operand, coerces the resulting value to a boolean primitive, and returns the logical complement of that boolean. If the operand is truthy, it returns false; if the operand is falsy, it returns true.

!expression

Mechanics and Type Coercion

When the JavaScript engine evaluates the ! operator, it executes the following sequence:

Evaluates the provided expression.
Applies the internal ECMAScript ToBoolean abstract operation to the evaluated result.
Inverts the resulting boolean value.

Because JavaScript employs implicit type coercion, the ! operator does not require a boolean operand. The language’s truthiness and falsiness rules allow the operator to accept any data type and force coercion to a boolean primitive.

Falsy Evaluation

Applying ! to any falsy value strictly yields true. JavaScript defines exactly eight falsy values. The operator evaluates all of the following to true:

!false      // true
!0          // true (Number zero)
!-0         // true (Negative zero)
!0n         // true (BigInt zero)
!""         // true (Empty string)
!null       // true (Absence of any object value)
!undefined  // true (Uninitialized variable)
!NaN        // true (Not a Number)

Truthy Evaluation

Applying ! to any value not present in the falsy list yields false. This includes all objects, arrays, and functions, regardless of whether they are empty.

!true           // false
!1              // false (Non-zero number)
!"hello"        // false (Non-empty string)
![]             // false (Empty array is an object, therefore truthy)
!{}             // false (Empty object is truthy)
!function(){}   // false (Functions are objects, therefore truthy)

Operator Precedence

The ! operator has a very high precedence, sitting below grouping () and member access, but above all arithmetic, relational, and equality operators. It associates right-to-left. Because of this high precedence, it binds tightly to its immediate operand.

// Evaluates as !(typeof x) === "object"
// !(typeof x) becomes false, so false === "object" evaluates to false
!typeof x === "object" 

// Evaluates the equality first, then inverts the boolean result
!(typeof x === "object") 

Double NOT (`!!`)

Stacking two logical NOT operators (!!) is syntactically valid. The first ! coerces the operand to a boolean and inverts it. The second ! inverts it back. Mechanically, this exposes the exact result of the internal ToBoolean operation without the final inversion.

!!1         // true  (!1 is false, !false is true)
!!0         // false (!0 is true, !true is false)
!!"text"    // true
!!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 Logical NOT

Mechanics and Type Coercion

Falsy Evaluation

Truthy Evaluation

Operator Precedence

Double NOT (`!!`)

​Mechanics and Type Coercion

​Falsy Evaluation

​Truthy Evaluation

​Operator Precedence

​Double NOT (!!)

Mechanics and Type Coercion

Falsy Evaluation

Truthy Evaluation

Operator Precedence

Double NOT (`!!`)