# 内置类型
## 常见内置类型
 - Readonly 只读
 - Partial 可选
 - Requiled 必选
 - Pick 选择
 - Record 记录
 - Exclude 排除
 - Extract 取出
 - Omit 省略
 - NonNullable 非null和undefined
 - Parametes 参数
 - ConstructorParameters 构造函数参数
 - ReturnType 返回值
 - InstanceType 构造函数、实例的返回类型
 - Uppercase 大写
 - Lowercase 小写
 - Capitalize 首字母大写
 - Uncapitalize 首字母小写




# 映射类型

## 说明

只会作用于obj原本属性，不会引入新的属性

### 只读映射
通过`Readonly`关键字实现

```ts
interface Prople {
	name: string
	age: number
}

type myPeople = Readonly<Prople> 
/*
type myPeople = {
	readonly name: string;
	readonly age: number;
}
*/
```

### 可选映射
#### 说明
通过关键字`Partial`实现

```ts
interface Prople {
	name: string
	age: number
}

type myPartial = Partial<Prople>

/*
	type myPartial = {
		name?: string | undefined;
		age?: number | undefined;
	}
*/
```

#### 模拟原理示意

```ts
type Partial<T> = { 
	[P in keyof T]?: T[P];
};

/*
Partial<T>: T 表示泛型
keyof T: 索引类型的查询操作符，返回类型T的所有公共属性字面量构成的联合类型

in 操作符: 用于判断某个属性是否在指定对象或其原型链中，如果存在则in运算符返回true
*/


// EG： 
interface A {
    id:string,
    name:string
}

type D = Partial<A>

/*
type Partial<T> = { 
	[P in keyof T]?: T[P];
};
*/

/*
keyof T : 索引类型的查询操作符，表示类型A的所有公共属性的字面量构成的联合类型
*/

// keyof A : 'id' | 'string'
let B:keyof A = 'id'  // sure
B = 'name' // sure
// B = 'age' // Type '"age"' is not assignable to type 'keyof A'.

/*
in 操作符: 用于判断某个属性是否在指定对象或其原型链中，如果存在则in运算符返回true
*/

```


### 必选映射
#### 说明

和`Partial`相反，用于让可选属性变为必选属性, 通过`Required`实现

```ts
Required<T>
```

#### 模拟原理示意

```ts
type Required<T> = { 
    [P in keyof T]-?: T[P]; 
};
```



# 条件类型

## 说明

条件类型是一种由条件表达式决定的类型

## 用途

实现类型过滤

### 普通条件类型

#### 语法

若类型T可以被赋值给类型U，那么结果类型为X类型，否则为Y类型

```ts
T extends U ? X : Y
```

#### EG

```ts
type TypeName<T> =
	T extends string ? "string" :
	T extends number ? "number" :
	T extends boolean ? "boolean" :
	T extends undefined ? "undefined" :
	T extends Function ? "function" :
	"object";
type T1 = TypeName<string>//T1类型为字面量类型"string"  
```

### 分布式条件类型

#### 语法

若类型T可以被赋值给类型U，那么结果类型为X类型，否则为Y类型

```ts
(A | B) extends U ? X : Y
//相当于  
(A  extends U ? X : Y) | (B extends U ? X : Y)
```

#### Eg

```ts
type TypeName<T> =
	T extends string ? "string" :
	T extends number ? "number" :
	T extends boolean ? "boolean" :
	T extends undefined ? "undefined" :
	T extends Function ? "function" :
	"object";
	
type T3 = TypeName<string | string[]>//TS类型为字面量类型"string"和字面量类型"object"的联合类型
```


# Pick

## 说明

从`T`中选择部分类型组合成新类型

## 语法

```ts
Pick<T, K>
```

## 模拟原理示意

```ts
type Pick<T, K extends keyof T> = { 
    [P in K]: T[P]; 
};

/*
K extends keyof T： K继承于类型T的所有字面量类型构成的联合类型
*/
```

# Record

## 说明

构造一个对象类型，其属性`key`是`Keys`,属性`value`是`Type`，被用于映射一个类型的属性到另一个类型

第一个参数接受预定义的新的属性，第二个参数接受已知的类型

## 语法

```ts
interface Prople {
	name: string
	age: number
}

type myRecord = Record<"x"|"y",Prople>
/*
	type myRecord = {
		x: Prople;
		y: Prople;
	}
*/
```

## 模拟原理示意

```ts
type Record<K extends keyof any, T> = { 
  [P in K]: T; 
};
```


# Exclude
## 说明
从类型`T`中过滤掉可以赋值给类型`U`的类型

## 语法

```ts
Exclude<T,U>
```

## 模拟原理示意

```ts
type Diff<T, U> = T extends U ? never : T
/*
  // Diff被拆解为多个类型的联合类型  
  // Diff<"a", "a" | "e"> | Diff<"b", "a" | "e"> | Diff<"c", "a" | "e">
  // 字面量类型"a"可以被赋值给字面量联合类型"a" | "e"，所以返回never
  // 字面量类型"b"无法被赋值给字面量联合类型"a" | "e"，所以返回字面量类型"b"
  // 字面量类型"c"无法被赋值给字面量联合类型"a" | "e"，所以返回字面类类型"c"
  // never | "b" | "c"
  //最后类型为 "b" | "c"
*/
```

## EG

```ts
type A = 'id' | 'name'

type B = 'id' | 'name' | 'age'

const D:Exclude<B,A> // 类型为'age'
```

# Extract
## 说明
与`Exclude`相反,从类型`T`中抽取出可以赋值给类型`U`的类型

## 语法

```ts
Extract<T,U>
```

## 模拟原理示意

```ts
type Extract<T, U> = T extends U ? T : never;
```

## EG

```ts
type A = 'id' | 'name'

type B = 'id' | 'name' | 'age'

const D:Extract<B,A> // 类型为"id" | "name"
```

# Omit
## 说明
省略，传入一个类型，和此类型的几个属性，把传入的属性省略掉，剩余的类型组合为一个新类型

## 语法

```ts
Omit<T,U>
```

## 模拟原理示意

```ts
type Omit<T, K extends keyof any> = Pick<T, Exclude<keyof T, K>>;
```

## EG

```ts
// type A = keyof any //类型为:  string | number | symbol

// type B = never | null
// type C = B extends A ? 'yes' : 'no'; // 'yes'


interface  A {
  name: string;
  age: number;
  id: number;
}

type B = 'name' | 'age'

const C: Omit<A, B> = { 'id':2233 }

/*
type Omit<T, K extends keyof any> = Pick<T, Exclude<keyof T, K>>;
*/

// keyof any： string | number | symbol
// K extends keyof any:  泛型k必须可以赋值给`string | number | symbol`构成的联合类型

/*
Pick<T, Exclude<keyof T, K>>;
*/

/* 
Exclude<keyof T, K>

keyof T: 'name' | 'age' | 'id'

故而：
Exclude<keyof T, K>: 'id'
*/

/*
Pick<T, Exclude<keyof T, K>>变成了： Pick<T,'id'>

即根据Pick的定义，会从此处例子中的类型A中抽取属性'id'组成新的类型
*/
```


# NonNullable

## 说明

过滤掉`null`类型和`undefined`类型

### 语法

```ts
NonNullable<T>
```

### 模拟原理示意

```ts
// 方法一
type NonNullable<T> = T & {}
/*
{}：排除了null和undefined以外的任何类型

T & {}: 返回的是类型T与{}的交叉类型
*/

// 方法二
type NonNullable<T> = T extends null | undefined ? never : T;
```


# Parameters

## 说明
获取传入函数的参数组成的类型

## 语法

```ts
Parameters<T>
```

## 模拟原理示意
```ts
type Parameters<T extends (...args: any) => any> = T extends (...args: infer P) => any ? P : never
```

## EG

```ts
// 通过接口约束函数
interface myTtest {
    (x:number,y:number):number
}

let myFunction:myTtest= function(x,y){return x+y}

console.log(myFunction(1,2))

const user: Parameters<myTtest> = [1,2]// [x: number, y: number]
```

# ConstructorParameters

## 说明
获取传入的构造函数的参数组成的类型

## 语法

```ts
ConstructorParameters<T>
```

## 模拟原理示意

```ts
type ConstructorParameters<T extends abstract new (...args: any) => any> = T extends abstract new (...args: infer P) => any ? P : never
```

## EG
```ts
interface A {
  name: string;
  age: number;
}

interface B {
  new (name: string, age: number): A
}

const C: ConstructorParameters<B> = ['1',2]// [name: string, age: number]


```

# ReturnType

## 说明

可以获取函数返回值类型，接受一个函数作为参数

## 语法

```ts
ReturnType<Fnction>
```

## 模拟原理示意

```ts
type ReturnType<T extends (...args: any) => any> = T extends (...args: any) => infer R ? R : any;
```

## EG

```ts
type TB = ReturnType<() => string> 
//TB类型为string类型
```


# InstanceType

## 说明
获取构造函数、实例的返回类型

## 语法

```ts
InstanceType<T>
```

## 模拟原理示意

```ts
type InstanceType<T extends abstract new (...args: any) => any> = T extends abstract new (...args: any) => infer R ? R : any;
```

## EG

```ts
const user = class {
  name: string;
  age: number;
  constructor (name: string, age: number) {
    this.name = name
    this.age = age
  }
  showInfo () {
    console.log('name: ', this.name, 'age: ', this.age);
  }
}

const user1: InstanceType<typeof user> = new user('张三', 20)
// const user2: user = new user('张三', 20) // Error: user作为值，此处却用为类型
```

# Uppercase

## 说明

转大写

## 语法

```ts
Uppercase<T>
```

## 模拟原理示意
```ts
type Uppercase<S extends string> = intrinsic;
```

## EG
```ts
type userinfo = 'name' | 'age' | 'id'

let userID: Uppercase<userinfo> = 'ID'  // "NAME" | "AGE" | "ID"
```


# Lowercase

## 说明
转小写

## 语法

```ts
Lowercase<T>
```

## 模拟原理示意
```ts
type Lowercase<S extends string> = intrinsic
```

## EG
```ts
type userinfo = "NAME" | "AGE" | "ID"

let userID: Lowercase<userinfo> = 'id'  // "name" | "age" | "id"
```

# Capitalize
## 说明
首字母大写

## 语法

```ts
Capitalize<T>
```

## 模拟原理示意
```ts
type Capitalize<S extends string> = intrinsic
```

## EG
```ts
type userinfo = "name" | "age" | "id"

let userID: Capitalize<userinfo> = 'Id'  // "Name" | "Age" | "Id"
```



# Uncapitalize
## 说明
首字母小写

## 语法

```ts
Uncapitalize<T>
```

## 模拟原理示意
```ts
type Uncapitalize<S extends string> = intrinsic
```

## EG
```ts
type userinfo = "Name" | "Age" | "Id"

let userID: Uncapitalize<userinfo> = 'id'  // "name" | "age" | "id"
```

TS-高级类型_映射类型与条件类型

# 字面量类型  
## 说明  
在TS中字面量不仅可以表示值，还可表示类型  

TS支持3种字面量类型：字符串字面量类型、数字字面量类型、布尔字面量类型  



## 分类   
#### 字符串字面量类型  
可以使用一个字符串字面量作为变量的类型  
应用场景： 将多个字面量类型组合成一个联合类型  

相当于string类型的子集    

![字符串字面量类型](https://dev.dwxzbz.com/blogphoto/TypeScriptLearn/TypeInferenceAndTypeAssertion/%E5%AD%97%E7%AC%A6%E4%B8%B2%E5%AD%97%E9%9D%A2%E9%87%8F%E7%B1%BB%E5%9E%8B.jpg)  

#### 数字字面量类型  
和字符串字面量类型一样  

![数字字面量类型](https://dev.dwxzbz.com/blogphoto/TypeScriptLearn/TypeInferenceAndTypeAssertion/%E6%95%B0%E5%AD%97%E5%AD%97%E9%9D%A2%E9%87%8F%E7%B1%BB%E5%9E%8B.jpg)  

##### 布尔值字面量  
布尔字面量只包含true和false，true | false 的组合类型跟直接使用boolean没有区别  

![布尔值字面量类型](https://dev.dwxzbz.com/blogphoto/TypeScriptLearn/TypeInferenceAndTypeAssertion/%E5%B8%83%E5%B0%94%E5%80%BC%E5%AD%97%E9%9D%A2%E9%87%8F%E7%B1%BB%E5%9E%8B.jpg)   


## 索引类型  
### 用途 
获取对象的值建立一个集合  

### 索引类型的操作符

#### 查询操作符

##### 语法
```ts
keyof T
```

##### 说明  
表示类型为类型T的所有公共属性的字面量构成的联合类型  
```
interface Prople {
    name: string
    age: number
}

let a:keyof Prople  //此时a的类型为类型Prople的所有公共属性的字面量(name,string)构成的联合类型  "name" | "age"
```

#### 索引访问操作符 

##### 语法
```ts
T[K] 
```

##### 说明  
表示对象T的属性K所代表的类型  
```
interface Prople {
    name: string
    age: number
}

let b:Prople["age"] //此时b的类型为Prople的属性K所代表的的属性  number
```

### 索引类型EG

```ts
let obj = {
    a: 1,
    b: 2,
    c: 3
}

function getValues<T,K extends keyof T>(obj: T, keys: K[]): T[K][] {
    return keys.map(key => obj[key])
}

console.log(getValues(obj,["a","b","c"]))
console.log(getValues(obj,["a","b","d"]))//error 不能将类型“"d"”分配给类型“"a" | "b" | "c"”
```

TS-高级类型_字面量类型与索引类型

## 说明
用于将多个类型合并为一个类型，它包含了所需的所有类型的特性，使用`&`定义交叉类型



## 常见使用场景
常用于将多个接口类型合并成一个类型，从而实现等同接口继承的效果，即合并接口类型

## Eg
```ts
// 交叉类型
interface A { a: number };
interface B { b: string };

type C = A & B 
	
let a:C = {
	a:110,
	b:"w"
}
console.log(a)
```

## 注意点

### 两个接口中同一个属性有多个类型，冲突

当两个接口中同一个属性有多个类型，如一个接口中name是number，另一个接口中name是string，使用交叉类型后，name就变为number和string两个原子类型的交叉类型，即never

![交叉类型同属不同类冲突1](https://dev.dwxzbz.com/blogphoto/TypeScriptLearn/typeInference/%E4%BA%A4%E5%8F%89%E7%B1%BB%E5%9E%8B-error1.jpg)

### 同名属性的类型兼容

当一个接口中name是string(number),另一个接口中name是字符串字面量类型(数字字面量类型)，使用交叉类型后,name就是两者之中的子类型即字符串字面量类型(数字字面量类型)

![交叉类型同属不同类冲突2](https://dev.dwxzbz.com/blogphoto/TypeScriptLearn/typeInference/%E4%BA%A4%E5%8F%89%E7%B1%BB%E5%9E%8B-error2.jpg)

### 同名属性是非基本数据类型

```ts
interface Admin {
	name: { usersName: string };
}
//Employee接口
interface Employee {
	name: { id: number };
}
//类型别名 交叉类型
type UnknownEmployee = Employee & Admin;

let test: UnknownEmployee = { name: { id: 1, usersName: "咩啊" } } //正常，不报错
```

混入多个类型时，若存在相同的属性，且属性类型为非基本数据类型，则是可以成功合并

TS-高级类型_交叉类型

## 联合类型
### 说明
联合类型表示取值可以为多种类型中的一种，使用(竖直分隔符) `|`分隔每个类型
取交集



### 特点
联合类型通常与null和udefined一起使用

### 其它用法
```ts
let num: 1 | 2 = 1;
let EventNames = 'click' | 'scroll' | 'mousemove';
```

用来约束取值只能为这几个中的一个

### Eg

```ts
let text1: number | string;
text1 = 10
text1 = "abc"
```

## 类型别名
### 说明
用于给一个类型创建一个新名字(只是别名，并不是创建一个新的类名)，常用于联合类型

### Eg

```ts
type textClass="act" | "string" | "normalClass"
```

TS-高级类型_联合类型

## 说明  
类型保护是可执行运行时检查的一种表达式，用于在特定的区块中保证变量属于某种确定的类型，可以在此区块中放心的引用此类型的属性，或者调用此类型的方法    

TS在遇到以下这些条件语句时，会在语句的块级作用域内「收紧」变量的类型，这种类型推断的行为称作类型守卫(Type Guard)  



## 分类  
- in 属性判断 
- typeof  类型判断
- instanceof关键字
- 字面量类型保护

## in 属性判断
### in操作符概念
#### 说明  
in操作符用来判断某个属性是否在指定的对象或其原型链中，若存在则in运算符返回true  

#### 语法
```
prop in object
```
prop: 一个字符串类型或者 symbol 类型的属性名或者数组索引（非symbol类型将会强制转为字符串）
object：需要检查的对象(或其原型链)

#### EG
```ts
interface Foo {
    foo: string;
}

interface Bar {
    bar: number;
}

type myClass = Foo | Bar

function test(input: myClass) {
    if ('foo' in input) {
        // 这里 input 的类型「收紧」为 Foo
        console.log(1)
    } else {
        // 这里 input 的类型「收紧」为 Bar
        console.log(2)
    }
}

test({bar:1})
```


## typeof  类型判断  
### typeof 操作符概念  
用于检测变量数据类型  
typeof操作符返回一个字符串

#### 常见返回结果
可能有如下这几种情况："number"、"string"、"boolean"、"object"、"function" 和 "undefined"  
#### **注意**
Array,Null等特殊对象使用typeof一律返回object  

### EG
```ts
function test(text: string | number) {
    if (typeof text == "string") {
        // 这里 text 的类型「收紧」为 string
        console.log(1)
    } else {
        // 这里 text 的类型「收紧」为 number
        console.log(2)
    }
}

test(15)
```

### 特殊点  
typeof类型保护只支持两种形式：`typeof v === "typename"` 和 `typeof v !== typename` 
"typename" 必须是 "number"， "string"， "boolean" 或 "symbol"  
但是TS并不会阻止你与其它字符串比较，语言不会把那些表达式识别为类型保护  


## instanceof  实例判断  
### instanceof概念  
#### 说明  
用于判断一个变量是否属于某个对象的实例  

### EG 
```ts
//实例判断  
class Foo {
    foo="abc"
}

class Bar {
    bar=123
}


function test(input: Foo | Bar) {
    if(input instanceof Foo){
        //这里input的类型「收紧」为 Foo
        console.log(input,typeof input)
    }else{
         //这里input的类型「收紧」为 bar
         console.log(input,typeof input)
    }
}

test({bar:123})
```



## 字面量类型保护  
### EG
```ts
type myRules1 = {
    id: number,
    name: string,
    success: 1
}

type myRules2 = {
    id: number,
    name: string,
    success: 0
}

function test(input: myRules1 | myRules2) {
    if (input.success === 1) {
        console.log("login success")
    } else {
        console.log("login falied")
    }
}

test({id:1,name:"mi",success:0})
```



## 自定义类型保护(也称为类型保护函数)  
### is 类型谓词  
#### 说明  
TS中is关键字也被称为类型谓词，用于判断一个变量属于某个接口或类型  

#### 语法  
```ts
prop is object
```

#### 常用场景  
is关键字一般用于函数返回值类型中，判断参数是否属于某一类型，并根据结果返回对应的布尔类型  

### EG 
```ts
//自定义类型保护  
function test(input:number): input is number  {
    let result = typeof input === "number"
    console.log(result,typeof result)
    return result
}

test(100)
```


### 扩展函数
自定义类型保护扩展    
```ts
const isNumber = (val: unknown): val is number => typeof val === 'number'
const isString = (val: unknown): val is string => typeof val === 'string'
const isSymbol = (val: unknown): val is symbol => typeof val === 'symbol'
const isFunction = (val: unknown): val is Function => typeof val === 'function'
const isObject = (val: unknown): val is Record<any, any> => val !== null && typeof val === 'object'

function isPromise<T = any>(val: unknown): val is Promise<T> {
  return isObject(val) && isFunction(val.then) && isFunction(val.catch)
}

const objectToString = Object.prototype.toString
const toTypeString = (value: unknown): string => objectToString.call(value)
const isPlainObject = (val: unknown): val is object => toTypeString(val) === '[object Object]'
```