第 112 题：编程题，写个程序把 entry 转换成如下对象

Question

var entry = {
  'a.b.c.dd': 'abcdd',
  'a.d.xx': 'adxx',
  'a.e': 'ae'
}

// 要求转换成如下对象
var output = {
  a: {
   b: {
     c: {
       dd: 'abcdd'
     }
   },
   d: {
     xx: 'adxx'
   },
   e: 'ae'
  }
}

Answer 1

@RGXMG 我的实现思路和你这个一致，喜欢你这个

Answer 2

var entry = {
    'a.b.c.dd': 'abcdd',
    'a.d.xx': 'adxx',
    'a.e': 'ae'
}

function getOutput(obj) {
    let output = {};

    if (Object.prototype.toString.call(entry) === '[object Object]') {
        for (let i in obj) {
            let splitKey = i.split('.');

            (function getKeys(output, splitKey, value) {
                const key = splitKey.shift();
                if (!splitKey.length) {
                    output[key] = value;
                } else {
                    output[key] = output[key] || {};
                    getKeys(output[key], splitKey, value)
                }
            })(output, splitKey, obj[i])
        }
    } else {
        console.log('传入的不是对象');
    }

    return output;
}

getOutput(entry)

Answer 3

function changeToNormal(obj) {
    let newObj = {};
    let t = newObj;
    const keys = Object.keys(obj);
    for (key of keys) {
        const fArr = key.split('.');
        while (fArr.length) {
            const val = fArr.length === 1 ? entry[key] : {};
            const tmpKey = fArr.shift();
            t[tmpKey] = t[tmpKey] || val;
            t = t[tmpKey];
        }
        t = newObj;
    }
    return newObj;
}

Answer 4

实现思路：

1. 对象entry的key中含有的.就是一个对象嵌套，所以可以用split()函数将其划分为一个array，所以array的length - 1下标所对应的元素就是entry的一个key的具体值。
2. 利用对象为地址引用原理，进行增加元素。
3. 采用reduce函数，将每一次的引用返回。

const entry = {
  'a.b.c.dd': 'abcdd',
  'a.d.xx': 'adxx',
  'a.e': 'ae',
};
const changObjStructureOfNormal = output => {
  const keys = Object.keys(output);
  const resObj = {};
  for (const key of keys) {
    const everyKey = key.split('.');
    everyKey.reduce((pre, next, index, array) => {
      if (index === array.length - 1) {
        pre[next] = output[key];
        return;
      }
      pre[next] = pre[next] || {};
      return pre[next];
    }, resObj);
  }
  return resObj;
};
changObjStructureOfNormal(entry);

Answer 5

var entry = {
    'a.b.c.dd': 'abcdd',
    'a.d.xx': 'adxx',
    'a.e': 'ae'
}

function transObj(input) {
    let ouput = null
    let arr = Object.entries(input)
    arr.forEach((item,index)=>{
        let cellArr = item[0].split('.')
        let cellObj = {}
        let count = 0
        while(cellArr.length) {
            let key = cellArr.splice(-1)
            if(count == 0) {
                cellObj = {[key]:item[1]}
                count ++
            }else {
                if(ouput && ouput[key]) {
                    ouput[key] = Object.assign(ouput[key],cellObj)
                }else {
                    cellObj = {[key]:cellObj}
                }
                
            }  
        }
        if(!ouput) {
            ouput = cellObj
        }
    })
    return ouput
}

console.log(transObj(entry))

Answer 6

var entry = {
    'a.b.c.dd': 'abcdd',
    'a.d.xx': 'adxx',
    'a.e': 'ae'
}
function setFlat (entry) {
    let res = {}
    function namespace(oNamespace, sPackage, value) {
        let iner = oNamespace
        let arr = sPackage.split('.')
        let len = arr.length
        arr.forEach((key, idx) => {
            iner = iner[key] = (idx === len - 1 ? value : (iner[key] instanceof Object ? iner[key] : {}))
        })
    }
    for (let k in entry) {
        namespace(res, k, entry[k])
    }
    return res
}
console.log(JSON.stringify(setFlat(entry)))
// {"a":{"b":{"c":{"dd":"abcdd"}},"d":{"xx":"adxx"},"e":"ae"}}

Answer 7

var deFlat = function(entry) {
  const res = {};
  for (let key in entry) {
    const sequenceKey = key.split('.');
    format(res, sequenceKey, entry[key]);
  }
  return res;
}

var format = function(obj, sequenceKey, value) {
  const key = sequenceKey.shift();
  if (!sequenceKey.length) {
    obj[key] = value;
  } else {
    obj[key] = obj[key] || {};
    format(obj[key], sequenceKey, value);
  }
}

var entry = {
  'a.b.c.dd': 'abcdd',
  'a.d.xx': 'adxx',
  'a.e': 'ae'
}

console.log(deFlat(entry))

Answer 8

var entry = {
    'a.b.c.dd': 'abcdd',
    'a.d.xx': 'adxx',
    'a.e': 'ae',
    'd.e.x': 'dex'
}
const obj = {};
Object.keys(entry).map((keyName) => {
    return keyName.split('.');
}).forEach(keysArr => {
    let currObj = obj;
    const keysArrLength = keysArr.length;
    for (let i = 0; i < keysArrLength; i += 1) {
        const keyItem = keysArr[i];
        if (!currObj[keyItem]) {
            currObj[keyItem] = i !== keysArrLength - 1 ? {} : entry[keysArr.join('.')];
        }
        currObj = currObj[keyItem];
    }
});
console.log(obj);

Answer 9

const func2 = (input, output = {}) => {
  const generateKeys = (key, value, output = {}) => {
    const index = key.indexOf('.')
    if (index > 0) {
      const s = key.substring(0, index)
      const e = key.substring(index + 1)
      if (!output[s]) output[s] = {}

      generateKeys(e, value, output[s])
    } else {
      output[key] = value
    }
  }

  for (const k in input) {
    generateKeys(k, input[k], output)
  }
}

const o2 = {}
const input = func2(entry, o2)
console.log('o2', JSON.stringify(o2))

Answer 10

题目

// 输入
var entry = {
    'a.b.c.dd': 'abcdd',
    'a.d.xx': 'adxx',
    'a.e': 'ae'
};

// 要求转换成如下对象
var output = {
    a: {
        b: {
            c: {
                dd: 'abcdd'
            }
        },
        d: {
            xx: 'adxx'
        },
        e: 'ae'
    }
};

实现思路

遍历对象，如果键名称含有 . 将最后一个子键拿出来，构成对象，如 {'a.b.c.dd': 'abcdd'} 变为 {'a.b.c': { dd: 'abcdd' }} , 如果变换后的新父键名中仍还有点，递归进行以上操作即可。

// 输入
{
    'a.b.c.dd': 'abcdd',
    'a.d.xx': 'adxx',
    'a.e': 'ae'
}
// 1
t1 = {
    'a.b.c': { dd: 'abcdd' },
    'a.d': { xx: 'adxx' },
    a: { e: 'ae' }
};
// 2
// t1 = {
//     'a.b': { c: { { dd: 'abcdd' } },
//     a: { d: { { xx: 'adxx' } },
//     a: { e: 'ae' }
// };
// a.d 属性进行拆分时 需要新加入父键 a 而a已经存在 则进行合并
t2 = {
    'a.b': { c: { dd: 'abcdd' } },
    a: { e: 'ae', d: { xx: 'adxx' }  }
};
// 3
// t3 = {
//     'a': { b: { c: { dd: 'abcdd' } } },
//     a: { e: 'ae', d: { xx: 'adxx' }  }
// };
t3 = {
    a: { b: { c: { dd: 'abcdd' } }, e: 'ae', d: { xx: 'adxx' }  }
};

代码

function nested(obj) {
    Object.keys(obj).map(k => {
        getNested(k);
    });

    return obj;

    function getNested(key) {
        const idx = key.lastIndexOf('.');
        const value = obj[key];
        if (idx !== -1) {
            delete obj[key];
            const mainKey = key.substring(0, idx);
            const subKey = key.substr(idx + 1);
            if (obj[mainKey] === undefined) {
                obj[mainKey] = { [subKey]: value };
            } else {
                obj[mainKey][subKey] = value;
            }
            if (/./.test(mainKey)) {
                getNested(mainKey);
            }
        }
    }
}

console.log(JSON.stringify(nested(entry), 0, 2));

Answer 11

我继续先来

 var entry = {
    'a.b.c.dd': 'abcdd',
    'a.d.xx': 'adxx',
    'a.e': 'ae'
  }

  function map(entry) {
    const obj = Object.create(null);
    for (const key in entry) {
      const keymap = key.split('.');
      set(obj, keymap, entry[key])
    }
    return obj;
  }

  function set(obj, map, val) {
    let tmp;
    if (!obj[map[0]]) obj[map[0]] = Object.create(null);
    tmp = obj[map[0]];
    for (let i = 1; i < map.length; i++) {
      if (!tmp[map[i]]) tmp[map[i]] = map.length - 1 === i ? val : Object.create(null);
      tmp = tmp[map[i]];
    }
  }
  console.log(map(entry));