当前位置：首页 > JavaScript

js 实现重载

2026-03-14 21:04:21JavaScript

JavaScript 本身不支持传统意义上的方法重载（即同名方法根据参数类型或数量不同实现不同功能），但可以通过以下方式模拟类似效果：

利用参数数量和类型判断

通过检查 arguments 对象或剩余参数，动态决定函数行为：

js 实现重载

function overloadExample() {
  if (arguments.length === 1) {
    console.log('单参数版本:', arguments[0]);
  } else if (arguments.length === 2) {
    console.log('双参数版本:', arguments[0], arguments[1]);
  }
}
overloadExample(10);       // 输出: 单参数版本: 10
overloadExample(5, 'abc'); // 输出: 双参数版本: 5 abc

使用对象参数统一处理

通过配置对象参数实现灵活的参数传递：

js 实现重载

function configurableFunc(options) {
  const { param1, param2, callback } = options || {};
  if (callback) {
    callback(param1 + param2);
  } else {
    return param1 * param2;
  }
}
configurableFunc({ param1: 2, param2: 3 }); // 返回 6
configurableFunc({ param1: 1, param2: 2, callback: console.log }); // 输出 3

利用默认参数和类型检查

ES6+环境下可通过默认参数和类型判断实现：

function typedOverload(a, b = 0, c) {
  if (typeof a === 'string') {
    return a.repeat(b);
  }
  if (c instanceof Array) {
    return c.map(x => x * a + b);
  }
  return a + b;
}
typedOverload(2, 3);          // 返回 5
typedOverload('Hi', 3);       // 返回 "HiHiHi"
typedOverload(2, 1, [4,5,6]); // 返回 [9, 11, 13]

通过函数工厂创建重载

高阶函数可生成具有不同行为的函数组：

function createOverload() {
  const handlers = new Map();
  function overload(...args) {
    const key = args.map(arg => typeof arg).join('|');
    const handler = handlers.get(key);
    if (handler) return handler.apply(this, args);
    throw new Error('No matching overload');
  }
  overload.addImpl = function(types, fn) {
    handlers.set(types.join('|'), fn);
  };
  return overload;
}

const smartFunc = createOverload();
smartFunc.addImpl(['number'], n => n * 2);
smartFunc.addImpl(['string'], s => s.toUpperCase());
smartFunc(4);   // 返回 8
smartFunc('ab'); // 返回 "AB"

这些方法各有适用场景，选择时需考虑代码可读性、维护成本和实际需求复杂度。对象参数法适合参数较多的情况，而类型判断法则在需要严格区分参数类型时更有效。

标签: js