TypeScript 学习笔记 之 高级类型

Intersection Types 组合类型

比如 Serializable 和 Deserializable 可以通过 & 组合出一样新的类型：Serializable & Deserializable ，也可以看作是一个匿名的扩展类型。
因为如果上面两个类型是接口类型的话，我们可以这样声明一个具名的新类型：
interface Json extends Serializable,Deserializable {}
使用实例：

function extend<T,U>(first:T,second:U): T&U{
  let result = <T&U>{};
  for(let id in first){
    (<any>result)[id] = (<any>first)[id];
  }
  for(let id in second){
      if(!result.hasOwnProperty(id)){
            (<any>result)[id] = (<any>second)[id];
      }
   }
  return result;
}

Union Types 联合类型

可以通过 | 联合多个类型，创建出联合类型，例如： number|string
使用示例：

/**
 * Takes a string and adds "padding" to the left.
 * If 'padding' is a string, then 'padding' is appended to the left side.
 * If 'padding' is a number, then that number of spaces is added to the left side.
 */
function padLeft(value: string, padding: string | number) {
    // ...
}

注意： 对于联合类型的对象，我们只可以访问联合类型中各个类型存在交集的方法。要访问某一子类型的方法，需要先通过类型转换。

类型防御

1. 用户自定义的类型防御

TS 提供了类型 kotlin 中经过检查的smartcast 的功能。
只要在类型判断函数中返回 parameterName is Type 这样的断言。即可

function isFish(pet: Fish|Bird): pet is Fish{
  return (<Fish>pet).swim !== undefined;
}
// 经过类型判断之后，pet 可以直接当某一联合类型的字类型对象使用。
if(isFish(pet)){
  pet.swim()
}else{
  pet.fly();
}

2. 使用 typeof 的类型防御
   支持两种写法：typeof v === "typename" 和 typeof v!== "typename"。
   typename 只能是 "number","string","boolean","symbol"。如果是其他的话，TS 不会将其当作是类型防御断言。

使用 typeof 类型防御改写 padLeft

function isNumber(x:any): x is number{
  return typeof x === "number";
}

function isString(x:any): x is string{
  return typeof x === "string";
}

function padLeft(value: string, padding: string | number) {
    if (isNumber(padding)) {
        return Array(padding + 1).join(" ") + value;
    }
    if (isString(padding)) {
        return padding + value;
    }
    throw new Error(`Expected string or number, got '${padding}'.`);
}

3. 使用 instanceof 的类型防御
   使用 instanceof 也会有智能转换的效果，instanceof 右边只能是构造函数。

类型别名

可以使用 type 创建新的类型或类型别名.

type Name = string;
type NameResolver = () => string;
type NameOrResolver = Name | NameResolver;
function getName(n:NameOrResolver):Name{
   if(typeof n == "string"){
    return n;   
  }else{
    return n(); 
  }
}

别名声明也可以使用泛型和组合类型及联合类型。

type Container<T> = { value:T};
type Tree<T> = {
  value: T;
  left : Tree<T>;
  right: Tree<T>;
}

type LinkedList<T> = T & { next: LinkedList<T> };

一些特殊用法示例：

1. 字符串联合
   type Easing = "ease-in" | "ease-out" | "ease-in-out";
   这将限制 Easing 类型只能取上面的三个值。有点类似枚举的意思。

2. 数值联合,类型字符串联合 。
   type DieCode = 1|2|3|4|5|6;

3. 其他类型联合。
   type Shape = Square | Rectangle | Circle;
   现在 Shape 类型将可以使用上面联合类型的属性的交集。

Index types 索引类型

keyof T
例如：

interface Person{
  name:string,
  age:number
}

let personProps: keyof Person; // 相当于 'name' | 'age'

看一下下面的使用示例：

function getProperty<T, K extends keyof T>(o: T, name: K): T[K] {
    return o[name]; // o[name] is of type T[K]
}

T[K] 是一个动态类型。表示 T 类开中 名为 K 的属性的类型。

Mapped types 映射类型

type Keys = 'options1' | 'option2';
type Flags = { [K in Keys] : boolean };
 // 相当于 

type Flags = {
  option1: boolean;
  option2: boolean;
}

只读代理包装:

type Readonly<T> = {
   readonly [P in keyof T]: T[P];
}
type ReadonlyPerson = Readonly<Person>;

参考 ：Advanced types