json怎么从最后一层过滤

深度解析：如何精准过滤JSON数据的最后一层**

在处理JSON数据时，我们常常会遇到需要根据特定条件筛选或提取信息的需求。“从最后一层过滤”是一个比较常见但又需要仔细对待的场景，这里的“最后一层”通常指的是JSON结构中不再包含嵌套JSON对象或数组的那些基本数据类型节点（如字符串、数字、布尔值、null等）,本文将详细探讨如何理解和实现从JSON数据的最后一层进行过滤。

明确“最后一层”的含义

我们需要清晰界定“最后一层”具体指什么,以一个嵌套的JSON对象为例：

{
  "user": {
    "id": 101,
    "name": "张三",
    "contacts": {
      "email": "zhangsan@example.com",
      "phone": "13800138000"
    },
    "tags": ["developer", "python"]
  },
  "status": "active"
}

在这个例子中：

• "user" 和 "status" 是第一层（根对象的直接属性）。
• "id", "name", "contacts", "tags" 是第二层（"user"对象的属性）。
• "email", "phone" 是第三层（"contacts"对象的属性），它们是字符串,属于最后一层。
• 数组 "tags" 中的元素 "developer" 和 "python" 也是字符串，它们是数组元素的值，也属于最后一层（相对于数组这个容器而言）。
• "id": 101 中的 101 是数字,也是最后一层。

“从最后一层过滤”可以理解为：

1. 找到所有值为基本数据类型（非对象、非数组）的键值对。
2. 根据这些值的特征（如等于某个特定值、满足某个条件等）进行筛选。
3. 可能需要保留这些值以及它们通往根的路径信息。

实现“最后一层过滤”的方法

实现这一过滤，通常需要递归或迭代地遍历JSON对象（或数组），直到到达基本数据类型的叶子节点，以下是几种常见的实现方式，主要以JavaScript为例说明,因为JSON在JS中处理最为便捷。

递归遍历（适用于嵌套结构复杂的情况）

递归是一种非常直观处理嵌套数据结构的方法，我们可以编写一个函数,遍历对象的每个属性：

• 如果属性的值是对象（且不是null，因为typeof null也是'object'）,则递归调用该函数。
• 如果属性的值是数组，则遍历数组元素，对每个元素如果是对象,则递归调用。
• 如果属性的值是基本数据类型,则进行过滤判断。

示例代码：

假设我们要过滤出所有值为字符串 "python" 的最后一层节点,并记录其完整路径。

function filterLastLayerByValue(data, targetValue, path = [], result = []) {
  if (typeof data === 'object' && data !== null) {
    // 如果是对象或数组
    for (const key in data) {
      if (Array.isArray(data[key])) {
        // 处理数组
        data[key].forEach((item, index) => {
          filterLastLayerByValue(item, targetValue, [...path, key, index], result);
        });
      } else if (typeof data[key] === 'object') {
        // 处理嵌套对象
        filterLastLayerByValue(data[key], targetValue, [...path, key], result);
      } else {
        // 基本数据类型，进行过滤
        if (data[key] === targetValue) {
          result.push({
            path: [...path, key].join('.'),
            value: data[key]
          });
        }
      }
    }
  } else {
    // 如果是根节点本身就是一个基本类型（不太常见于复杂过滤场景）
    if (data === targetValue) {
      result.push({
        path: 'root',
        value: data
      });
    }
  }
  return result;
}
// 示例JSON数据
const jsonData = {
  "user": {
    "id": 101,
    "name": "张三",
    "contacts": {
      "email": "zhangsan@example.com",
      "phone": "13800138000"
    },
    "tags": ["developer", "python"]
  },
  "status": "active",
  "emptyObj": {},
  "emptyArr": [],
  "targetHere": "python"
};
const filteredResults = filterLastLayerByValue(jsonData, "python");
console.log(filteredResults);
// 输出:
// [
//   { path: 'user.tags.1', value: 'python' },
//   { path: 'targetHere', value: 'python' }
// ]

迭代遍历（使用栈或队列，避免递归深度限制）

对于非常深的嵌套结构，递归可能会导致调用栈溢出，可以使用迭代的方式，借助栈（深度优先）或队列（广度优先）来模拟遍历过程。

示例代码（使用栈进行深度优先遍历）：

function filterLastLayerByValueIterative(data, targetValue) {
  const result = [];
  // 栈中存储当前节点和其路径
  const stack = [{ node: data, path: [] }];
  while (stack.length > 0) {
    const { node, path } = stack.pop();
    if (typeof node === 'object' && node !== null) {
      for (const key in node) {
        if (Array.isArray(node[key])) {
          // 处理数组，反向遍历以保证顺序（如果需要）
          for (let i = node[key].length - 1; i >= 0; i--) {
            stack.push({ node: node[key][i], path: [...path, key, i] });
          }
        } else if (typeof node[key] === 'object') {
          // 处理嵌套对象
          stack.push({ node: node[key], path: [...path, key] });
        } else {
          // 基本数据类型，进行过滤
          if (node[key] === targetValue) {
            result.push({
              path: [...path, key].join('.'),
              value: node[key]
            });
          }
        }
      }
    }
    // 如果根节点是基本类型（处理简单情况）
    else if (path.length === 0 && node === targetValue) {
      result.push({ path: 'root', value: node });
    }
  }
  return result;
}
// 使用相同的jsonData
const filteredResultsIterative = filterLastLayerByValueIterative(jsonData, "python");
console.log(filteredResultsIterative);
// 输出与递归方法相同

利用现有库（如Lodash，简化开发）

在实际项目中，我们常常会使用成熟的工具库来简化操作，Lodash提供了许多遍历和操作集合的函数,可以间接帮助我们实现过滤。

虽然Lodash没有直接名为“filterLastLayer”的函数，但我们可以结合_.transform、_.forEach或_.filter以及_.isPlainObject、_.isArray等辅助函数来实现。

示例代码（使用Lodash的transform）：

const _ = require('lodash');
function filterLastLayerLodash(data, targetValue) {
  const result = [];
  _.transform(data, (acc, value, key) => {
    const currentPath = acc.currentPath ? [...acc.currentPath, key] : [key];
    if (_.isPlainObject(value) && !_.isEmpty(value)) {
      // 如果是对象且非空，继续，更新路径
      acc.currentPath = currentPath;
      filterLastLayerLodash(value, targetValue, acc); // 递归调用，并将acc传递下去
      acc.currentPath = acc.currentPath.slice(0, -acc.currentPath.length + currentPath.length); // 回溯路径
    } else if (_.isArray(value)) {
      // 如果是数组，遍历元素
      _.forEach(value, (item, index) => {
        const itemPath = [...currentPath, index];
        if (_.isPlainObject(item)) {
          acc.currentPath = itemPath;
          filterLastLayerLodash(item, targetValue, acc);
          acc.currentPath = acc.currentPath.slice(0, -acc.currentPath.length + itemPath.length);
        } else {
          if (item === targetValue) {
            acc.result.push({
              path: itemPath.join('.'),
              value: item
            });
          }
        }
      });
    } else {
      // 基本数据类型
      if (value === targetValue) {
        acc.result.push({
          path: currentPath.join('.'),
          value: value
        });
      }
    }
  }, { result: [], currentPath: [] }); // 初始acc对象
  return result.result; // 从acc中取出结果
}
// 使用相同的jsonData
const filteredResultsLodash = filterLastLayerLodash(jsonData, "python");
console.log(filteredResultsLodash);
// 输出与之前相同

*(注意：上述Lodash示例为了清晰路径传递，做