What does !1 and !0 mean in Javascript?

Understanding !1 and !0 in JavaScript: The Boolean Coercion Shorthand

Explore the meaning and practical applications of !1 and !0 in JavaScript, common shorthand for boolean false and true respectively, and how they leverage type coercion.

In JavaScript, you might occasionally encounter expressions like !1 or !0. While they might look cryptic at first glance, they are simply concise ways to represent boolean false and true respectively, leveraging JavaScript's type coercion rules and the logical NOT operator (!). Understanding these constructs is key to deciphering some common JavaScript patterns and writing more idiomatic code.

The Logical NOT Operator (!)

The core of !1 and !0 lies in the logical NOT operator (!). This operator performs two main actions:

1. Type Coercion: It first converts its operand to a boolean value.
2. Inversion: It then inverts that boolean value (true becomes false, and false becomes true).

JavaScript has a set of 'falsy' values that coerce to false when evaluated in a boolean context, and 'truthy' values that coerce to true. Knowing these is crucial for understanding !.

Deconstructing !1

Let's break down !1:

1. Operand: The operand is the number 1.
2. Coercion: In a boolean context, the number 1 is a 'truthy' value. Therefore, it coerces to true.
3. Inversion: The logical NOT operator (!) then inverts true to false.

So, !1 evaluates to false.

console.log(Boolean(1)); // true
console.log(!1);        // false

Demonstrating the evaluation of !1

Deconstructing !0

Now, let's look at !0:

1. Operand: The operand is the number 0.
2. Coercion: The number 0 is one of JavaScript's 'falsy' values. Therefore, it coerces to false.
3. Inversion: The logical NOT operator (!) then inverts false to true.

Thus, !0 evaluates to true.

console.log(Boolean(0)); // false
console.log(!0);        // true

Demonstrating the evaluation of !0

flowchart TD
    A["Expression: !1"] --> B{"Coerce 1 to Boolean"}
    B --> C["Result: true"]
    C --> D{"Apply NOT operator"}
    D --> E["Final: false"]

    F["Expression: !0"] --> G{"Coerce 0 to Boolean"}
    G --> H["Result: false"]
    H --> I{"Apply NOT operator"}
    I --> J["Final: true"]

Flowchart illustrating the evaluation of !1 and !0

Practical Applications and Double NOT (!!)

While !1 and !0 are direct replacements for false and true, their primary utility often comes in conjunction with the double logical NOT operator (!!). The !! operator is a common idiom to explicitly convert any value to its strict boolean equivalent without inverting it.

• !!value will return true if value is truthy, and false if value is falsy.

This is particularly useful when you need to ensure a variable holds a strict boolean true or false rather than a truthy/falsy value.

const myString = "hello";
const myNumber = 42;
const myNull = null;

console.log(!!myString); // true (because "hello" is truthy)
console.log(!!myNumber); // true (because 42 is truthy)
console.log(!!myNull);   // false (because null is falsy)

// Compare with Boolean() constructor
console.log(Boolean(myString)); // true
console.log(Boolean(myNumber)); // true
console.log(Boolean(myNull));   // false

Using the double NOT operator (!!) for explicit boolean conversion