这种比较似乎是无意的，因为类型“X”和“Y”没有重叠

This condition will always return ‘false’ since the types have no overlap

当条件保证 100% 的情况下具有相同的结果时，会出现错误“此比较似乎是无意的，因为类型 ‘X’ 和 ‘Y’ 没有重叠”。

要解决该错误，请更正条件中的逻辑，或者在 TypeScript 变得混乱时使用类型断言。

这种比较似乎是无意的

以下是错误发生方式的 3 个示例。

索引.ts

复制了！
const num = 30;
const str = '30';

// ⛔️ Error: This comparison appears to be unintentional because the types 'number' and 'string' have no overlap.
if (num === str) {
  console.log('success');
}

// ---------------------------------------------------------

const str2 = 'bobby';

// ⛔️ This comparison appears to be unintentional because the types '"bobby"' and '"hadz"' have no overlap.
if (str2 === 'bobby' && str2 === 'hadz') {
  console.log('success');
}


// ---------------------------------------------------------

export enum Sizes {
  Small = 'S',
  Medium = 'M',
  Large = 'L',
}

let size: Sizes = Sizes.Medium;

[1, 2].forEach((_) => {
  size = Sizes.Large;
});

console.log(size); // 👉️ "L"

// ⛔️ This comparison appears to be unintentional because the types 'Sizes.Medium' and 'Sizes.Large' have no overlap.
if (size === Sizes.Large) {
  console.log('success');
}

以严格相等的方式比较不同类型的两个值

在第一个示例中，我们尝试比较不同类型的两个值，保证返回false。

索引.ts

复制了！
const num = 30;
const str = '30';

// ⛔️ Error: This comparison appears to be unintentional because the types 'number' and 'string' have no overlap.
if (num === str) {
  console.log('success');
}

要解决此场景中的错误：

确保您正在比较兼容类型的值。
console.log条件中的值。
确保条件的结果并非 100% 相同。

索引.ts

复制了！
const num = 30;
const str = '30';

if (num === Number(str)) {
  console.log('success');
}

在比较值之前，我们使用Number()构造函数将字符串转换为数字。

现在左侧和右侧的值是兼容类型，因此比较按预期进行。

想要了解有关比较 TypeScript 中的值的更多信息？查看这些资源：如何比较 TypeScript 中的对象、如何比较 JavaScript 和 TypeScript 中的日期、如何比较 Typescript 中的枚举。

混合逻辑 AND (&&) 和逻辑 OR (||) 运算符

在第二个示例中，我们收到错误，因为我们使用了逻辑 AND (&&) 运算符而不是逻辑 OR (||) 运算符。

索引.ts

复制了！
const str = 'bobby';

// ⛔️ This comparison appears to be unintentional because the types '"bobby"' and '"hadz"' have no overlap.
if (str === 'bobby' && str === 'hadz') {
  console.log('success');
}

该str变量不可能同时具有bobby和的值，因此条件总是返回。hadzfalse

要解决该错误，请改用逻辑 OR (||) 运算符。

索引.ts

复制了！
const str = 'bobby';

if (str === 'bobby' || str === 'hadz') {
  console.log('success'); // 👉️ this runs
}

当在语句中使用逻辑 OR (||) 运算符时if，必须至少满足一个条件才能if运行该块。

当在语句中使用逻辑 AND (&&) 运算符时if，必须满足两个条件才能if运行块。

逻辑或 (||) 如果左侧的值为假，则返回右侧的值，否则返回左侧的值。
逻辑与 (&&) 如果为假则返回左侧的值，否则返回右侧的值。

错误地使用逻辑 NOT (!) 运算符

如果我们在比较值时错误地使用逻辑 NOT (!) 运算符，也会发生该错误。

索引.ts

复制了！
const str1 = 'bobby';

const str2 = Math.random() > 0.5 ? 'bobby' : 'hadz';

// ⛔️ This comparison appears to be unintentional because
// the types 'boolean' and 'string' have no overlap.
if (str1 === 'bobby' && !str1 !== str2) {
  console.log('success');
}

请注意，我们在表达式中使用了逻辑 NOT (!) 运算符：

索引.ts

复制了！
!str1 !== str2

我们没有将表达式括在括号中，因此逻辑 NOT (!) 运算符只是对左侧的值求反并将其转换为布尔值。

要解决该错误，请将表达式括在括号中。

索引.ts

复制了！
const str1 = 'bobby';

const str2 = Math.random() > 0.5 ? 'bobby' : 'hadz';

// ✅ wrapped the expression in parentheses
if (str1 === 'bobby' && !(str1 !== str2)) {
  console.log('success');
}

现在我们对表达式取反，str1 !== str2而不仅仅是str1变量中存储的值，因此一切都按预期进行。

解决 TypeScript 的限制（例如使用枚举）

在某些情况下，问题不在于我们的代码，而在于 TypeScript 编译器的限制。

索引.ts

复制了！
export enum Sizes {
  Small = 'S',
  Medium = 'M',
  Large = 'L',
}

let size: Sizes = Sizes.Medium;

[1, 2].forEach((_) => {
  size = Sizes.Large;
});

console.log(size); // 👉️ "L"

// ⛔️ This comparison appears to be unintentional because the types 'Sizes.Medium' and 'Sizes.Large' have no overlap.
if (size === Sizes.Large) {
  console.log('success');// 👉️ this runs
}

代码示例显示变量在
方法中size被设置为，但 TypeScript 不知道这一点。Sizes.LargeforEach()

您可以在本文中阅读有关比较枚举的更多信息
。

使用类型断言来解决错误

在这种情况下，解决错误的最简单方法是使用类型断言。

索引.ts

复制了！
export enum Sizes {
  Small = 'S',
  Medium = 'M',
  Large = 'L',
}

let size: Sizes = Sizes.Medium;

[1, 2].forEach((_) => {
  size = Sizes.Large;
});

console.log(size); // 👉️ "L"

// ✅ Use type assertion
if ((size as Sizes) === Sizes.Large) {
  console.log('success'); // 👉️ this runs
}

我们使用
类型断言
将变量键入size为Sizes。

有时我们拥有 TypeScript 无法知道的有关值类型的信息。

通过使用类型断言，我们有效地告诉 TypeScript 该size
变量保证具有的类型Sizes，因此不必担心。

我们还可以在声明size变量时使用类型断言。

索引.ts

复制了！
export enum Sizes {
  Small = 'S',
  Medium = 'M',
  Large = 'L',
}

// 👇️ Use type assertion here 👇️
let size: Sizes = Sizes.Medium as Sizes;

[1, 2].forEach((_) => {
  size = Sizes.Large;
});

console.log(size); // 👉️ "L"

if (size === Sizes.Large) {
  console.log('success'); // 👉️ this runs
}

在这种情况下，这要好一些，因为我们不必每次size在比较中使用变量时都重复自己。

在本例中，我们通过让 TypeScript 相信该条件不能保证 100% 的时间具有相同的结果来解决该错误。

忘记访问对象的属性

这是错误如何发生的另一个示例。

索引.ts

复制了！
// ⛔️ src/index.ts:19:5 - error TS2367:
// This comparison appears to be unintentional because the types
// 'ProcessEnv' and 'string' have no overlap.
if (process.env === 'development') {
  console.log('dev');
}

我们正在尝试将process.envdevelopment对象与导致问题的
字符串进行比较。

为了解决这个错误，我们必须确保左侧和右侧的值是兼容的类型。

在这种情况下，我们必须访问process.env对象的属性并将该属性与字符串进行比较。

索引.js

复制了！
if (process.env.NODE_ENV === 'production') {
  console.log('prod');
} else if (process.env.NODE_ENV === 'development') {
  console.log('dev');
} else {
  console.log(process.env.NODE_ENV);
}

该NODE_ENV属性只是一个例子。

但是，如果该属性返回 type 的值string，则比较有效。

解决错误时需要注意的事项

确保：

您正在比较兼容类型的值。
console.log条件中的值。
条件的结果并非 100% 相同。
您没有混淆逻辑 AND (&&) 和逻辑 OR (||) 运算符。

额外资源

您可以通过查看以下教程了解有关相关主题的更多信息：