JavaScript对象按路径提取子树方法

本文介绍一种轻量、无依赖的路径式对象字段提取方案，支持嵌套属性、数组索引（如 [0]、[:last]）、通配符（如 book.heroes.name）及包含/排除混合策略，适用于 API 层动态字段裁剪场景。

在构建面向客户端的灵活 API 时，一个常见的挑战是如何根据前端需求动态裁剪响应体。这要求方案既能保留标准字段如 `user.name`，又能处理结构开放、不可预知的嵌套字段，例如 `user.custom.preferences.theme`。

GraphQL 功能强大，但它依赖预定义的 Schema，对于 `custom` 这类结构完全开放的字段场景，处理起来并不灵活。相比之下，一套基于路径表达式的运行时提取机制更为实用。

JavaScript 对象路径提取方案的核心实现

以下是一个可直接用于生产环境的核心实现。它支持 `include`（包含）和 `exclude`（排除）的混合语义，并能处理数组切片和通配符访问，功能全面。

const extractData = (data, filters) => {
  // 解析过滤规则：true → 包含路径；false → 排除路径
  const [pathsToInclude, pathsToExclude] = Object.entries(filters).reduce(
    (acc, [keyPath, include]) => {
      const pathParts = parsePath(keyPath);
      acc[include ? 0 : 1].push(pathParts);
      return acc;
    },
    [[], []]
  );

  // 初始化结果：若存在 include 规则，则从空对象开始；否则深拷贝原始数据
  const result = pathsToInclude.length > 0 ? {} : deepClone(data);

  // 执行包含逻辑：逐路径递归挂载目标值
  pathsToInclude.forEach((path) => {
    let current = path.shift();
    let obj = result;
    let dataObj = data;

    while (current !== undefined && obj !== null && dataObj !== undefined) {
      if (path.length === 0) {
        // 叶子节点：直接赋值（支持数组索引与通配）
        obj[current] = resolveValueAt(dataObj, current, path);
      } else {
        // 中间节点：确保目标位置为对象
        obj[current] = obj[current] ?? {};
        dataObj = dataObj?.[current];
      }
      obj = obj[current];
      current = path.shift();
    }
  });

  // 执行排除逻辑：定位父级后删除指定键
  pathsToExclude.forEach((path) => {
    const keyToDelete = path.pop();
    let current = path.shift();
    let obj = result;

    while (obj && current !== undefined) {
      if (path.length === 0) break;
      obj = obj[current];
      current = path.shift();
    }
    if (obj && obj.hasOwnProperty(keyToDelete)) {
      delete obj[keyToDelete];
    }
  });

  return result;
};

// 解析路径字符串（支持 . 和 [] 语法）
const parsePath = (str) => {
  return str
    .replace(/\[(\d+|:last|:all)\]/g, '.$1') // 将 [0] → .0, [:last] → .:last
    .split('.')
    .filter(Boolean);
};

// 根据路径片段解析值（处理数组索引与通配）
const resolveValueAt = (obj, key, remainingPath) => {
  if (!obj || typeof obj !== 'object') return undefined;

  // 处理数组索引：0, :last, :all
  if (Array.isArray(obj) && /^[0-9]+|:last|:all$/.test(key)) {
    if (key === ':last' && obj.length > 0) {
      return resolveDeep(obj[obj.length - 1], remainingPath);
    }
    if (key === ':all') {
      return obj.map(item => resolveDeep(item, remainingPath));
    }
    const idx = parseInt(key, 10);
    if (!isNaN(idx) && idx >= 0 && idx < obj.length) {
      return resolveDeep(obj[idx], remainingPath);
    }
    return undefined;
  }

  // 普通对象属性访问
  return resolveDeep(obj[key], remainingPath);
};

// 递归解析剩余路径（用于通配如 heroes.name）
const resolveDeep = (value, path) => {
  if (path.length === 0 || value === undefined) return value;
  if (Array.isArray(value)) {
    return value.map(item => resolveDeep(item, path));
  }
  if (typeof value === 'object' && value !== null) {
    const [first, ...rest] = path;
    return resolveDeep(value[first], rest);
  }
  return undefined;
};

// 简易深克隆（仅处理普通对象/数组，不含 Date/RegExp 等）
const deepClone = (obj) => {
  if (obj === null || typeof obj !== 'object') return obj;
  if (Array.isArray(obj)) return obj.map(deepClone);
  const cloned = {};
  for (const key in obj) {
    if (Object.prototype.hasOwnProperty.call(obj, key)) {
      cloned[key] = deepClone(obj[key]);
    }
  }
  return cloned;
};

动态字段提取的实际应用示例

通过具体示例，可以更清晰地了解这套方案的功能。

const data = {
  user: { age: 25, weight: 170, name: "Joe" },
  book: {
    title: "Dune",
    description: "Space opera",
    location: { planet: "Arakis", population: 100000 },
    heroes: [
      { name: "Duke", age: 43 },
      { name: "Paul", age: 16 }
    ]
  }
};

//  提取指定字段
console.log(extractData(data, { "user.name": true, "book.location.planet": true }));
// → { user: { name: "Joe" }, book: { location: { planet: "Arakis" } } }

//  排除子树
console.log(extractData(data, { "book": true, "book.heroes": false }));
// → { book: { title: "Dune", description: "Space opera", location: { ... } } }

//  数组操作
console.log(extractData(data, { "book.heroes[0].name": true })); // → { book: { heroes: [{ name: "Duke" }] } }
console.log(extractData(data, { "book.heroes[:last].name": true })); // → { book: { heroes: [{ name: "Paul" }] } }
console.log(extractData(data, { "book.heroes.name": true })); // → { book: { heroes: ["Duke", "Paul"] } }

无论是精确提取、排除特定子树，还是对数组进行索引（`[0]`）、取末尾（`[:last]`）或通配符（`.name`）操作，该方案都能有效处理。

API 字段裁剪方案的关键注意事项

在实际应用前，有几个重要细节需要注意：

• 集成与扩展：该方案无外部依赖，可轻松集成到 Express 或 Koa 中间件中，解析 `req.query.fields` 等参数。`parsePath` 函数可通过扩展正则表达式来支持更多语法，如数组切片 `[1:3]`。
• 深克隆的考量：示例中的 `deepClone` 为简化版，仅处理普通对象和数组。生产环境中，若运行环境支持（Node.js ≥ 17.0），建议使用原生 `structuredClone`；或引入 `lodash.cloneDeep` 等库处理复杂类型。
• 安全第一：路径表达式可能来自用户输入，务必在服务端进行白名单校验。警惕并禁止 `__proto__`、`constructor` 等可能引发原型污染的安全敏感键。
• 性能优化：高频调用场景下，可考虑缓存 `parsePath` 解析结果或预编译路径解析器，以提升性能。

总体而言，该方案在灵活性与可控性之间取得了良好平衡，使 API 响应能够真正“按需生成”，是 GraphQL 在轻量化落地场景下的理想补充方案。