使用typescript推导已有变量的盲盒类型详情_javascript技巧_

let a = 1; type A = typeof a; // number; let b = '2' type B = typeof b; // string; let c; type C = typeof c; // undefined;

// 没错，7种数据类型 type Base = string | number | boolean | null | undefined | symbol | bigint;

let obj = { a: 1, b: '2', c: true, d: null }; type Obj = typeof obj; // { a: number; b: string; c: boolean; d: null; }

type isContain = [1, 2] extends Array ? true : false; // true

let arr = [1, '2', null, false]; type Arr = typeof arr; // (string | number | boolean | null)[] ??? type Arr1 = typeof arr[0] // string | number | boolean | null ???

let arr = [1, '2', null, false] as const; type Arr = typeof arr; // readonly [1, '2', null, false] type Arr1 = typeof arr[0] // 1

type GetType = T extends string ? string : T extends number ? number : T extends boolean? boolean : T extends null ? null : T extends undefined ? undefined : T extends symbol ? symbol : T extends bigint ? bigint : T; type Arr1 = typeof arr[0] // number type Arr2 = typeof arr[1] // string

type TransArr, R extends unknown[] = []> = { 'loop': TransArr: T[R['length']] ] >, 'result': R, }[T['length'] extends R['length'] ? 'result': 'loop']; let arr = [1, '2', null, false] as const; type Arr = typeof arr; type ArrType = TransArr; // [number, string, null, boolean]

let fn1 = (a, b) => a * b; type Fn1 = typeof fn1; // (a: any, b: any) => number function fn2(a) { return Promise.resolve(a); } type Fn2 = typeof fn2; // (a: any) => Promise

function fn3(a, b, c) { return a + b + c; } function fn4(d) { return d + 1; } type Fn3 = typeof fn3; // (a: any, b: any, c: any) => any type Fn4 = typeof fn4; // (d: any) => any type F3_4 = Fn3 extends Fn4 ? true : false; // false type F4_3 = Fn4 extends Fn3 ? true : false; // true

type isFunc = (() => any) extends T ? true : false;

type Trans = T extends Base ? GetType : T extends Array ? TransArr : isFunc extends true ? T : { [key in keyof T]: T[key] extends Base ? GetType : T[key] extends Array ? TransArr : Trans; };

let a1 = 1; type test1 = Trans; // number let a2 = '2'; type test2 = Trans; // string let a3 = [1, '2', true, '3', 4] as const; type test3 = TransArr; // [number, string, boolean, string, number] let a4 = { a: 1, b: true, c: { a: 1, b: [1, '2'] }, d: [true, null] } as const; type test4 = Trans; // { // readonly a: number; // readonly b: boolean; // readonly c: { // readonly a: number; // readonly b: readonly [number, string]; // }; // readonly d: readonly [boolean, null]; // } let a5 = { a: [ { b: [ { c: 1 } ] } ] } as const; type test5 = Trans; // { // readonly a: readonly [{ // readonly b: readonly [{ // readonly c: number; // }]; // }]; // } let a6 = (a, b, c) => a + b + c; type test6 = Trans; // (a: any, b: any, c: any) => any let a7 = [ function fn() { return 1; }, (a, b) => a * b, (a) => Promise.resolve(a) ] as const; type test7 = TransArr; // [() => number, (a: any, b: any) => number, (a: any) => Promise] let a8 = { a: 1, b: [true, null], c: [() => void, (a, b) => a], d: { e: [ (a, b) => null, { f: [1] } ] } } as const; type test8 = Trans; // { // readonly a: number; // readonly b: readonly [boolean, null]; // readonly c: readonly [() => undefined, (a: any, b: any) => any]; // readonly d: { // readonly e: readonly [(a: any, b: any) => null, { // readonly f: readonly [number]; // }]; // }; // }