TypeScript特有运算符和操作符

TypeScript 特有运算符

1. keyof

• 作用：用于获取对象类型的所有键（属性名）组成的联合类型。
• 语法：keyof Type

interface Person {name: string;age: number;
}type PersonKeys = keyof Person; // "name" | "age"

2. typeof

• 作用：用于获取变量或值的类型。
• 语法：typeof variable

let j: string = "hello";
type JType = typeof j; // string

3. in

• 作用：用于检查对象是否包含某个属性。
• 语法：key in object

interface User {name: string;age: number;
}let m: keyof User = "name";
let n: User = { name: "风茫", age: 18 };
console.log(m in n); // true

4. extends

• 作用：用于泛型约束，表示一个类型是否是另一个类型的子类型。
• 语法：T extends U

function add<T extends number>(a: T, b: T): T {return a + b;
}add(1, 2); // 合法
// add("1", "2"); // 报错

5. is

• 作用：用于类型保护，定义一个返回布尔值的函数，用于类型判断。
• 语法：parameter is Type

function isString(value: any): value is string {return typeof value === "string";
}let o: any = "hello";
if (isString(o)) {console.log(o.toUpperCase()); // 合法
}

6. as 和 <Type>

• 作用：用于类型断言，告诉编译器某个值的具体类型。
• 语法：value as Type 或 <Type>value

let p: any = "123";
let q = p as number; // 类型断言
// 或者
let r = <number>p; // 类型断言

7. never

• 作用：表示永远不会发生的值的类型，通常用于函数的返回类型。
• 语法：never

function error(message: string): never {throw new Error(message);
}

8. readonly

• 作用：用于定义只读属性。
• 语法：readonly property: Type

interface Person {readonly id: number;name: string;
}const person: Person = {id: 1,name: "风茫"
};// person.id = 2; // 报错

9. ?

• 作用：用于定义可选属性。
• 语法：property?: Type

interface SquareConfig {color?: string;width?: number;
}

10. []

• 作用：用于定义数组类型。
• 语法：Type[] 或 Array<Type>

let s: number[] = [1, 2, 3];
let t: Array<number> = [1, 2, 3];

11. | 和 &

• 联合类型 (|)：表示一个值可以是多种类型之一。
• 交叉类型 (&)：表示一个值必须同时满足多种类型。

let u: string | number = "hello";
u = 123;interface A {a: string;
}interface B {b: number;
}let v: A & B = {a: "hello",b: 123
};

12. !

• 非空断言操作符：告诉编译器某个值不会是 null 或 undefined。
• 语法：value!

function printLength(str: string | null) {console.log(str!.length); // 非空断言
}

13. ?? 和 ?.

• 空值合并操作符 (??)：如果左侧操作数为 null 或 undefined，则返回右侧操作数。
• 可选链操作符 (?.)：如果对象属性存在，则返回该属性值，否则返回 undefined。

let w: string | null = null;
let x = w ?? "default"; // "default"interface User {name?: string;
}let y: User = {};
console.log(y?.name); // undefined

总结

TypeScript 中的这些特有运算符主要用于类型定义和类型检查，帮助开发者编写更安全、更可靠的代码。通过合理使用这些运算符，可以提高代码的可读性和可维护性。

• keyof：获取对象的所有键。
• typeof：获取变量的类型。
• in：检查对象是否包含某个属性。
• extends：泛型约束。
• is：类型保护。
• as 和 <Type>：类型断言。
• never：表示永远不会发生的值。
• readonly：定义只读属性。
• ?：定义可选属性。
• [] 和 Array<Type>**：定义数组类型。
• | 和 &：联合类型和交叉类型。
• !：非空断言。
• ?? 和 ?.：空值合并和可选链操作符。

这些运算符使得 TypeScript 成为一种强大的静态类型语言，能够更好地帮助开发者进行类型安全的编程。