我们可以到处使用 `const` 而不是 `let` 吗？

Question

flowtype 我们更喜欢 const 而不是 let

我有一个函数需要以最高效的方式工作，它对我来说效果很好，它比较两个数组，所以它是我的问题的一个很好的例子：

/**
* @function compare
* @description function compares two arrays with ids to figure out: are they equal? (elements position can be different)
* @param arraFrom {Array}
* @param arraTo {Array}
* @param compareFunction {Function}
* @returns {Boolean}
*/
function compare(arraFrom, arraTo, compareFunction) {
  let notEqual = true;
  if(arraFrom.length !== arraTo.length) return false;
    for (let i = 0; i < arraFrom.length; i++) {
      notEqual = true;
      for (let j = 0; j < arraTo.length; j++) {
        if (compareFunction ?
            compareFunction(arraFrom[i], arraTo[j]) :
          arraFrom[i] === arraTo[j]) {
          notEqual = false;
          break;
        }
      }
      if (notEqual) return false;
   }
   return true;
}

问题是：我们如何在不使用 let 的情况下以最高效的方式实现它？

谢谢！

Answer 1

如果您不更改它的值，那么您可以在任何地方使用它。不同的是const的值不能改。除了一个

没有其他区别

Answer 2

为什么您更喜欢 const 而不是 let？ const 有一个属性它不会让自己改变。不过，您在尝试更改它时不会遇到错误。相反，它只会保持其初始值。您发布的代码绝对没有 const 的位置。

Answer 3

您可以使用 for…of 循环，而不是通过改变索引变量来迭代数组：

function compare(arraFrom, arraTo, compareFunction) {
  let notEqual = true;
  if(arraFrom.length !== arraTo.length) return false;
  for (const a of arraFrom) {
    notEqual = true;
    for (const b of arraTo) {
      if (compareFunction ? compareFunction(a,b) : a === b) {
        notEqual = false;
        break;
      }
    }
    if (notEqual) return false;
  }
  return true;
}

而不是那个可变的 notEqual 标志，你可以简单地 return 提早：

function compare(arraFrom, arraTo, compareFunction) {
  if (arraFrom.length !== arraTo.length) return false;
  outer: for (const a of arraFrom) {
    for (const b of arraTo) {
      if (compareFunction ? compareFunction(a,b) : a === b) {
        continue outer;
      }
    }
    return false;
  }
  return true;
}

但这很难读。我建议使用以下内容：

function compare(arrayFrom, arrayTo, compareFunction) {
  if (arrayFrom.length !== arrayTo.length) return false;
  const test = typeof compareFunction == "function"
    ? a => b => compareFunction(a, b)
    : a => b => a === b;
  return arrayFrom.every(a => arrayTo.some(test(a)));
}

我们可以到处使用 `const` 而不是 `let` 吗？

Can we use `const` instead of `let` everywhere?

javascript

arrays

ecmascript-6

immutability

flowtype