【TypeScript】不想用是因为你不知道这些好处

前言

最近，团队在开发组件库时，部分成员对使用TypeScript抱怨频繁，表示“TypeScript太麻烦了，我们不想用！”于是我进行了代码审查，发现了许多重复的类型定义，导致代码复用性下降。进一步交流后发现，很多人并不清楚如何在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，可以使用 TypeScript 提供的工具类型 Omit 更高效地实现：

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

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

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分别用于排除和选择类型中的属性，具体使用哪一个取决于具体需求。

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

😊在开发组件库时，我们为解决相似功能组件属性命名不一致的问题，可以采用定义一套统一的基础类型的方法。这样可确保所有组件在命名上的一致性，提高组件库的易用性和可维护性。

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

interface InputProps {
    value: string;
    onChange: (value: string) => void;
}

interface CheckboxProps {
    checked: boolean;
    onChange: (checked: boolean) => void;
}

interface ButtonProps {
    text: string;
    onClick: () => void;
}
interface InputProps {
    value: string;
    onChange: (value: string) => void;
}

interface CheckboxProps {
    checked: boolean;
    onChange: (checked: boolean) => void;
}

interface ButtonProps {
    text: string;
    onClick: () => void;
}

​
👨‍💻以上是基础类型的定义，接下来，我们只需要在定义具体组件时引用这些基础类型，并依照业务需求进行属性的扩展即可。这样做不仅使属性的命名更加清晰明了，也提高了代码的可读性和可维护性。

😊通过使用type关键字定义基础类型，我们还可以避免类型被意外修改。一旦定义好基础类型，所有引用该类型的代码都将具备同样的属性结构，从而增强代码的稳定性和可维护性。

👍在项目实践中，统一组件属性命名已经成为了一种主流的规范化开发方法。部分企业甚至会在内部开发平台上推行使用统一基础类型的方式。因此，学习和掌握这种规范化开发技巧，对于每一个前端开发者而言都非常重要。
在开发组件库时，我们经常面临相似功能组件属性命名不一致的问题，例如，用于表示组件是否显示的属性，可能会被命名为show、open或visible。这不仅影响了组件库的易用性，也降低了其可维护性。

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

在软件开发中，尤其是在审查自定义Hook时，如何处理返回值是至关重要的一环。有时团队成员可能犯一些常见错误，比如倾向于返回对象而不是数组，尤其是当Hook只需要返回两个不同类型的值时。

团队成员可能选择返回对象是因为对象可以容纳不同类型的值，但这会导致代码冗余和类型安全问题。这时候，元组可以成为一个更好的选择。通过使用元组，我们可以清晰明了地定义一个包含不同类型元素的数组。

举个例子，假设我们需要一个自定义Hook来返回一个字符串和一个数字。通过使用元组，我们可以明确声明返回值的类型为 [string, number]，使得代码更加清晰简洁。

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

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

在这个简单的例子中，我们展示了如何使用元组来优化自定义Hook的返回值。在实际开发中，采用元组可以帮助我们更好地处理不同类型元素的数组，同时保持代码的可读性和类型安全性。

标签：#数组元组 #元组应用 #开发规范 #类型安全 #Hook最佳实践

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

在软件开发中，处理参数数量和类型不固定的函数是一项常见而又挑战性的任务。审查团队成员封装的函数时，你发现他们倾向于使用any定义参数和返回值。这种做法虽然看似简单，但却带来了代码类型不安全、可读性差等问题。

😕 他们解释说，他们只知道如何定义参数数量固定、类型相同的函数，对于复杂情况则不知所措，而且不愿意将函数拆分为多个函数。这种情况下，函数重载可以成为你的得力助手。

在JavaScript中，函数重载通过在同一函数名下定义多个函数实现，根据不同的参数类型、数量或返回类型进行区分。比如，在下面这个例子中，我们为greet函数提供了两种调用方式，使得函数使用更加灵活，同时保持类型安全。

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

🤖 对于箭头函数，虽然它们不直接支持函数重载，但我们可以通过定义函数签名的方式来实现类似的效果。比如下面这段代码：

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

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

这种方法利用了类型系统来提供编译时的类型检查，模拟了函数重载的效果。通过合理运用函数重载，你可以使代码更加灵活、可读性更高，提升代码质量。

标签：函数重载 JavaScript 编程技巧 参数类型 JavaScript技巧%!(EXTRA string=)

六、组件属性定义：使用type还是interface？

🌟 在 TypeScript 中，我们经常需要定义组件的属性类型。但是，在团队协作中，你可能会发现有些成员使用 type 定义组件属性，而有些人则使用 interface。

👉 这个问题让我们不禁思考：在 TypeScript 中，应该使用 type 还是 interface 来定义组件属性呢？两者之间到底有什么区别呢？

🤔 首先，让我们来看一下这两种语法。

💡 type 是类型别名的关键字，它通常用于给一个复杂类型起个“简短”的别名。例如，我们可以使用 type 关键字定义如下类型别名：

type User = {
  name: string;
  age: number;
}

💡 interface 是接口的关键字，它通常用于描述对象的形状。例如，我们可以使用 interface 关键字定义如下接口：

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

👉 在定义组件属性时，两者有一个显著的区别：同名接口会自动合并，而同名类型别名会冲突。

👉 比如，我们定义了两个同名接口 UserInfo：

interface UserInfo {
  name: string;
}

interface UserInfo {
  age: number;
}

👉 这两个接口会被自动合并成一个 UserInfo 接口，其类型为：

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

👉 而如果我们将一个接口改为类型别名，那么就会冲突报错：

type UserInfo = {
  name: string;
}

type UserInfo = {
  age: number;
}
// Error: Duplicate identifier 'UserInfo'

👉 因此，我推荐大家在定义组件属性时，使用 interface 关键字。这样，使用者可以通过 declare module 语句自由扩展组件属性，增强了代码的灵活性和可扩展性。

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

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

结语

🎉 最后，希望以上内容能够对你在 TypeScript 开发中的组件属性定义有所启发。如果你在使用 TypeScript 的过程中遇到困难，也欢迎在评论区留言，让我们共同解决这些挑战！

标签：#TypeScript #组件属性 #接口 #类型别名 #declare module