TypeScript 中的函数重载允许你为一个函数提供多个函数类型定义，以便它可以以不同的方式处理不同的参数类型或参数数量。函数重载可以提高代码的可读性和类型安全性。
在 TypeScript 中实现函数重载的步骤如下：

1. 声明重载签名：首先，你需要声明一个或多个重载签名，这些签名描述了函数可以接受的不同参数类型和返回值类型。这些签名不会包含函数体。
2. 实现签名：然后，你需要提供一个实现签名，这个签名必须与所有的重载签名兼容。实现签名包含了函数的实际逻辑。
3. 调用函数：在调用函数时，TypeScript 编译器会根据提供的参数类型来检查哪个重载签名与之匹配，并应用相应的类型检查。
   下面是一个简单的函数重载示例：

// 重载签名
function makeDate(timestamp: number): Date;
function makeDate(m: number, d: number, y: number): Date;
function makeDate(mOrTimestamp: number, d?: number, y?: number): Date {
    if (d !== undefined && y !== undefined) {
        return new Date(y, mOrTimestamp - 1, d);
    } else {
        return new Date(mOrTimestamp);
    }
}
const d1 = makeDate(12345678);
const d2 = makeDate(5, 5, 5);
// const d3 = makeDate(1, 3);  // Error: No matching overload calls.

在这个例子中，makeDate 函数有两个重载签名：一个接受一个 number 类型的参数，另一个接受三个 number 类型的参数。实现签名接受一个必选的 number 参数和两个可选的 number 参数，并根据这些参数来创建一个 Date 对象。
函数重载的主要优点是它可以提供更精确的类型检查和更好的代码组织。然而，它也增加了代码的复杂性，因此应该谨慎使用。在许多情况下，使用泛型或联合类型可能会是更简单的解决方案。

替换方案

在 TypeScript 中，由于 JavaScript 的运行时不会保留函数的重载信息，因此编译器仅在编译阶段使用函数重载。到达运行时后，所有的重载都合并为单个函数实现。在某些情况下，开发者可能希望通过泛型或联合类型来达到与函数重载相似的效果，以下是一些替代函数重载的方法：

使用泛型

泛型允许你定义一个通用的函数，它可以在多种类型的数据上工作，而无需为每种类型写一个重载签名。

function identity<T>(arg: T): T {
    return arg;
}

let output1 = identity<string>("Hello World");  // 类型为 string
let output2 = identity<number>(2048);           // 类型为 number

在这个例子中，identity 函数使用了一个泛型参数 T，这样它就可以接受任何类型的参数并返回相同类型的值，从而避免了为每种类型定义一个重载。

使用联合类型

联合类型允许你定义一个函数，该函数可以接收多种类型的参数。

function createPerson(name: string): Person;
function createPerson(name: string, age: number): Person {
  // 实现细节...
}

// 可以替换为：

type Person = {
  name: string;
  age?: number;
};

function createPerson(name: string, age?: number): Person {
  // 实现细节...
}

在这个例子中，我们定义了一个 Person 类型，它具有一个必需的 name 属性，而 age 属性是可选的。createPerson 函数现在接受一个必需的 name 参数和一个可选的 age 参数，这使得它可以用与重载相同的方式调用。

使用类型断言

类型断言可以用来告诉 TypeScript 编译器，某个参数是特定的类型。

function calculate(a: number, b: number): number;
function calculate(a: string, b: string): string;
function calculate(a: any, b: any): any {
  // 实现细节...
}

// 使用类型断言来指定参数的类型
let result = calculate(1, 2);  // 断言参数为 number 类型
let result2 = calculate("hello" as string, "world" as string);  // 断言参数为 string 类型

使用类型守卫

类型守卫可以用来在运行时检查参数的类型，从而决定执行哪个逻辑分支。

function executeCommand(command: string | { type: string, payload: any }): void {
  if (typeof command === "string") {
    // 命令是字符串类型
  } else {
    // 命令是复杂对象类型
  }
}

在这个例子中，我们检查 command 参数是否为 string 类型，以此来决定执行哪个分支的代码。

使用函数参数的默认值

函数参数的默认值可以提供一种灵活的方式来处理不同数量的参数。

function combineValues(...values: any[]): any[] {
  return values;
}

// 这可以代替多个重载，例如：
// function combineValues(a: number, b: number): number[];
// function combineValues(a: string, b: string, c: string): string[];

使用泛型、联合类型、类型断言、类型守卫或函数参数的默认值，你可以在不使用函数重载的情况下编写灵活且类型安全的代码。这些方法在很多情况下可以替代函数重载，同时保持代码的可读性和类型安全性。