> ## Documentation Index
> Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt
> Use this file to discover all available pages before exploring further.
# 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`.
```javascript theme={"dark"}
!expression
```
## Mechanics and Type Coercion
When the JavaScript engine evaluates the `!` operator, it executes the following sequence:
1. Evaluates the provided `expression`.
2. Applies the internal ECMAScript `ToBoolean` abstract operation to the evaluated result.
3. 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`:
```javascript theme={"dark"}
!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.
```javascript theme={"dark"}
!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.
```javascript theme={"dark"}
// 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.
```javascript theme={"dark"}
!!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
