Jak utworzyć obiekt JSON z wieloma tablicami?

83

Nigdy wcześniej nie korzystałem z formatu JSON, więc nie znam jego składni.

W tej chwili mam wiele tablic zawierających różne elementy danych.

Chciałbym utworzyć jeden obiekt JSON, który zawiera wiele tablic, z których każda zawiera kilka fragmentów danych.

Na przykład

Obiekt zwany samochodami, zawierający wiele tablic, z których każda dotyczy samochodu innej marki. W każdej tablicy byłby model samochodu wraz z innymi typami danych, np. Liczbą drzwi (nie ma znaczenia, że ​​jest to tylko fikcyjny przykład).

Byłoby bardzo wdzięczne, gdyby ktoś wyjaśnił składnię na przykładzie.

json 
— Złupić
źródło
2
Nie pracujesz bezpośrednio z JSON, z wyjątkiem bardzo rzadkich okoliczności. Pracujesz z natywnymi strukturami danych, a następnie używasz biblioteki, aby przekonwertować tę strukturę na ciąg JSON.
— Marc B

Odpowiedzi:

160

Na najbardziej zewnętrznym poziomie obiekt JSON zaczyna się od {a kończy na }.

Przykładowe dane:

{
    "cars": {
        "Nissan": [
            {"model":"Sentra", "doors":4},
            {"model":"Maxima", "doors":4},
            {"model":"Skyline", "doors":2}
        ],
        "Ford": [
            {"model":"Taurus", "doors":4},
            {"model":"Escort", "doors":4}
        ]
    }
}

Jeśli JSON jest przypisany do zmiennej o nazwie data, dostęp do niego wyglądałby następująco:

data.cars['Nissan'][0].model   // Sentra
data.cars['Nissan'][1].model   // Maxima
data.cars['Nissan'][2].doors   // 2

for (var make in data.cars) {
    for (var i = 0; i < data.cars[make].length; i++) {
        var model = data.cars[make][i].model;
        var doors = data.cars[make][i].doors;
        alert(make + ', ' + model + ', ' + doors);
    }
}

Inne podejście (użycie tablicy asocjacyjnej dla modeli samochodów zamiast tablicy indeksowanej):

{
    "cars": {
        "Nissan": {
            "Sentra": {"doors":4, "transmission":"automatic"},
            "Maxima": {"doors":4, "transmission":"automatic"}
        },
        "Ford": {
            "Taurus": {"doors":4, "transmission":"automatic"},
            "Escort": {"doors":4, "transmission":"automatic"}
        }
    }
}

data.cars['Nissan']['Sentra'].doors   // 4
data.cars['Nissan']['Maxima'].doors   // 4
data.cars['Nissan']['Maxima'].transmission   // automatic

for (var make in data.cars) {
    for (var model in data.cars[make]) {
        var doors = data.cars[make][model].doors;
        alert(make + ', ' + model + ', ' + doors);
    }
}

Edytować:

Poprawka: obiekt JSON zaczyna się {i kończy na }, ale ważne jest również, aby mieć tablicę JSON (na najbardziej zewnętrznym poziomie), która zaczyna się [i kończy na ].

Poprawiono także istotne błędy składniowe w oryginalnych danych JSON: wszystkie nazwy kluczy w obiekcie JSON muszą być w podwójnych cudzysłowach, a wszystkie wartości ciągów w obiekcie JSON lub tablicy JSON również muszą być w cudzysłowie.

Widzieć:

— Matt Coughlin
źródło
Dla wyjaśnienia: czy to jest przedmiot? Czy potrzebuje [] nawiasów?
— Harry,
5
Dane JSON to obiekt (w zasadzie tablica asocjacyjna). Tablice indeksowane używać nawiasów kwadratowych [0,1,2], natomiast tablice asocjacyjne użyciu nawiasów klamrowych, {x:1,y:2,z:3}. Dowolne dane w najbardziej zewnętrznym obiekcie mogą być tablicami dowolnego typu, ale sam najbardziej zewnętrzny obiekt musi używać nawiasów klamrowych.
— Matt Coughlin,
A jak miałbym przeglądać miasta w tym: pastebin.com/qyQ2Y9sn, aby uzyskać dostęp do lat i lng.
— Harry,
1
for (var town in markers.towns) { alert(markers.towns[town].lat) }
— Matt Coughlin,
1
Jasne, nie ma problemu :) Dodałem kilka przykładów iteracji po danych JSON w obu powyższych przykładach.
— Matt Coughlin
21

Dobra książka, którą czytam: Professional JavaScript for Web Developers autorstwa Nicholasa C. Zakas 3rd Edition zawiera następujące informacje dotyczące składni JSON:

„Składnia JSON umożliwia reprezentację trzech typów wartości”.

Jeśli chodzi o ten, który Cię interesuje, tablice mówi:

„Tablice są reprezentowane w formacie JSON przy użyciu notacji literału tablicowego z JavaScript. Na przykład jest to tablica w JavaScript:

var values = [25, "hi", true];

Możesz przedstawić tę samą tablicę w JSON, używając podobnej składni:

[25, "hi", true]

Zwróć uwagę na brak zmiennej lub średnika. Tablice i obiekty mogą być używane razem do reprezentowania bardziej złożonych zbiorów danych, takich jak:

{
    "books":
              [
                {
                    "title": "Professional JavaScript",
                    "authors": [
                        "Nicholas C. Zakas"
                    ],
                    "edition": 3,
                    "year": 2011
                },
                {
                    "title": "Professional JavaScript",
                    "authors": [
                        "Nicholas C.Zakas"
                    ],
                    "edition": 2,
                    "year": 2009
                },
                {
                    "title": "Professional Ajax",
                    "authors": [
                        "Nicholas C. Zakas",
                        "Jeremy McPeak",
                        "Joe Fawcett"
                    ],
                    "edition": 2,
                    "year": 2008
                }
              ]
}

Ta tablica zawiera wiele obiektów reprezentujących książki. Każdy obiekt ma kilka kluczy, z których jeden to „autorzy”, czyli inna tablica. Obiekty i tablice są zazwyczaj częściami najwyższego poziomu struktury danych JSON (nawet jeśli nie jest to wymagane) i można ich używać do tworzenia dużej liczby struktur danych ”.

Aby serializować (przekonwertować) obiekt JavaScript na ciąg JSON, możesz użyć metody stringify () obiektu JSON. Na przykład odpowiedź Marka Linusa:

var cars = [{
    color: 'gray',
    model: '1',
    nOfDoors: 4
    },
    {
    color: 'yellow',
    model: '2',
    nOfDoors: 4
}];

cars jest teraz obiektem JavaScript. Aby przekształcić go w obiekt JSON, możesz zrobić:

var jsonCars = JSON.stringify(cars);

Co daje:

"[{"color":"gray","model":"1","nOfDoors":4},{"color":"yellow","model":"2","nOfDoors":4}]"

Aby zrobić odwrotnie, przekonwertować obiekt JSON na obiekt JavaScript (nazywa się to analizowaniem), należy użyć metody parse (). Wyszukaj te terminy, jeśli potrzebujesz więcej informacji ... lub pobierz książkę, ma wiele przykładów.

— Obed
źródło
W powyższym przykładzie „wydanie” i „rok” powinny być w cudzysłowach - jsonlint.co.uk nie zweryfikuje inaczej
— rexall
2

Inny przykład:

[  
[  
    {  
        "@id":1,
        "deviceId":1,
        "typeOfDevice":"1",
        "state":"1",
        "assigned":true
    },
    {  
        "@id":2,
        "deviceId":3,
        "typeOfDevice":"3",
        "state":"Excelent",
        "assigned":true
    },
    {  
        "@id":3,
        "deviceId":4,
        "typeOfDevice":"júuna",
        "state":"Excelent",
        "assigned":true
    },
    {  
        "@id":4,
        "deviceId":5,
        "typeOfDevice":"nffjnff",
        "state":"Regular",
        "assigned":true
    },
    {  
        "@id":5,
        "deviceId":6,
        "typeOfDevice":"44",
        "state":"Excelent",
        "assigned":true
    },
    {  
        "@id":6,
        "deviceId":7,
        "typeOfDevice":"rr",
        "state":"Excelent",
        "assigned":true
    },
    {  
        "@id":7,
        "deviceId":8,
        "typeOfDevice":"j",
        "state":"Excelent",
        "assigned":true
    },
    {  
        "@id":8,
        "deviceId":9,
        "typeOfDevice":"55",
        "state":"Excelent",
        "assigned":true
    },
    {  
        "@id":9,
        "deviceId":10,
        "typeOfDevice":"5",
        "state":"Excelent",
        "assigned":true
    },
    {  
        "@id":10,
        "deviceId":11,
        "typeOfDevice":"5",
        "state":"Excelent",
        "assigned":true
    }
],
1
]

Przeczytaj tablicę

$.each(data[0], function(i, item) {
         data[0][i].deviceId + data[0][i].typeOfDevice  + data[0][i].state +  data[0][i].assigned 
    });

Użyj http://www.jsoneditoronline.org/, aby lepiej zrozumieć kod JSON

— Jason Glez
źródło
Co jest z 1 w przedostatniej linii twojego json?
— Philip Kirkbride
1
@PhilipKirkbride Drugi element najbardziej zewnętrznej tablicy?
— rootkea
1 
var cars = [
    manufacturer: [
        {
            color: 'gray',
            model: '1',
            nOfDoors: 4
        },
        {
            color: 'yellow',
            model: '2',
            nOfDoors: 4
        }
    ]
]
— Danilo Valente
źródło
A co z tablicą producenta samochodów wewnątrz obiektu? tak cars> manufacturer> model, color, doors. (tablice w tablicach w obiekcie)
— Harry,
-4

Używając poniższej metody przekaż dowolną wartość będącą dowolną tablicą:

Parametr wejściowy: url, np. Przykład: „/ node / [dowolna wartość int tablicy] / anyKeyWhichInArray” Przykład: „samochody / Nissan / [0] / model”

Można go użyć do dowolnej odpowiedzi:

    public String getResponseParameterThroughUrl(Response r, String url) throws JsonProcessingException, IOException {
    String value = "";
    String[] xpathOrder = url.split("/");
    ObjectMapper objectMapper = new ObjectMapper();
    String responseData = r.getBody().asString();       
    JSONObject jsonObject = new JSONObject(responseData);
    byte[] jsonData = jsonObject.toString().getBytes();
    JsonNode rootNode = objectMapper.readTree(jsonData);
    JsonNode node = null;
    for(int i=1;i<xpathOrder.length;i++) {
        if(node==null)
            node = rootNode;
        if(xpathOrder[i].contains("[")){
            xpathOrder[i] = xpathOrder[i].replace("[", "");
            xpathOrder[i] = xpathOrder[i].replace("]", "");
            node = node.get(Integer.parseInt(xpathOrder[i]));
        }
        else
            node = node.path(xpathOrder[i]);
    }
    value = node.asText();
    return value;
}
— Ankit Gupta
źródło
Korzystając z naszej strony potwierdzasz, że przeczytałeś(-aś) i rozumiesz nasze zasady używania plików cookie i zasady ochrony prywatności.
Licensed under cc by-sa 3.0 with attribution required.