Objekteigenschaften rekursiv hinzufügen

Question

Wenn ich ein Array von Arrays habe, die jeweils aus Objekteigenschaftsnamen (Strings) bestehen, wie kann ich ein Objekt rekursiv ändern, um zu prüfen, ob die Eigenschaft existiert oder nicht, und sie entsprechend hinzufügen. Der letzte Wert im Array wird als Zeichenfolgenwert der angegebenen Eigenschaft angewendet.

const propsToAdd = [ 
    ['propA', 'value'], 
    ['propB', 'propC', 'propD', 'value'], 
    ['propB', 'propF', 'value'] 
]; 

Das resultierende Objekt enthalten würde die relevanten Eigenschaften (verschachtelt entsprechend) und den Wert der letzten Eigenschaft würde in dem Array zu dem letzten Elemente gleich sein.

const resultingObj = { 
    propA: 'value', 
    propB: { 
     propC: { 
      propD: 'value' 
     } 
     propF: 'value' 
    } 
}; 

Ich mag würde ein solches Objekt rekursiv erzeugen, wie die Anordnung von unbekannter Länge sein wird, ebenso wie die Subarrays.

Es ist wichtig zu beachten, dass die folgenden nicht auftreten auftreten und nicht berücksichtigt werden müssen.

const propsToAdd = [ 
    ['propA', 'value'], 
    ['propA', 'value', 'value1'] 
]; 

sonst Stoßen, value (als Kind propA) können nicht beide eine Eigenschaft und ein Wert Name sein.

Wie kann ich eine rekursive Funktion schreiben, die Schlüssel/Wert-Paare zu einem Objekt hinzufügt (und nistet)?

Answer 1

createRec erstellt rekursiv das Objekt in einer verschachtelten Form.

function processInput(propsToAdd) { 
 
    var resultingObj = {}, 
 
    propArr; 
 

 
    for (var i = 0, len = propsToAdd.length; i < len; i += 1) { 
 
    propArr = propsToAdd[i]; 
 
    createRec(propArr, resultingObj); 
 
    } 
 

 
    return resultingObj; 
 
} 
 

 
function createRec(propArr, resultingObj, index) { 
 
    var prop, 
 
    value_Str = 'value'; 
 
    for (var j = index || 0, len1 = propArr.length; j < len1; j += 1) { 
 
    prop = propArr[j]; 
 
    if (!resultingObj[prop]) { 
 
     resultingObj[prop] = {}; 
 
    } 
 
    if (propArr[j + 1] === value_Str) { 
 
     resultingObj[prop] = propArr[j + 1]; 
 
     j += 1; 
 
    } else { 
 
     createRec(propArr, resultingObj[prop], j + 1); 
 
     j = len1; 
 
    } 
 
    } 
 
} 
 

 
console.log(processInput([ 
 
    ['propA', 'value'], 
 
    ['propB', 'propC', 'propD', 'value'], 
 
    ['propB', 'propF', 'value'] 
 
]));

Answer 2

Es ist nicht rekursive Version, aber warum nicht?

function createObj(propsToAdd){ 
    obj = {} 
    for(var i = 0; i < propsToAdd.length; i++){ 
     var tmp = obj; 
     var props = propsToAdd[i]; 
     for(var j = 0; j < props.length-2; j++){ 
      var prop_name = props[ j ]; 
      if(!(prop_name in tmp)) 
       tmp[ prop_name ] = {} 
      tmp = tmp[ prop_name ]; 
     } 
     if(props.length > 1) 
      tmp[ props[ j ] ] = props[ j + 1 ] 
     else 
      obj = props[0]; 
    } 
    return obj; 
} 

Answer 3

Verschluss ist hier über alle Eigenschaftslisten zu durchlaufen, die das Objekt hinzugefügt werden sollen.

Immer wenn eine neue Eigenschaft gefunden wird, wird ein neues Objekt erstellt. Dieses neue Objekt wird für weitere Erweiterungen gesendet.

Immer wenn wir zum letzten Wert der Eigenschaftenliste gelangen, wird er der aktuellen Eigenschaft zugewiesen.

var addProperties = (function() { 
 

 
    var addProperties = function(object, properties) { 
 
    var currentProperty = properties.shift(); 
 
    if (properties.length === 1) { 
 
     object[currentProperty] = properties[0]; 
 
    } 
 
    else{ 
 
     if (!object.hasOwnProperty(currentProperty)) 
 
     object[currentProperty] = {}; 
 
     addProperties(object[currentProperty], properties); 
 
    } 
 
    }; 
 

 

 
    return function(object, propertiesArray) { 
 
    propertiesArray.forEach(function(propertyList) { 
 
     addProperties(object, propertyList); 
 
    }); 
 
    }; 
 

 
}()); 
 

 

 
const propsToAdd = [ 
 
    ['propA', 'value'], 
 
    ['propB', 'propC', 'propD', 'value'], 
 
    ['propB', 'propF', 'value'] 
 
]; 
 
var object = {}; 
 
addProperties(object, propsToAdd); 
 
console.log(object);

Answer 4

Da die Nutzung von const ES2015 schon sagt, können Sie nutzen arrow functions machen, destructuring assignment und default parameters:

const nest = ([x, ...xs], o={}) => 
 
    xs.length === 0 ? x : (o[x] = nest(xs,o[x]), o); 
 

 
const nestmany = ([xs, ...yss], o={}) => 
 
    xs === undefined ? o : nestmany(yss, nest(xs,o)); 
 

 
const propsToAdd = [ 
 
    ['propA', 'value1'], 
 
    ['propB', 'propC', 'propD', 'value2'], 
 
    ['propB', 'propF', 'value3'] 
 
]; 
 

 
console.log(nestmany(propsToAdd));