TypeScript 中提高幸福感的 10 个高级技巧

用了一年时间的 TypeScript 了，项目中用到的技术是 Vue + TypeScript 的，深感中大型项目中 TypeScript 的必要性，特别是生命周期比较长的大型项目中更应该使用 TypeScript。

如下是我在工做中总结到的常常会用到的 TypeScript 技巧。

1. 注释

经过 /** */ 形式的注释能够给 TS 类型作标记提示，编辑器会有更好的提示：

/** This is a cool guy. */
interface Person {
  /** This is name. */
  name: string,
}

const p: Person = {
    name: 'cool'
}

若是想给某个属性添加注释说明或者友好提示，这种是很好的方式了。

2. 接口继承

和类同样，接口也能够相互继承。

这让咱们可以从一个接口里复制成员到另外一个接口里，能够更灵活地将接口分割到可重用的模块里。

interface Shape {
    color: string;
}

interface Square extends Shape {
    sideLength: number;
}

let square = <Square>{};
square.color = "blue";
square.sideLength = 10;

一个接口能够继承多个接口，建立出多个接口的合成接口。

interface Shape {
    color: string;
}

interface PenStroke {
    penWidth: number;
}

interface Square extends Shape, PenStroke {
    sideLength: number;
}

let square = <Square>{};
square.color = "blue";
square.sideLength = 10;
square.penWidth = 5.0;

3. interface & type

TypeScript 中定义类型的两种方式：接口（interface）和 类型别名（type alias）。

好比下面的 Interface 和 Type alias 的例子中，除了语法，意思是同样的：

Interface

interface Point {
  x: number;
  y: number;
}

interface SetPoint {
  (x: number, y: number): void;
}

Type alias

type Point = {
  x: number;
  y: number;
};

type SetPoint = (x: number, y: number) => void;

---

并且二者均可以扩展，可是语法有所不一样。此外，请注意，接口和类型别名不是互斥的。接口能够扩展类型别名，反之亦然。

Interface extends interface

interface PartialPointX { x: number; }
interface Point extends PartialPointX { y: number; }

Type alias extends type alias

type PartialPointX = { x: number; };
type Point = PartialPointX & { y: number; };

Interface extends type alias

type PartialPointX = { x: number; };
interface Point extends PartialPointX { y: number; }

Type alias extends interface

interface PartialPointX { x: number; }
type Point = PartialPointX & { y: number; };

---

它们的差异能够看下面这图或者看 TypeScript: Interfaces vs Types。

因此檙想巧用 interface & type 仍是不简单的。

若是不知道用什么，记住：能用 interface 实现，就用 interface , 若是不能就用 type 。

4. typeof

typeof 操做符能够用来获取一个变量或对象的类型。

咱们通常先定义类型，再使用：

interface Opt {
  timeout: number
}
const defaultOption: Opt = {
  timeout: 500
}

有时候能够反过来：

const defaultOption = {
  timeout: 500
}
type Opt = typeof defaultOption

当一个 interface 总有一个字面量初始值时，能够考虑这种写法以减小重复代码，至少减小了两行代码是吧，哈哈~

5. keyof

TypeScript 容许咱们遍历某种类型的属性，并经过 keyof 操做符提取其属性的名称。

keyof 操做符是在 TypeScript 2.1 版本引入的，该操做符能够用于获取某种类型的全部键，其返回类型是联合类型。

keyof 与 Object.keys 略有类似，只不过 keyof 取 interface 的键。

const persion = {
  age: 3,
  text: 'hello world'
}

// type keys = "age" | "text"
type keys = keyof Point;

写一个方法获取对象里面的属性值时，通常人可能会这么写

function get1(o: object, name: string) {
  return o[name];
}

const age1 = get1(persion, 'age');
const text1 = get1(persion, 'text');

可是会提示报错

由于 object 里面没有事先声明的 key。

固然若是把 o: object 修改成 o: any 就不会报错了，可是获取到的值就没有类型了，也变成 any 了。

这时可使用 keyof 来增强 get 函数的类型功能，有兴趣的同窗能够看看 _.get 的 type 标记以及实现

function get<T extends object, K extends keyof T>(o: T, name: K): T[K] {
  return o[name]
}

6. 查找类型

interface Person {
    addr: {
        city: string,
        street: string,
        num: number,
    }
}

当须要使用 addr 的类型时，除了把类型提出来

interface Address {
    city: string,
    street: string,
    num: number,
}

interface Person {
    addr: Address,
}

还能够

Person["addr"] // This is Address.

好比：

const addr: Person["addr"] = {
    city: 'string',
    street: 'string',
    num: 2
}

有些场合后者会让代码更整洁、易读。

7. 查找类型 + 泛型 + keyof

泛型（Generics）是指在定义函数、接口或类的时候，不预先指定具体的类型，而在使用的时候再指定类型的一种特性。

interface API {
    '/user': { name: string },
    '/menu': { foods: string[] }
}
const get = <URL extends keyof API>(url: URL): Promise<API[URL]> => {
    return fetch(url).then(res => res.json());
}

get('');
get('/menu').then(user => user.foods);

8. 类型断言

Vue 组件里面常常会用到 ref 来获取子组件的属性或者方法，可是每每都推断不出来有啥属性与方法，还会报错。

子组件：

<script lang="ts">
import { Options, Vue } from "vue-class-component";

@Options({
  props: {
    msg: String,
  },
})
export default class HelloWorld extends Vue {
  msg!: string;
}
</script>

父组件：

<template>
  <div class="home">
    <HelloWorld
      ref="helloRef"
      msg="Welcome to Your Vue.js + TypeScript App"
    />
  </div>
</template>

<script lang="ts">
import { Options, Vue } from "vue-class-component";
import HelloWorld from "@/components/HelloWorld.vue"; // @ is an alias to /src

@Options({
  components: {
    HelloWorld,
  },
})
export default class Home extends Vue {
  print() {
    const helloRef = this.$refs.helloRef;
    console.log("helloRef.msg: ", helloRef.msg); 
  }

  mounted() {
    this.print();
  }
}
</script>

由于 this.$refs.helloRef 是未知的类型，会报错误提示：

作个类型断言便可：

print() {
    // const helloRef = this.$refs.helloRef;
    const helloRef = this.$refs.helloRef as any;
    console.log("helloRef.msg: ", helloRef.msg); // helloRef.msg:  Welcome to Your Vue.js + TypeScript App
  }

可是类型断言为 any 时是很差的，若是知道具体的类型，写具体的类型才好，否则引入 TypeScript 冒似没什么意义了。

9. 显式泛型

$('button') 是个 DOM 元素选择器，但是返回值的类型是运行时才能肯定的，除了返回 any ，还能够

function $<T extends HTMLElement>(id: string): T {
    return (document.getElementById(id)) as T;
}

// 不肯定 input 的类型
// const input = $('input');

// Tell me what element it is.
const input = $<HTMLInputElement>('input');
console.log('input.value: ', input.value);

函数泛型不必定非得自动推导出类型，有时候显式指定类型就好。

10. DeepReadonly

被 readonly 标记的属性只能在声明时或类的构造函数中赋值。

以后将不可改（即只读属性），不然会抛出 TS2540 错误。

与 ES6 中的 const 很类似，但 readonly 只能用在类（TS 里也能够是接口）中的属性上，至关于一个只有 getter 没有 setter 的属性的语法糖。

下面实现一个深度声明 readonly 的类型：

type DeepReadonly<T> = {
  readonly [P in keyof T]: DeepReadonly<T[P]>;
}

const a = { foo: { bar: 22 } }
const b = a as DeepReadonly<typeof a>
b.foo.bar = 33 // Cannot assign to 'bar' because it is a read-only property.ts(2540)

最后

大佬们，以为有用就赞一个呗。

挺久没写原创技术文章了，做为 2021 第一篇原创技术文章，质量应该还能够吧 😅

笔者的年终总结在这里： 前端工程师的 2020 年终总结 - 乾坤未定，你我皆黑马，但愿能带给你一点启发。

参考文章：

• TypeScript 高级技巧
• 巧用 Typescript
• 巧用 Typescript (二)
• 接口

推荐阅读

• 前端工程师的 2019 年终总结 - 当勤精进，但念无常
• 前端工程师的 2018 年终总结 - 个人本命年