在学习一个Omit.js的包源码的时候学习到了TypeScript的辅助类型Omit，从而真正掌握TS的Omit，如需查看Omit与Exclude的区别，请跳转Omit与Exclude的区别。
Ts中的Omit是什么
Omit是TS3.5新增的一个辅助类型，其作用是：以一个类型为基础支持剔除某些属性，然后返回一个新类型。
type Person = {
name: string;
age: string;
location: string;
};
type PersonWithoutLocation = Omit<Person,'location'>;
//PersonWithoutLocation is equal to QuntumPerson
type QuantumPerson = {
name: string;
age: string;
}
Omit的源码定义
/**\
* Construct a type with the properties of T except for those in type K.\
*/
type Omit<T, K entends keyof any> = Pick<T, Exclude<keyof T, K>>
具体来理解该段源码：
keyof
keyof诞生于TS2.1，其作用是获取某种类型的所有键，返回的是一个联合类型。即
function getProperty<T, K ectends keyof T>(obj: T, key: K){
return obj[K]
}
function setPeroperty<T, K extends keyof T>(obj: T, key: K,value: T[k]){
obj[k]= value
}
Exclude
- 用法：Exclude<Type, ExcludeUnion>.即Exclude就是数学集合中找出Type的“差集”，就是将类型A与B对比，返回A中独有的类型，示例如下：
type T0 = Exclude<'a'|'b'|'c', 'a'>;//T0:'b'|'c'
//其中Exclude的定义为：
type Exclude<T, U>= T extends U ? never: T;
Extends
T extends U ? never: T这里的extends可与class的extends不是一回事；
-
extends关键字在TS中的两种用法：接口继承和
条件判断。- 借口继承：extends用来做继承功能，类似于Es6的class语法用它来做类的继承。
interface T1 { name: string } interface T2 { sex: number } //多重继承，逗号隔开 interface T3 extends T1,T2 { age: number; } //合法 const t3: T3 = { name: 'xiaoming', sex: 1, age: 18 }示例中：T3继承了T1和T2两个接口；即同时拥有了来自T1和T2的属性。
-
条件判断
- 普通用法
interface Animal { eat(): void } interface Dog extends Animal { bite(): void } type A = Dog extends Animal ? string: number const a: A = 'this is string'extends用来条件判断的语法和JS的三元表达很相似，如果问好前面的判断为真，则将第一个类型string赋值给A， 否则将第二个类型number赋值给A； 那么接下来的问题是：extends判断条件真假的逻辑是什么？ 即：如果extends前面的类型能够赋值给extends后面的类型，那么表达式判断为真，都则为假；所以，上面的示例中，Dog是Animal的子类，父类比子类的限制更少，能满足子嘞，则一定满足父类，Dog类型的值可以肤质给Annimal类型的值，判断为真。
// 示例2 interface A1 { name: string } interface A2 { name: string age: number } // A的类型为string type A = A2 extends A1 ? string : number const a: A = 'this is string'- 泛型用法
- 分配条件类型
type A1 = 'x' extneds 'x' ? string: number; //string type A2 = 'x'|'y' extends 'x' ? string: number; //number type P<T> = T extends 'x' ? string :number; type A3 = P<'x'|'y'> //?A1和A2是extends的普通用法，和上面的判断方法一样。
P是带参数T泛型类型，其表达式和A1，A2的形式完全相同，A3是泛型类型P传入参数‘x’｜‘y’得到的类型，如果将‘x’｜‘y’带入泛型类表达式，可以看到A2类型的形式完全一样的，那是不是说明，A3和A2的类型完全一样呢？答案是否定的
type P<T> = T extends 'x' ? string : number; type A3 = P<'x' | 'y'> // A3的类型是 string | number答案是不是很反直觉，这个原因就是分配调价类型（Distributive Conditional Types）；这里可以这样解释：对于extends关键字的条件类型（即上面的三元表达式类型）。如果extends前面的参数是一个泛型类型，当传入该参数的是联合类型，则使用分配律计算最终的结果。分配率是指，将联合类型的联合项拆成单项，分别带入条件类型，然后将每个单项代入的呆的结果再联合起来，得到最终的判断结果。
type P<T> = T extends 'x' ? string : number; type A3 = P<'x' | 'y'> // A3的类型是 string | number P<'x' | 'y'> => P<'x'> | P<'y'> //'x'代入得到 `'x' extends 'x' ? string : number => string` //'y'代入得到 `'y' extends 'x' ? string : number => number`然后将每一项代入得到的结果联合起来，得到
string | number- 即满足两个要点即可适用分配律：1、参数是泛型类型；2、代入参数的是联合类型；但是有一个例外，即特殊的never
type A1 = never extends ‘x'? string:number; // string type P<T> = T extends 'x' ? string : number; type A2 = P<never> //nerver上面的示例中，A2和A1的结果竟然不一样，看起来never并不是一个联合类型，所以直接代入条件类型的定义即可，获取的结果应该和A1才对啊？ 实际上，这里还是条件分配类型在起作用。never被认为是空的联合类型，即没有联合项的联合类型，所以还是满足上面的分配律，然而因为没有联合项可以分配，所以P的表达式其实根本就没有执行，所以A2的定义也就类似于永远没有返回的函数一样的，是never类型的。
-
防止条件判断中的分配: 在条件判断类型的定义中，将泛型参数使用
[]括起来，即可阻断条件判断类型的分配，此时，传入参数T的类型将被当作一个整体，不再分配。type P<T> = [T] extends ['x'] ? string : number;
type A1 = P<'x'|'y'> // number
type A2 = P //string ```
Pick
Pick<Type ,Keys>:将Type的部分类型keys挑出来，返回这部分类型。
其背后的定义：
```js
type Pick<T, K extends keyof T> = {
[P in K]: T[P];
}
```
推导Omit
`type Omit <T , K extends keyof any> = Pick<T, Exclude<keyof T, K>>`
type Person = {
name: string;
age: string;
location: string;
}
type PersonWithoutLocaton = Omit<Person, 'location'>;
//推导
type PersonWithoutLocation = Pick<Person, Exclude<'name'|'age'|'location, 'location'>>
// 推导
type PersonWithoutLocation = Pick<Person,(('name' extends 'location' ? never : 'name') | ('age' extends 'location' ? never : 'age') | ('location' extends 'location' ? never : 'location'))>
// 推导 type PersonWithoutLocation = Pick<Person, ('name' | 'age' | never)>;
// 推导
type PersonWithoutLocation = Pick<Person, ('name' | 'age')>;
// 推导
type PersonWithoutLocation = {
[p in 'name' | 'age']: Person[p]
};
// 推导
type PersonWithoutLocation = {
name: string;
age: string;
}
Omit.js源码
function omit(obj, fields) {
// eslint-disable-next-line prefer-object-spread
const shallowCopy = Object.assign({}, obj);
for (let i = 0; i < fields.length; i += 1) {
const key = fields[i];
delete shallowCopy[key];
}
return shallowCopy;
}
export default omit;
//使用 const newObj = omit(targetObj,[keyName1,keyName2,..])
- 函数内部创建一个局部变量shallowCopy 通过Object.assign复制了obj创建一个新对象
- fields传入一个对象属性名数组，通过循环遍历将shallowCopy上对应数组的属性挨个删除
- 最后返回这个新对象
