使用typescript类型系统实现正整数加法运算

夙***

本期将单纯使用工具类型实现，无任何js代码（除了展示类型的除外）
代码量巨大，我就不搞解析了，完全基于本人对ts的理解写出来的原创代码，无任何借鉴，你说史山那就是史山
type number_string = ['0','1','2','3','4','5','6','7','8','9']
type number_ = [0,1,2,3,4,5,6,7,8,9]
type big = [10,11,12,13,14,15,16,17,18,19]
//移除元组开头元素
export type removeTop<A> = A extends [infer T,...infer data] ? [...data] : never
//结构对比
export type isOneType<t,T> = keyof t extends keyof T ? keyof T extends keyof t ? true : false : false
//全同对比
export type isOne<ty,yt> = ty extends yt ? yt extends ty ? true : false : false
//移除字符串开头的字符
type string_remove_top<s> = s extends `${infer _h}${infer data}` ? data : never
//获取字符串开头的字符
type get_string_top<s> = s extends `${infer _h}${infer ho}` ? _h :never
//字符串转数组
type string_to_array<s extends string,new_ extends []> = true extends isOne<s,''> ? new_ : string_to_array<string_remove_top<s>,[...new_,get_string_top<s>]>
export type StringToArray<s extends string> = string_to_array<s,[]>
//类型映射
export type type_to_else<t,contrast extends any[],to extends any[]> = true extends isOneType<t,contrast[0]> ? to[0] : type_to_else<t,removeTop<contrast>,removeTop<to>>
//获取元素索引
type indexof<target extends any[],type_ extends any,Counter extends []> = true extends isOne<target[0],type_> ? Counter['length'] : indexof<removeTop<target>,type_,[0,...Counter]>
export type indexOf<target,type_> = indexof<target,type_,[]>
//填充数组
export type fill_array<array extends any[],length extends number,element extends any[]> = true extends isOne<array['length'],length> ? array : fill_array<[element,...array],length,element>
//分割数组
type partition<array extends any[],length extends number,result extends [[],[...array]]> = true extends isOne<result[0]['length'],length> ? result : partition<removeTop<array>,length,[[...result[0],array[0]],[...removeTop<array>]]>
export type Partition<array extends any[],length extends number> = partition<array,length,[[],[...array]]>
//简单加法
type ad<a extends number,b extends number> = [...fill_array<[],a,0>,...fill_array<[],b,0>]['length']
//给字符串开头添加字符串
type string_add_top<s extends string,a extends string> = `${a}${s}`
//字符串转数字(9以内)
type string_to_number<s extends string> = indexOf<number_string,s>
//个位
type individual_position<n extends number> = indexOf<big,n>
//移除数组末尾
type array_remove_end<n extends any[]> = n extends [...infer h,infer e] ? h : []
//获取数组末尾
type get_array_end<n extends any[]> =  n extends [...infer h,infer e] ? e : n
//判断元素在不在数组
type includes<array extends any[],element extends any> = true extends isOne<array,[]> ? false : true extends isOne<get_array_end<array>,element> ? true : includes<array_remove_end<array>,element>
//进位
type carry<n extends number[],after extends number[],> = true extends isOne<n,[]> ? after : true extends isOne<n['length'],1> ? [n[0],...after] : true extends includes<big,get_array_end<n>> ? carry<[...array_remove_end<array_remove_end<n>>,ad<get_array_end<array_remove_end<n>>,1>],[individual_position<get_array_end<n>>,...after]> : carry<array_remove_end<n>,[get_array_end<n>,...after]>
type Carry<n extends number[]> = carry<n,[]>
//拆解数字字符串
type partition_string<s extends string,new_ extends []> = true extends isOne<s,''> ? new_ : partition_string<string_remove_top<s>,[...new_,string_to_number<get_string_top<s>>]>
type PartitionString<s extends string> = partition_string<s,[]>
//默认值
type default_value<n,de> = true extends isOne<n,never> ? de : true extends isOne<n,undefined> ? de : true extends isOne<n,[]> ? de : n
//数组相加-末起
type array_number_add<a extends number[],b extends number[],c extends []> = true extends isOne<a[0],undefined> ? true extends isOne<b[0],undefined> ? c : array_number_add<array_remove_end<a>,array_remove_end<b>,[ad<default_value<get_array_end<a>,0>,default_value<get_array_end<b>,0>>,...c]> :array_number_add<array_remove_end<a>,array_remove_end<b>,[ad<default_value<get_array_end<a>,0>,default_value<get_array_end<b>,0>>,...c]>
type ArrayNumberAdd< a extends number[],b extends number[]> = array_number_add<a,b,[]>
//数字字符串数组转数字数组
type string_number_array_to_number_array<a extends string,result extends []> = true extends isOne<a,''> ? result : string_number_array_to_number_array<string_remove_top<a>,[...result,string_to_number<get_string_top<a>>]>
type StringArrayToNumberArray<a extends string> = string_number_array_to_number_array<a,[]>
display<string_number_array_to_number_array<'2738',[]>>()
//数组转字符串
type array_to_string<array extends any[],s extends string> = true extends isOne<array,[]> ? s : array_to_string<removeTop<array>,`${s}${array[0]}`>
type add<a extends string,b extends string> = array_to_string<Carry<ArrayNumberAdd<StringArrayToNumberArray<a>,StringArrayToNumberArray<b>>>,''>
使用
function display<T>():T

雪***

你的ts基本功是我一辈子无法比拟的

ak***

ts体操一般难度，基本就是const数组特性

1. 
   
2. type MetaNum = ['9', '8', '7', '6', '5', '4', '3', '2', '1', '0']
   
3. // 分割
   
4. type Split<
   
5.   T extends string,
   
6.   R extends boolean = false,
   
7.   _R extends Array<string> = [],
   
8. > = T extends `${infer X}${infer Y}` ? (R extends true ? Split<Y, R, [X, ..._R]> : Split<Y, R, [..._R, X]>) : _R
   
9. // 联合
   
10. type Join<T extends Array<string>, R extends boolean = false, _R extends string = ''> = T extends [
    
11.   infer A extends string,
    
12.   ...infer B extends Array<string>,
    
13. ]
    
14.   ? Join<B, R, R extends true ? `${A}${_R}` : `${_R}${A}`>
    
15.   : _R
    
16. // 获取索引
    
17. type ResolveIdx<T extends string, R extends Array<string> = MetaNum> = R extends [infer X, ...infer Y]
    
18.   ? T extends X
    
19.     ? R extends [infer _, ...infer Rest]
    
20.       ? Rest['length']
    
21.       : never
    
22.     : ResolveIdx<T, Extract<Y, Array<string>>>
    
23.   : never
    
24. // 创建空白索引数组
    
25. type GenBlankArr<T extends number, R extends Array<number> = []> = R['length'] extends T
    
26.   ? R
    
27.   : GenBlankArr<T, [...R, R['length']]>
    
28. // 原子加发
    
29. type MetaAdd<A extends string, B extends string> = Extract<
    
30.   [...GenBlankArr<ResolveIdx<A>>, ...GenBlankArr<ResolveIdx<B>>]['length'],
    
31.   number
    
32. >
    
33. // 获取进位和余位
    
34. type ResolveNum<T extends number> = `${T}` extends `${infer X}${infer Y}` ? (Y extends '' ? ['0', X] : [X, Y]) : never
    
35. // 递推进位值计算
    
36. type ReduceNum<
    
37.   A extends string,
    
38.   B extends string,
    
39.   R extends Array<number> = [],
    
40.   SplitA = Split<A, true>,
    
41.   SplitB = Split<B, true>,
    
42. > = SplitA extends [infer XA extends string, ...infer YA extends Array<string>]
    
43.   ? SplitB extends [infer XB extends string, ...infer YB extends Array<string>]
    
44.     ? ReduceNum<Join<YA, true>, Join<YB, true>, [...R, MetaAdd<XA, XB>]>
    
45.     : ReduceNum<Join<YA, true>, '', [...R, MetaAdd<XA, '0'>]>
    
46.   : SplitB extends [infer XB extends string, ...infer YB extends Array<string>]
    
47.   ? ReduceNum<'', Join<YB, true>, [...R, MetaAdd<'0', XB>]>
    
48.   : R
    
49. // 地推进位
    
50. type Tee<T extends Array<number>, R extends string = '', CR extends string = '0'> = T extends [
    
51.   infer A extends number,
    
52.   ...infer B extends Array<number>,
    
53. ]
    
54.   ? ResolveNum<A> extends [infer X extends string, infer Y extends string]
    
55.     ? ResolveNum<MetaAdd<Y, CR>> extends [infer _X extends string, infer _Y extends string]
    
56.       ? Tee<B, `${_Y}${R}`, `${MetaAdd<X, _X>}`>
    
57.       : never
    
58.     : never
    
59.   : CR extends '0'
    
60.   ? R
    
61.   : `${CR}${R}`
    
62. // 判断是否合法
    
63. type IsValid<
    
64.   T extends string,
    
65.   Temp extends Array<string> = [],
    
66.   SplitT extends Array<string> = Split<T>,
    
67. > = SplitT extends [infer X, ...infer Y extends Array<string>]
    
68.   ? X extends MetaNum[number]
    
69.     ? X extends '0'
    
70.       ? Temp['length'] extends 0
    
71.         ? SplitT['length'] extends 1
    
72.           ? true
    
73.           : false
    
74.         : IsValid<Join<Y>, [...Temp, X]>
    
75.       : IsValid<Join<Y>, [...Temp, X]>
    
76.     : false
    
77.   : Temp['length'] extends 0
    
78.   ? false
    
79.   : true
    
80. // 组合加法
    
81. type Add<A extends string, B extends string, IsValidA = IsValid<A>, IsValidB = IsValid<B>> = IsValidA extends IsValidB
    
82.   ? IsValidA extends true
    
83.     ? // @ts-ignore
    
84.       Tee<ReduceNum<A, B>>
    
85.     : never
    
86.   : never
    
87. 
    
88. type Foo_1 = Add<'0', '1'>
    
89. type Foo_1_1 = Add<'0', ''>
    
90. type Foo_2 = Add<'1', '0'>
    
91. type Foo_3 = Add<'0', '0'>
    
92. type Foo_4 = Add<'123', '456'>
    
93. type Foo_5 = Add<'937', '9999999999999878'>
    
94. type Foo_6 = Add<'12846026972358281685236841339743503218625460074', '16738438016761768034928435260197280468667948046'>
    

复制代码