使用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 [...R,
T extends Base ?
GetType: 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];
// }];
// };
// }