Сериализация объекта (точнее даже десериализация).

[quikki]

var objNew = {
    text: {
        subText: {
            value: 'value1'
        },
        modificator: {
            name: 'name1',
            params: 'params1'
        }
    },
    attrs: {
        title: 'title1'
    }
};


obj2 = {
    'text.subText.value': 'value1',
    'text.modificator.name': 'name1',
    'text.modificator.params': 'params1',
    'attrs.title': 'title1'
};

Такая задачка, ребят, что нужно привести obj2 к objNew.

За несколько дней смог добиться некоторых успехов, но не понимаю, как можно реализовать глубину свойств (вложенность).

var obj4 = {};
var keysOfObj = [];
var valueOfObj = [];
var sum = 0;

function funBack(object) {

    //получаю значения свойств и записываю их в качестве элементов масива valueOfObj
    for (var key in object) {
        valueOfObj.push(object[key]);
    }


    //Ключи первоначального объекта записываю в качестве элементов массива keysOfObjWithDots
    var keysOfObjWithDots = [];
    keysOfObjWithDots = Object.getOwnPropertyNames(obj3);
    console.log(keysOfObjWithDots);



    //Ключи первоначального объекта записываю в качестве элементов массива keysOfObj (причём каждый элемент из keysOfObjWithDots представляет отдельный массив)
    for (var key1 = 0; key1 < keysOfObjWithDots.length; key1++) {
        keysOfObj.push(keysOfObjWithDots[key1].split('.'));
    }
    console.log(keysOfObj);


    //В каждый элемент (который является массивом) массива keysOfObj, добавляю последним элементом соответсвующее valueOfObj.
    for (var key2 = 0; key2 < keysOfObj.length; key2++) {
        keysOfObj[key2].push(valueOfObj[sum]);
        sum++;
    }
    //получаем обновлённый keysOfObj, который соответствует первоначальному объекту оформленному в виде массива. 
    console.log(keysOfObj);

    //---------------пытаюсь сделать функцию, которая через рекурсию будет добавлять свойства

    analize(obj4);

    function analize(object) {
        for (var key3 = 0; key3 < keysOfObj.length; key3++) {
            step:
            for (var key4 = 0; key4 < keysOfObj[key3].length; key4++) {
                
                if (!object.hasOwnProperty(keysOfObj[key3][key4]))
                {
                    object[keysOfObj[key3][key4]] = new Object(keysOfObj[key3][key4 + 1]); 
                }

            }


            // Удаляю из объекта каждое последнее свойство, которые были добавлены из многомерного массива keysOfObj, потому что они являются не свойствами, а значениями самых глубоких свойств. сравнить можно с picture1 (на рабочем столе)

            if (object.hasOwnProperty(keysOfObj[key3][keysOfObj[key3].length - 1])) {
                delete object[keysOfObj[key3][keysOfObj[key3].length - 1]];
            }
        }
    }
}
funBack(obj3);

и вот какой результат я получаю: Untitled.jpg

Думаю решение намного более элегантное, но пока я не умею красиво мыслить. Если кто-то заинтересуется и наставит, как справиться то буду очень благодарен)

[рони]

quikki,

<script>
  var objNew = {
    text: {
        subText: {
            value: 'value1'
        },
        modificator: {
            name: 'name1',
            params: 'params1'
        }
    },
    attrs: {
        title: 'title1'
    }
};
function fn(a) {
    var b = {},
        c;
    for (c in a) {
        var d = a[c];
        if ("object" == typeof d) {
            var e = true;
            Object.keys(d).forEach(function(a) {
                b[c + "." + a] = d[a]
            })
        } else b[c] = d
    }
    return e ? fn(b) : b
};
var obj = fn(objNew);
document.write(JSON.stringify(obj, null, 4))
  </script>

[Malleys]

var obj2 = {
    'text.subText.value': 'value1',
    'text.modificator.name': 'name1',
    'text.modificator.params': 'params1',
    'attrs.title': 'title1'
};

function expand(object) {
    var result = {};

    for(var key in object) {
        var context = result;
        var keys = key.split(".");
        var property = keys.pop();

        context = keys.reduce((m,v) => {
            return v in m ? m[v] : m[v] = {};
        }, context);

        context[property] = object[key];
    }

    return result;
}

alert(JSON.stringify(expand(obj2), null, "\t"));

[рони]

quikki,

<script>
  var objNew = {
    text: {
        subText: {
            value: 'value1'
        },
        modificator: {
            name: 'name1',
            params: 'params1'
        }
    },
    attrs: {
        title: 'title1'
    }
};
function fn(a) {
    //a = {...a}
    for (var b in a) {
        var c = a[b];
        if ("object" == typeof c) {
            var e = !0;
            Object.keys(c).forEach(function(d) {
                a[b + "." + d] = c[d]
            });
            delete a[b]
        }
    }
    return e ? fn(a) : a
};
var obj = fn(objNew);
document.write(JSON.stringify(obj, null, 4))
  </script>

[рони]

наоборот сделал ))) objNew в obj2

[рони]

quikki,
Генерация названий объектов - конкатенация названий объектов

[quikki]

context = keys.reduce((m,v) => {
            return v in m ? m[v] : m[v] = {};
        }, context);

        context[property] = object[key];
    }

    return result;
}

alert(JSON.stringify(expand(obj2), null, "\t"));

Можете объяснить эту часть кода, именно то что делает стрелочная функция, спасибо большое заранее)

[Artur_Hopf]

Это крутой уровень JS просто, им владеет рони и другие программисты. А мы из своей пещеры, почесывая дубинкой задницу используем обычные слова function или if else

(m,v) => {
 return v in m ? m[v] : m[v] = {};

//это все ровно что:

function (m){
   return v if(m){
       return m[v];
    }else{
        return  m[v] = {};
    }
}

может где то ошибся, но примерно так =)
=> в данном случае говорит что это функция, ? говорит что перед ним условие if , : говорит о том что это else

Хацкеры они все там, кто такое использует =))