目录
上文中介绍了 对象操作的内置类型的使用，本文介绍几个基于内置类型，扩展的自定义类型，(类型名称自定义的)
将部分属性变为可选属性
实现思路：先将 name 属性挑出来变为可选的 & 除了 name 属性的
// 有时处理类型之后，对象类型结构不明显。只是简单做一个映射，并未其他意义。
type Compute<T extends object> = {
[K in keyof T]: T[K]; // 映射
};
interface Person {
name: string;
age: number;
address: string;
}
// 先将name属性挑出来变为可选的 & 除了name属性的
// Partial<Pick<T, K>> & & Omit<T, K>
type PartialPropsOption<T, K extends keyof T> = Partial<Pick<T, K>> & Omit<T, K>;
type x1 = PartialPropsOption<Person, "name">;
type x2 = Compute<PartialPropsOption<Person, "name">>; // 使用Compute包一层可以看清楚结构，不包也可以
根据值的类型 反选 key
之前的常见做法都是用过 key 值来获取属性，反之，如果根据值的类型 反选 key？
写法一：基础原理写法，使用不同的内置类型，Pick 和 Omit
定义一个接口 Person。通过不同的内置类型，实现挑选 值类型为string的keys和过滤 值类型为string的keys
interface Person {
name: string;
age: number;
address: string;
}
// 判断两个类型是否相等
type isEqual<T, U, Success, Fail> = [T] extends [U] ? ([U] extends [T] ? Success : Fail) : Fail;
type ExtractKeysByValueType<T, U> = {
[K in keyof T]: isEqual<T[K], U, K, never>;
}[keyof T]; // 找到需要的属性 name | address **注：联合类型中没有never
type PickKeysByValue<T, U> = Pick<T, ExtractKeysByValueType<T, U>>;
type PickedKeys = PickKeysByValue<Person, string>; // 挑选 值类型为string的keys 返回 name address
type OmitKeysByValue<T, U> = Omit<T, ExtractKeysByValueType<T, U>>;
type OmitedKeys = OmitKeysByValue<Person, string>; // 过滤 值类型为string的keys 返回 age
写法二：基础原理写法，使用 Pick 内置类型 + 传参的方式
interface Person {
name: string;
age: number;
address: string;
}
// 判断两个类型是否相等
type isEqual<T, U, Success, Fail> = [T] extends [U] ? ([U] extends [T] ? Success : Fail) : Fail;
type ExtractKeysByValueType<T, U, O = false> = {
[K in keyof T]: isEqual<T[K], U, isEqual<O, true, never, K>, isEqual<O, true, K, never>>;
}[keyof T]; // 找到需要的属性 name | address **注：联合类型中没有never
type PickKeysByValue<T, U> = Pick<T, ExtractKeysByValueType<T, U>>;
type PickedKeys = PickKeysByValue<Person, string>; // 挑选 值类型为string的keys 返回 name address
type OmitKeysByValue<T, U> = Pick<T, ExtractKeysByValueType<T, U, true>>;
type OmitedKeys = OmitKeysByValue<Person, string>; // 过滤 值类型为string的keys 返回 age
写法三：使用映射条件做双重映射
interface Person {
name: string;
age: number;
address: string;
}
type PickKeysByValue<T extends object, U> = {
// [K in keyof T as `a_${K & string}`]: T[K]; // 使用模板字符串 重命名
// as 语法 映射成一个新的变量
[K in keyof T as T[K] extends U ? K : never]: T[K];
};
type PickKeysByAs = PickKeysByValue<Person, string>; // 挑选 值类型为string的keys 返回 name address
求对象的交集 ObjectInter
交集：指的是类型中的属性，属性，属性，即存在于 A 中，又存在于 B 中，属性的类型可以不同，取交集后者类型,
type A = {
name: string;
age: number;
address: string;
};
type B = {
name: string;
male: boolean;
address: number;
};
// 返回的是联合类型 name | address
type ObjectInter<T extends object, U extends object> = Pick<U, Extract<keyof T, keyof U>>;
type X1 = ObjectInter<A, B>; // 从B中取A，address类型取B中的类型 number
求对象的差集 ObjectDiff
算一下 B - A，使用内置类型组合：Omit + Extract == Pick + Exclude
组合的写法比较多种，只要可以实现就可以，需要注意的是 谁-谁,就是从哪个对象中挑选
type A = {
name: string;
age: number;
address: string;
};
type B = {
name: string;
male: boolean;
address: number;
};
type ObjectDiff<T extends object, U extends object> = Omit<U, Extract<keyof T, keyof U>>;
type X2 = ObjectDiff<A, B>; // B - A = male: boolean;
type ObjectDiff2<T extends object, U extends object> = Pick<T, Exclude<keyof T, keyof U>>;
type X3 = ObjectDiff2<A, B>; // A - B = age: number;
type OmitDiff<T extends object, U extends Object> = Omit<T, keyof U>;
type X4 = OmitDiff<A, B>; // A - B = age: number;
求对象的并集 ObjectMerge
希望最终得到的结果是 type X7 = { age: number; name: string; address: number; male: boolean;}
实现思路：先找出A - B的差集，再& B
type A = {
name: string;
age: number;
address: string;
};
type B = {
name: string;
address: number;
male: boolean;
};
type Compute<T extends object> = {
[K in keyof T]: T[K]; // 只是做了映射，为了显示类型结果
};
type ObjectMerge<T extends object, U extends object> = Omit<T, keyof U> & U;
type X5 = Compute<ObjectMerge<A, B>>;
求对象的补集 ObjectComp
补集：存在于 A 中，不存在于 B 中，属性相差。互补，注意：双方得存在父子关系，才能互补 也就是 B 是 A 的子类型
type A = {
name: string;
age: number;
address: string;
};
type B = {
name: string;
address: string;
};
// 类型“B” 需要满足约束 “A”。
type ObjectComp<T extends object, U extends T> = Omit<U, Extract<keyof T, keyof U>>;
type X6 = ObjectComp<B, A>; // age: number;
重写对象类型 Overwrite
使用 B 重写 A 中相同的属性，案例中就是 使用 address: string => address: number,其他不变
希望最终得到的结果是 A=> { name: string; age: number; address: number }
实现思路：先找出交集，在找差集,利用上边已经实现的代码
type A = {
name: string;
age: number;
address: string;
};
type B = {
name: string;
address: number;
male: boolean;
};
type Compute<T extends object> = {
[K in keyof T]: T[K]; // 只是做了映射，为了显示类型结果
};
type Overwrite<T extends object, U extends object> = ObjectInter<A, B> & ObjectDiff2<A, B>;
type X7 = Compute<Overwrite<A, B>>;