最近做了一道面试题，想用javascript做出来，就是感觉差了那么一点，其各位大佬解答

给定一个“Flatten” Dictionary 对象其键是点分割的，例如:{"A":1,"B.A":2,"B.B":3,"CC.D.E":4,"CC.D.F":5},实现一个函数，将其转换 为一个嵌套的字典对象，根据上面例子，嵌套对象结果为{A:1,"B":{"A":2,"B":3},"CC":{"D":{"E":4,"F":5}}}
 

    /**
     * {A：1, B.A:2 B.B:3 CC.D.E:4 CC.DF:5}
     * @param args
     */
    public static void main(String[] args) {
        Map<String, Integer> flatten = new HashMap<>();
        //生成例子数据
        flatten.put("A",1);
        flatten.put("B.A",2);
        flatten.put("B.B",3);
        flatten.put("CC.D.E",4);
        flatten.put("CC.D.F",5);

        Map<String, Object> newFlatten = new HashMap<>();
        flatten.forEach((key,val)->{
            recursion(key,newFlatten, val);
        });
        System.out.println(flatten);
        System.out.println(newFlatten);
    }

    /**
     * 递归方法
     * @param key
     * @param map
     * @param val
     */
    public  static void recursion(String key ,Map<String,Object> map,Integer val){
        boolean contains = key.contains(".");
        //最后一个赋值
        if(!contains){
            map.put(key,val);
        }else{
            String beforeKey = StrUtil.subBefore(key, ".", false);
            String afterKey = StrUtil.subAfter(key, ".", false);
            HashMap<String, Object> newMap = new HashMap<>();
            if (!map.containsKey(beforeKey)){
                map.put(beforeKey,newMap);
            }else {
                newMap = (HashMap<String, Object>) map.get(beforeKey);
            }
            recursion(afterKey,newMap,val);
        }
    }

(function(a){
  var r={};
  for(var k in a){
    var i=k.split('.');
    for(var m=0;m<i.length;m++){
      var e='';
      if(m==i.length-1){
        e='r'+k.replace(/([^\.]+)/gi,'[\'$1\']').replace(/\./gi,'')+'=a[k]';
      }else{
        var x='r'+(k.match(new RegExp('((\\.|^)[^\\.]+){'+(m+1)+'}','gi'))[0]).replace(/([^\.]+)/gi,'[\'$1\']').replace(/\./gi,'');
        e=x+'='+x+'||{}';
      }
      console.log(e);
      eval(e);
    }
  }
  console.log(r)
})({"A":1,"B.A":2,"B.B":3,"CC.D.E":4,"CC.D.F":5})

笨办法

您好，我是有问必答小助手，您的问题已经有小伙伴解答了，您看下是否解决，可以追评进行沟通哦~

如果有您比较满意的答案 / 帮您提供解决思路的答案，可以点击【采纳】按钮，给回答的小伙伴一些鼓励哦～～

ps:问答VIP仅需29元，即可享受5次/月 有问必答服务，了解详情>>>https://vip.csdn.net/askvip?utm_source=1146287632

function fn(o){
    let keys = Reflect.ownKeys(o)
    let t = {}
    keys.forEach(str => {
        // 获取值
        let v = o[str]
        // 创建一个新的临时对象用来保存值
        // 从最内部的键名开始
        let _t = {}
        str.split(".").reverse().forEach((key, index) => {
            let obj = {}
            index === 0 ? obj[key] = v : obj[key] = _t
            _t = obj
        })

        // 比较对象赋值
        let outT= t;
        let b = true;
        while(b){
            if(Object.prototype.toString(_t).slice(8,-1) !== "Object"){
                console.error('_t 不是一个对象： ',_t)
                break;
            }
            // 获取临时对象的键名
            key = Reflect.ownKeys(_t)
            // 因为参数对象不会有重复的属性
            // 所以只需要检查属性的值 === undefined
            if(outT[key] === undefined){
                outT[key] = _t[key]
                b = false;
            }else{
                outT = outT[key];
                _t = _t[key]
            }
        }
    })
    return t;
}


let t = fn({"A":1,"B.A":2,"B.B":3,"CC.D.E":4,"CC.D.F":5})