TS为什么被叫做类型体操

[1. 简单类型系统](#1. 简单类型系统 "#1.%E7%AE%80%E5%8D%95%E7%B1%BB%E5%9E%8B%E7%B3%BB%E7%BB%9F")

[2. 支持泛型系统](#2. 支持泛型系统 "#2.%E6%94%AF%E6%8C%81%E6%B3%9B%E5%9E%8B%E7%B3%BB%E7%BB%9F")

[3. 类型编程的类型系统](#3. 类型编程的类型系统 "#3%E3%80%81%E7%B1%BB%E5%9E%8B%E7%BC%96%E7%A8%8B%E7%9A%84%E7%B1%BB%E5%9E%8B%E7%B3%BB%E7%BB%9F")

类型系统不止ts有，比如说java、c++都有，为什么只有ts被称为类型体操

本文将讲述为什么ts被称为类型体操。静态类型编程语言都有一套自己的类型系统，从简单到复杂可以分为3类。

1、简单类型系统

最基本的类型系统，类型不匹配会报错，能保证数据安全，但几乎没有拓展性

例如:

ts 复制代码

int add(int a ,int b){
    return a+ b
}

double add(double a, double b){
    return a + b
}

2、支持泛型系统

泛型的意思是可以代表任何一种类型，也叫类型参数，他可以给你定义的类型点增加一些灵活性，但整体比较固定，可以减少很多重复代码，例如上面的add函数

ts 复制代码

T add<T>(T a, T b) {
    return a + b;
}

add(2,3);
add(3.14, 3.14156);

如上所示，声明的时候会把类型去声明成泛型，在调用的时候去确定泛型的类型

那如果想要返回对象中的某一个属性值该怎么去写呢？

ts 复制代码

const fn = <T>(obj: T, key): key => {
  return obj[key];
};

但是这样我们该如何实现对去做一些逻辑处理呢？所以就有了第三种类型系统

3、类型编程的类型系统

我们可以对传入的类型（泛型）去各种逻辑计算，产生新的类型，例如

ts 复制代码

const getObjValue = <T extends object, key extends keyof T>(
  obj: T,
  key: key
): T[key] => {
  return obj[key];
};

在这段代码中：

我们声明了两个泛型<T>、<key>并且对这两个泛型进行了约束，<T>必须是一个带有属性的object，key 必须是中的某一个键名

所以这个函数的的意思就是 getObjValue 函数接受两个参数

一个带有属性的对象
一个该属性下的键名

返回的是这个键对应的值

像java中的类型系统是不能像ts一样去做各种泛型的逻辑处理，所以都说ts的类型编程是是类型体操。

例如下面的这段代码，第一眼看上去难免会有些迷糊

ts 复制代码

type ParseParam<Param extends string> = 
    Param extends `${infer Key}=${infer Value}`
        ? {
            [K in Key]: Value 
        } : {};

type MergeValues<One, Other> = 
    One extends Other 
        ? One
        : Other extends unknown[]
            ? [One, ...Other]
            : [One, Other];

type MergeParams<
    OneParam extends Record<string, any>,
    OtherParam extends Record<string, any>
> = {
  [Key in keyof OneParam | keyof OtherParam]: 
    Key extends keyof OneParam
        ? Key extends keyof OtherParam
            ? MergeValues<OneParam[Key], OtherParam[Key]>
            : OneParam[Key]
        : Key extends keyof OtherParam 
            ? OtherParam[Key] 
            : never
}
type ParseQueryString<Str extends string> = 
    Str extends `${infer Param}&${infer Rest}`
        ? MergeParams<ParseParam<Param>, ParseQueryString<Rest>>
        : ParseParam<Str>;

本系列会持续更新ts的类型编程用法，最后希望大家最后都能看懂编写这种类型体操哈哈