如何从Redis获取的特定结构对象生成标准嵌套对象

嘿，这个场景我太熟悉了！Redis经常会把复杂的嵌套对象扁平化成这种带路径和_Type后缀的键值对，要把它转回标准的嵌套结构其实不难，核心就是按路径拆分键，再根据类型信息把值转换成对应格式。

核心思路 #

1. 分离类型与数据：先把所有带_Type后缀的键单独提取出来，建立「数据键-类型」的映射关系，方便后续转换值的类型。
2. 拆分路径：把类似meta.someArr.0.field这种带点分隔的键拆分成路径数组（比如['meta', 'someArr', '0', 'field']）。
3. 构建嵌套结构：迭代路径数组，逐步在目标对象中创建对应的对象/数组层级，同时根据类型映射把字符串值转换成正确的类型（比如把'false'转成布尔值false，'123'转成数字123）。

代码实现（JavaScript） #

先写一个类型转换工具函数，负责把字符串值转成对应类型：

function convertValue(value, type) {
  switch(type.toLowerCase()) {
    case 'string':
      return value;
    case 'number':
      return Number(value);
    case 'boolean':
      return value.toLowerCase() === 'true';
    case 'array':
      return [];
    case 'object':
      return {};
    default:
      return value; // 未知类型默认返回原值
  }
}

然后是主转换函数，处理扁平对象并生成嵌套结构：

function flattenToNested(flatObj) {
  const nestedObj = {};
  const typeMap = {};

  // 第一步：收集所有类型信息
  for (const key in flatObj) {
    if (key.endsWith('_Type')) {
      const originalKey = key.slice(0, -5); // 去掉末尾的"_Type"
      typeMap[originalKey] = flatObj[key];
    }
  }

  // 第二步：遍历所有数据键，构建嵌套结构
  for (const key in flatObj) {
    if (key.endsWith('_Type')) continue; // 跳过类型键

    const dataType = typeMap[key];
    if (!dataType) continue; // 没有类型信息的字段可根据需求调整处理逻辑

    // 转换值为对应类型
    const processedValue = convertValue(flatObj[key], dataType);
    // 拆分路径为数组
    const pathSegments = key.split('.');

    let currentNode = nestedObj;
    for (let i = 0; i < pathSegments.length; i++) {
      const segment = pathSegments[i];
      const isLastSegment = i === pathSegments.length - 1;

      // 处理数组索引（比如"0"、"1"这种数字字符串）
      if (!isNaN(Number(segment))) {
        const index = Number(segment);
        // 确保当前节点是数组
        if (!Array.isArray(currentNode)) {
          currentNode = Object.assign([], currentNode);
        }
        if (isLastSegment) {
          currentNode[index] = processedValue;
        } else {
          // 如果当前索引未初始化，根据对应类型创建空结构
          const parentPath = pathSegments.slice(0, i + 1).join('.');
          if (!currentNode[index]) {
            currentNode[index] = convertValue('', typeMap[parentPath]);
          }
          currentNode = currentNode[index];
        }
      } else {
        // 处理对象属性
        if (isLastSegment) {
          currentNode[segment] = processedValue;
        } else {
          // 如果属性未初始化，根据对应类型创建空结构
          const parentPath = pathSegments.slice(0, i + 1).join('.');
          if (!currentNode[segment]) {
            currentNode[segment] = convertValue('', typeMap[parentPath]);
          }
          currentNode = currentNode[segment];
        }
      }
    }
  }

  return nestedObj;
}

测试示例 #

用你提供的Redis对象测试一下：

const flatRedisData = {
  'username': 'hamet',
  'username_Type': 'string',
  'meta': 'object',
  'meta_Type': 'object',
  'meta.avatar': '/avatar.png',
  'meta.avatar_Type': 'string',
  'meta.active': 'false',
  'meta.active_Type': 'boolean',
  'meta.someArr': 'array',
  'meta.someArr_Type': 'array',
  'meta.someArr.0': 'object',
  'meta.someArr.0_Type': 'object',
  'meta.someArr.0.field': '123',
  'meta.someArr.0.field_Type': 'number',
  'meta.someArr.1': 'object',
  'meta.someArr.1_Type': 'object'
};

const nestedResult = flattenToNested(flatRedisData);
console.log(nestedResult);

输出的标准嵌套对象如下：

{
  username: 'hamet',
  meta: {
    avatar: '/avatar.png',
    active: false,
    someArr: [
      { field: 123 },
      {}
    ]
  }
}

注意事项 #

• 如果某个数据键没有对应的_Type键，当前函数会跳过该字段，你可以根据需求修改逻辑（比如默认按string类型处理）。
• 数组索引必须是数字格式的字符串（比如'0'、'1'），否则会被当成对象的属性名。
• 这个逻辑支持任意深度的嵌套结构，不管是多层对象还是数组嵌套都能处理。
• 如果用其他语言（比如Python、Java）实现，思路是完全一致的：拆分路径、类型转换、逐步构建嵌套结构。

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