Jak utworzyć obiekt JSON z wieloma tablicami?

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.

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ć:

• Specyfikacja JSON
• JSONLint - walidator JSON

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.

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

var cars = [
    manufacturer: [
        {
            color: 'gray',
            model: '1',
            nOfDoors: 4
        },
        {
            color: 'yellow',
            model: '2',
            nOfDoors: 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;
}