经验首页 前端设计 程序设计 Java相关 移动开发 数据库/运维 软件/图像 大数据/云计算 其他经验
当前位置：技术经验 » JSJS库框架 » JavaScript » 查看文章
如何编写 Typescript 声明文件
来源：cnblogs　　作者：贾顺名　　时间：2018/10/16 9:29:36　　对本文有异议

使用TypeScript已经有了一段时间，这的确是一个好东西，虽说在使用的过程中也发现了一些bug，不过都是些小问题，所以整体体验还是很不错的。

TypeScript之所以叫Type，和它的强类型是分不开的，这也是区别于JavaScript最关键的一点，类型的声明可以直接写在代码中，也可以单独写一个用来表示类型的描述文件*.d.ts。

常用方式

首先在d.ts中是不会存在有一些简单的基本类型定义的（因为这些都是写在表达式、变量后边的，在这里定义没有任何意义），声明文件中定义的往往都是一些复杂结构的类型。

大部分语法都与写在普通ts文件中的语法一致，也是export后边跟上要导出的成员。

最简单的就是使用type关键字来定义：

  1. type A = {                 // 定义复杂结构
  2.   b: number
  3.   c: string
  4. }
  5.  
  6. type Func = () => number   // 定义函数
  7.  
  8. type Key = number | string // 多个类型

组合类型

以及在TypeScript中有着很轻松的方式针对type进行复用，比如我们有一个Animal类型，以及一个Dog类型，可以使用&来进行复用。

P.S> &符号可以拼接多个

  1. type Animal = {
  2.   weight: number
  3.   height: number
  4. }
  5.  
  6. type Dog = Animal & {
  7.   leg: number
  8. }

动态的 JSON 类型指定

如果我们有一个JSON结构，而它的key是动态的，那么我们肯定不能将所有的key都写在代码中，我们只需要简单的指定一个通配符即可：

  1. type info = {
  2.   [k: string]: string | number // 可以指定多个类型
  3. }
  4.  
  5. const infos: info = {
  6.   a: 1,
  7.   b: '2',
  8.   c: true, // error 类型不匹配
  9. }

以及在新的版本中更推荐使用内置函数Record来实现：

  1. const infos: Record<string, string | number> = {
  2.   a: 1,
  3.   b: '2',
  4.   c: true, // error
  5. }

获取变量的类型

假如我们有一个JSON对象，里边包含了name、age两个属性，我们可以通过一些TypeScript内置的工具函数来实现一些有意思的事情。

通过keyof与typeof组合可以得到我们想要的结果：

  1. const obj = {
  2.   name: 'Niko',
  3.   age: 18
  4. }
  5.  
  6. // 如果是这样的取值，只能写在代码中，不能写在 d.ts 文件中，因为声明文件里边不能存在实际有效的代码
  7. type keys = keyof typeof obj
  8.  
  9. let a: keys = 'name' // pass
  10. let b: keys = 'age'  // pass
  11.  
  12. let c: keys = 'test' // error

而如果我们想要将一个类型不统一的JSON修改为统一类型的JSON也可以使用这种方式：

  1. const obj = {
  2.   name: 'Niko',
  3.   age: 18,
  4.   birthday: new Date()
  5. }
  6.  
  7. const infos: Record<keyof typeof obj, string> = {
  8.   name: '',
  9.   age: '',
  10.   birthday: 123, // 出错，提示类型不匹配
  11.   test: '', // 提示不是`info`的已知类型
  12. }

获取函数的返回值类型

又比如说我们有一个函数，函数会返回一个JSON，而我们需要这个JSON来作为类型。

那么可以通过ReturnType<>来实现：

  1. function func () {
  2.   return {
  3.     name: 'Niko',
  4.     age: 18
  5.   }
  6. }
  7.  
  8. type results = ReturnType<typeof func>
  9.  
  10. // 或者也可以拼接 keyof 获取所有的 key
  11. type resultKeys = keyof ReturnType<typeof func>
  12.  
  13. // 亦或者可以放在`Object`中作为动态的`key`存在
  14. type infoJson = Record<keyof ReturnType<typeof func>, string>

在代码中声明函数和class类型

因为我们知道函数和class在创建的时候是都有实际的代码的（函数体、构造函数）。
但是我们是写在d.ts声明文件中的，这只是一个针对类型的约束，所以肯定是不会存在真实的代码的，但是如果在普通的ts文件中这么写会出错的，所以针对这类情况，我们需要使用declare关键字，表示我们这里就是用来定义一个类型的，而非是一个对象、函数：

  1. class Personal {
  2.   name: string
  3.   // ^ 出错了，提示`name`必须显式的进行初始化
  4. }
  5.  
  6. function getName (personal: Personal): name
  7. // ^ 出错了，提示函数缺失实现

以下为正确的使用方式：

  1. -declare class Personal {
  2. +declare class Personal {
  3.   name: string
  4. }
  5.  
  6. -function getName (personal: Personal): name
  7. +declare function getName (personal: Personal): name

当然了，一般情况下是不建议这么定义class的，应该使用interface来代替它，这样的class应该仅存在于针对非TS模块的描述，如果是自己开发的模块，那么本身结构就具有声明类型的特性。

函数重载

这个概念是在一些强类型语言中才有的，依托于TypeScript，这也算是一门强类型语言了，所以就会有需要用到这种声明的地方。

例如我们有一个add函数，它可以接收string类型的参数进行拼接，也可以接收number类型的参数进行相加。

需要注意的是，只有在做第三方插件的函数重载定义时能够放到d.ts文件中，其他环境下建议将函数的定义与实现放在一起（虽说配置paths也能够实现分开处理，但是那样就失去了对函数创建时的约束）

  1. // index.ts
  2.  
  3. // 上边是声明
  4. function add (arg1: string, arg2: string): string
  5. function add (arg1: number, arg2: number): number
  6. // 因为我们在下边有具体函数的实现，所以这里并不需要添加 declare 关键字
  7.  
  8. // 下边是实现
  9. function add (arg1: string | number, arg2: string | number) {
  10.   // 在实现上我们要注意严格判断两个参数的类型是否相等，而不能简单的写一个 arg1 + arg2
  11.   if (typeof arg1 === 'string' && typeof arg2 === 'string') {
  12.     return arg1 + arg2
  13.   } else if (typeof arg1 === 'number' && typeof arg2 === 'number') {
  14.     return arg1 + arg2
  15.   }
  16. }

TypeScript 中的函数重载也只是多个函数的声明，具体的逻辑还需要自己去写，他并不会真的将你的多个重名 function 的函数体进行合并

多个函数的顺序问题

想象一下，如果我们有一个函数，传入Date类型的参数，返回其unix时间戳，如果传入Object，则将对象的具体类型进行toString输出，其余情况则直接返回，这样的一个函数应该怎么写？

仅做示例演示，一般正常人不会写出这样的函数...

  1. function build (arg: any) {
  2.   if (arg instanceof Date) {
  3.     return arg.valueOf()
  4.   } else if (typeof arg === 'object') {
  5.     return Object.prototype.toString.call(arg)
  6.   } else {
  7.     return arg
  8.   }
  9. }

但是这样的函数重载在声明的顺序上就很有讲究了，一定要将精确性高的放在前边：

  1. // 这样是一个错误的示例，因为无论怎样调用，返回值都会是`any`类型
  2. function build(arg: any): any
  3. function build(arg: Object): string
  4. function build(arg: Date): number

因为TypeScript在查找到一个函数重载的声明以后就会停止不会继续查找，any是一个最模糊的范围，而Object又是包含Date的，所以我们应该按照顺序从小到大进行排列：

  1. function build(arg: Date): number
  2. function build(arg: Object): string
  3. function build(arg: any): any
  4.  
  5. // 这样在使用的时候才能得到正确的类型提示
  6. const res1 = build(new Date()) // number
  7. const res2 = build(() => { })  // string
  8. const res3 = build(true)       // any

一些不需要函数重载的场景

函数重载的意义在于能够让你知道传入不同的参数得到不同的结果，如果传入的参数不同，但是得到的结果（类型）却相同，那么这里就不要使用函数重载（没有意义）。

如果函数的返回值类型相同，那么就不需要使用函数重载

  1. function func (a: number): number
  2. function func (a: number, b: number): number
  3.  
  4. // 像这样的是参数个数的区别，我们可以使用可选参数来代替函数重载的定义
  5. function func (a: number, b?: number): number
  6. // 注意第二个参数在类型前边多了一个`?`
  7.  
  8. // 亦或是一些参数类型的区别导致的
  9. function func (a: number): number
  10. function func (a: string): number
  11.  
  12. // 这时我们应该使用联合类型来代替函数重载
  13. function func (a: number | string): number

Interface

interface是在TypeScript中独有的，在JavaScript并没有interface一说。
因为interface只是用来规定实现它的class对应的行为，没有任何实质的代码，对于脚本语言来说这是一个无效的操作

在语法上与class并没有什么太大的区别，但是在interface中只能够进行成员属性的声明，例如function只能够写具体接收的参数以及返回值的类型，并不能够在interface中编写具体的函数体，同样的，针对成员属性也不能够直接在interface中进行赋值：

  1. // 这是一个错误的示例
  2. interface PersonalIntl {
  3.   name: string = 'Niko'
  4.  
  5.   sayHi (): string {
  6.     return this.name
  7.   }
  8. }
  9.  
  10. // 在 interface 中只能存在类型声明
  11. interface PersonalIntl {
  12.   name: string
  13.  
  14.   sayHi (): string
  15. }

其实在一些情况下使用interface与普通的type定义也没有什么区别。
比如我们要导出一个存在name和age两个属性的对象：

  1. // types/personal.d.ts
  2. export interface PersonalIntl {
  3.   name: string
  4.   age:  number
  5. }
  6.  
  7. // index.d.ts
  8. import { PersonalIntl } from './types/personal'
  9.  
  10. const personal: PersonalIntl = {
  11.   name: 'Niko',
  12.   age:  18,
  13. }

如果将interface换成type定义也是完全没问题的：

  1. // types/personal.d.ts
  2. export type PersonalIntl = {
  3.   name: string
  4.   age:  number
  5. }

这样的定义在基于上边的使用是完全没有问题的，但是这样也仅仅适用于Object字面量的声明，没有办法很好的约束class模式下的使用，所以我们采用interface来约束class的实现：

  1. import { PersonalIntl } from './types/personal'
  2.  
  3. class Personal implements PersonalIntl {
  4.   constructor(public name: string, public age: number) { }
  5.  
  6.   // 上边的简写与下述代码效果一致
  7.  
  8.   public name: string
  9.   public age: number
  10.  
  11.   constructor (name: string, age: number) {
  12.     this.name = name
  13.     this.age = age
  14.   }
  15. }
  16.  
  17. const personal = new Personal('niko', 18)

关于函数成员声明的一些疑惑

首先，在接口中有两种方式可以定义一个函数，一个被定义在实例上，一个被定义在原型链上。
两种声明方式如下：

  1. interface PersonalIntl {
  2.   func1 (): any      // 实例属性
  3.  
  4.   func2: () => any   // 原型链属性
  5. }

但是我们在实现这两个属性时其实是可以互相转换的，并没有强要求必须使用哪种方式：

  1. class Personal implements PersonalIntl {
  2.   func1 () {
  3.     console.log(this)
  4.   }
  5.  
  6.   func2 = () => {
  7.     console.log(this)
  8.   }
  9. }

其实这两者在编译后的JavaScript代码中是有区别的，并不清楚这是一个bug还是设计就是如此，类似这样的结构：

  1. var Personal = /** @class */ (function () {
  2.     function Personal() {
  3.         var _this = this;
  4.         this.func2 = function () {
  5.             console.log(_this);
  6.         };
  7.     }
  8.     Personal.prototype.func1 = function () {
  9.         console.log(this);
  10.     };
  11.     return Personal;
  12. }());

所以在使用的时候还是建议最好按照interface定义的方式来创建，避免一些可能存在的奇奇怪怪的问题。

接口声明的自动合并

因为interface是TypeScript特有的，所以也会有一些有意思的特性，比如相同命名的interface会被自动合并：

  1. interface PersonalIntl {
  2.   name: string
  3. }
  4.  
  5. interface PersonalIntl {
  6.   age: number
  7. }
  8.  
  9. class Personal implements PersonalIntl {
  10.   name = 'Niko'
  11.   age = 18
  12. }

不要在 interface 中使用函数重载

在interface中使用函数重载，你会得到一个错误的结果，还是拿上边的build函数来说，如果在interface中声明，然后在class中实现，那么无论怎样调用，返回值的类型都会认为是any。

所以正确的做法是在class中声明重载，在class中实现，interface中最多只定义一个any，而非三个重载。

  1. class Util implements UtilIntl {
  2.   build(arg: Date): number
  3.   build(arg: Object): string
  4.   build(arg: any): any
  5.  
  6.   build(arg: any) {
  7.     if (arg instanceof Date) {
  8.       return arg.valueOf()
  9.     } else if (typeof arg === 'object') {
  10.       return Object.prototype.toString.call(arg)
  11.     } else {
  12.       return arg
  13.     }
  14.   }
  15. }

小结

有关TypeScript声明类型声明相关的目前就总结了这些比较常用的，欢迎小伙伴们进行补充。

在之前的版本中有存在module和namespace的定义，但是目前来看，好像更推荐使用 ES-Modules 版本的 import/export来实现类似的功能，而非自定义的语法，所以就略过了这两个关键字相关的描述

官方文档中有针对如何编写声明文件的模版，可以参考：传送阵

参考资料

 友情链接：直通硅谷 　点职佳 　北美留学生论坛

JavaScript热门文章

  • echarts 饼图 + 全屏显示
  • js正则匹配以{开头,以}结尾的表达式怎么写？-附源码
  • echarts 实现数据(tooltip)自动轮播插件
  • Js设置博客园主题色(theme-color)
  • elementUI 设置input的只读或禁用的方法
  • 超级好用的流程图js框架 值得收藏
  • layui table+复杂表头+合并单元格
  • 获取地理位置
  • 如何使用JavaScript导入和导出Excel文件
  • WebStorm eslint插件报错解决 - TypeError: this.CliEngine is not a constructor

    • JavaScript推荐文章

  • 一些八股：1.fetch 的理解。2.let、const、var
  • 电子表格转身购物车：三步轻松实现
  • Canvas简历编辑器-图形绘制与状态管理(轻量级DOM)
  • IntersectionObserver + scrollIntoView 实现电梯导航 - xingba-coder
  • 可视化—gojs 超多超实用经验分享(三)
  • PixiJS源码分析系列： 第一章 从最简单的例子入手
  • WebRTC入门
  • 前端 Array.sort() 源码学习
  • 【技巧】JS代码这么写，前端小姐姐都会爱上你
  • 【JS】await异常捕获，这样做才完美

    • 本站QQ群：前端 618073944 | Java 606181507 | Python 626812652 | C/C++ 612253063 | 微信 634508462 | 苹果 692586424 | C#/.net 182808419 | PHP 305140648 | 运维 608723728

    W3xue 的所有内容仅供测试，对任何法律问题及风险不承担任何责任。通过使用本站内容随之而来的风险与本站无关。
    关于我们  |  意见建议  |  捐助我们  |  报错有奖  |  广告合作、友情链接（目前9元/月）请联系QQ：27243702 沸活量
    皖ICP备17017327号-2　皖公网安备34020702000426号