了解复杂数组三元运算符

Question

我刚刚浏览了inArray方法代码，遇到了以下内容：：

inArray: function (elem, arr, i) {
    var len;
    if (arr) {
        if (indexOf) {
            return indexOf.call(arr, elem, i);
        }
        len = arr.length;
        i = i ? i < 0 ? Math.max(0, len + i) : i : 0;
        for (; i < len; i++) {
            // Skip accessing in sparse arrays
            if (i in arr && arr[i] === elem) {
                return i;
            }
        }
    }
    return -1;
},

现在我明白了 tenary 运算符是如何工作的，但是有人可以告诉我，下面的代码行实际上是如何工作的吗？

i = i ? i < 0 ? Math.max( 0, len + i ) : i : 0;

还是JS中的某种新结构？

谢谢。

亚历克斯-兹。

Answer 1

原始语句：

i = i ? i < 0 ? Math.max(0, len + i) : i : 0;

为了更好地理解它，

i = i ? (i < 0 ? Math.max(0, len + i) : i) : 0;
//      ^                                ^

是的，这是嵌套ternary operator ? :.

以下是上述语句的if else表示，逐步if..else表示。

if (i) {
    i = i < 0 ? Math.max(0, len + i) : i;
} else {
    i = 0;
}

它的工作原理如下：

if (i) {
    if (i < 0) {
        i = Math.max(0, len + i);
    } else {
        i = i;
    }
} else {
    i = 0;
}

Answer 2

它是 2 个三元运算符，嵌套。你可以这样读：

i = i ? (i < 0 ? Math.max( 0, len + i ) : i) : 0;

或者，完全转换为if / else：

if(i)
    if (i < 0)
        i = Math.max(0, len + i);
    else
        i = i;
else
    i = 0;

您可以稍微缩短if / else结构：

if(i) {
    if (i < 0)
        i = Math.max(0, len + i);
} else
    i = 0;

或：

if(i && i < 0)
    i = Math.max(0, len + i);
if(!i)
    i = 0;

这将删除冗余else i = i 。在三元语句中，else是必需的，但此处可以省略。

---

请记住，您在这些 if / else 语句中看到的所有i =赋值都基于三元运算符前面的单个i =赋值。三元运算符本身（a ? b : c）不给变量赋值。

Answer 3

它是两个三元嵌套的。

展开外层会给我们：

var x;
if (i) {
  x = i < 0 ? Math.max( 0, len + i ) : i;
} else {
  x = 0;
}
i = x;

展开内部分支，然后给我们：

var x;
if (i) {
  if (i < 0) {
    x = Math.max( 0, len + i );
  } else {
    x = i;
  }
} else {
  x = 0;
}
i = x;

表示重新分配给 i 的临时值的 x。

括号可能会有所帮助（父母或换行符应该分解这些，任何时候它们都比简单的更难）：

i = i ? ( i < 0 ? Math.max( 0, len + i ) : i ) : 0;

现在你可以看到子表达式隐藏在真正的分支中间，外三元的中间。

Answer 4

它以

简单的逻辑分解为编码时你脑海中的想法。请注意，此函数不会捕获未定义的、nan 的 null、字符串、浮点数、布尔值、字节或任何可以被正常流捕获的输入。

这就是我认为简化逻辑背后的意图。当我编写这样的行时，这就是我脑海中的想法。

function calculatewhat(i) {
    if(i != 0) {/*i = i;*/ // i gets assigned and then evaluated. 
                           //If its anything but zero it's true, if its zero its false.
        if(i < 0) { // Test if its smaller than zero
          return Math.max( 0, len + i ) ; 
        }
        else { // its bigger than 0
           return i 
        }
    else { // if its 0... but you could just as wel return i 
           // instead of creating a new variable for the return since i is zero.
       return 0;
    }
}

我会对其进行编码而不是嵌套，如下所示

i = i < 0 ? Math.max( 0, len + i ) : i

为了满足Cerbrus，这就是它的真正运作方式。

function calculatewhat(i) {
    if(i) { //check if its a true value. This will evaluate true also on "1", "blah",true, etc... 
             //To be typesafe you should make it an integer test. if(typeof i === 'number' && i !== 0);
        if(i < 0) { // Test if its smaller than zero This will also return true on "-20" and -20.555
          return Math.max( 0, len + i ) ; 
        }
        else { // its bigger than 0 return i. but its type can be anything but an integer, so beware.
           return i 
        }
    else { //it's not a number or its 0. 
           //We can't be sure about type so lets return 0 to i making it a valid integer.
       return 0;
    }
}

Answer 5

实际上这就足够了：

if (i < 0) {
  return Math.max(0, len + I);
}

Answer 6

正如其他答案中提到的，这是一个嵌套的三元。我希望在这里提供的是此行为父函数执行的工作的自然语言翻译。

i = i ? i < 0 ? Math.max(0, len + i) : i : 0;
       [------|----------------------|--]         inner ternary
   [--|----------------------------------|---]    outer ternary

<小时 />

译本：

i ？ ... ： 0

（外三元）

如果从i开始搜索的索引作为函数的参数提供（这使用的事实，如果未提供参数，则i将是"falsy"），则继续计算内部三元并将i更新到结果，否则i设置为 0。

i < 0 ？ Math.max(0, len + i) ： i

（内三元）

如果 i 小于零，则返回数组长度 + i（由于i小于零，因此从数组末尾i位置查找元素的索引），下限为零;否则返回 i 。

<小时 />

我们现在可以看到，这条线允许函数将正整数解释为数组开头的位置，将负整数解释为数组末尾的位置，同时包括对位置索引的数组边界限制，并允许完全省略参数以默认为数组开始。

Answer 7

在初始代码中，我们有：

inArray: 
function (elem, arr, i) {
    /* [...] */
    i = i ? i < 0 ? Math.max(0, len + i) : i : 0;
    for (; i < len; i++) {
        /* [...] */
    }
    return -1;
}

所以基本上，这个：

   i = i ? i < 0 ? Math.max(0, len + i) : i : 0;

也可以表示：（前提是 i = 5）

// i = 5 is same as 5 = i
if (5) {
   if (5 < 0) {
      i = Math.max(0, len + 5);
   } else {
      i = 5;
   }
} else {
   i = 0;
}

这只是一种过于简化的做事方式。