Javascript 最短的重写方法是什么；“松散的平等逻辑”；至；严格平等逻辑“；比如：`=`到`=`？

我有很多JavaScript遗留代码，我想重写所有松散的等式以使用严格的等式，即

=

vs

===

。但我通常不知道比较变量存储了什么值

在不知道这些值是什么的情况下，有没有一种方法可以重写这样的内容，使用对所有情况都适用的严格相等

        if (transformedValue != value) {
          ...
        }

到目前为止，我得到的（可能不正确）

---

不，没有自动方式将代码中的所有

==

重写为

===

，以便它适用于所有可能的情况

您必须咬紧牙关，将它们全部更改为

==

，并运行单元测试以发现哪些问题（您确实有单元测试，对吗？对！？）。或者一个接一个地检查，确保您了解潜在的价值，以便做出正确的选择。或者将它们保持为

=

，并处理异常值

---

需要注意的是，首选方法是最后的选择-保持原样。

在这里回答我自己的问题，并同意@VLAZ和@heretic monkey

也许可以检查所有变量的类型，并生成@flashthunder提到的相等函数，但这是完全不切实际的。我在下面发布了我的尝试，它通过了上面列出的所有等式，但它显然不是“定义性的”

如果（！loseequals（transformedValue，value））{

function looseEquals(a, b) {
  var typeA = typeof a;
  if (a === null) {
    typeA = 'null';
  }
  if (Array.isArray(a) || a instanceof String) {
    a = '' + a;
  }
  if (Array.isArray(b)) {
    b = '' + b;
  }

  switch (typeA) {
    case 'object':
      return a === b;
    case 'string':
      if (a === '') {
        return b === '' || b === false || b === 0;
      }
      return a === '' + b;
    case 'number':
      if (a === 0) {
        return b === '' || b === false || b === 0;
      }
      return a === Number(b);
    case 'undefined':
    case 'null':
      return b === undefined || b === null;
    case 'boolean':
      if (a) {
        return b === true || b === 1;
      } else {
        return b === false || b === 0 || b === '';
      }
    default:
  }
}

var tests = [
  [undefined, undefined],
  [null, null],
  [true, true],
  [false, false],
  ['foo', 'foo'],
  [0, 0],
  [0, false],
  ['', false],
  ['', 0],
  ['0', 0],
  ['17', 17],
  [[1, 2], '1,2'],
  [new String('foo'), 'foo'],
  [null, undefined],
  [null, false],
  [undefined, false],
  [{ foo: 'bar' }, { foo: 'bar' }],
  [new String('foo'), new String('foo')],
  [0, null],
  [0, NaN],
  ['foo', NaN],
  [NaN, NaN],
];

for (const [a, b] of tests) {
  if (looseEquals(a, b) !== (a == b)) {
    console.log('mismatch!', a, b);
  }
}

---

您可以使用助手方法

const isEqual=（a，b）=>a==b

---

用这个方法调用替换所有发生的事件，这样你就可以抽象出这个逻辑。

你就不能在编辑器中使用find/replace吗？？？@silenedogood在think OP中的意思是“找到所有在执行正则表达式替换时会断开的东西”但是问题还不是很清楚。@JaredSmith哦，我明白了。你为什么要这样做？也许是某个函数将所有内容都转换为左边的类型，检查

值的类型

？为什么你要在不使用loose equals的情况下重新创建loose equals？当然，loose equality在很多情况下并不精确但它实际上定义得很清楚。重新实现它似乎是浪费时间，这将导致代码看起来更糟糕，甚至可能包含bug。在类似的情况下（我愚蠢地认为我会“修复”很多松散的等式），我绝对建议不要这样做。将

==

更改为

==

会在一个地方引入一个微妙的错误，其中一个值有时为

null

其他时间为

未定义的

，因此只有在某些情况下才会失败。即使是单元测试，除非对代码进行广泛测试，否则很难捕捉到它d。从我对遗留代码的经验来看，事实并非如此。很多，甚至所有测试都是新编写的，可能不会使用您实际获得的所有当前值。@VLAZ:TRUTH.：）这似乎是一个有趣的解决方案……我宁愿不这样做，因为这种做法有多么奇怪。最好按照公认的answ来做er建议“咬紧牙关”或依赖单元测试。我没有否决你的帖子。其他人否决了。我同意你的观点，那是没有根据的。

function looseEquals(a, b) {
  var typeA = typeof a;
  if (a === null) {
    typeA = 'null';
  }
  if (Array.isArray(a) || a instanceof String) {
    a = '' + a;
  }
  if (Array.isArray(b)) {
    b = '' + b;
  }

  switch (typeA) {
    case 'object':
      return a === b;
    case 'string':
      if (a === '') {
        return b === '' || b === false || b === 0;
      }
      return a === '' + b;
    case 'number':
      if (a === 0) {
        return b === '' || b === false || b === 0;
      }
      return a === Number(b);
    case 'undefined':
    case 'null':
      return b === undefined || b === null;
    case 'boolean':
      if (a) {
        return b === true || b === 1;
      } else {
        return b === false || b === 0 || b === '';
      }
    default:
  }
}

var tests = [
  [undefined, undefined],
  [null, null],
  [true, true],
  [false, false],
  ['foo', 'foo'],
  [0, 0],
  [0, false],
  ['', false],
  ['', 0],
  ['0', 0],
  ['17', 17],
  [[1, 2], '1,2'],
  [new String('foo'), 'foo'],
  [null, undefined],
  [null, false],
  [undefined, false],
  [{ foo: 'bar' }, { foo: 'bar' }],
  [new String('foo'), new String('foo')],
  [0, null],
  [0, NaN],
  ['foo', NaN],
  [NaN, NaN],
];

for (const [a, b] of tests) {
  if (looseEquals(a, b) !== (a == b)) {
    console.log('mismatch!', a, b);
  }
}