世界上刚有typescript的时候，我本文版权归作者所有，未经授权不得转载。【本文受版权保护】就开始关注它了。我很明确，它是一门新语言【未经授权禁止转载】【原创内容，转载请注明出处】，只是和javascript是近亲。在它【作者：唐霜】原创内容，盗版必究。的介绍文档中，我看到private关键字【版权所有】唐霜 www.tangshuang.net著作权归作者所有，禁止商业用途转载。，甚是兴奋。但我开始去用它的时候，发现它【作者：唐霜】本文版权归作者所有，未经授权不得转载。的private的骗人的。除了priva【访问 www.tangshuang.net 获取更多精彩内容】【本文首发于唐霜的博客】te骗人外，它的所谓类型检查系统也有欺骗【本文受版权保护】【版权所有，侵权必究】性。现在很多人已经叫嚣着，不懂types原创内容，盗版必究。【转载请注明来源】cript就是不会前端。说实话，除了对t未经授权，禁止复制转载。本文版权归作者所有，未经授权不得转载。ypescript不满意，我连对ES标准【关注微信公众号：wwwtangshuangnet】【作者：唐霜】的#符也不满意。不是我挑剔，是有些东西人未经授权，禁止复制转载。未经授权，禁止复制转载。会天然不喜欢。

本文版权归作者所有，未经授权不得转载。本文作者：唐霜，转载请注明出处。

读完这个答案之后，我更加确信，原来自己的反感是有根源著作权归作者所有，禁止商业用途转载。原创内容，盗版必究。的，并非我有问题，而是typescrip著作权归作者所有，禁止商业用途转载。【原创不易，请尊重版权】t有问题。有什么问题呢？先来说一些旁的不【访问 www.tangshuang.net 获取更多精彩内容】原创内容，盗版必究。喜欢点：

【原创内容，转载请注明出处】转载请注明出处：www.tangshuang.net【作者：唐霜】

• 繁琐的类型定义方式，明明是一门新语言，非【原创内容，转载请注明出处】【作者：唐霜】要按照js的语法来写，但是又发明一些莫名未经授权，禁止复制转载。著作权归作者所有，禁止商业用途转载。其妙的新语法
【关注微信公众号：wwwtangshuangnet】【原创内容，转载请注明出处】本文作者：唐霜，转载请注明出处。
• 类型声明实在受不了，我知道使用 : 是受本文作者：唐霜，转载请注明出处。【转载请注明来源】了其他语言的启发，但是真正好的类型声明很著作权归作者所有，禁止商业用途转载。本文版权归作者所有，未经授权不得转载。明显要放在变量前面
著作权归作者所有，禁止商业用途转载。【本文首发于唐霜的博客】未经授权，禁止复制转载。
• 对象属性的类型声明？呵呵，太恶心。: 和【原创内容，转载请注明出处】本文版权归作者所有，未经授权不得转载。 as 能让人写作烦躁10倍。
原创内容，盗版必究。【未经授权禁止转载】【访问 www.tangshuang.net 获取更多精彩内容】
• any？哎。。。
【访问 www.tangshuang.net 获取更多精彩内容】【访问 www.tangshuang.net 获取更多精彩内容】未经授权，禁止复制转载。
• 结构类型检查！WTF
本文版权归作者所有，未经授权不得转载。【版权所有】唐霜 www.tangshuang.net本文版权归作者所有，未经授权不得转载。
• 据说类型检查能减少bug，但是，你怎么能原创内容，盗版必究。本文版权归作者所有，未经授权不得转载。确保你编写的类型本身没有bug？
转载请注明出处：www.tangshuang.net未经授权，禁止复制转载。
• 降低效率，用在解决（编写）一个类型问题上【本文受版权保护】【转载请注明来源】的时间，可能够我写完2个需求
转载请注明出处：www.tangshuang.net本文版权归作者所有，未经授权不得转载。【版权所有】唐霜 www.tangshuang.net转载请注明出处：www.tangshuang.net
• 使代码可读性降低，你需要在阅读代码过程中转载请注明出处：www.tangshuang.net【转载请注明来源】，跳到类型定义的部分去阅读，阅读完再跳回【访问 www.tangshuang.net 获取更多精彩内容】【作者：唐霜】来来，一去一来，我是谁，在哪里？
本文版权归作者所有，未经授权不得转载。【原创不易，请尊重版权】
• 增加运行难度，据说deno支持直接运行t【版权所有】唐霜 www.tangshuang.net【版权所有，侵权必究】s，但是实际上，还是先翻译为js后执行
本文作者：唐霜，转载请注明出处。【原创内容，转载请注明出处】

我们来看上面那篇回答中的一个经典案例：

【本文受版权保护】【版权所有】唐霜 www.tangshuang.net转载请注明出处：www.tangshuang.net

interface A {
    x: number;
}

let a: A = { x: 3 }
let b: { x: number | string } = a;

b.x = "unsound";

let x: number = a.x;

a.x.toFixed(0);

恶心死你。你不是静态类型检查吗？给你查，著作权归作者所有，禁止商业用途转载。【本文首发于唐霜的博客】查破了你能告诉我 bug 来自哪里？人生转载请注明出处：www.tangshuang.net【版权所有】唐霜 www.tangshuang.net啊，不要相信所谓了“在准确和效率之间找平未经授权，禁止复制转载。【关注微信公众号：wwwtangshuangnet】衡”，忽悠。别的类型系统，之所以成立，是【版权所有，侵权必究】未经授权，禁止复制转载。因为别的语言需要先编译，后执行，有健全类未经授权，禁止复制转载。【原创不易，请尊重版权】型系统，类型声明不用慌，而且类型本身就是【版权所有】唐霜 www.tangshuang.net【版权所有，侵权必究】运行时的。从我的不成熟的想法来看，不在运【版权所有】唐霜 www.tangshuang.net【关注微信公众号：wwwtangshuangnet】行时的类型系统，都是扯虎皮。使用type【转载请注明来源】【版权所有，侵权必究】script嘛，和语句末尾使用使用;结束【本文首发于唐霜的博客】【转载请注明来源】一样，技术不到位，有;也避免不了各种错，【作者：唐霜】【版权所有】唐霜 www.tangshuang.net技术到家，没;照样优雅健壮。

【关注微信公众号：wwwtangshuangnet】【本文首发于唐霜的博客】

我理想中的js变量类型声明：

【版权所有】唐霜 www.tangshuang.net原创内容，盗版必究。【本文受版权保护】原创内容，盗版必究。

int a = 1
bigint b = 299300002390809238n
float c = 2.2
bigfloat d = 4.394085943789534809830543l
string e = 'xxx'
Date date = new Date()
Promise p = new Promise(...)

// 多层结构的对象，可以在内部属性上独立确定类型
object o = {
  string name: 'my name',
  int age: 10,
  // 用<>表达其内部结构
  array<[
    object<{
      string name,
      number price,
    }>
  ]> books: [
    // 纯值，当然，也可以在内部进行类型定义，类型系统自己推演
    {
      name: 'book name',
      price: 6.6,
    },
  ],
}

let x = 1 // 相当于 any
const y = 'ok' // 不可变
var z = null // 带变量提升的 let

如果一个变量想要发生类型转化。。。不可以【未经授权禁止转载】【原创内容，转载请注明出处】的。

【访问 www.tangshuang.net 获取更多精彩内容】著作权归作者所有，禁止商业用途转载。著作权归作者所有，禁止商业用途转载。【本文首发于唐霜的博客】

int a = 10
string b = a + ''

这样操作是唯一的途径吧。

本文作者：唐霜，转载请注明出处。【关注微信公众号：wwwtangshuangnet】

但是实际上，在运行时，你怎么知道后端接口【未经授权禁止转载】本文作者：唐霜，转载请注明出处。会返回给你什么？大部分情况下，null 【作者：唐霜】【原创不易，请尊重版权】值无法避免。

未经授权，禁止复制转载。【本文受版权保护】【本文受版权保护】【转载请注明来源】

// 用 type 关键字声明和定义类型
type ResponseType = object<{
  int code,
  object data: {
    string name,
    number|null age, // 支持 null
    array<[
      // array 内部可以有多种结构，只要元素满足其中之一，就可以通过类型检查
      object<{
        string name,
        number price,
      }>,
      object<{
        string name,
        int pages,
      }>,
    ]> books,
  },
  ?string error, // ? 开头表示可能不存在，存在的情况下才遵循类型
}>

现在我要使用它：

【原创内容，转载请注明出处】本文版权归作者所有，未经授权不得转载。【本文首发于唐霜的博客】本文版权归作者所有，未经授权不得转载。

fetch('/api').then(res => res.json()).then(string (ResponseType data) => {
  // 如果data的类型检查不通过，直接抛出 TypeError
})

看看函数：

著作权归作者所有，禁止商业用途转载。原创内容，盗版必究。【本文受版权保护】原创内容，盗版必究。

function a(int x, int y) int {
  return x + y
}

object o = {
  a(int x, int y) int {
    return x + y
  },
}

class Some {
  string _name = 'my name'

  static get name() string {
    return this._name
  }
}

// 直接使用原生 function 范型（借鉴 python 的 lambda 表达式）
function<int, int: int> sum(a, b) {
  return a + b
}

// 声明一个函数类型（借鉴 python 的 lambda 表达式）
type func = int, int: int

// 遵循将类型放在变量前面的规则，func 是类型名，sum 是函数（变量）名
func sum(a, b) {
  return a + b
}

再搞一个泛型耍耍。我在这篇文章中已经说过了，泛型，实际上就是函数：

【本文首发于唐霜的博客】本文版权归作者所有，未经授权不得转载。转载请注明出处：www.tangshuang.net本文版权归作者所有，未经授权不得转载。

// 用 <> => 定义泛型，其中 book<a, b> 中的 book 是泛型的名字，<a, b> 是替代符，=> 后面是返回的形式化结果
type book<a, b> => object<{
  a name,
  b price,
}>

怎么用？这样子啊：

原创内容，盗版必究。【转载请注明来源】本文版权归作者所有，未经授权不得转载。

book<string, number> book = {
  name: 'xxx',
  price: 12,
}

看看泛型的演化：

【访问 www.tangshuang.net 获取更多精彩内容】【访问 www.tangshuang.net 获取更多精彩内容】

// 定义一个泛型，泛型的结果是一个 object 描述，（而非一个类型）
type a<x, y> => {
  x a,
  y b,
}

type b<z> => a<z, z> // 直接运行 a<z, z> 将得到的结果作为 b<> 泛型结果

// b<string> 的结果，作为 object<> 的参数
object<b<string>> o = {
  a: 'xxx',
  b: 'yyy',
}

实际上，我不大推崇这种声明，因为通过这样【访问 www.tangshuang.net 获取更多精彩内容】著作权归作者所有，禁止商业用途转载。的声明，我并不能马上看清楚在声明 boo【未经授权禁止转载】未经授权，禁止复制转载。k 这个变量时，它的结构，我更喜欢：

【原创不易，请尊重版权】转载请注明出处：www.tangshuang.net

object<{
  string name,
  number price,
}> book

即使这个时候，我并不给 book 赋值，【本文首发于唐霜的博客】著作权归作者所有，禁止商业用途转载。这样声明 book 这个变量我就知道它的【本文首发于唐霜的博客】【未经授权禁止转载】内部结构是啥。虽然这样我可能需要写很多重本文版权归作者所有，未经授权不得转载。转载请注明出处：www.tangshuang.net复代码，但是相对来说，理解成本更低。

【转载请注明来源】【版权所有】唐霜 www.tangshuang.net【原创内容，转载请注明出处】

当然，在函数上，泛型确实还是有好处：

转载请注明出处：www.tangshuang.net转载请注明出处：www.tangshuang.net

function a(int|string x, int|string y) int|string {
  return x + y
}

这种声明明显不好，因为你怎么知道 x=1【版权所有】唐霜 www.tangshuang.net原创内容，盗版必究。, y=’a’ 【作者：唐霜】【关注微信公众号：wwwtangshuangnet】这种情况不会发生。所以，这种情况，要使用【本文受版权保护】【版权所有，侵权必究】泛型：

【未经授权禁止转载】未经授权，禁止复制转载。

// 通过泛型，实现函数参数和返回值统一类型
type f<T> => T, T: T
f<int|string> a(x, y) {
  return x + y
}

// 或者通过一个匿名的泛型来简化写作
function<(T => T, T: T)<int|string>> a(x, y) {
  return x + y
}

作为一个特殊结构，<> 内是未经授权，禁止复制转载。【本文受版权保护】一个复杂体。因为任何 <> 未经授权，禁止复制转载。【原创不易，请尊重版权】前面的东西，会被认为是一个范型而被运行，未经授权，禁止复制转载。著作权归作者所有，禁止商业用途转载。因此 (T => T, T : T原创内容，盗版必究。本文版权归作者所有，未经授权不得转载。) 将会被作为范型，传入 int|str未经授权，禁止复制转载。【访问 www.tangshuang.net 获取更多精彩内容】ing 运行，得到的结果作为 funct【关注微信公众号：wwwtangshuangnet】【作者：唐霜】ion 范型的参数。

本文作者：唐霜，转载请注明出处。【关注微信公众号：wwwtangshuangnet】【关注微信公众号：wwwtangshuangnet】

type some = function
type some<T> => T, T: T

上面这段代码表示，我们可以直接使用 so【作者：唐霜】【转载请注明来源】me 作为类型，也可以使用 some&l【转载请注明来源】著作权归作者所有，禁止商业用途转载。t;xxx> 作为类型，some 【本文首发于唐霜的博客】【访问 www.tangshuang.net 获取更多精彩内容】既是类型，也是范型。

原创内容，盗版必究。【版权所有，侵权必究】本文作者：唐霜，转载请注明出处。

这一套东西，是在运行时做的，这样的定义，【关注微信公众号：wwwtangshuangnet】【原创内容，转载请注明出处】岂不是爽歪歪。当然，我依靠 tyshemo 还是有可能把这套东西给实现的。对了，有【未经授权禁止转载】【原创内容，转载请注明出处】兴趣可以看下 C# 的类型系统。

【本文受版权保护】【关注微信公众号：wwwtangshuangnet】著作权归作者所有，禁止商业用途转载。【作者：唐霜】