Question

我正在查看来自MDN的indexOf的实施情况。这就是我很好奇的事情：

n = (n > 0 || -1) * Math.floor(Math.abs(n));

在我看来，(n > 0 || -1)将评估为true或false，但随后它会成倍增加？

如果链接中断，这是来自MDN的indexOf实现：

if (!Array.prototype.indexOf) {
    Array.prototype.indexOf = function (searchElement /*, fromIndex */ ) {
        "use strict";
        if (this == null) {
            throw new TypeError();
        }
        var t = Object(this);
        var len = t.length >>> 0;
        if (len === 0) {
            return -1;
        }
        var n = 0;
        if (arguments.length > 1) {
            n = Number(arguments[1]);
            if (n != n) { // shortcut for verifying if it's NaN
                n = 0;
            } else if (n != 0 && n != Infinity && n != -Infinity) {
                n = (n > 0 || -1) * Math.floor(Math.abs(n));
            }
        }
        if (n >= len) {
            return -1;
        }
        var k = n >= 0 ? n : Math.max(len - Math.abs(n), 0);
        for (; k < len; k++) {
            if (k in t && t[k] === searchElement) {
                return k;
            }
        }
        return -1;
    }
}

Answer 1

在我看来，（n> 0 || -1）将评估为真或假

不。 JavaScript中的||运算符为curiously powerful，如果n为<= 0，则表达式为-1，而不是false。

如果n > 0，那个表达式确实会产生true，是的，它们确实会将true乘以一个数字。没关系（我不会这样做，但是允许这样做），true会自动强制转换为数字（1），因为{{1}的两边都是在乘法之前被强制转换为数字。各种类型到数字的转换是在规范的Section 9.3中。

Answer 2

首先：

(n > 0 || -1)

按以下顺序排列：

  n > 0  // if true it stops here and -1 is not evaluated.
  -1

然后它试图乘以

   true * Math.floor(Math.abs(n))
   or
   -1 * Math.floor(Math.abs(n))

最后它要么存储：

n = 1 * Math.floor(Math.abs(n))
or 
n = -1 * Math.floor(Math.abs(n))

Answer 3

如果第一部分为假，则它将乘以-1，否则将乘以1。如果左侧是“falsy”，则OR运算符会返回表达式的右侧

（n> 0 || -1）是否评估为真/假？如果是这样，那怎么能成倍增加呢？

3 个答案: