Memoize函数缓存异常：无法区分不同类型的传入参数

你的问题和in运算符无关，核心是**args.toString()生成的缓存键无法区分参数的类型与结构**：

• 调用memoAdd(1,2)时，args是[1,2]，toString()结果为"1,2"
• 调用memoAdd([1,2])时，args是[[1,2]]，数组的toString()会递归转换元素，结果同样是"1,2"
• 调用memoAdd("1",2)时，args是["1",2]，toString()结果还是"1,2"

三种完全不同的参数组合最终共用了同一个缓存键，导致缓存混淆。

需要为参数生成能保留类型、结构信息的唯一键，以下两种方案可供选择：

方案1：用JSON.stringify快速实现（适合基础场景） #

JSON.stringify会将参数的结构、类型编码进字符串，能区分绝大多数常规参数组合：

var memoize = function(func) {
  var cache = {};
  return function(...args) {
    const cacheKey = JSON.stringify(args);
    if (cacheKey in cache) {
      console.log('cached');
      return cache[cacheKey];
    }
    var result = func(...args);
    cache[cacheKey] = result;
    return result;
  }
}

var add = function(a, b) {
  return a;
};

var memoAdd = memoize(add);
console.log(memoAdd([1,2])); // 返回[1,2]，无缓存
console.log(memoAdd(1,2));    // 返回1，无缓存
console.log(memoAdd([1,2])); // 返回[1,2]，命中缓存
console.log(memoAdd("1",2));  // 返回"1"，无缓存

此时三个参数组合的缓存键分别为"[[1,2]]"、"[1,2]"、"[\"1\",2]"，完全不会混淆。

方案2：自定义序列化函数（适合复杂类型场景） #

如果需要处理函数、Symbol、循环引用对象等JSON.stringify无法处理的类型，可以自定义序列化逻辑，给每个参数加上类型标记：

// 生成单个参数的唯一标识
function getParamKey(param) {
  const type = typeof param;
  if (type === 'object' && param !== null) {
    if (Array.isArray(param)) {
      return `Array:[${param.map(getParamKey).join(',')}]`;
    }
    // 普通对象的序列化（可根据需求扩展）
    return `Object:{${Object.entries(param).map(([k, v]) => `${k}:${getParamKey(v)}`).join(',')}}`;
  }
  // 基础类型直接返回「类型:值」格式
  return `${type}:${param}`;
}

var memoize = function(func) {
  var cache = {};
  return function(...args) {
    const cacheKey = args.map(getParamKey).join('|');
    if (cacheKey in cache) {
      console.log('cached');
      return cache[cacheKey];
    }
    var result = func(...args);
    cache[cacheKey] = result;
    return result;
  }
}

这种方式能更精准地区分参数，比如数字1的标识是"number:1"，字符串"1"的标识是"string:1"，完全不会被混淆。

内容的提问来源于stack exchange，提问作者maximosis