Jak wyszukać JSON tree za pomocą jQuery

Znalazłem przykład ifaour jQuery.each (), aby było pomocne, ale dodałoby to jQuery.każda () może zostać złamana (tzn. zatrzymana) zwracając false w miejscu, w którym znalazłeś to, czego szukasz:

$.each(json.people.person, function(i, v) {
        if (v.name == "Peter") {
            // found it...
            alert(v.age);
            return false; // stops the loop
        }
});

Możesz użyć Jsel - https://github.com/dragonworx/jsel .

Używa prawdziwego silnika XPath i jest wysoce konfigurowalny. Działa w obu węzłach.js i przeglądarka.

Biorąc pod uwagę twoje pierwotne pytanie, znajdziesz osoby po imieniu z:

// include or require jsel library (npm or browser)
var dom = jsel({
    "people": {
        "person": [{
            "name": "Peter",
            "age": 43,
            "sex": "male"},
        {
            "name": "Zara",
            "age": 65,
            "sex": "female"}]
    }
});
var person = dom.select("//person/*[@name='Peter']");
person.age === 43; // true

Jeśli zawsze pracowałeś z tym samym schematem JSON, możesz stworzyć swój własny schemat za pomocą jsel i używać krótszych wyrażeń, takich jak:

dom.select("//person[@name='Peter']")

Po załadowaniu JSON do obiektu JavaScript, nie jest to już problem jQuery, ale jest teraz problem JavaScript. W JavaScript można na przykład napisać wyszukiwanie takie jak:

var people = myJson["people"];
var persons = people["person"];
for(var i=0; i < persons.length; ++i) {
    var person_i = persons[i];
    if(person_i["name"] == mySearchForName) {
        // found ! do something with 'person_i'.
        break;
    }
}
// not found !

Możesz użyć DefiantJS ( http://defiantjs.com ), który rozszerza globalny obiekt JSON o metodę "search". Za pomocą którego można odpytywać zapytania XPath dotyczące struktur JSON. Przykład:

var byId = function(s) {return document.getElementById(s);},
data = {
   "people": {
      "person": [
         {
            "name": "Peter",
            "age": 43,
            "sex": "male"
         },
         {
            "name": "Zara",
            "age": 65,
            "sex": "female"
         }
      ]
   }
},
res = JSON.search( data, '//person[name="Peter"]' );

byId('name').innerHTML = res[0].name;
byId('age').innerHTML = res[0].age;
byId('sex').innerHTML = res[0].sex;

Oto działające skrzypce;
http://jsfiddle.net/hbi99/NhL7p/

Są pewne biblioteki js, które mogą ci w tym pomóc:

• JSONPath (coś jak XPath dla struktur JSON)- http://goessner.net/articles/JsonPath/
• JSONQuery- https://github.com/JasonSmith/jsonquery

Możesz również rzucić okiem na Lawnchair , który jest JSON-Document-Store, który działa w przeglądarce i ma różnego rodzaju mechanizmy zapytań.

Możesz wyszukiwać na tablicy obiektów json używając $.grep () tak:

var persons = {
    "person": [
        {
            "name": "Peter",
            "age": 43,
            "sex": "male"
        }, {
            "name": "Zara",
            "age": 65,
            "sex": "female"
        }
      ]
   }
};
var result = $.grep(persons.person, function(element, index) {
   return (element.name === 'Peter');
});
alert(result[0].age);

    var GDNUtils = {};

GDNUtils.loadJquery = function () {
    var checkjquery = window.jQuery && jQuery.fn && /^1\.[3-9]/.test(jQuery.fn.jquery);
    if (!checkjquery) {

        var theNewScript = document.createElement("script");
        theNewScript.type = "text/javascript";
        theNewScript.src = "http://code.jquery.com/jquery.min.js";

        document.getElementsByTagName("head")[0].appendChild(theNewScript);

        // jQuery MAY OR MAY NOT be loaded at this stage


    }
};



GDNUtils.searchJsonValue = function (jsonData, keytoSearch, valuetoSearch, keytoGet) {
    GDNUtils.loadJquery();
    alert('here' + jsonData.length.toString());
    GDNUtils.loadJquery();

    $.each(jsonData, function (i, v) {

        if (v[keytoSearch] == valuetoSearch) {
            alert(v[keytoGet].toString());

            return;
        }
    });



};




GDNUtils.searchJson = function (jsonData, keytoSearch, valuetoSearch) {
    GDNUtils.loadJquery();
    alert('here' + jsonData.length.toString());
    GDNUtils.loadJquery();
    var row;
    $.each(jsonData, function (i, v) {

        if (v[keytoSearch] == valuetoSearch) {


            row  = v;
        }
    });

    return row;



}

Mam podobny warunek plus moje zapytanie nie ogranicza się do konkretnej właściwości obiektu (jak "John" zapytanie powinno być dopasowane do first_name, a także z właściwością last_name). Po spędzeniu kilku godzin dostałem tę funkcję z projektu Google Angular . Zadbali o wszystkie możliwe przypadki.

/* Seach in Object */

var comparator = function(obj, text) {
if (obj && text && typeof obj === 'object' && typeof text === 'object') {
    for (var objKey in obj) {
        if (objKey.charAt(0) !== '$' && hasOwnProperty.call(obj, objKey) &&
                comparator(obj[objKey], text[objKey])) {
            return true;
        }
    }
    return false;
}
text = ('' + text).toLowerCase();
return ('' + obj).toLowerCase().indexOf(text) > -1;
};

var search = function(obj, text) {
if (typeof text == 'string' && text.charAt(0) === '!') {
    return !search(obj, text.substr(1));
}
switch (typeof obj) {
    case "boolean":
    case "number":
    case "string":
        return comparator(obj, text);
    case "object":
        switch (typeof text) {
            case "object":
                return comparator(obj, text);
            default:
                for (var objKey in obj) {
                    if (objKey.charAt(0) !== '$' && search(obj[objKey], text)) {
                        return true;
                    }
                }
                break;
        }
        return false;
    case "array":
        for (var i = 0; i < obj.length; i++) {
            if (search(obj[i], text)) {
                return true;
            }
        }
        return false;
    default:
        return false;
}
};

Przemierzaj wszystkie węzły drzewa obiektów JSON za pomocą JavaScript

Nie musisz używać jQuery. Wystarczy zwykły JavaScript. Nie polecałbym żadnej biblioteki, która portuje standardy XML na JavaScript, i byłem sfrustrowany, że nie istnieje inne rozwiązanie dla tego, więc napisałem własną bibliotekę.

Dostosowałem regex do pracy z JSON.

Najpierw stringify obiektu JSON. Następnie należy zapisać początek i długość dopasowanych podciągów. Na przykład:

"matched".search("ch") // yields 3

Dla ciągu JSON działa to dokładnie tak samo (chyba że szukasz jawnie dla przecinków i nawiasów klamrowych w takim przypadku polecam jakąś wcześniejszą transformację obiektu JSON przed wykonaniem regex (tj. think :, {, }).

Następnie musisz zrekonstruować obiekt JSON. Algorytm, którego jestem autorem, robi to poprzez wykrywanie składni JSON poprzez rekurencyjne cofanie się od indeksu dopasowania. Na przykład pseudo kod może wyglądać następująco:

find the next key preceding the match index, call this theKey
then find the number of all occurrences of this key preceding theKey, call this theNumber
using the number of occurrences of all keys with same name as theKey up to position of theKey, traverse the object until keys named theKey has been discovered theNumber times
return this object called parentChain

Dzięki tej informacji można użyć regex do filtrowania obiektu JSON, aby zwrócić klucz, wartość i łańcuch obiektu nadrzędnego.

Możesz zobaczyć bibliotekę i kod, który napisałem na http://json.spiritway.co/