如何避免在复杂的布尔表达式上三元

Question

In linting my Javascript, I ran across a no-unneeded-ternary warning on a complex ternary option of mine.

I know how to solve this on simple boolean expressions:

var obvious = (1 === 1) ? true : false;
// can simply become:
var obvious = (1 === 1);

However, on my below boolean expression, I don't know how to properly narrow this down without fear of breaking something which happens to be very complicated:

const include =
  (options.directory && file !== '.') ? false :
  (!dotted) ? true :
  (dotted && options.all) ? true :
  (dotted && !implied && options.almostall) ? true :
  (options.directory && file === '.') ? true :
  false;

What would be the proper shorthand implementation of this?

---

Taking a stab at it:

const include = !(options.directory && file !== '.') || 
  (!dotted) || 
  (dotted && options.all) ||
  (dotted && !implied && options.almostall) ||
  (options.directory && file === '.');

Is this correct?

Answer 1

When you write code using a bunch of chained ternary operators, it becomes more terse and typically less readable.

const include =
  (options.directory && file !== '.') ? false :
  (!dotted) ? true :
  (dotted && options.all) ? true :
  (dotted && !implied && options.almostall) ? true :
  (options.directory && file === '.') ? true :
  false;

To break this down, I will first expand it using a module pattern:

include = (function () {
    //set up some simple names for concepts:
    var directory = options.directory;
    var isDot = file === '.';
    var all = options.all;
    var almost = options.almostall;

    if (directory && !isDot)
        return false;

    if (!dotted)
        return true;

    if (dotted && all)
        return true;

    if (dotted && implied && almost)
        return true;

    if (directory && isDot)
        return true;

    return false;
}());

This can be simplified. After checking !dotted , dotted must be true, and becomes redundant:

 true && a 

converts to:

 a 

include = (function () {
    //set up some simple names for concepts:
    var directory = options.directory;
    var isDot = file === '.';
    var all = options.all;
    var almost = options.almostall;

    if (directory && !isDot)
        return false;

    if (!dotted)
        return true;

    if (all)
        return true;

    if (implied && almost)
        return true;

    if (directory && isDot)
        return true;

    return false;
}());

As a matter of leaving well enough alone, you could feel free to stop here knowing that the code is simple and efficient.

---

Of course...this can be simplified. The last if statement can be changed to a return :

 if (a) return true; return false; 

converts to:

 return a; 

include = (function () {
    //set up some simple names for concepts:
    var directory = options.directory;
    var isDot = file === '.';
    var all = options.all;
    var almost = options.almostall;

    if (directory && !isDot)
        return false;

    if (!dotted)
        return true;

    if (all)
        return true;

    if (implied && almost)
        return true;

    return directory && isDot;
}());

which of course can be simplified by converting the last if to a return again:

 if (a) return true; return b; 

converts to:

 return a || b; 

include = (function () {
    //set up some simple names for concepts:
    var directory = options.directory;
    var isDot = file === '.';
    var all = options.all;
    var almost = options.almostall;

    if (directory && !isDot)
        return false;

    if (!dotted)
        return true;

    if (all)
        return true;

    return (implied && almost) ||
        (directory && isDot);
}());

...and again:

include = (function () {
    //set up some simple names for concepts:
    var directory = options.directory;
    var isDot = file === '.';
    var all = options.all;
    var almost = options.almostall;

    if (directory && !isDot)
        return false;

    if (!dotted)
        return true;

    return (all) ||
        (implied && almost) ||
        (directory && isDot);
}());

...and again:

include = (function () {
    //set up some simple names for concepts:
    var directory = options.directory;
    var isDot = file === '.';
    var all = options.all;
    var almost = options.almostall;

    if (directory && !isDot)
        return false;

    return (!dotted) ||
        (all) ||
        (implied && almost) ||
        (directory && isDot);
}());

...and again:

 if (a) return false; return b; 

converts to:

 return !a && b; 

include = (function () {
    //set up some simple names for concepts:
    var directory = options.directory;
    var isDot = file === '.';
    var all = options.all;
    var almost = options.almostall;

    return !(directory && !isDot) && (
        (!dotted) ||
        (all) ||
        (implied && almost) ||
        (directory && isDot)
    );
}());

This can be simplified further by using De Morgan's laws :

 !(a && b) 

converts to:

 !a || !b 

include = (function () {
    //set up some simple names for concepts:
    var directory = options.directory;
    var isDot = file === '.';
    var all = options.all;
    var almost = options.almostall;

    return (!directory || isDot) && (
        (!dotted) ||
        (all) ||
        (implied && almost) ||
        (directory && isDot)
    );
}());

---

And there you have it, about as simple as the logic can get. You could, of course, choose to expand the variables back to their original definition, but I would encourage you not to. I would actually encourage you not to simplify beyond the simple chain of if..return statements.

If you make the code terser it's more challenging to read and understand which makes it more challenging to debug. It's quite likely that I've made a mistake somewhere in this post while "simplifying" the code, and it's not immediately obvious when reading the series of && and || operators if mistakes were made.