TypeScript开发过程中发现一些问题及解决方案

TypeScript 作为一种强类型的 JavaScript 超集，具有类型检查、代码提示和更好的代码维护等优势。然而，对于初次接触 TypeScript 的开发者来说，可能会面临一些困扰。比如，类型定义，与 JavaScript 库的兼容性，一些高级的 JavaScript 特性（如原型继承、动态类型等）在 TypeScript 中可能会有所限制等一系列问题。本文就 TypeScript 开发常遇到一些问题做一个分享以及它的解决方案。

问题一、类型复用不足

对于经验不足的开发者来说，在开发过程中会出现大量的重复类型定义，这就会降低了我们代码的复用性。

在类型定义的时候我们要先问问自己，如何在 TypeScript 中复用类型？type与interface之间的区别是什么呢？

在 TypeScript 中允许我们使用type和interface来定义类型，type定义的类型可以通过交叉类型（&）来进行复用，而interface定义的类型则可以通过继承（extends）来实现复用。而且，type和interface定义的类型它们之间也可以相互复用。

下面是一些简单的代码示例。

复用 type 定义的类型

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

type Coordinate = Point & {
  z: number;
};

复用 interface 定义的类型

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

interface Coordinate extends Point {
  z: number;
}

interface 复用 type 定义的类型

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

interface Coordinate extends Point {
  z: number;
}

 type 复用 interface 定义的类型

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

type Coordinate = Point & {
  z: number;
};

问题二、复用时只会新增属性的定义

在类型复用时，有时只是简单地为已有类型新增属性，却忽略了更高效的复用方式。

比如说，我们有一个已有的类型Props需要复用，但不需要其中的属性c。在这种情况下，团队成员会重新定义Props1，仅包含Props中的属性a和b，同时添加新属性e。

interface Props {
  a: string;
  b: string;
  c: string;
}

interface Props1 {
  a: string;
  b: string;
  e: string;
}

是不是很繁琐且不高效，实际上，我们可以利用 TypeScript 提供的工具类型Omit来更高效地实现这种复用。

interface Props {
  a: string;
  b: string;
  c: string;
}

interface Props1 extends Omit<Props, 'c'> {
  e: string;
}

同样地，工具类型Pick也可以用于实现此类复用。

interface Props {
  a: string;
  b: string;
  c: string;
}

interface Props1 extends Pick<Props, 'a' | 'b'> {
  e: string;
}

Omit和Pick分别用于排除和选择类型中的属性，具体使用哪一个取决于具体需求。

问题三、未统一使用组件库的基础类型

前端在开发组件库时，经常遇到相似功能组件属性命名不一致的问题，比如，用于表示组件是否显示的属性，可能会被命名为show、open或visible。这样命名不仅影响了组件库的易用性，也降低了它的可维护性。

所以，针对这一问题，我们定义一套统一的基础类型就显得至关重要了。该组件库的基础类型套件为开发提供了坚实的基础，确保了所有组件在命名上的一致性。

我们以表单控件为例，我们就可以定义如下基础类型：

import { CSSProperties } from 'react';

type Size = 'small' | 'middle' | 'large';

type BaseProps<T> = {
  /**
   * 自定义样式类名
   */
  className?: string;
  /**
   * 自定义样式对象
   */
  style?: CSSProperties;
  /**
   * 控制组件是否显示
   */
  visible?: boolean;
  /**
   * 定义组件的大小，可选值为 small（小）、middle（中）或 large（大）
   */
  size?: Size;
  /**
   * 是否禁用组件
   */
  disabled?: boolean;
  /**
   * 组件是否为只读状态
   */
  readOnly?: boolean;
  /**
   * 组件的默认值
   */
  defaultValue?: T;
  /**
   * 组件的当前值
   */
  value?: T;
  /**
   * 当组件值变化时的回调函数
   */
  onChange: (value: T) => void;
}

基于上面基础类型，定义具体组件的属性类型变得简单而直接：

interface WInputProps extends BaseProps<string> {
  /**
   * 输入内容的最大长度
   */
  maxLength?: number;
  /**
   * 是否显示输入内容的计数
   */
  showCount?: boolean;
}

通过使用type关键字定义基础类型，我们可以避免类型被意外修改，进而增强代码的稳定性和可维护性。

问题四、处理含有不同类型元素的数组

有时候在自定义 Hook 时，有些小伙伴倾向于返回对象，即使 Hook 只返回两个值。

当然，这样做并非错误，但是却违背了自定义 Hook 的一个常见规范：即当 Hook 返回两个值时，应使用数组返回。

而且有的童鞋不知道如何定义含有不同类型元素的数组，通常就会选择使用any[]，但这样会带来类型安全问题，因此就选择返回对象。

实际上，元组是处理这种情况的理想选择。通过元组，我们可以在一个数组中包含不同类型的元素，同时保持每个元素类型的明确性。

function useMyHook(): [string, number] {
  return ['示例文本', 42];
}

function MyComponent() {
  const [text, number] = useMyHook();
  console.log(text);  // 输出字符串
  console.log(number);  // 输出数字
  return null;
}

useMyHook函数返回一个明确类型的元组，包含一个string和一个number。在MyComponent组件中使用这个 Hook 时，可以通过解构赋值来获取这两个不同类型的值，同时保持类型安全。

问题五、处理参数数量和类型不固定的函数

有些小伙伴在封装函数时，当函数的参数数量不固定、类型不同或返回值类型不同时，他们更倾向于使用any定义参数和返回值。

通常他们只知道如何定义参数数量固定、类型相同的函数，然而对于一些复杂情况往往不知所措，也不愿意将函数拆分为多个函数。

这正是函数重载发挥作用的场景。通过函数重载，我们可以在同一函数名下定义多个函数实现，根据不同的参数类型、数量或返回类型进行区分。

function query(name: string): string;
function query(age: number): string;
function query(value: any): string {
  if (typeof value === "string") {
    return `Hello, ${value}`;
  } else if (typeof value === "number") {
    return `You are ${value} years old`;
  }
}

代码中，我们为query函数提供了两种调用方式，使得函数使用更加灵活，同时保持类型安全。

对于箭头函数，虽然它们不直接支持函数重载，但我们可以通过定义函数签名的方式来实现类似的效果。

type QueryFunction = {
  (name: string): string;
  (age: number): string;
};

const greet: QueryFunction = (value: any): string => {
  if (typeof value === "string") {
    return `Hello, ${value}`;
  } else if (typeof value === "number") {
    return `You are ${value} years old.`;
  }
  return '';
};

这种方法利用了类型系统来提供编译时的类型检查，模拟了函数重载的效果。

问题六、组件属性的定义是使用 type 还是 interface？

我发现有些小伙伴在定义组件属性时既使用type也使用interface。

虽然两者都可以用于定义组件属性，表面上看没有明显区别。

但由于同名接口会自动合并，而同名类型别名会冲突，所以，我推荐使用interface定义组件属性。这样，使用者可以通过declare module语句自由扩展组件属性，增强了代码的灵活性和可扩展性。

interface UserInfo {
  name: string;
}
interface UserInfo {
  age: number;
}

const userInfo: UserInfo = { name: "张三", age: 23 };

总结

TypeScript 的使用并不困难，关键在于理解和应用其提供的强大功能。在当今的软件开发领域中，TypeScript 已经成为许多开发者的首选语言。尽管初学者可能会觉得它有些复杂，但它实际上为我们带来了许多优势。首先，TypeScript 的类型系统可以帮助我们更早地捕捉到潜在的错误，减少了调试过程中的不确定性。其次，TypeScript 支持面向对象编程的特性，如类、接口和模块，使得代码更加结构化和可维护。此外，借助于类型定义文件，我们可以轻松地与 JavaScript 生态系统集成，并享受到良好的开发工具支持。因此，只要我们认真学和掌握 TypeScript 的基本概念和语法，它并不会给我们带来太多麻烦，反而能够提高我们的开发效率和代码质量。