Question

我正在尝试构建一个扩展对象的函数，如：

{
    'ab.cd.e' : 'foo',
    'ab.cd.f' : 'bar',
    'ab.g' : 'foo2'
}

进入嵌套对象：

{ab: {cd: {e:'foo', f:'bar'}, g:'foo2'}}

喜欢这个php函数：Set::expand()

当然不使用eval。

Answer 1

我相信这就是你所追求的：

function deepen(o) {
  var oo = {}, t, parts, part;
  for (var k in o) {
    t = oo;
    parts = k.split('.');
    var key = parts.pop();
    while (parts.length) {
      part = parts.shift();
      t = t[part] = t[part] || {};
    }
    t[key] = o[k]
  }
  return oo;
}

例如：

> JSON.stringify(deepen({'ab.cd.e' : 'foo', 'ab.cd.f' : 'bar', 'ab.g' : 'foo2'}))`

"{"ab":{"cd":{"e":"foo","f":"bar"},"g":"foo2"}}"

Answer 2

如果你正在使用Node.js（例如 - 如果没有剪切并粘贴我们的模块），试试这个包：https://www.npmjs.org/package/dataobject-parser

构建了一个执行正向/反向操作的模块：

https://github.com/Gigzolo/dataobject-parser

它现在被设计为自我管理对象。通过实例化DataObjectParser的实例来使用。

var structured = DataObjectParser.transpose({
    'ab.cd.e' : 'foo',
    'ab.cd.f' : 'bar',
    'ab.g' : 'foo2'
});

structured.data()返回嵌套对象：

{ab: {cd: {e:'foo', f:'bar'}, g:'foo2'}}

所以这是JSFiddle中的一个工作示例：

http://jsfiddle.net/H8Cqx/

Answer 3

函数名称很糟糕，代码很快就生成了，但它应该可以工作。请注意，这会修改原始对象，我不确定您是否要创建一个新对象，该对象是旧对象的扩展版本。

(function(){

    function parseDotNotation( str, val, obj ){
    var currentObj = obj,
        keys = str.split("."), i, l = keys.length - 1, key;

        for( i = 0; i < l; ++i ) {
        key = keys[i];
        currentObj[key] = currentObj[key] || {};
        currentObj = currentObj[key];
        }

    currentObj[keys[i]] = val;
    delete obj[str];
    }

    Object.expand = function( obj ) {

        for( var key in obj ) {
        parseDotNotation( key, obj[key], obj );
        }
    return obj;
    };

})();



var expanded = Object.expand({
    'ab.cd.e' : 'foo',
        'ab.cd.f' : 'bar',
    'ab.g' : 'foo2'
});



JSON.stringify( expanded );  


//"{"ab":{"cd":{"e":"foo","f":"bar"},"g":"foo2"}}"

Answer 4

派生自Esailija's answer，修复程序支持多个顶级密钥。

(function () {
    function parseDotNotation(str, val, obj) {
        var currentObj = obj,
            keys = str.split("."),
            i, l = Math.max(1, keys.length - 1),
            key;

        for (i = 0; i < l; ++i) {
            key = keys[i];
            currentObj[key] = currentObj[key] || {};
            currentObj = currentObj[key];
        }

        currentObj[keys[i]] = val;
        delete obj[str];
    }

    Object.expand = function (obj) {
        for (var key in obj) {
            if (key.indexOf(".") !== -1)
            {
                parseDotNotation(key, obj[key], obj);
            }            
        }
        return obj;
    };

})();

var obj = {
    "pizza": "that",
    "this.other": "that",
    "alphabets": [1, 2, 3, 4],
    "this.thing.that": "this"
}

输出：

{
    "pizza": "that",
    "alphabets": [
        1,
        2,
        3,
        4
    ],
    "this": {
        "other": "that",
        "thing": {
            "that": "this"
        }
    }
}

`Fiddle`

Answer 5

您需要将每个字符串键转换为对象。使用以下功能可以获得欲望结果。

 function convertIntoJSON(obj) {

                var o = {}, j, d;
                for (var m in obj) {
                    d = m.split(".");
                var startOfObj = o;
                for (j = 0; j < d.length  ; j += 1) {

                    if (j == d.length - 1) {
                        startOfObj[d[j]] = obj[m];
                    }
                    else {
                        startOfObj[d[j]] = startOfObj[d[j]] || {};
                        startOfObj = startOfObj[d[j]];
                    }
                }
            }
            return o;
        }

现在调用此函数

 var aa = {
                'ab.cd.e': 'foo',
                'ab.cd.f': 'bar',
                    'ab.g': 'foo2'
                };
   var desiredObj =  convertIntoJSON(aa);

Answer 6

您可以通过将默认对象用于未访问的级别，将键字符串拆分为路径，并减少它以分配值。

function setValue(object, path, value) {
    var keys = path.split('.'),
        last = keys.pop();

    keys.reduce((o, k) => o[k] = o[k] || {}, object)[last] = value;
    return object;
}

var source = { 'ab.cd.e': 'foo', 'ab.cd.f': 'bar', 'ab.g': 'foo2' },
    target = Object
        .entries(source)
        .reduce((o, [k, v]) => setValue(o, k, v), {});

console.log(target);

Answer 7

有效的方法，但可能不是最有效的方法（也依赖于ECMA 5 Object.keys（）方法，但可以轻松替换。

var input = {
    'ab.cd.e': 'foo',
    'ab.cd.f': 'bar',
    'ab.g': 'foo2'
};

function createObjects(parent, chainArray, value) {
    if (chainArray.length == 1) {
        parent[chainArray[0]] = value;
        return parent;
    }
    else {
        parent[chainArray[0]] = parent[chainArray[0]] || {};
        return createObjects(parent[chainArray[0]], chainArray.slice(1, chainArray.length), value);
    }
}

var keys = Object.keys(input);
var result = {};

for(var i = 0, l = keys.length; i < l; i++)
{
    createObjects(result, keys[i].split('.'), input[keys[i]]);
}

JSFiddle是here。

将javascript点表示法对象转换为嵌套对象

7 个答案:

`Fiddle`