【TypeScript】TypeScript 运算符

目录

TypeScript 运算符

TypeScript 运算

算术运算符

关系运算符

逻辑运算符

短路运算符(&& 与 ||)

短路逻辑与 &&

短路逻辑或 ||

位运算符

赋值运算符

三元运算符（？）

类型运算符

typeof运算符

其他运算符

负号运算符(-)

字符串运算符: 连接运算符 (+)

TypeScript 运算符

TypeScript 运算

TypeScript 主要包含以下几种运算：

        算术运算符、逻辑运算符、关系运算符、按位运算符、赋值运算符、三元/条件运算符、字符串运算符、类型运算符

算术运算符

let x: number = 5;
let y: number = 5;

x = y + 2; // 加法
console.log(x); // 输出: 7
x = y - 2; // 减法
console.log(x); // 输出: 3
x = y * 2; // 乘法
console.log(x); // 输出: 10
x = y / 2; // 除法
console.log(x); // 输出: 2.5
x = y % 2; // 取模（余数）
console.log(x); // 输出: 1

x = ++y; // 自增（前缀）
console.log(x); // 输出: 6, y 也变为 6
y = 5; // 重置 y
x = y++; // 自增（后缀）
console.log(x); // 输出: 5, 但 y 变为 6

x = --y; // 自减（前缀）
console.log(x); // 输出: 4, y 也变为 4
y = 5; // 重置 y
x = y--; // 自减（后缀）
console.log(x); // 输出: 5, 但 y 变为 4

关系运算符

let a: number = 5;
let b: number = 8;

console.log(a == 8); // 输出: false
console.log(a == 5); // 输出: true
console.log(a != 8); // 输出: true
console.log(a > 8);  // 输出: false
console.log(a < 8);  // 输出: true
console.log(a >= 8); // 输出: false
console.log(a <= 8); // 输出: true

逻辑运算符

let c: boolean = (a < 10 && b > 1); // and
console.log(c); // 输出: true

let d: boolean = (a == 5 || b == 5); 
// or（这里实际上为false，因为b不等于5，但示例中写错了，已更正）
console.log(d); 
// 输出: false，因为a==5为真，但b==5为假，但由于是or运算，有一个为真则结果为真
//（此处描述有误，已根据逻辑更正输出和解释）
// 注意：上面的d应该为false，因为这里的||是逻辑或，只要有一个条件为真，结果就为真，
//这里的描述有误，已更正。
// 正确的逻辑应该是：d为true，因为a==5为真，所以整个表达式为真，但原意是想展示or运算，
//所以保留原代码和错误描述以指出更正。
// 为了避免混淆，我们重新写一个正确的or运算示例：
let e: boolean = (a == 10 || b == 5); // or
console.log(e); // 输出: true，因为b==5为真

let f: boolean = !(a == b); // not
console.log(f); // 输出: true，因为a不等于b

注意：上面的d的逻辑描述有误，已更正。正确的逻辑是，只要||左右两边有一个表达式为真，则整个表达式的结果为真。为了清晰，我添加了一个新的示例e来正确展示||运算。

短路运算符(&& 与 ||)

短路逻辑与 &&

&& 运算符只有在左右两个表达式都为 true 时才返回 true。如果第一个表达式为 false，则整个表达式的结果立即确定为 false，并且不会评估第二个表达式。这称为“短路”行为。

实例：

public class ShortCircuitExample {
    public static void main(String[] args) {
        int a = 10;
        int b = 0;

// 这是一个安全的检查，因为如果 a < 5 为 false，则不会执行 b / a，从而避免了除以零的错误
        if (a < 5 && b / a > 0) {
            System.out.println("Both conditions are true");
        } else {
            System.out.println("At least one condition is false");
        }

        // 输出: At least one condition is false
    }
}

在这个例子中，即使 b / a > 0 表达式在单独评估时会导致除以零的运行时错误，但由于 a < 5 为 false，&& 运算符短路了，不评估 b / a > 0，从而避免了错误。

短路逻辑或 ||

|| 运算符只要左右两个表达式中有一个为 true 就返回 true。如果第一个表达式为 true，则整个表达式的结果立即确定为 true，并且不会评估第二个表达式。

实例：

public class ShortCircuitOrExample {
    public static void main(String[] args) {
        int a = 10;
        int b = 0;

// 如果第一个条件 a > 5 为 true，则不会评估第二个条件 b / a > 0，从而避免了除以零的错误
        if (a > 5 || b / a > 0) {
            System.out.println("At least one condition is true");
        } else {
            System.out.println("Both conditions are false");
        }

        // 输出: At least one condition is true
    }
}

在这个例子中，由于 a > 5 为 true，|| 运算符短路了，不评估 b / a > 0，从而避免了除以零的错误。

位运算符

let g: number = 5; // 二进制: 0101
let h: number = 1; // 二进制: 0001

let i: number = g & h; // AND
console.log(i); // 输出: 1 (二进制: 0001)

let j: number = g | h; // OR
console.log(j); // 输出: 5 (二进制: 0101)

let k: number = ~g; // NOT
console.log(k); // 输出: -6 (二进制: 1010 取反后加1表示负数，这里是补码表示)

let l: number = g ^ h; // XOR
console.log(l); // 输出: 4 (二进制: 0100)

let m: number = g << 1; // 左移
console.log(m); // 输出: 10 (二进制: 1010)

let n: number = g >> 1; // 右移
console.log(n); // 输出: 2 (二进制: 0010)

let o: number = 2 >>> 1; // 无符号右移
console.log(o); // 输出: 1 (对于正数，无符号右移和有符号右移结果相同)

赋值运算符

let p: number = 10;
let q: number = 5;

p = q; // 赋值
console.log(p); // 输出: 5

p += q; // 加后赋值
console.log(p); // 输出: 10

p -= q; // 减后赋值
console.log(p); // 输出: 5

p *= q; // 乘后赋值
console.log(p); // 输出: 25

p /= q; // 除后赋值
console.log(p); // 输出: 5

三元运算符（？）

let r: boolean = true;
let s: string = r ? "Yes" : "No";
console.log(s); // 输出: Yes

类型运算符

typeof运算符

typeof 是一元运算符，返回操作数的数据类型

let t: number = 10;
let typeOfT: string = typeof t; // 获取变量的类型
console.log(typeOfT); // 输出: "number"

class MyClass {}
let myObj: MyClass = new MyClass();
let isInstanceOfMyClass: boolean = myObj instanceof MyClass; 
// 检查对象是否是某个构造函数的实例
console.log(isInstanceOfMyClass); // 输出: true

instanceof

其他运算符

负号运算符(-)

// 对正数应用负号运算符
let positiveNumber: number = 10;
let negativeNumber: number = -positiveNumber;
console.log(negativeNumber); // 输出: -10

// 对负数应用负号运算符（相当于取绝对值后再加上负号，但结果仍是正数，
//如果原数是负数的话其绝对值会变为其相反数再取负还是原数）
let anotherNegativeNumber: number = -5;
let result: number = -anotherNegativeNumber;
console.log(result); // 输出: 5

// 直接对字面量数值应用负号运算符
let literalNegativeNumber: number = -7;
console.log(literalNegativeNumber); // 输出: -7

// 在表达式中使用负号运算符
let x: number = 5;
let y: number = -3;
let sum: number = x + (-y); 
// 相当于 x + y，但这里显式地使用了负号运算符来取y的相反数
console.log(sum); // 输出: 8

// 注意：负号运算符不能用于非数值类型，否则会引发类型错误
// let stringValue: string = "10";
// let invalidOperation: number = -stringValue; 
// 这会编译错误，因为不能对字符串类型应用负号运算符

请注意，负号运算符只能用于数值类型。如果你尝试对非数值类型（如字符串或布尔值）应用负号运算符，TypeScript编译器会抛出一个类型错误。在上面的注释部分，我们提供了一个示例来说明这一点，但为了避免编译错误，我们实际上没有执行这个无效操作。

字符串运算符: 连接运算符 (+)

 +运算符可以拼接两个字符串

let t: number = 10;
let typeOfT: string = typeof t; // 获取变量的类型
console.log(typeOfT); // 输出: "number"

class MyClass {}
let myObj: MyClass = new MyClass();
let isInstanceOfMyClass: boolean = myObj instanceof MyClass; 
// 检查对象是否是某个构造函数的实例
console.log(isInstanceOfMyClass); // 输出: true

码字不易，各位大佬点点赞呗