如何给 JavaScript 函数添加参数校验？

在 JavaScript 中，对函数参数进行校验是确保代码健壮性和防止错误的重要手段。参数校验不仅能提高代码的可读性，还能帮助捕获潜在的错误。下面，我们将结合实际项目代码示例，讲解如何给 JavaScript 函数添加参数校验。

常见的参数校验方式

1. 基本类型校验：校验参数的类型是否符合预期。
2. 参数值范围校验：校验参数值是否在指定范围内。
3. 参数个数校验：校验传入的参数个数是否正确。
4. 自定义校验：对更复杂的业务逻辑进行校验。

示例 1：基本类型校验

假设我们有一个函数，要求传入的参数是一个数字：

function square(number) {
  // 参数类型校验
  if (typeof number !== 'number') {
    throw new Error('参数必须是数字');
  }

  return number * number;
}

// 调用
console.log(square(4));   // 输出: 16
console.log(square('4')); // 抛出错误: 参数必须是数字

解释： 我们使用 typeof 来检查传入的 number 是否为数字类型。如果不是数字类型，抛出一个错误，提示开发者进行修正。

示例 2：参数个数校验

假设我们有一个函数，它期望两个参数：一个数字和一个字符串：

function greet(name, age) {
  // 参数个数校验
  if (arguments.length !== 2) {
    throw new Error('必须传入两个参数：名字和年龄');
  }

  // 参数类型校验
  if (typeof name !== 'string' || typeof age !== 'number') {
    throw new Error('第一个参数应该是字符串，第二个参数应该是数字');
  }

  console.log(`Hello ${name}, you are ${age} years old.`);
}

// 调用
greet('Alice', 30);       // 输出: Hello Alice, you are 30 years old.
greet('Alice');           // 抛出错误: 必须传入两个参数：名字和年龄
greet('Alice', '30');     // 抛出错误: 第一个参数应该是字符串，第二个参数应该是数字

解释： 我们使用 arguments.length 来检查传入参数的个数。如果参数个数不符合预期，就抛出错误。然后，我们进一步使用 typeof 来检查每个参数的类型。

示例 3：参数值范围校验

假设我们有一个函数，它要求传入的数字在特定范围内：

function setAge(age) {
  // 参数类型校验
  if (typeof age !== 'number') {
    throw new Error('参数必须是数字');
  }

  // 参数值范围校验
  if (age < 0 || age > 120) {
    throw new Error('年龄必须在 0 到 120 之间');
  }

  console.log(`Your age is set to ${age}`);
}

// 调用
setAge(25);    // 输出: Your age is set to 25
setAge(150);   // 抛出错误: 年龄必须在 0 到 120 之间
setAge(-5);    // 抛出错误: 年龄必须在 0 到 120 之间

解释： 我们首先检查传入参数是否为数字类型，然后验证 age 是否在合法的范围内（0 到 120）。如果不在范围内，就抛出错误。

示例 4：复杂的自定义校验

在一些更复杂的场景中，可能需要对参数进行更复杂的校验，比如正则表达式验证、对象结构校验等。例如，一个要求传入邮箱地址的函数：

function setEmail(email) {
  // 参数类型校验
  if (typeof email !== 'string') {
    throw new Error('参数必须是字符串');
  }

  // 正则表达式校验邮箱格式
  const emailRegex = /^[a-zA-Z0-9._-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,4}$/;
  if (!emailRegex.test(email)) {
    throw new Error('无效的邮箱地址');
  }

  console.log(`Your email is set to ${email}`);
}

// 调用
setEmail('alice@example.com');  // 输出: Your email is set to alice@example.com
setEmail('alice.com');          // 抛出错误: 无效的邮箱地址

解释： 我们使用正则表达式来校验邮箱的格式是否正确。正则表达式非常适合用于对字符串进行格式校验。

示例 5：结合解构的参数校验

在现代 JavaScript 中，我们常常使用解构赋值来传递多个参数。如果参数较多，解构赋值使得代码更加简洁，但也需要进行相应的参数校验：

function createUser({ name, age, email }) {
  // 参数解构与类型校验
  if (typeof name !== 'string') {
    throw new Error('name 必须是字符串');
  }
  if (typeof age !== 'number' || age < 0 || age > 120) {
    throw new Error('age 必须是数字，且在 0 到 120 之间');
  }
  if (typeof email !== 'string' || !email.includes('@')) {
    throw new Error('email 必须是有效的邮箱地址');
  }

  console.log(`User created: ${name}, ${age}, ${email}`);
}

// 调用
createUser({ name: 'Alice', age: 30, email: 'alice@example.com' });  // 输出: User created: Alice, 30, alice@example.com
createUser({ name: 'Alice', age: -5, email: 'alice@example.com' });  // 抛出错误: age 必须是数字，且在 0 到 120 之间
createUser({ name: 'Alice', age: 30, email: 'aliceexample.com' });  // 抛出错误: email 必须是有效的邮箱地址

解释： 通过解构，我们可以方便地提取传入的参数，并进行一系列的校验。每个参数的类型和有效性都需要进行校验，如果不符合要求，就抛出相应的错误。

使用外部库进行参数校验

除了手动编写校验逻辑，我们还可以使用一些流行的外部库来简化参数校验的过程。例如，Joi 、Yup 等库可以帮助我们更加方便地进行数据验证。

示例 6：使用 Joi 进行参数校验

const Joi = require('joi');

const schema = Joi.object({
  name: Joi.string().min(3).max(30).required(),
  age: Joi.number().integer().min(0).max(120).required(),
  email: Joi.string().email().required()
});

function createUser(data) {
  const { error } = schema.validate(data);
  if (error) {
    throw new Error(error.details[0].message);
  }
  console.log('User created:', data);
}

// 调用
createUser({ name: 'Alice', age: 30, email: 'alice@example.com' }); // User created: { name: 'Alice', age: 30, email: 'alice@example.com' }
createUser({ name: 'Al', age: 150, email: 'alice@example.com' });   // 抛出错误: "age" must be less than or equal to 120

解释： 通过 Joi，我们可以定义一个模式并验证数据。Joi 提供了丰富的功能，允许我们进行多种类型的校验，并返回详细的错误信息。

总结

通过这些方法，我们可以有效地为 JavaScript 函数添加参数校验，确保函数在执行时接收到有效且符合要求的参数：

1. 基本类型校验 ：使用 typeof 或 instanceof 进行类型检查。
2. 参数个数校验 ：通过 arguments.length 检查传入的参数个数。
3. 参数值范围校验：验证参数是否在有效的范围内。
4. 自定义校验：使用正则表达式等方式进行格式或值的校验。
5. 解构赋值校验：对解构后的参数进行类型检查。
6. 外部库 ：使用如 Joi、Yup 等库进行更复杂的校验。

通过这些校验，可以避免许多潜在的错误，使代码更加健壮且易于维护。