// 创建一个对象，包括以下属性，类型为IBytedancer
// I表示自定义的一个类型（一个命名约定），与类和对象进行区分
const bytedancer: IBytedancer = {
    jobId: 9303245,
    name: 'Lin',
    sex: 'man',
    age: 28,
    hobby: 'swimming',
}
// 定义一个类型为IBytedancer
interface IBytedancer {
	/* 只读属性readonly:约束属性不可在对象初始化外赋值 */
	readonly jobId: number;
    name: string;
    sex: 'man' | 'woman' | 'other';
    age: number;
    /* 可选属性:定义该属性可以不存在 */
    hobby?: string;
    /* 任意属性:约束所有对象属性都必须是该属性的子类型 */
    [key: string]: any; // any 任何类型
}
/* 报错:无法分配到"jobId"，因为它是只读属性 */
bytedancer. jobId = 12345;
/* 成功:任意属性标注下可以添加任意属性 */
bytedancer .plateform = 'data';
/* 报错:缺少属性"name", 而hobby可缺省 */
const bytedancer2: IBytedancer = {
    jobId: 89757,
    sex: "woman",
    age: 18,
}

function add(x, y!) {
	return x + y;
}
const mult = (x, y) =>  x * y;

function add(x: number, y: number): number {
	return x + y;
}
const mult: (x: number, y: number) => number = (x, y) => x * y;
// 简化写法，定义接口IMult
interface IMult {
	(x: number, y: number): number ;
}
const mult: IMult = (x, y) => x * y;

/* 对getDate函数进行重载，timestamp为可缺省参数 */
function getDate(type: 'string', timestamp?: string): string;
function getDate(type: 'date', timestamp?: string): Date;
function getDate(type: 'string' | 'date', timestamp?: string): Date | string {
    const date = new Date(timestamp);
    return type === 'string' ? date.toLocaleString() : date;
};
const x = getDate('date'); // x: Date
const y = getDate('string', '2018-01-10'); // y: string

interface IGetDate {
	(type : 'string', timestamp ?: string): string; // 这个地方返回类型改为any就可以通过了
	(type : 'date', timestamp?: string): Date;
	(type: 'string' | 'date', timestamp?: string): Date | string;
}
/* 报错：不能将类型"(type: any, timestamp: any) => string | Date"分配给类型"IGetDate"。
	不能将类型"string | Date" 分配给类型"string"。
	不能将类型 "Date"分配给类型"string"。ts(2322) */
const getDate2: IGetDate = (type, timestamp) => {
	const date = new Date( timestamp) ; 
	return type === 'string' ? date.toLocaleString() : date;
}

/* 「类型+方括号」表示 */
type IArr1 = number[];
/* 泛型表示 这两种最常用*/ 
type IArr2 = Array<string | number| Record<string, number> > ;
/* 元组表示 */
type IArr3 = [number, number, string, string];
/* 接口表示 */
interface IArr4 {
	[key: number]: any;
}

const arrl: IArr1 = [1, 2, 3, 4, 5, 6];
const arr2: IArr2 = [1, 2, '3', '4', { a: 1 }];
const arr3: IArr3 = [1, 2, '3', '4'];
const arr4: IArr4 = ['string', () => null, {}, []];

/* 空类型，表示无赋值 */
type IEmptyFunction = () => void;
/* 任意类型，是所有类型的子类型 */
type IAnyType = any;
/* 枚举类型:支持枚举值到枚举名的正、反向映射 */
enum EnumExample {
    add = '+',
	mult = '*',
}
EnumExample['add'] === '+';
EnumExample['+'] === 'add';
enum ECorlor { Mon, Tue, Wed, Thu, Fri, Sat, Sun };
ECorlor['Mon'] === 0;
ECorlor[0] === 'Mon' ;
/*泛型*/
type INumArr = Array<number>;

function getRepeatArr(target) {
	return new Array(100).fill(target); 
}
type IGetRepeatArr = (target: any) => any[];
/* 不预先指定具体的类型，而在使用的时候再指定类型的一种特性 */
type IGetRepeatArrR = <T>(target: T) => T[];

/*泛型接口&多泛型*/
interface IX<T, U> {
	key: T;
	val: U;
}
/* 泛型类 */
class IMan<T> {
	instance: T;
}
/* 泛型别名 */
type ITypeArr<T> = Array<T>;

/* 泛型约束:限制泛型必须符合字符串 */
type IGetRepeatStringArr = <T extends string>(target: T) => T[];
const getStrArr: IGetRepeatStringArr = target => new Array(100).fill(target);
/* 报错:类型"number"的参数不能赋给类型“string"的参数 */
getStrArr(123) ;

/* 泛型参数默认类型 */
type IGetRepeatArr<T = number> = (target: T) => T[];// 与结构中的默认赋值有点类似
const getRepeatArr: IGetRepeatArr = target => new Array(100).fill(target);// 这里的IGetRepeatArr就是一个类型别名，此处没有传参数给这个类型别名
/* 报错:类型"string"的参数不能赋给类型“numbe r"的参数 */
getRepeatArr('123');

/*通过type关键字定义了IObjArr的别名类型*/
type IObjArr = Array<{
	key: string;
	[objKey: string]: any;
}>
function keyBy<T extends IObjArr>(objArr: Array<T>) {
	/* 未指定类型时，result类型为{} */
	const result = objArr.reduce((res, val, key) => {
		res[key] = val;
		return res;
	}, {});
    /* 通过as关键字，断言result类型为正确类型 */
    return result as Record<string, T> ; 
}

/* 允许指定字符 串/数字必须的固定值*/
/* IDomTag必须为html、body、div、 span中的其一*/
type IDomTag = 'html' | ' body' | 'div' | 'span';
/* IOddNumber必须为1、 3、5、7、9中的其一 */
type IOddNumber = 1 | 3 | 5 | 7 | 9;

const bookList = [ {	// 普通js
	author:'xiaoming',
    type:'history',
    range: '2001 -2021',
}, {
    author:'xiaoli',
    type:'Story',
    theme:'love',
}] 
// ts 繁琐
interface IHistoryBook {
    author:String;
    type:String;
    range:String
}
interface IStoryBook { 
    author:String;
    type:String;
    theme:String;
}
type IBookList = Array<IHistoryBook | IStoryBook>;

type IBookList = Array<{
	author: string;
} & ({
	type: 'history';
	range: string;
} | {
	type: 'story';
	theme: string;
})>; 
/* 限制了author只能为string类型，而type只能'history'/'story'二选一，并且type不同可能的属性不同 */

interface IA { a: 1, a1: 2 }
interface IB { b: 1, b1: 2 }
function log(arg: IA | IB) {
    /*报错:类型"IA | IB" 上不存在属性"a”。 类型"IB"上不存在属性"a"
    结论:访问联合类型时，处于程序安全，仅能访问联合类型中的交集部分*/

	if(arg.a) {
        console.log(arg.a1);
    } else {
        console.log(arg.b1);
    }
}

interface IA { a: 1, a1: 2 }
interface IB { b: 1, b1: 2 }

/*类型守卫:定义一个函数，。它的返回值是一个类型谓词，生效范围为子作用域 */
function getIsIA(arg: IA | IB): arg is IA {
    return !!(arg as IA).a;
}
function log2(arg: IA | IB) {
    /* 不存在报错了 */
	if(getIsIA(arg) ) {
        console.log(arg.a1);
    } else {
        console.log(arg.b1);
    }
}

// 实现函数reverse 可将数组或字符串进行反转
function reverse(target: string | Array<any>) {
	/* typof 类型保护*/
    if (typeof target === 'string') {
       return target.split('').reverse().join('');
    }
    /* instance 类型保护*/
    if (target instanceof Object) {
        return target.reverse() ;
    }
}

// 实现函数logBook类型
// 函数接受书本类型，并logger出相关特征
function logBook(book: IBookItem) {
	// 联合类型+类型保护=自动类型推断
	if (book.type === 'history'){
		console.log(book.range)
    } else{
        console.log book.theme);
    }
}

function merge1(sourceObj, targetObj) {	// js中，实现复杂，这样才能不污染
    const result = { ...sourceObj };
    for(let key in targetObj) {
        const itemVal = sourceObj[key];
        itemVal && ( result[key] = itemVal );
    }
    return result;
}
function merge2(sourceObj, targetObj) {// 若这两个入参的类型没问题，则可以这样
    return { ...sourceObj, ...targetObj };
}

interface ISource0bj { 
    x?: string; 
    y?: string; 
}
interface ITarget0bf {
    x: string;
    y: string;
}
type IMerge = (source0bj: ISource0bj, target0bj: ITarget0bj) => ITargetObj;
/* 类型实现繁琐:若obj类型较为复杂，则声明source和target便需要大量重复2遍
容易出错:若target增加/减少key,则需要source联动去除 */

interface IMerge {
    <T extends Record<string, any>>(sourceObj: Partial<T>, targetObj: T): T;
}
// Partial内部实现
type IPartial<T extends Record<string, any>> = {
            [P in keyof T]?:T[P];
}
// 索引类型:关键字[keyof] ，其相当于取值对象中的所有key组成的字符串字面量，如
type IKeys = keyof{a: string; b: number }; // => type IKeys ="a" | "b"
// 关键字[in]，其相当于取值 字符串字面量中的一种可能，配合泛型P， 即表示每个key 
// 关键字[ ? ]，通过设定对象 可选选项，即可自动推导出子集类型

// 如何实现函数delayCall的类型声明
// delayCall接受一个函数作为入参，其实现延迟1s运行函数
// 其返回promise，结果为入参函数的返回结果
function delayCall(func) {
    return new Promisd(resolve => {
        setTimeout(() => {
            const result= func );
            resolve(result);
        },1000);
    });
}

type IDelayCall= <T extends () => any>(func: T) => ReturnType<T>;
type IReturnType<T extends (...args: any) => any> = T extends(...args: any ) => inferR ? R : any
    
// 关键字[extends] 跟随泛型出现时，表示类型推断，其表达可类比三元表达式
// 如T === 判断类型?类型A:类型B
// 关键字[infer] 出现在类型推荐中，表示定义类型变量，可以用于指代类型
// 如该场景下，将函数的返回值类型作为变量，使用新泛型R表示，使用在类型推荐命中的结果中

type MyPick<T, K extends keyof T> = {
  [Key in K]: T[Key]
}

Type 'K' is not assignable to type 'string | number | symbol'.
Type 'key' cannot be used to index type 'T'.

type MyReadonly<T> = {
  readonly [Key in keyof T]: T[Key]
}

type TupleToObject<T extends readonly any[]> = {
  [Key in T[number]]: Key
}

type First<T extends any[]> = T extends [infer F, ...any[]] ? F : never

type Length<T extends readonly unknown[]> = T['length']

type MyExclude<T, U> = T extends U ? never : T

type ToArray<Type> = Type extends any ? Type[] : never
// 如果我们将联合类型插入 ToArray，则条件类型将应用于该联合的每个成员。
type StrArrOrNumArr = ToArray<string | number>
//   ^type StrArrOrNumArr = string[] | number[]

type MyAwaited<T extends PromiseLike<any>> = T extends PromiseLike<infer V>
  ? V extends PromiseLike<any>
    ? MyAwaited<V>
    : V
  : never

type If<C extends boolean, T, F> = C extends true ? T : F

type Concat<T extends unknown[], U extends unknown[]> = [...T, ...U]

type IsEqual<A, B> = (A extends B ? true : false) & (B extends A ? true : false)
type Includes<T extends readonly any[], U> = T extends [infer F, ...infer Rest]
  ? IsEqual<F, U> extends true
    ? true
    : Includes<Rest, U>
  : false

type Push<T, U> = T extends [...infer Rest] ? [...Rest, U] : never

type Unshift<T, U> = T extends [...infer Rest] ? [U, ...Rest] : never

type MyParameters<T extends (...args: any[]) => any> = T extends (...args: infer A) => any ? A : never

const fn = (v: boolean) => {
  if (v) return 1
  else return 2
}

type a = MyReturnType<typeof fn> // 应推导出 "1 | 2"

type MyReturnType<T> = T extends (...args: any[]) => infer R ? R : never

interface Todo {
  title: string
  description: string
  completed: boolean
}

type TodoPreview = MyOmit<Todo, 'description' | 'title'>

const todo: TodoPreview = {
  completed: false,
}

type MyOmit<T, K extends keyof T> = {
  [Key in keyof T as Key extends K ? never : Key]: T[Key]
}

interface Todo {
  title: string
  description: string
  completed: boolean
}

const todo: MyReadonly2<Todo, 'title' | 'description'> = {
  title: 'Hey',
  description: 'foobar',
  completed: false,
}

todo.title = 'Hello' // Error: cannot reassign a readonly property
todo.description = 'barFoo' // Error: cannot reassign a readonly property
todo.completed = true // OK

type MyReadonly2<T, K extends keyof T = keyof T> = {
  readonly [Key in K]: T[Key]
} & Omit<T, K>

type X = {
  x: {
    a: 1
    b: 'hi'
  }
  y: 'hey'
}

type Expected = {
  readonly x: {
    readonly a: 1
    readonly b: 'hi'
  }
  readonly y: 'hey'
}

type Todo = DeepReadonly<X> // should be same as `Expected`

type DeepReadonly<T extends Object> = {
  readonly [Key in keyof T]: T[Key] extends Record<any, any>
    ? T[Key] extends Function
      ? T[Key]
      : DeepReadonly<T[Key]>
    : T[Key]
}

type Arr = ['1', '2', '3']

type Test = TupleToUnion<Arr> // expected to be '1' | '2' | '3'

type TupleToUnion<T> = T extends [infer V, ...infer Rest] ? V | TupleToUnion<Rest> : never

type TupleToUnion<T extends any[]> = T[number]

type Chainable = {
  option(key: string, value: any): any
  get(): any
}

declare const config: Chainable

const result = config.option('foo', 123).option('name', 'type-challenges').option('bar', { value: 'Hello World' }).get()

// 期望 result 的类型是：
interface Result {
  foo: number
  name: string
  bar: {
    value: string
  }
}

type Chainable<Obj extends Record<string, any> = {}> = {
  option<K extends string, V>(
    key: K extends keyof Obj ? (V extends Obj[K] ? never : V) : K,
    value: V,
  ): Chainable<Omit<Obj, K> & Record<K, V>>
  get(): Obj
}

type Last<T extends any[]> = T extends [...infer Rest, infer L] ? L : never

type arr1 = ['a', 'b', 'c', 'd']
type arr2 = [3, 2, 1]

type re1 = Pop<arr1> // expected to be ['a', 'b', 'c']
type re2 = Pop<arr2> // expected to be [3, 2]

type Pop<T extends any[]> = T extends [...infer Rest, infer L] ? Rest : T
type Push<T extends any[], Arr extends any[]> = [...T, ...Arr]
type Shift<T extends any[]> = T extends [infer F, ...infer Rest] ? Rest : T
type Unshift<T extends any[], Arr extends any[]> = [...Arr, ...T]

const promise1 = Promise.resolve(3)
const promise2 = 42
const promise3 = new Promise<string>((resolve, reject) => {
  setTimeout(resolve, 100, 'foo')
})

// expected to be `Promise<[number, 42, string]>`
const p = PromiseAll([promise1, promise2, promise3] as const)

declare function PromiseAll<Args extends readonly unknown[]>(
  values: readonly [...Args],
): Promise<{ [Key in keyof Args]: Args[Key] extends Promise<infer V> ? V : Args[Key] }>

interface Cat {
  type: 'cat'
  breeds: 'Abyssinian' | 'Shorthair' | 'Curl' | 'Bengal'
}

interface Dog {
  type: 'dog'
  breeds: 'Hound' | 'Brittany' | 'Bulldog' | 'Boxer'
  color: 'brown' | 'white' | 'black'
}

type MyDog = LookUp<Cat | Dog, 'dog'> // expected to be `Dog`

type LookUp<U, T extends string> = U extends { type: infer S } & Record<any, any> ? (S extends T ? U : never) : never

type LookUp<U, T extends string> = U extends { type: T } ? U : never

type trimed = TrimLeft<'  Hello World  '> // 应推导出 'Hello World  '

type Space = ' ' | '\n' | '\t'
type TrimLeft<S extends string> = S extends `${Space}${infer NewS}` ? TrimLeft<NewS> : S

type trimed = Trim<'  Hello World  '> // expected to be 'Hello World'

type Space = ' ' | '\n' | '\t'
type TrimLeft<S extends string> = S extends `${Space}${infer NewS}` ? TrimLeft<NewS> : S
type TrimRight<S extends string> = S extends `${infer NewS}${Space}` ? TrimLeft<NewS> : S
type Trim<S extends string> = TrimLeft<TrimRight<S>>

type Space = ' ' | '\n' | '\t'
type Trim<S extends string> = S extends `${Space}${infer NewS}` | `${infer NewS}${Space}` ? Trim<NewS> : S

type capitalized = Capitalize<'hello world'> // expected to be 'Hello world'

type MyCapitalize<S extends string> = S extends `${infer F}${infer Rest}` ? `${Uppercase<F>}${Rest}` : S

type replaced = Replace<'types are fun!', 'fun', 'awesome'> // 期望是 'types are awesome!'

type Replace<S extends string, From extends string, To extends string> = S extends `${infer Pre}${From}${infer Post}`
  ? From extends ''
    ? S
    : `${Pre}${To}${Post}`
  : S

type replaced = ReplaceAll<'t y p e s', ' ', ''> // 期望是 'types'

type ReplaceAll<S extends string, From extends string, To extends string> = S extends `${infer Pre}${From}${infer Post}`
  ? From extends ''
    ? S
    : `${Pre}${To}${ReplaceAll<Post, From, To>}`
  : S

type Fn = (a: number, b: string) => number

type Result = AppendArgument<Fn, boolean>
// 期望是 (a: number, b: string, x: boolean) => number

type AppendArgument<Fn extends (...args: any) => any, A> = Fn extends (...args: infer Args) => infer R
  ? (...args: [...Args, A]) => R
  : never

type perm = Permutation<'A' | 'B' | 'C'> // ['A', 'B', 'C'] | ['A', 'C', 'B'] | ['B', 'A', 'C'] | ['B', 'C', 'A'] | ['C', 'A', 'B'] | ['C', 'B', 'A']

type Permutation<T, Rest = T> = [T] extends [never] ? [] : Rest extends Rest ? [T, ...Permutation<Exclude<T, Rest>>] : []

type LengthOfString<S extends string, T extends string[] = []> = S extends `${string}${infer Rest}`
  ? LengthOfString<Rest, [string, ...T]>
  : T['length']

type flatten = Flatten<[1, 2, [3, 4], [[[5]]]]> // [1, 2, 3, 4, 5]

type Flatten<Arr extends any[]> = Arr extends [infer Item, ...infer Rest]
  ? [...(Item extends any[] ? Flatten<Item> : [Item]), ...Flatten<Rest>]
  : []

type Test = { id: '1' }
type Result = AppendToObject<Test, 'value', 4> // expected to be { id: '1', value: 4 }

type AppendToObject<T extends Record<string, any>, U extends string, V> = {
  [Key in keyof T]: T[Key]
} & {
  [key in U]: V
} extends infer Obj
  ? { [K in keyof Obj]: Obj[K] }
  : never

type AppendToObject<T, U extends keyof any, V> = {
  [K in keyof T | U]: K extends keyof T ? T[K] : V
}