//infer 推断一个变量的类型
type arr<T> = Array<T extends () => infer U ? U : string>;
//此时传入的类型T是number | string，不属于类型()=>infer U所以返回的是string
type menus = arr<number | string>;
//此时传入的类型T是函数返回boolean 属于类型()=>infer U所以返回的是函数类型，根据infer推断U的类型就是boolean
type menus1 = arr<() => boolean>;
type obj = {
name: string;
id: number;
};
// pick，就是从原始类型中截取部分类型做为新的类型使用
// 原始类型
interface TState {
name: string;
age: number;
like: string[];
}
// 如果我只想要name和age怎么办，最粗暴的就是直接再定义一个（我之前就是这么搞得）
interface TSingleState {
name: string;
age: number;
}
// 这样的弊端是什么？就是在Tstate发生改变的时候，TSingleState并不会跟着一起改变
interface TSingleState extends Pick<TState, 'age' | 'like'> {}
// pick 第一个参数是要截取属性的目标，第二个参数是要截取的属性
type C = Pick<obj, 'id'>;
// 元组类型，元组类型的每个值类型和顺序都已经确定，添加的时候要按照定义的顺序添加
//as const 会转化为readonly类型
const tuple = ['tesla', 'model 3', 'model X', 'model Y'] as const;
let tom: [string, number];
tom = ['Tom', 25];
//后面再次添加数据的时候以[string, number]两个其中一个类型为参照，如果有其他类型就会报错
tom.push(1);
tom.push('male');
tom.push(1);
//实现一个Awaited方法，Promise的接口定义使用了PromiseLike
type Unwrap<T> = T extends PromiseLike<infer U> ? U : T;
// resolve类型实现是
// resolve<T>(value: T): Promise<Awaited<T>>;
// 所以传入的变量会做推断并且传回对应的类型
const resultPromise = Promise.resolve('sss');
type resultUnwrapType = Unwrap<typeof resultPromise>;
//Awaited接口，从promise中获取具体的返回类型
const a = Promise.resolve('123');
// reject的实现是
// reject<T = never>(reason?: any): Promise<T>;
// 所以reject不声明参数类型就会传回never类型
//const a = Promise.reject('123');
type resultUnwrapType1 = Awaited<typeof a>;
//自定义一个if,可以不叫if，叫if1 if2....之类的也可以，这里主要是实现if的逻辑
type If<C extends boolean, T, F> = C extends true ? T : F;
type A = If<true, 'a', 'b'>; // expected to be 'a'
type B = If<false, 'a', 'b'>; // expected to be 'b'
// 自定义一个拼接属性
type Concat<T extends string[], U extends number[]> = [...T, ...U];
type Result = Concat<['1'], [2]>; // expected to be [1, 2]
type Fruits = 'apple' | 'banana' | 'peach' | 'orange';
type DislikeFruits = 'apple' | 'banana';
//交集,取DislikeFruits和Fruits都有的部分
type FloveFruits = Extract<Fruits, DislikeFruits>; // 等效于 type FloveFruits = "apple" | "banana"
//补集，取DislikeFruits没有的部分
type FloveFruits1 = Exclude<Fruits, DislikeFruits>; // 等效于 type FloveFruits1 = "peach" | "orange"
// 将元组转换一个value为true的对象
// 1.分解后类似于{
// Kars: true;
// Esidisi: true;
// }['Kars']
// 相当于在数组取值能否取到
// 2.取到的话就是一个true值，如果是的话就返回true，数组没有的key肯定返回不是true，一般是any，这时候就用false代替，
// 利用这样的逻辑就实现了一个includes
type Includes<T extends any[], U> = {
[K in T[number]]: true;
}[U] extends true
? true
: false;
type isPillarMen = Includes<['Kars', 'Esidisi', 'Wamuu', 'Santana', 1], 'Dio'>; // expected to be `false`
type IEqual<T, U> = (<X>() => X extends T ? 1 : 2) extends <X>() => X extends U ? 1 : 2
? true
: false;
// type IEqual<T, U> = T extends U ? (U extends T ? 1 : 0) : 0;
type isPillarMen1 = IEqual<
['Kars', 'Esidisi', 'Wamuu', 'Santana', 1],
['Kars', 'Esidisi', 'Wamuu', 'Santana', 1]
>;
// type c = <T>() => T;
// const aaa: c = () => {
// return null
// };
// aaa<number>();
type bbb = IEqual<1, true>;
function getUser(a: string[]) {
return { name: 'xxx', age: 10 };
}
type GetUserType = typeof getUser;
// ReturnType,获取函数返回值的类型
type ReturnUserFunc = ReturnType<GetUserType>;
// Parameters,获取函数参数的类型
type ReturnUserParams = Parameters<GetUserType>;
// 链式调用，参考；https://ghaiklor.github.io/type-challenges-solutions/en/medium-chainable-options.html
type Chainable<P = {}> = {
option<K extends string, T>(
key: K extends keyof P ? never : K,
value: T
): Chainable<P & { [key in K]: T }>;
get(): P;
};
declare const config: Chainable;
const result = config
.option('foo', 123)
.option('name', 'type-challenges')
.option('bar', { value: 'Hello World' })
.get().name;
console.log();
type petsGroup = 'dog' | 'cat' | 'fish';
interface IPetInfo {
name: string;
age: number;
}
type IPets = Record<petsGroup, IPetInfo>;
const animalsInfo: IPets = {
dog: {
name: 'dogName',
age: 2
},
cat: {
name: 'catName',
age: 3
},
fish: {
name: 'fishName',
age: 5
}
};
interface PageInfo {
title: string;
}
type Page = {
home: string;
about?: string;
contact?: string;
};
const nav: Record<keyof Page, PageInfo> = {
home: { title: 'a' },
about: { title: 'b' },
contact: { title: 'c' },
};
interface Foo {
a: number
b: number
}
type PartialFoo = Partial<Foo> // { a?: number, b?: number}
type PartialFoo1 =Pick<PartialFoo,'a'>
const ret:PartialFoo={
a:1
}