JavaScript 高阶函数：实现可链式调用的默认参数设置

function defaultMethod(func, params) {
    var funcStr = func.toString();
    let requiredArgs = funcStr
      .slice(funcStr.indexOf('(') + 1, funcStr.indexOf(')')) // 获取括号内的内容
      .match(/([^\s,]+)/g) || []; // 匹配参数名，例如 ['a', 'b']

    return function (...args) {
      let calledArgs = args;
      // 填充默认参数逻辑
      for (let i = calledArgs.length; i < requiredArgs.length; i++) {
          if (calledArgs[i] === undefined) {
              calledArgs[i] = params[requiredArgs[i]];
          }
      }
      return func(...calledArgs);
    };
}

var add_ = defaultMethod(add, {b:9}); // 第一次调用
add_ = defaultMethod(add_, {b:3, a:2}); // 第二次调用，此时func是add_

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

// 使用闭包来创建私有的 registry
const defaultMethod = (function () {
    const registry = new WeakMap(); // WeakMap 用于存储装饰器函数及其对应的参数名

    return function (func, params) {
        // 尝试从 registry 中获取当前 func 的参数名
        // 如果 func 是一个已经被 defaultMethod 装饰过的函数，
        // 那么它的参数名应该已经存储在 registry 中
        let requiredArgs = registry.get(func);

        // 如果 registry 中没有，说明 func 是一个原始函数，或者是一个新的未被注册的函数
        if (!requiredArgs) {
            const funcStr = func.toString();
            // 从 func.toString() 中解析参数名
            requiredArgs = funcStr
                .slice(funcStr.indexOf('(') + 1, funcStr.indexOf(')'))
                .match(/([^\s,]+)/g) || [];
        }

        console.log("当前函数参数名为:", ...requiredArgs); // 辅助调试

        // 创建新的装饰器函数
        const decoratedFunc = function (...args) {
            let calledArgs = [...args]; // 复制一份传入的参数，避免直接修改 arguments 对象

            // 遍历所需参数，如果传入参数不足且对应位置为 undefined，则应用默认值
            for (let i = 0; i < requiredArgs.length; i++) {
                if (calledArgs[i] === undefined) {
                    // 注意：这里需要确保 params[requiredArgs[i]] 能够正确获取到值
                    // 并且不会覆盖已经传入的 undefined 值（如果用户确实想传入 undefined）
                    // 原始逻辑是 `if (calledArgs[i] === undefined)`，所以如果用户明确传入了 undefined，
                    // 也会被默认值覆盖。这符合原始问题的意图。
                    calledArgs[i] = params[requiredArgs[i]];
                }
            }

            // 调用原始函数或上一个装饰器函数
            return func(...calledArgs);
        };

        // 将新创建的装饰器函数及其对应的参数名注册到 WeakMap 中
        registry.set(decoratedFunc, requiredArgs);
        return decoratedFunc;
    };
})();

// 原始函数
function add(a, b) {
    return a + b;
}

console.log("--- 第一次设置默认值：b=9 ---");
let add_ = defaultMethod(add, { b: 9 });

// 测试用例 1: 只传入 a 的值
console.log("调用 add_(10): 预期 19 (10 + 9)");
console.log("结果:", add_(10)); // 输出 19 (10 + 9)

// 测试用例 2: 传入 a 和 b 的值
console.log("调用 add_(10, 7): 预期 17 (10 + 7)");
console.log("结果:", add_(10, 7)); // 输出 17 (10 + 7)

// 测试用例 3: 不传入任何值
console.log("调用 add_(): 预期 NaN (undefined + 9)");
console.log("结果:", add_()); // 输出 NaN (因为 a 为 undefined)

console.log("\n--- 第二次设置默认值：b=3, a=2 (链式调用) ---");
// 此时 add_ 是一个装饰器函数，defaultMethod 会从 registry 中获取其参数签名
add_ = defaultMethod(add_, { b: 3, a: 2 });

// 测试用例 4: 只传入 a 的值
console.log("调用 add_(10): 预期 13 (10 + 3)");
console.log("结果:", add_(10)); // 输出 13 (a=10, b取新默认值3)

// 测试用例 5: 不传入任何值
console.log("调用 add_(): 预期 5 (2 + 3)");
console.log("结果:", add_()); // 输出 5 (a取默认值2, b取默认值3)

console.log("\n--- 第三次设置默认值：c=3 (无关参数) ---");
// 传入一个与原始函数参数不匹配的默认值
add_ = defaultMethod(add_, { c: 3 });

// 测试用例 6: 只传入 a 的值
console.log("调用 add_(10): 预期 13 (10 + 3)");
console.log("结果:", add_(10)); // 输出 13 (a=10, b取默认值3，c不影响)