namespace a {
  interface Bird {
    name: string;
    fly(): void;
  }
  interface Person {
    name: string;
    eat(): void;
  }
  //交叉类型其实就是两个接口类型属性的并集
  // | 或  & 且
  // & 表示两个类的属性都需要要
  type BirdMan = Bird & Person;
  let p: BirdMan = {
    name: "1",
    fly() { },
    eat() { }
  }
}
namespace b {
  //typeof 可以获取一个变量的类型
  // type Person = {
  //   name: string,
  //   age: number
  // }
  let p = {
    name: "aaa",
    age: 10
  }
  //使用type 定义类型 let 只能定义值
  type Person = typeof p;
  let p2: Person = {
    name: '',
    age: 1,
  }
  //我们可以通过[]来获取一个类型的子类型
  interface Person2 {
    name: string;
    age: number;
    job: {
      name: string
    }
    interests: { name: string; level: number }[]
  }
  let myName: Person2['job'] = {
    name: "ff"
  }
  let myName2: Person2['job']['name'] = 'f2'
  let mylevel: Person2['interests'][0]['level'] = 0;
  //keyof 索引类型查询操作符
  interface Person3 {
    name: string;
    age: number;
    gender: 'male' | 'female'
  }
  // type Person3Keys = 'name' | 'age' | 'gender';
  type Person3Keys = keyof Person3;//返回一个接口，它的key的一个集合
  function getValueByKey(val: Person3, key: Person3Keys): any {
    return val[key];
  }
  //映射类型： 在定义的时候用in操作符去批量定义
  interface Person4 {
    name: string;
    age: number;
    gender: 'male' | 'female'
  }
  //会把原来接口里的所有类型，映射出一个新的全部可选的类型
  type partialPerson = {
    [key in keyof Person4]?: Person4[key]
    //name?:string
  }
  //更简单的写法
  // type Partial<T> = {
  //   [key in keyof T]?: T[key]
  // }
  //Partial这里是ts 内置的就想上面写的一个type
  type partialPerson3 = Partial<Person4>;
  let p4: partialPerson3 = {
    name: '123'
  }
  //Partial的是必填选项， 
  //Required 表示映射的都是必填项
  //模拟Required ?表示可选，但是前面加一个-就表示必填
  //  type Required<T> = {
  //   [key in keyof T]-?: T[key]
  // }
  type partialPerson5 = Required<Person4>;
  let p5: partialPerson5 = {
    name: '123',
    age: 123,
    gender: 'female'
  }
  //只读 Readonly ,就不可以修改了
  //模拟readeronly 
  // type Readonly<T> = {
  //   readonly [key in keyof T]: T[key]
  // }
  type partialPerson6 = Readonly<Person4>;
  let p6: partialPerson6 = {
    name: '123',
    age: 123,
    gender: 'female'
  }
  //pick 过滤提取一个参数  
  //模拟实现Pick 
  // type Pick<T, K extends keyof T> = {
  //   [key in K]: T[key]
  // }
  type PickPerson = Pick<Person4, 'name'>;
  let x: PickPerson = { name: "142" }
}

ts 要区分 类型和值

类型 interface class enum
值 let var function
class enum 既可以作为类型又可以作为值

interface可以赋值么

instanceof 接口 = 接口么 ？不可以
因为是类型不能进行赋值操作 ，也不可以当成值来用

type 可以赋值么

type 类型 = 类型 是可以的
let a1 = typeof x; //一个返回数据类型，赋值给a
type a2 = typeof x; //一个是取出x原有的类型

什么时候用interface , 什么时候用type，还有class ，三者一般在什么时候使用

//interface 是定义接口类型，它是一个真实的类型，也可能会被导出和导入
//type只是临时用的别名，并不会产出一个真正的类型
//class就是定义类的 ，可以来new

条件类型

  //条件类型
  interface Fish {
    name1: string
  }
  interface Fish2 {
    name1: string
    age: number
  }
  interface Water {
    name2: string
  }
  interface Bird {
    name3: string
  }
  interface Sky {
    name4: string
  }
  //判断传入的泛型T 是不是继承与接口
  //但是这里实际比较的不是 名称或者是不是完全一致，而是之前说的比较类型
  //看传入的类型 是不是完全满足 了原来的类型
  type Condition<T> = T extends Fish ? Water : Sky;
  let condition: Condition<Fish2> = {
    name2: 's',
  }
  //条件类型的分发
  type Condition2<T> = T extends Fish ? Water : Sky;
  let condition1: Condition<Fish | Bird> = {
    name2: "22"
  }
  let condition2: Condition<Fish | Bird> = {
    name4: "3"
  }