无需类型断言解决Record<string, unknown>与对象的类型兼容警告

问题出在你定义的函数参数是Record<string, unknown>，但递归时传入的value是object类型，TypeScript无法确认它带有字符串索引签名，因此抛出警告。不用显式类型断言的话，可以通过调整函数参数类型+添加类型守卫来解决：

方案1：使用联合类型定义可清理对象，并添加类型守卫 #

先定义包含普通对象和数组的联合类型，再通过类型守卫确认递归的value属于该类型，避免类型不匹配：

// 定义可清理的类型：普通对象或任意类型数组
type Cleanable = Record<string, unknown> | unknown[];

const cleanObject = (obj: Cleanable): Cleanable => {
  Object.entries(obj).forEach(([key, value]) => {
    // 先确认value是对象且非null，再判断是否为可清理的普通对象/数组
    if (value && typeof value === 'object') {
      const isPlainObject = Object.prototype.toString.call(value) === '[object Object]';
      if (Array.isArray(value) || isPlainObject) {
        cleanObject(value); // 此处无类型警告，value已被收窄为Cleanable类型
      }
    }

    // 空值清理逻辑
    if (
      (value && typeof value === 'object' && !Object.keys(value).length) ||
      value === null ||
      value === undefined ||
      value === ''
    ) {
      if (Array.isArray(obj)) {
        obj.splice(Number(key), 1);
      } else {
        delete obj[key];
      }
    }
  });
  return obj;
};

方案2：使用泛型约束，保留输入类型信息 #

如果需要函数返回与输入一致的具体类型（而非统一的Cleanable），可以用泛型约束配合类型守卫：

const cleanObject = <T extends object>(obj: T): T => {
  Object.entries(obj).forEach(([key, value]) => {
    if (value && typeof value === 'object') {
      const isPlainObject = Object.prototype.toString.call(value) === '[object Object]';
      if (Array.isArray(value) || isPlainObject) {
        cleanObject(value); // 泛型自动推导value符合T extends object的约束
      }
    }

    // 空值清理逻辑
    if (
      (value && typeof value === 'object' && !Object.keys(value).length) ||
      value === null ||
      value === undefined ||
      value === ''
    ) {
      if (Array.isArray(obj)) {
        obj.splice(Number(key), 1);
      } else {
        // 此处断言仅针对删除操作（因泛型T可能无明确索引签名），不属于递归调用的断言
        delete (obj as Record<string, unknown>)[key];
      }
    }
  });
  return obj;
};

额外优化提示 #

原函数处理数组时存在逻辑漏洞：使用forEach遍历并splice删除元素会导致索引错乱（删除元素后后续元素前移，forEach会跳过部分元素）。建议改用从后往前的for循环处理数组：

// 替换原数组处理逻辑
if (Array.isArray(obj)) {
  // 从后往前遍历，避免删除元素导致的索引偏移
  for (let i = obj.length - 1; i >= 0; i--) {
    const value = obj[i];
    if (
      (value && typeof value === 'object' && !Object.keys(value).length) ||
      value === null ||
      value === undefined ||
      value === ''
    ) {
      obj.splice(i, 1);
    } else if (value && typeof value === 'object') {
      const isPlainObject = Object.prototype.toString.call(value) === '[object Object]';
      if (Array.isArray(value) || isPlainObject) {
        cleanObject(value);
      }
    }
  }
} else {
  // 普通对象处理逻辑不变
  Object.entries(obj).forEach(([key, value]) => {
    // ... 原逻辑
  });
}

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