函数

函数在 TypeScript 中是一种可以调用的对象，并且它们可以具有参数和返回值。TypeScript 为 JavaScript 的函数增加了额外的特性，包括类型检查和更丰富的功能。

• 函数类型：TypeScript 允许你指定函数的参数类型和返回值类型。

  • 示例：

    function add(x: number, y: number): number {
      return x + y;
    }
    

• 可选参数与默认参数：可以定义函数参数为可选的，或者提供一个默认值。

  • 可选参数示例：

    function buildName(firstName: string, lastName?: string) {
      if (lastName) return firstName + " " + lastName;
      else return firstName;
    }
    

  • 默认参数示例：

    function buildName(firstName: string, lastName = "Smith") {
      return firstName + " " + lastName;
    }
    

• 剩余参数：当你想要一个函数接受多个参数作为数组时，可以使用剩余参数（...）。

  • 示例：

    function buildName(firstName: string, ...restOfName: string[]) {
      return firstName + " " + restOfName.join(" ");
    }
    

• this 和箭头函数：TypeScript 能够识别箭头函数自动绑定this的行为。

  • 示例：

    const myObject = {
      name: "Happy Object",
      sayLater: function () {
        setTimeout(() => {
          console.log(this.name); // 正确地引用了myObject中的name属性
        }, 1000);
      },
    };
    

• 重载：TypeScript 允许函数根据传入不同的参数而有不同的类型签名。

  • 示例：

    function pickCard(x: { suit: string; card: number }[]): number;
    function pickCard(x: number): { suit: string; card: number };
    function pickCard(x): any {
      // 实现函数体...
    }
    

• 泛型函数：可以创建适用于任何类型的组件。

  • 示例：

    function identity<T>(arg: T): T {
      return arg;
    }
    let output = identity<string>("myString");
    

通过使用 TypeScript 的这些功能，你可以编写出更加严谨、易于维护的代码，因为编译器会帮助你捕捉类型相关的错误。

函数

在 TypeScript 中，函数是执行特定任务或计算并返回结果的代码块。TypeScript 为 JavaScript 函数提供了额外的功能和更严格的类型检查，使得开发过程中能够更清晰地定义函数的输入和输出类型。这有助于避免许多常见的错误，并提高代码的可维护性和可读性。

• 参数和返回值类型注解：在 TypeScript 中，你可以为函数的参数和返回值指定类型。这确保了函数接收到正确类型的参数，并且按照预期返回正确类型的结果。

  • 示例：

    function add(a: number, b: number): number {
      return a + b;
    }
    

    这个例子中，add函数接收两个类型为number的参数，并返回一个number类型的结果。

• 可选参数和默认参数：TypeScript 允许你指定函数参数为可选的，或者给参数一个默认值。

  • 示例：

    function greet(name: string, greeting: string = "Hello"): string {
      return `${greeting}, ${name}!`;
    }
    

    在这个例子中，greet函数有一个默认参数greeting。调用时如果不提供第二个参数，它将默认使用"Hello"作为问候语。

• 剩余参数（Rest Parameters）：当你想要一个函数接受任意数量的参数时，可以使用剩余参数。

  • 示例：

    function buildName(firstName: string, ...restOfName: string[]): string {
      return firstName + " " + restOfName.join(" ");
    }
    

    这里buildName函数接受一个firstName和任意数量的其他名字部分，然后将它们组合成一个完整的名字。

• 函数重载：TypeScript 允许为同一个函数定义多个调用签名，这被称为函数重载。通过这种方式，你可以精确地指定输入类型与对应的返回类型。

  • 示例：

    function getInfo(name: string): string;
    function getInfo(age: number): string;
    function getInfo(value: string | number): string {
      if (typeof value === "string") {
        return `My name is ${value}.`;
      } else {
        return `I am ${value} years old.`;
      }
    }
    

    在这个例子中，根据getInfo函数接收到的参数类型不同（字符串或数字），它会返回不同格式的信息。

通过上述示例，你可以看出 TypeScript 在处理函数方面提供了很多强大的特性，帮助开发者以类型安全的方式编写更加清晰和可维护的代码。

函数类型

在 TypeScript 中，函数类型用于为函数定义参数和返回值的类型。这有助于确保函数以预期的方式使用，并在编译时提供类型安全性。下面将详细说明如何定义和使用函数类型。

• 为函数定义类型:

  • 当你定义一个函数时，可以指定参数类型和返回值类型。
  • 示例：

    function add(x: number, y: number): number {
      return x + y;
    }
    

    在这个例子中，x和y都被定义为number类型，返回值也是number类型。

• 匿名函数类型:

  • 在变量声明或其他地方可以直接定义一个函数的类型。
  • 示例：

    let myAdd: (x: number, y: number) => number = function (
      x: number,
      y: number
    ): number {
      return x + y;
    };
    

    这里myAdd变量被定义为一个函数类型，函数接收两个number类型参数并返回一个number类型。

• 类型推断:

  • TypeScript 能够根据赋值语句自动推断出变量的类型。
  • 示例：

    let myAdd = function (x: number, y: number): number {
      return x + y;
    };
    

    即便没有显式声明myAdd的类型，TypeScript 也能推断出它是一个函数，接收两个number类型的参数并返回一个number。

• 可选参数和默认参数:

  • TypeScript 函数中的参数可以是可选的，或有默认值。
  • 示例（可选参数）：

    function buildName(firstName: string, lastName?: string): string {
      if (lastName) return firstName + " " + lastName;
      else return firstName;
    }
    

  • 示例（默认参数）：

    function buildName(firstName: string, lastName = "Smith"): string {
      return firstName + " " + lastName;
    }
    

    在这两个例子中，lastName参数要么是可选的，要么有默认值。这意味着调用函数时可以不传递lastName参数。

• 剩余参数:

  • 当函数需要处理不固定数量的参数时，可以使用剩余参数语法。
  • 示例：

    function buildName(firstName: string, ...restOfName: string[]): string {
      return firstName + " " + restOfName.join(" ");
    }
    

    在这个例子中，...restOfName表示可以传递任意数量的字符串参数，这些参数会被聚合成一个数组。

通过上述示例，我们可以看到 TypeScript 在定义函数类型时提供了丰富的语法和功能，使得在实际开发中可以更精准地表达函数的预期行为，同时也增强了代码的可读性和健壮性。

为函数定义类型

在 TypeScript 中，可以为函数定义类型来指定函数的参数类型和返回值类型。这样可以更精确地控制函数接收什么类型的参数以及它返回什么类型的结果。

• 函数类型包括两部分：参数类型和返回值类型。

  • 当你声明一个函数时，你可以给参数加上类型注解。
  • 返回值类型是在参数类型后面，用箭头=>标记表示。

• 例子 1：定义一个简单的函数类型

function add(x: number, y: number): number {
  return x + y;
}

• 在这个例子中：

  • x和y都有类型注解number，意味着它们必须是数字。
  • 函数的返回类型也通过: number指定为number，意味着这个函数返回一个数字。

• 为函数表达式定义类型

  • 不仅完整的函数声明可以有类型，匿名函数或者函数表达式也能够被类型化。

let myAdd: (baseValue: number, increment: number) => number = function (
  x: number,
  y: number
): number {
  return x + y;
};

• 这里：

  • myAdd是一个函数变量。
  • : (baseValue: number, increment: number) => number是myAdd的类型。
  • 意味着myAdd是一个函数，它接受两个number类型的参数，并返回一个number类型的值。

• 类型推断

  • TypeScript 能够根据函数体和返回语句自动地推断出返回值类型，因此通常不需要显式地写出返回值类型。

// TypeScript 推断出返回值类型为 number
let myAdd = function (x: number, y: number) {
  return x + y;
};

• 在这段代码中，尽管我们没有明确指定myAdd的返回值类型，TypeScript 会检查函数体并根据返回的值推断出类型。

通过对函数的参数和返回值进行类型注解，你可以让 TypeScript 帮助你跟踪函数期望什么样的输入和输出，增强代码的可读性和可维护性，并在编程阶段就避免潜在的类型错误。

书写完整函数类型

在 TypeScript 中，书写完整的函数类型涉及为函数的每个参数以及函数自身的返回值指定类型。这就像是在 JavaScript 中给函数加上注释，告诉你期望的参数类型和返回值类型。以下是关于如何书写一个完整函数类型的说明：

• 指定参数类型：为函数中每个参数指定类型，参数之间用逗号分隔。
• 返回箭头（=>）：用来连接参数类型和返回值类型。
• 指定返回值类型：在箭头=>后面指定函数返回值的类型。

举例说明：

// 定义一个函数类型变量，它代表了一个接收两个number类型参数的函数，并返回一个number类型的值。
let add: (x: number, y: number) => number;

// 实现该函数
add = function (x: number, y: number): number {
  return x + y;
};

// 使用函数
console.log(add(1, 2)); // 输出：3

上面的代码段定义了一个名为add的变量，其类型被定义为一个函数，这个函数接受两个number类型的参数，并且返回一个number类型的结果。

当你从 JavaScript 迁移到 TypeScript 时，理解并正确使用函数类型很重要，因为它有助于确保你传递正确类型的参数，同时也能清晰地知道函数的预期返回类型。这样提高了代码的可读性和可维护性。

推断类型

函数类型的推断通常指的是 TypeScript 编译器能够根据上下文自动识别（即“推断”）函数参数和返回值的类型。这意味着你在写 TypeScript 代码时，不总是需要显式地指定每个函数的参数类型和返回类型。

• 参数类型推断：

  • 当你将一个函数直接赋给一个变量时，TypeScript 可以根据赋值右侧的函数来推断左侧变量类型包括其参数。

  // TypeScript可以从右侧匿名函数的参数推断出leftSideFunction的参数类型
  let leftSideFunction = (x: number) => x + 10;
  // 等价于
  let explicitFunction: (x: number) => number = (x) => x + 10;
  

• 返回值类型推断：

  • TypeScript 也可以推断出函数的返回值类型。如果函数体中有足够的信息让 TypeScript 确定返回值的类型，你就不必显式指定它。

  // 返回值类型被推断为number
  function add(x: number, y: number) {
    return x + y; // TypeScript看到你返回了两个数字的和，会推断返回类型为number
  }
  

• 上下文归类：

  • 在某些情况下，当一个函数是另一个函数的参数时，TypeScript 可以根据外层函数期望的参数类型来推断内层函数的参数类型。

  // times函数期望传入一个接收数字并返回任意值的函数
  function times(num: number, fn: (x: number) => void) {
    for (let i = 0; i < num; i++) {
      fn(i);
    }
  }
  
  // 这里我们传入一个匿名函数作为fn的参数，TypeScript可以推断i的类型为number
  times(3, (i) => console.log(i * 2)); // 输出：0, 2, 4
  

使用推断可以减少代码冗余，并提高开发效率。不过，请注意过度依赖推断可能使得代码的可读性降低，特别是对于更加复杂的逻辑，因此有时候明确标注类型也是非常必要的。

可选参数和默认参数

• TypeScript 中，函数可以有可选参数和默认参数。

• 可选参数允许在调用函数时不传递某些参数。在 TypeScript 中，可选参数通过在参数名后添加一个问号?来标记。

  function greet(name: string, greeting?: string): string {
    return `${greeting || "Hello"}, ${name}!`;
  }
  
  console.log(greet("Alice")); // 输出: "Hello, Alice!"
  console.log(greet("Alice", "Hi")); // 输出: "Hi, Alice!"
  

• 默认参数是当调用函数时没有提供该参数或者提供的参数是 undefined 时被使用的值。在 TypeScript 中，可以直接在参数声明时指定默认值。

  function greet(name: string, greeting: string = "Hello"): string {
    return `${greeting}, ${name}!`;
  }
  
  console.log(greet("Bob")); // 输出: "Hello, Bob!"
  console.log(greet("Bob", "Hi")); // 输出: "Hi, Bob!"
  

• 在带有可选参数和默认参数的函数中，可选参数必须跟在必需参数之后。如果默认参数出现在必需参数之前，那么调用时需要明确地传入undefined来获得默认值。

  function greet(greeting: string = "Hello", name?: string): string {
    if (name) {
      return `${greeting}, ${name}!`;
    } else {
      return `${greeting}, friend!`;
    }
  }
  
  console.log(greet()); // 输出: "Hello, friend!"
  console.log(greet("Hi")); // 输出: "Hi, friend!"
  console.log(greet("Hi", "Sarah")); // 输出: "Hi, Sarah!"
  console.log(greet(undefined, "Tom")); // 输出: "Hello, Tom!"
  

• 当把函数作为类型时，可选参数与默认参数也要正确的表示出来。

  let greetFunction: (name: string, greeting?: string) => string = greet;
  
  // 或者带有默认参数
  
  let anotherGreetFunction: (name: string, greeting: string) => string = greet;
  

• 在使用函数参数时，TypeScript 会根据参数是否有默认值或可选来检查调用的正确性，从而减少因缺失参数或不匹配参数而引起的错误。

剩余参数

剩余参数（Rest Parameters）允许函数接收任意数量的参数，这些参数被放置在一个数组中。在 TypeScript 中，剩余参数通过在变量名前添加三点（...）来表示。这对于创建可以接受多个值的函数特别有用，而你不需要预先知道会有多少参数传入。使用剩余参数可以使函数调用更加灵活，并且可以简化处理参数的代码。

• 基本使用：

  • 假设你想编写一个函数，该函数能够接受任意数量的数字，并返回它们的总和。

    function sum(...numbers: number[]): number {
      return numbers.reduce((total, num) => total + num, 0);
    }
    
    console.log(sum(1, 2, 3)); // 输出：6
    console.log(sum(10, 20)); // 输出：30
    

• 与普通参数混用：

  • 当剩余参数与其他参数一起使用时，剩余参数必须位于参数列表的最后。

    function buildName(firstName: string, ...restOfName: string[]): string {
      return firstName + " " + restOfName.join(" ");
    }
    
    let employeeName = buildName("Joseph", "Samuel", "Lucas", "MacKinzie");
    console.log(employeeName); // 输出："Joseph Samuel Lucas MacKinzie"
    

• 类型注解：

  • 在 TypeScript 中，你需要为剩余参数提供一个数组类型的注解，以确保传递给函数的所有参数都是正确的类型。

    function storeItems(itemCategory: string, ...items: string[]): void {
      console.log(
        `Storing the following items in category ${itemCategory}: ${items.join(
          ", "
        )}`
      );
    }
    
    storeItems("Fruits", "Apple", "Banana"); // 输出："Storing the following items in category Fruits: Apple, Banana"
    

使用剩余参数，可以提高函数的灵活性和可读性，特别是在处理不确定数量的输入参数时。通过上述示例，希望你能了解到如何在 TypeScript 中有效利用剩余参数来构建更加灵活的函数。

this

在 TypeScript 官方文档中，关于## 函数 > this的部分主要讨论了如何在函数中使用this关键字，并且解释了 TypeScript 如何在类型层面处理this。这里是几个重点：

• this和 JavaScript 中的用法相同，但 TypeScript 提供了类型检查。
• 在一个函数内部，this指向调用该函数的上下文对象。

以下是一些涉及this的使用场景及注意事项的例子：

• 全局上下文：在全局执行上下文中（非严格模式），this指向全局对象；在浏览器中是window，而在 Node.js 中通常是global。

console.log(this); // 在浏览器中将输出window对象

• 函数内部：在普通函数内部，this的值取决于函数是如何被调用的。

function myFunction() {
  console.log(this);
}

myFunction(); // 非严格模式下，this将指向全局对象；严格模式下为undefined

class MyClass {
  method() {
    function test() {
      console.log(this); // 这里的this将不指向MyClass实例
    }
    test();
  }
}

const myInstance = new MyClass();
myInstance.method();

• 箭头函数：箭头函数不绑定自己的this，它们会捕获其所在上下文的this值。

class MyClass {
  method() {
    const test = () => {
      console.log(this); // 这里的this指向的是method调用时的this，即MyClass的实例
    };
    test();
  }
}

const myInstance = new MyClass();
myInstance.method();

• TypeScript 中的this参数：TypeScript 允许在函数参数列表的第一个位置放置一个伪参数this来显式指定this的类型。

function fn(this: SomeType, arg1: number) {
  // 使用this
}

• 在类的回调函数中：如果你想确保类方法作为回调时this的类型正确，可以在方法签名中包含this。

class MyClass {
  callback(this: MyClass, value: string) {
    // 这样可以保证this在使用时是MyClass的实例
  }
}

let instance = new MyClass();
let callback = instance.callback;

callback.call(instance, "test"); // 正确的使用方式

• 在接口中定义this类型：可以在接口中定义一个带有this的调用签名，以期确保实现此接口的类方法具有适当的this上下文。

interface UIElement {
  addClickListener(onclick: (this: void, e: Event) => void): void;
}

在这个例子中，onclick函数的this类型是void，意味着onclick中不能使用this。

理解this的行为对于编写可维护的 TypeScript 代码至关重要。遵循 TypeScript 的类型系统能够帮助避免运行时中的this相关错误，并且更好地说明函数如何被调用。

this 和箭头函数

当你在 JavaScript 中使用函数时，this关键字是一个特殊变量，它指向函数当前的上下文对象。但在 TypeScript 中使用this时，可能会遇到一些问题，特别是在类的方法中和传递函数作为参数的情况下。箭头函数可以帮助解决这些问题。

• this 在函数中

  • 当你定义一个类的方法时，你可能希望在那个方法内部使用this来访问类的属性和其他方法。
  • 但如果你把这个方法作为回调函数传递给另一个函数（例如一个事件监听器），this可能不会像你期待的那样指向类的实例。

• 常规函数与 this 的问题

  • 如果你使用普通函数（非箭头函数）作为方法，当你从一个上下文（比如一个按钮点击事件）调用这个函数时，this可能会丢失原有的类上下文，而是指向调用它的对象（比如按钮元素）。

  class Component {
    data = "some data";
  
    showData() {
      console.log(this.data);
    }
  }
  
  const myComponent = new Component();
  document.addEventListener("click", myComponent.showData); // this will not refer to myComponent instance
  

• 箭头函数与 this

  • 箭头函数不绑定自己的this，它们“继承”它们被创建时的上下文中的this值。
  • 这意味着，如果你在类中使用箭头函数定义方法，无论你何时何地调用此方法，this总是指向类实例。

  class Component {
    data = "some data";
  
    showData = () => {
      console.log(this.data);
    };
  }
  
  const myComponent = new Component();
  document.addEventListener("click", myComponent.showData); // this now correctly refers to myComponent instance
  

  • 在上面的例子中，无论showData方法在哪里被调用，它都能够准确地访问到data属性，因为this始终指向Component的实例。

• 箭头函数的缺点

  • 尽管箭头函数解决了this的问题，但它们也有自己的限制。例如，不能用作构造函数，也没有arguments对象。
  • 此外，在性能要求极高的应用程序中，过度使用箭头函数可能会导致性能略微下降，因为每个箭头函数都是一个新的函数实例。

总结：在 TypeScript 中，了解函数中的this是如何工作的以及箭头函数是如何修复相关问题的可以帮助你更好地管理和预测this的行为。在实际开发中，利用箭头函数保持正确的this上下文通常很方便，但应当注意它们的使用场景和潜在的限制。

this 参数

在 TypeScript 中，this 参数是一种特殊的参数，您可以用它来显式地为函数指定 this 的类型。这在 JavaScript 中是隐式的，并且很容易弄错 this 的上下文，尤其是在回调函数中。使用 TypeScript，您可以告诉编译器期望 this 是什么类型，从而避免错误。

• 当您在一个对象的方法中使用 this 时，TypeScript 通常可以正确推断 this 的类型。
• 但是，在某些情况下，如回调函数，您可能需要手动指定 this 的类型。
• 您可以通过在函数参数列表的第一个位置添加一个假的参数来指定 this 类型，该参数以 this: 开头，并不会被当作真正的参数传递。

这里是几个例子：

interface UIElement {
  addClickListener(onclick: (this: void, e: Event) => void): void;
}

class Handler {
  info: string;
  onClickBad(this: Handler, e: Event) {
    // 使用了错误的 this 类型会导致编译错误
    this.info = e.message;
  }
}

let h = new Handler();
let uiElement: UIElement = {
  // ...
  addClickListener() {
    // ...
  },
};

// 你现在不能将 `onClickBad` 直接赋值给 `addClickListener`
// 因为 `onClickBad` 需要 `this` 类型为 `Handler`
uiElement.addClickListener(h.onClickBad); // 错误!

// 正确的做法是绑定正确的 `this` 上下文
uiElement.addClickListener(h.onClickBad.bind(h)); // 正确!

在以上例子中，UIElement 接口期望 onclick 函数的 this 类型为 void，表示 onclick 在执行时不应该引用任何东西（即没有 this 上下文）。然而，Handler 类型的 onClickBad 方法声明了 this 参数为 Handler 类型，这意味着它期望 this 是 Handler 的实例。解决方法是通过 bind 方法将 onClickBad 函数与 h 实例的 this 上下文绑定，然后才能传递到 addClickListener 中。

记住，this 参数在函数参数列表中只是用于类型检查，它在运行时并不会作为一个实际的参数传递到函数中去。

this 参数在回调函数里

TypeScript 的this参数在回调函数里特指在编写回调函数时，我们可以明确地注解this的类型。这是非常有用的，因为 JavaScript 中的this是一个常见的错误来源，尤其是当你从一个上下文（比如一个类的方法）移到另一个上下文（如事件处理器或回调）时。

在 JavaScript 中，this的值取决于函数如何被调用，它可能不是你预期的值。在 TypeScript 中，你可以通过向函数提供一个显式的this参数来解决这个问题，该参数并不会成为实际参数序列的一部分，但它会帮助 TypeScript 检查this的正确性。

• 当你在类的方法中传递一个函数作为回调时，这个函数中的this很容易丢失原有的上下文。
• TypeScript 允许你在函数参数列表的最前面声明一个虚拟的参数，通常命名为this，用来设置this的类型。
• 这个this参数在运行时是不存在的，仅用于编译时的类型检查。

例如：

class Counter {
  count = 0;
  increment() {
    this.count += 1;
  }
  registerCallback() {
    // 普通写法，容易丢失this上下文
    setTimeout(function () {
      this.increment(); // 这里的this可能并不是Counter的实例
    }, 1000);

    // 使用箭头函数保留this上下文
    setTimeout(() => {
      this.increment(); // 箭头函数可以正确地保持this指向Counter的实例
    }, 1000);

    // 使用TypeScript的this参数
    setTimeout(function (this: Counter) {
      this.increment(); // TypeScript将强制检查这里的this必须是Counter的实例
    }, 1000);
  }
}

let counter = new Counter();
counter.registerCallback();

在以上代码中，第一个setTimeout中的匿名函数丢失了this的上下文，导致运行时错误。第二个setTimeout使用箭头函数自动绑定了this。第三个setTimeout中，通过在函数参数列表中添加this: Counter，我们告诉 TypeScript，我们期望在回调函数内部的this应该是Counter类型的实例。如果我们尝试在其他类型的this上下文中使用这个回调函数，TypeScript 将给出错误提示。

重载

函数重载是 TypeScript 中一个非常有用的特性，它允许你为同一个函数提供多个函数类型定义。这意味着你可以根据不同的参数类型或参数数量调用同一个函数，但是在实现中只需要写一次。这对于提高代码的可读性和维护性非常有帮助。

• 基本概念：

  • 在 JavaScript 中，函数是非常灵活的，可以接受任意数量和类型的参数。但是，这种灵活性有时会导致问题，因为你不能直接从函数签名中知道函数期望什么样的参数。
  • TypeScript 通过允许你定义函数重载来解决这个问题，你可以为同一个函数定义多个签名，每个签名可以接受不同类型或数量的参数。

• 如何实现：

  1. 首先，在函数的实现之前，你需要声明所有的重载签名。
  2. 然后，你提供一个实现，这个实现必须与上面声明的重载签名兼容。

• 实用例子：

// 重载签名
function greet(name: string): string;
function greet(age: number): string;

// 实现签名（注意，实现的函数签名不会作为重载的一部分）
function greet(nameOrAge: any): string {
  if (typeof nameOrAge === "string") {
    return `Hello, ${nameOrAge}`;
  } else {
    return `You are ${nameOrAge} years old`;
  }
}

// 使用重载
console.log(greet("Alice")); // 调用第一个重载版本，打印：Hello, Alice
console.log(greet(42)); // 调用第二个重载版本，打印：You are 42 years old

在这个例子中，greet函数根据传入的参数类型（字符串或数字）来执行不同的操作，这是通过函数重载实现的。这样的设计让函数的用途更加清晰，并且能够提供给调用者关于如何使用该函数的明确信息。

• 重要点：
  • 函数重载并不意味着函数体内会发生变化，它仅仅是在类型层面上提供了多种可能性，以便 TypeScript 编译器能够根据不同的调用方式提供类型安全检查。
  • 实现函数时，其参数类型通常比较宽泛，这是为了能兼容所有重载的参数类型。在函数体内，你通常需要根据不同的参数类型进行相应的处理。
  • 函数重载能够极大地增强程序的可读性和易用性，但也需要谨慎使用，以避免过度复杂化。