Generare una struttura annidata oggetto stringa chiave/percorso

Question

Voglio fare una funzione chiamata createAssociativeArray che recive due parametri: string e object, in questo modo:

function createAssociativeArray(string, object) { 
    //... 
} 

L'ultima voce di string dovrebbe ottenere il object dati. Vedere un esempio di utilizzo/reso:

createAssociativeArray('key1.key2.key3', { 
    data1: 1, 
    data2: 2, 
    data3: 3 
}); 

// key1: { 
// key2: { 
//  key3: { 
//  data1: 1, 
//  data2: 2, 
//  data3: 3 
//  } 
// } 
// } 

Qual è il metodo più semplice e affidabile per farlo?

Utilizzare eval non è possibile.

---

Quello che mi è stato provato:

function createAssociativeArray(string, object) { 
    string = string.split('.'); 
    return string.reduce(function(_object, _target, i) { 
    _object[_target] = (i + 1 === string.length ? object : {}); 
    return _object; 
    }, {}); 
} 

Non ha prodotto il risultato atteso, perché l'oggetto viene azzerato a {}.

[JSFiddle]

Answer 1

Ecco cosa mi è venuta:

function createAssociativeArray(string, object) { 
    var parts = string.split('.'); 
    var last = parts[parts.length - 1]; 
    var tree = {}; 

    var node = parts.slice(0, -1).reduce(function (memo, current) { 
    return (memo[current] = {}); 
    }, tree); 

    node[last] = object; 
    return tree; 
} 

Answer 2

ero curioso di vedere se potevo fare una soluzione ricorsiva, ecco che è:

function createAssociativeArray(string, object) { 
    if (string === "") return object; 
    var stringarr = string.split('.'); 
    var laststr = stringarr.pop(); 
    var newobj = {}; 
    newobj[laststr] = object; 
    return createAssociativeArray(stringarr.join("."), newobj); 
} 

Demo di lavoro JSFiddle: https://jsfiddle.net/pt352dxg/

Answer 3

Possibile implementazione on:

Working demo

function createChain(keys, value) { 
    var obj = {}; 
    var target = obj; 
    keys = keys.split('.'); 
    keys.forEach(function(key, index) { 
    target = target[key] = index === keys.length - 1 ? value : {}; 
    }); 
    target = value; 
    return obj; 
} 

Answer 4

Questa funzione può effettivamente accettare un oggetto esistente opzionale ({k: 2, kk: 3, chiave1: 4}) e unire che con percorso determinato json. per esempio. Prova su console cromata debugger:

JSON.stringify(createAssociativeArray('key1.key2.key3', { data1: 1, data2: 2, data3: 3}, {k:2,kk:3, key1:{}})) 

stamperà questo:

"{"k":2,"kk":3,"key1":{"key2":{"key3":{"data1":1,"data2":2,"data3":3}}}}" 

..

function createAssociativeArray(key, value, data) { 
     if(!finalData && data) 
      finalData = data; 
     var finalData; 
     if (!data) 
      data = finalData = {}; 
     var keys = key.split('.'); 
     if (keys.length < 2) { 
      data[keys[0]] = value; 
     } else { 
      if (!data[keys[0]]) 
       data[keys[0]] = {}; 
      data = data[keys.shift()];    
      createAssociativeArray(keys.join("."),value,data); 
     } 
     return finalData; 
    }; 

Answer 5

Questo ha funzionato per me:

function createAssociativeArray(string, object){ 
    var array = string.split('.'); 
    var aArray = {}; 
    if(array.length > 1){ 
     aArray[array[array.length - 1]] = object; 
     array.splice(array.length - 1, 1); 
     createAssociativeArray(array.join('.'), aArray) 
    }else{ 
     aArray[array[array.length - 1]] = object; 
     return aArray 
    } 
}; 


createAssociativeArray('key1.key2.key3', {data1: 1, data2: 2, data3: 3}); 

In sostanza, costruisce oggetti da ground up, iniziando con l'oggetto originale t, quindi avvolgendo gli 'strati' attorno ad esso in modo ricorsivo

Answer 6

Bel caso per una funzione ricorsiva!

function createAssociativeArray(string, object) { 
    if (string.split('.').length == 1) { 
    var outObj = {}; 
    outObj[string] = object; 
    return outObj; 
    } else { 
    var outObj = {}; 
    outObj[string.split('.')[0]] = createAssociativeArray(string.split('.').slice(1).join('.'), object); 
    return outObj; 
    } 
} 

Answer 7

Eri molto vicino nel tuo tentativo originale.

function createAssociativeArray(string, object) { 
    return string.split('.').reverse().reduce(function (inner, key) { 
     var outer = {}; 
     outer[key] = inner; 
     return outer; 
    }, object); 
} 

http://jsfiddle.net/xewoa06t/

Answer 8

E 'più facile con un semplice ciclo, il punto chiave è fare in senso inverso (come @JustcallmeDrago)

function createAssociativeArray(keys, data) 
 
{ 
 
    var temp, keyPart 
 
    
 
    for(keys = keys.split('.'); keys.length; data = temp) 
 
    { 
 
    keyPart = keys.pop() 
 
    temp = {} 
 
    temp[keyPart] = data 
 
    } 
 
    return data 
 
} 
 

 
// TEST 
 

 
x = createAssociativeArray("key1.key2.key3", { data1: "value1", data2: "value2" }) 
 

 
document.write('<pre>'+x+'\n'+x.key1 +'\n' 
 
       +x.key1.key2 + '\n' 
 
       +x.key1.key2.key3 +'\n' 
 
       +x.key1.key2.key3.data1 +'\n' 
 
       +x.key1.key2.key3.data2 +'</pre>')

Answer 9

Dal momento che nessuno ha proviced un while soluzione -loop:

function namespace(path, context) { 
    var obj = context; 
    var s = path.split('.'); 
    var p; 
    while (s.length) { 
     p = s.shift(); 
     obj = obj[p] || (obj[p] = {}); 
    } 
    return context; 
}