Zugang / Verfahren (nested) Objekte, arrays oder JSON

Können Sie für den Zugriff auf diese Weise

data.items[1].name

oder

data["items"][1]["name"]

Beide Wege gleich sind.

InformationsquelleAutor der Antwort vitmalina

Zeitweise Zugriff auf eine verschachtelte Objekt mit einem string wünschenswert sein kann. Den einfachen Ansatz, ist die erste Ebene, zum Beispiel

var obj = { hello: "world" };
var key = "hello";
alert(obj[key]);//world

Aber das ist oft nicht der Fall mit komplexen json. Als json komplexer wird, die Ansätze für das Auffinden von Werten innerhalb der json-auch Komplex werden. Eine rekursive Ansatz für die Navigation in der json am besten, und wie, das ist die Rekursion genutzt wird, hängt von der Art der Daten gesucht wird. Wenn es bedingte Anweisungen beteiligt, eine suchbeispiel für json kann ein gutes Werkzeug zu verwenden.

Wenn die Eigenschaft zugegriffen wird, ist bereits bekannt, aber der Weg ist Komplex, zum Beispiel in diesem Objekt

var obj = {
 arr: [
    { id: 1, name: "larry" },    
    { id: 2, name: "curly" },
    { id: 3, name: "moe" }
 ]
};

Und Sie wissen, Sie wollen das erste Ergebnis ist das array in das Objekt, vielleicht möchten Sie verwenden

var moe = obj["arr[0].name"];

Jedoch, dass zu einer Ausnahme führen, da es keine Eigenschaft des Objekts mit diesem Namen. Die Lösung nutzen zu können, dies wäre zum glätten der Baum Aspekt des Objekts. Diese kann getan werden, rekursiv.

function flatten(obj){
 var root = {};
 (function tree(obj, index){
   var suffix = toString.call(obj) == "[object Array]" ? "]" : "";
   for(var key in obj){
    if(!obj.hasOwnProperty(key))continue;
    root[index+key+suffix] = obj[key];
    if( toString.call(obj[key]) == "[object Array]" )tree(obj[key],index+key+suffix+"[");
    if( toString.call(obj[key]) == "[object Object]" )tree(obj[key],index+key+suffix+".");   
   }
 })(obj,"");
 return root;
}

Nun, das komplexe Objekt kann vereinfacht werden,

var obj = previous definition;
var flat = flatten(obj);
var moe = flat["arr[0].name"];//moe

Hier ist ein jsFiddle Demo dieser Ansatz verwendet wird.

InformationsquelleAutor der Antwort Travis J

Wenn Sie suchen für ein oder mehrere Objekte, die bestimmte Kriterien erfüllt, Sie haben ein paar Optionen mit Abfrage-js

//will return all elements with an id larger than 1
data.items.where(function(e){return e.id > 1;});
//will return the first element with an id larger than 1
data.items.first(function(e){return e.id > 1;});
//will return the first element with an id larger than 1 
//or the second argument if non are found
data.items.first(function(e){return e.id > 1;},{id:-1,name:""});

Es gibt auch eine single und ein singleOrDefault Sie arbeiten viel wie firstund firstOrDefaultbeziehungsweise. Der einzige Unterschied ist, dass Sie werfen, wenn mehr als eine übereinstimmung gefunden wird.

für die weitere Erläuterung von query-js können Sie beginnen, mit dieser post

InformationsquelleAutor der Antwort Rune FS

Zugriff auf geschachtelte Attribut, müssen Sie geben Sie Ihren Namen und suchen Sie dann über das Objekt.

Wenn Sie bereits wissen, den genauen Pfad, dann können Sie es fest in Ihr script etwa so:

data['items'][1]['name']

diese auch arbeiten -

data.items[1].name
data['items'][1].name
data.items[1]['name']

Wenn Sie nicht wissen, den genauen Namen, bevor die hand, oder ein Benutzer derjenige ist, stellt den Namen für Sie. Dann dynamisch die Suche durch die Datenstruktur erforderlich ist. Einige, die hier vorgeschlagen werden, die Suche kann getan werden, mit einem for Schleife, aber es ist eine sehr einfache Möglichkeit zum traversieren eines Pfades mit Array.reduzieren.

const data = { code: 42, items: [{ id: 1, name: 'foo' }, { id: 2, name: 'bar' }] }
const path = [ 'items', '1', 'name']
let result = path.reduce((a,v) => a[v], data)

Pfad ist ein Weg, zu sagen: Zuerst nehmen Sie das Objekt mit Schlüssel itemswas passiert, um ein array sein. Dann nehmen Sie die 1-st-element (0-index-arrays). Zuletzt nehmen Sie das Objekt mit Schlüssel name im array-element,, die passiert werden die string bar.

Wenn Sie einen sehr langen Weg, Sie vielleicht sogar String.split um all das einfacher machen -

'items.1.name'.split('.').reduce((a,v) => a[v], data)

Dies ist einfach nur JavaScript, ohne Verwendung von Drittanbieter-Bibliotheken wie jQuery oder lodash.

InformationsquelleAutor der Antwort Evgeny

Alte Frage, aber da niemand erwähnt lodash (nur Unterstrich).

Falls Sie bereits mit lodash in Ihrem Projekt, denke ich, dass ein eleganter Weg, dies zu tun in einer komplexen Beispiel:

Opt 1

_.get(response, ['output', 'fund', 'data', '0', 'children', '0', 'group', 'myValue'], '')

gleiche wie:

Opt-2 -

response.output.fund.data[0].children[0].group.myValue

Den Unterschied zwischen der ersten und der zweiten option ist, dass in der Opt 1wenn Sie eine der Eigenschaften fehlt (undefined) in den Pfad, den Sie nicht erhalten eine Fehlermeldung, es gibt Sie den Dritten parameter.

Array-filter lodash hat _.find() aber ich würde lieber das normale filter(). Aber ich denke immer noch mit der oben beschriebenen Methode _.get() ist super nützlich bei der Arbeit mit sehr komplexen Daten. Ich Stand in der Vergangenheit wirklich komplexe APIs und es war praktisch!

Ich hoffe, es kann nützlich sein, für wer ist auf der Suche nach Möglichkeiten zu manipulieren, um wirklich komplexe Daten, die der Titel impliziert.

InformationsquelleAutor der Antwort Ventura

Einen pythonic, rekursive und funktionalen Ansatz zu entwirren beliebigen JSON-Bäume:

handlers = {
    list:  iterate,
    dict:  delve,
    str:   emit_li,
    float: emit_li,
}

def emit_li(stuff, strong=False):
    emission = '<li><strong>%s</strong></li>' if strong else '<li>%s</li>'
    print(emission % stuff)

def iterate(a_list):
    print('<ul>')
    map(unravel, a_list)
    print('</ul>')

def delve(a_dict):
    print('<ul>')
    for key, value in a_dict.items():
        emit_li(key, strong=True)
        unravel(value)
    print('</ul>')

def unravel(structure):
    h = handlers[type(structure)]
    return h(structure)

unravel(data)

wo Daten ist eine python Liste (analysiert aus einer JSON-Zeichenfolge):

data = [
    {'data': {'customKey1': 'customValue1',
           'customKey2': {'customSubKey1': {'customSubSubKey1': 'keyvalue'}}},
  'geometry': {'location': {'lat': 37.3860517, 'lng': -122.0838511},
               'viewport': {'northeast': {'lat': 37.4508789,
                                          'lng': -122.0446721},
                            'southwest': {'lat': 37.3567599,
                                          'lng': -122.1178619}}},
  'name': 'Mountain View',
  'scope': 'GOOGLE',
  'types': ['locality', 'political']}
]

InformationsquelleAutor der Antwort pX0r

Mit lodash wäre eine gute Lösung

Ex:

var object = { 'a': { 'b': { 'c': 3 } } };                                                                                               
_.get(object, 'a.b.c');                                                                                             
//=> 3  

InformationsquelleAutor der Antwort pradeep gowda