TS中的一些关键字

1. extends:

• 含义: 用于类继承、类型继承或泛型约束。
• 示例:

  // 类继承
  class Animal {
      name: string;
      constructor(name: string) {
          this.name = name;
      }
  }
  class Dog extends Animal {
      bark() {
          console.log('Woof! Woof!');
      }
  }
  const myDog = new Dog('Buddy');
  myDog.bark();  // 输出: Woof! Woof!
  // 泛型约束
  function logLength<T extends { length: number }>(arg: T): void {
      console.log(arg.length);
  }
  logLength('hello');  // 输出: 5
  

2. keyof:

• 含义: 用于提取对象类型的键的联合类型。
• 示例:

  interface Person {
      name: string;
      age: number;
  }
  type PersonKeys = keyof Person;  // 'name' | 'age'
  function getProperty<T, K extends keyof T>(obj: T, key: K): T[K] {
      return obj[key];
  }
  const person: Person = { name: 'Alice', age: 25 };
  const age = getProperty(person, 'age');  // age 的类型为 number
  

3. typeof:

• 含义: 用于获取变量或表达式的类型。
• 示例:

  let s = 'hello';
  let strType: typeof s;  // strType 的类型为 string
  const person = {
      name: 'Alice',
      age: 25
  };
  
  type PersonType = typeof person;  // PersonType 的类型为 { name: string; age: number; }
  

4. in:

• 含义: 用于遍历枚举类型，通常与映射类型一起使用。
• 示例:

  type Keys = 'a' | 'b' | 'c';
  type Obj = {
      [K in Keys]: number;
  };
  const obj: Obj = {
      a: 1,
      b: 2,
      c: 3
  };
  

5. as:

• 含义: 用于类型断言，将一种类型断言为另一种类型。
• 示例:

  let someValue: any = 'this is a string';
  let strLength: number = (someValue as string).length;
  // 也可以这样：
  let strLength2: number = (<string>someValue).length;
  

6. infer:

• 含义: 用于条件类型中推断类型变量。
• 示例:

  type GetReturnType<T> = T extends (...args: any[]) => infer R ? R : never;
  function example(): string {
      return 'hello';
  }
  type ReturnTypeOfExample = GetReturnType<typeof example>;  // ReturnTypeOfExample 的类型为 string
  

7. readonly:

• 含义: 用于使属性只读。
• 示例:

  interface Point {
      readonly x: number;
      readonly y: number;
  }
  let p1: Point = { x: 10, y: 20 };
  // p1.x = 5;  // Error: Cannot assign to 'x' because it is a read-only property.
  

8. never:

• 含义: 表示从不会发生的类型。
• 示例:

  function error(message: string): never {
      throw new Error(message);
  }
  function fail() {
      return error('Something failed');
  }
  

9. unknown:

• 含义: 表示未知类型，类似于 any，但更安全。
• 示例:

  let notSure: unknown = 4;
  if (typeof notSure === 'number') {
      let num: number = notSure;  // 可以赋值，因为我们进行了类型保护
  }
  

10. this:

• 含义: 引用当前对象，通常用于类方法或对象方法。
• 示例:

  class Counter {
      current: number = 0;
      
      increment() {
          this.current++;
      }
  }
  let counter = new Counter();
  counter.increment();
  console.log(counter.current);  // 输出: 1
  

---

一些严格来说不算关键字

11. ?(可选属性):

• 含义: ?修饰符用于表示对象中的某个属性是可选的。
• 示例:

  type Person = {
      name: string;
      age?: number; // 可选属性
    };
    const john: Person = { name: "John" }; // 不报错
    const alice: Person = { name: "Alice", age: 25 };
  

12. !(非空断言运算符):

• 含义: 当在变量或表达式后面使用 ! 时，它表示告诉编译器这个表达式不会是 null 或 undefined。
• 示例:

  let someValue: string | undefined;
   // 编译器会提示 someValue 可能为 undefined
   // console.log(someValue.length);
   // 使用非空断言运算符，告诉编译器 someValue 一定不是 undefined
   console.log(someValue!.length);
  

13.is:

• 含义: 用于定义类型守卫函数，判断特定类型。

• 示例:

    function isString(value: unknown): value is string {
      return typeof value === "string";
    }
    
    const value: unknown = "Hello";
    
    if (isString(value)) {
      console.log(value.toUpperCase()); // 类型安全的调用
    }