Javascript: ottieni un valore profondo dall’object passando il percorso ad esso come stringa

Possibile duplicato:
Accesso agli oggetti JavaScript nidificati con chiave di stringa

Forse il titolo non è abbastanza chiaro, semplicemente non sapevo come specificare cosa stavo cercando e il mio inglese è davvero brutto, mi dispiace.

Sto cercando di creare una funzione che restituisca il valore dell’object, ma che sia anche piacevole con oggetti nidificati. Per esempio:

var obj = { foo: { bar: 'baz' } }; 

Voglio accedere al valore di obj.foo.bar supplicando la stringa “foo.bar” alla funzione.

 function(obj, path) { // Path can be "foo.bar", or just "foo". } 

Grazie!

Considera questo:

 var obj = { foo: { bar: 'baz' } }; function deepFind(obj, path) { var paths = path.split('.') , current = obj , i; for (i = 0; i < paths.length; ++i) { if (current[paths[i]] == undefined) { return undefined; } else { current = current[paths[i]]; } } return current; } console.log(deepFind(obj, 'foo.bar')) 

Funziona correttamente:

 var deep_value = function(obj, path){ for (var i=0, path=path.split('.'), len=path.length; i 

Ecco la dimostrazione / demo: jsfiddle.net/tadeck/5Pt2q/13/

EDIT: ho rimosso le variabili ridondanti, abbreviato il codice.

Intendi qualcosa di simile ? È una versione ricorsiva

 function recLookup(obj, path) { parts = path.split("."); if (parts.length==1){ return obj[parts[0]]; } return recLookup(obj[parts[0]], parts.slice(1).join(".")); } 

Vedi http://jsfiddle.net/kExSr/

qualcosa di simile a:

 function(obj, path) { var current=obj; path.split('.').forEach(function(p){ current = current[p]; }); return current; } 

Dovresti dividere la stringa sul punto e quindi indicizzare ripetutamente nell’object, ad esempio sulla falsariga di:

 function goDeep(obj, path) { var parts = path.split('.'), rv, index; for (rv = obj, index = 0; rv && index < parts.length; ++index) { rv = rv[parts[index]]; } return rv; } 

Esempio dal vivo

Funziona perché puoi accedere alla proprietà di un object in un paio di modi diversi: c'è la syntax punteggiata usando un letterale ( obj.foo ), e c'è una syntax con obj.foo usando una stringa ( obj["foo"] ). In quest'ultimo caso, la stringa può essere il risultato di qualsiasi espressione, non deve essere una stringa letterale. In tutti i, rv è impostato sullo stesso valore:

 rv = obj.foo.bar; // Or rv = obj.foo["bar"]; // Or f = "foo"; rv = obj[f].bar; // Or s = "b"; rv = obj.foo[s + "ar"];