基于映射规则转换任意深度嵌套JS对象AST结构的方案问询

核心实现思路 #

方案基于递归遍历逻辑实现，天然支持任意层级深度的嵌套转换，可按需引入lodash简化对象取值、类型判断等操作，核心逻辑分层如下：

• 规则解析层：遍历映射规则的每一项，根据规则值的类型区分处理逻辑，支持直接字段映射、递归子节点映射、自定义转换函数三类基础规则，可按需扩展
• 递归转换层：处理到嵌套子节点配置时，自动读取源数据对应子数组，复用指定规则对每个子项递归执行转换，直到没有更深层级的子节点为止
• 扩展适配层：预留自定义转换、多规则切换能力，适配不同上游供应商的数据结构差异，不需要修改核心转换逻辑

可直接运行的实现代码 #

代码兼容给出的测试样例，同时预留了扩展能力：

const _ = require('lodash');

/**
 * 递归转换嵌套结构对象
 * @param {Object} sourceNode 源数据当前处理节点
 * @param {Object} currentRule 当前节点对应的映射规则
 * @param {Object} allRules 全量规则集合，用于子节点指定其他映射规则的场景
 * @returns {Object} 转换后的标准结构节点
 */
function convertNode(sourceNode, currentRule, allRules = currentRule) {
  if (!_.isPlainObject(sourceNode)) return sourceNode;
  const result = {};

  _.forOwn(currentRule, (ruleConfig, targetKey) => {
    // 规则为字符串：直接映射对应路径的源字段
    if (_.isString(ruleConfig)) {
      const sourceVal = _.get(sourceNode, ruleConfig);
      if (!_.isUndefined(sourceVal)) result[targetKey] = sourceVal;
      return;
    }

    // 规则为函数：执行自定义转换逻辑，支持多字段拼接、值格式化
    if (_.isFunction(ruleConfig)) {
      result[targetKey] = ruleConfig(sourceNode);
      return;
    }

    // 规则为对象：分两类场景处理
    if (_.isPlainObject(ruleConfig)) {
      // 场景1：配置了identifier，为嵌套子节点数组，递归转换
      if (ruleConfig.identifier) {
        const childSourceList = _.get(sourceNode, ruleConfig.identifier);
        if (!_.isArray(childSourceList)) return;

        // 确定子节点使用的映射规则：ofType为map时复用当前规则，否则取全量规则中对应配置
        const childRule = ruleConfig.ofType === 'map' 
          ? currentRule 
          : _.get(allRules, ruleConfig.ofType);
        
        if (childRule) {
          result[targetKey] = childSourceList.map(child => convertNode(child, childRule, allRules));
        }
        return;
      }

      // 场景2：无identifier，为当前节点下的自定义子结构，递归用子规则转换
      result[targetKey] = convertNode(sourceNode, ruleConfig, allRules);
    }
  });

  return result;
}

// 测试样例验证
const source = {
  a:1,
  b:2,
  c:7,
  children:[
    {
      a:3,
      b:7,
      d:8,
      children: [
        {
          a:6,
          b:8,
          x:4
        }
      ]
    },
    {
      a:5,
      b:3,
      c:9
    }
  ]
};

const map = {
  c:'a',
  d:'b',
  elements: {
    identifier:'children',
    ofType: 'map'
  }
};

const output = convertNode(source, map);
// 输出结果与预期完全一致

建模优化建议 #

针对多上游数据统一转换的场景，可以在现有规则模型基础上做三层拆分，降低后续维护成本：

• 第一层：固定标准产品模型，明确定义输出结构的字段名、字段类型、是否必填，作为所有转换的校验基准
• 第二层：为每个上游供应商单独维护映射规则，规则中除了基础字段映射，可扩展支持默认值配置、枚举值映射、值类型转换等能力，不同上游的规则互相独立不影响
• 第三层：转换后增加自动校验逻辑，对照标准产品模型检查输出结果，缺失必填字段、类型错误时提前抛出异常，避免异常数据流入下游

运行上述测试代码可以得到和需求完全一致的输出，针对不同结构的上游数据，只需要新增对应的映射规则即可，不需要修改核心转换函数。

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