TypeScript 比较和逻辑运算符

注意: 如果您是 TypeScript 新手，请先查看我们的 TypeScript 入门 教程。

TypeScript 比较运算符

比较运算符会比较两个值，并返回一个布尔结果（true 或 false）。例如，

const a: number = 3, b: number = 2;

console.log(a > b);

// Output: true 

在这里，我们使用 > 比较运算符来检查 a（值为 3）是否大于 b（值为 2）。

因为 3 大于 2，所以我们得到 true 作为输出。

注意：在上面的例子中，a > b 被称为 boolean 表达式，因为它求值后会得到一个 boolean 值。

常用比较运算符

1. TypeScript 相等运算符

等于运算符 == 的求值结果为

• true - 如果操作数的值相等。
• false - 如果操作数的值不相等。

例如，

const greeting1: string = "hello";
const greeting2: string = "Hello";

// Comparing different values of string type
console.log(greeting1 == greeting2);  // false

// Comparing a string variable with a string literal
console.log(greeting1 == "hello");  // true
const myAge: number = 25;
const yourAge: number = 25;

// Comparing identical values of number type
console.log(myAge == yourAge);  // true

// Comparing a number variable with a numerical literal
console.log(myAge == 36);  // false

此程序的工作原理如下：

注意： 在 TypeScript 中，== 是比较运算符，而 = 是赋值运算符。如果您错误地使用 = 而不是 ==，可能会得到意外的结果。

const greeting: string = "hello";
const age: number = 25;

// Comparing string and number results in error
console.log(greeting == age);

// Comparing two numerical literals that are identical in value
// This is a valid code
console.log(2 == 2);  // true

// Comparing a numerical literal with a string literal
// Gives an error because you can't compare different types
console.log(2 == "2");  // Error

// Comparing two numerical literals with different values
// Gives an error because they are considered different types
console.log(2 == 3);  // Error

2. 不等于运算符

不等于运算符 != 的求值结果为

• true - 如果操作数的值不相等。
• false - 如果操作数的值相等。

例如，

const myAge: number = 25;
const yourAge: number = 25;

const greeting1: string = "hello";
const greeting2: string = "Hello";

// Comparing variables of same type and different values
console.log(greeting1 != greeting2);  // true

// Comparing variables of same type and same values
console.log(myAge != yourAge);  // false

// Comparing string variable with string literal
console.log(greeting1 != "hello");  // false

// Comparing number variable with numerical literal
console.log(myAge != 36);  // true

// Comparing literals of same type and value
console.log(2 != 2);  // false

此程序的工作原理如下：

TypeScript 中的不安全比较

正如您所知，JavaScript 中有许多允许的比较在 TypeScript 中可能会抛出错误。这里有一些例子

// Comparing variables of different types
// console.log(greeting1 != myAge);  // Error

// Comparing variable of one type with literal of another type
// console.log(myAge != "36");  // Error

// Comparing literals of different types
// console.log(2 != "2");  // Error

// Comparing numerical literals with different values
// console.log(2 != 3);  // Error

这个程序不工作的原因是

3. 严格相等运算符

严格相等运算符 === 的计算结果为

• true - 如果操作数的值和类型都相同。
• false - 如果操作数的值或类型不相同。

由于 TypeScript 默认禁止比较不同类型，我们只看有效的例子

const myAge: number = 25;
const yourAge: number = 25;
const stringAge: string = "25";

// Comparing identical values of number type
console.log(myAge === yourAge);  // true

// Comparing a number variable and a numerical literal
console.log(myAge === 36);  // false

// Converting stringAge to number and comparing it with myAge
// Valid code because we're comparing two number values
console.log(myAge === Number(stringAge));  // true

4. 严格不相等运算符

严格不相等运算符 !== 的计算结果为

• true - 如果操作数的值或类型不相同。
• false - 如果操作数的值和类型都相同。

const myAge: number = 25;
const yourAge: number = 25;
const stringAge: string = "25";

console.log(myAge !== yourAge);  // false

console.log(myAge !== 36);  // true

console.log(myAge !== Number(stringAge));  // false

5. 大于运算符

大于运算符 > 的返回值

• true - 如果左侧的值大于右侧的值。
• false - 如果左侧的值不大于右侧的值。

例如，

const myAge: number = 48;
const yourAge: number = 25;

// Left operand is greater
console.log(myAge > yourAge);  // true

// Both operands are equal
console.log(myAge > 48);  // false

// Left operand is smaller
console.log(36 > 48);  // false

6. 大于等于运算符

大于或等于运算符 >= 的返回值

• true - 如果左侧的值大于或等于右侧的值。
• false - 如果左侧的值小于右侧的值。

例如，

const myAge: number = 48;
const yourAge: number = 25;

// Left operand is greater
console.log(myAge >= yourAge);  // true

// Both operands are equal
console.log(myAge >= 48);  // true

// Left operand is smaller
console.log(36 >= 48);  // false

7. 小于运算符

小于运算符 < 的返回值

• true - 如果左侧的值小于右侧的值。
• false - 如果左侧的值不小于右侧的值。

例如，

const myAge: number = 48;
const yourAge: number = 25;

// Left operand is smaller
console.log(yourAge < myAge);  // true

// Both operands are equal
console.log(myAge < 48);  // false

// Left operand is greater
console.log(48 < 36);  // false

8. 小于等于运算符

小于或等于运算符 <= 的返回值

• true - 如果左侧的值小于或等于右侧的值。
• false - 如果左侧的值大于右侧的值。

例如，

const myAge: number = 48;
const yourAge: number = 25;

// Left operand is smaller
console.log(yourAge <= myAge);  // true

// Both operands are equal
console.log(myAge <= 48);  // true

// Left operand is greater
console.log(48 <= 36);  // false

TypeScript 逻辑运算符

逻辑运算符通过求值 boolean 表达式来返回一个 boolean 值。例如，

const x: number = 5;
const y: number = 3;

console.log((x < 6) && (y < 5));

// Output: true

这里，&& 是逻辑运算符AND。由于布尔表达式 x < 6 和 y < 5 都为 true，因此使用 && 运算符求值它们的结果也为 true。

常用逻辑运算符

1. 逻辑 AND 运算符

逻辑 AND 运算符 && 当两个表达式都为 true 时返回 true。例如，

let x: number = 2;

// Both expressions are true
console.log((x < 4) && (3 >= x));  // true

// Only one expression is true
console.log((x <= 4) && (x == 3));  // false

// Both expressions are false
console.log((x > 4) && (x == 3));  // false

这里，

• (x < 4) && (3 >= x) 的结果为 true，因为两个表达式都为 true。
• (x <= 4) && (x == 3) 的结果为 false，因为表达式 x == 3 为 false。
• (x > 4) && (x == 3) 的结果为 false，因为两个表达式都为 false。

2. 逻辑 OR 运算符

逻辑 OR 运算符 || 当至少有一个表达式为 true 时返回 true。例如，

let x: number = 2;

// Both expressions are true
console.log((x < 4) || (3 >= x));  // true

// Only one expression is true
console.log((x <= 4) || (x == 3));  // true

// Both expressions are false
console.log((x > 4) || (x == 3));  // false

这里，

• (x < 4) || (3 >= x) 的结果为 true，因为两个表达式都为 true。
• (x <= 4) || (x == 3) 的结果为 true，因为表达式 x <= 4 为 true。
• (x > 4) || (x == 3) 的结果为 false，因为两个表达式都为 false。

3. 逻辑 NOT 运算符

逻辑 NOT 运算符 ! 当指定表达式为 false 时返回 true，反之亦然。例如，

let x: number = 2;

// NOT on true
console.log(!true);  // false

// NOT on false
console.log(!false);  // true

// Comparison example
console.log(!(x < 3));  // false

这里，

• !true 的结果为 false，因为 ! 将 true 的值反转为 false。
• !false 的结果为 true，因为 ! 将 false 的值反转为 true。
• !(x < 3) 的结果为 false，因为 ! 将 (x < 3) 的 true 值反转为 false。

// Less than operator
console.log(4 < 5);

// Output: true

// ! logical NOT
console.log(!(4 < 5));

// Output: false

另请阅读

• TypeScript 运算符
• TypeScript if...else 语句
• TypeScript for 循环