@putout/plugin-logical-expressions

The logical NOT (!) operator takes truth to falsity and vice versa.

(c) MDN

🐊Putout plugin adds ability to simplify logical expressions containing comparisons which will always evaluate to true or false since it's likely indications of programmer error.

Complements @putout/plugin-apply-comparison-order.

Install

npm i @putout/plugin-logical-expressions -D

Rules

• ✅ apply-destructuring;
• ✅ convert-bitwise-to-logical;
• ✅ convert-coalescing-to-logical;
• ✅ remove-boolean;
• ✅ remove-duplicates;
• ✅ simplify;

Config

{
    "rules": {
        "logical-expressions/convert-bitwise-to-logical": "on",
        "logical-expressions/convert-coalescing-to-logical": "on",
        "logical-expressions/remove-boolean": "on",
        "logical-expressions/remove-duplicates": "on",
        "logical-expressions/simplify": "on",
        "logical-expressions/apply-destructuring": "on"
    }
}

convert-bitwise-to-logical

The bitwise OR operator (|) returns a 1 in each bit position for which the corresponding bits of either or both operands are 1s.

The operands are converted to 32-bit integers and expressed by a series of bits (zeroes and ones).

(c) MDN

Convert bitwise to logical operator, when one of operands is not a number, since mostly likely it is an error.

❌ Example of incorrect code

a | !b;

if (!(a !== b))
    fn();

✅ Example of correct code

a || !b;

if (a === b)
    fn();

convert-coalescing-to-logical

Checkout in 🐊Putout Editor.

❌ Example of incorrect code

const fn = cb ?? noop;

✅ Example of correct code

const fn = cb || noop;

remove-boolean

A boolean is a logical data type that can have only the values true or false.

(c) MDN

❌ Example of incorrect code

const t = true && false;

✅ Example of correct code

const t = false;

remove-duplicates

❌ Example of incorrect code

const t = a && b && a;

✅ Example of correct code

const t = a && b;

Comparison

| Linter | Rule | Fix | |---------------|------|-----| | 🐊 Putout | logical-expressions | ✅ | | ⏣ ESLint | no-constant-binary-expression | ❌ |

simplify

❌ Example of incorrect code

const is = !(options && !options.bidirectional);

if (!left.type === 'UnaryExpression') {}

const oneOf = a || a;
const same = a === a;

a() && b;

✅ Example of correct code

const is = !options || options.bidirectional;

if (!isUnaryExpression(left)) {}

const oneOf = a;
const same = true;

a();

The rule also simplify duplication use:

-if (a && b || a && c) {
+if (a && (b || c)) {
}

Wrong cases with instanceof:

-!a instanceof b;
-a instanceof !b;
-!a instanceof !b;
+!(a instanceof b);

Wrong cases with in:

-!a in b;
-a in !b;
+!(a in b);

In case of duplicates:

-a && b && a
+a && b

apply-destructuring

Checkout in 🐊Putout Editor.

❌ Example of incorrect code

const arrow = (el) => el().text && el().text.trim();

const value = getState().workbench && getState().workbench.code;

✅ Example of correct code

const arrow = (el) => {
    const {text} = el();
    return text && text.trim();
};

const {workbench} = getState();
const value = workbench && workbench.code;

License

MIT