Bestimmen Sie, ob JSON ein JSONObject oder JSONArray ist

Ich werde entweder ein JSON-Objekt oder ein Array vom Server erhalten, aber ich habe keine Ahnung, welches es sein wird. Ich muss mit dem JSON arbeiten, aber dazu muss ich wissen, ob es sich um ein Objekt oder ein Array handelt.

Ich arbeite mit Android.

Hat jemand eine gute Möglichkeit, dies zu tun?

Ich habe einen besseren Weg gefunden, um festzustellen:

String data = "{ ... }";
Object json = new JSONTokener(data).nextValue();
if (json instanceof JSONObject)
  //you have an object
else if (json instanceof JSONArray)
  //you have an array

Tokenizer kann weitere Typen zurückgeben: http://developer.android.com/reference/org/json/JSONTokener.html#nextValue ()

Es gibt verschiedene Möglichkeiten, dies zu tun:

1. Sie können das Zeichen an der ersten Position des Strings überprüfen (nachdem Sie Leerzeichen entfernt haben, wie es in gültigem JSON zulässig ist). Wenn es ein ist {, haben Sie es mit einem zu tun JSONObject, wenn es ein ist [, haben Sie es mit einem zu tun JSONArray.
2. Wenn Sie mit JSON (an Object) zu tun haben, können Sie eine instanceofÜberprüfung durchführen. yourObject instanceof JSONObject. Dies gibt true zurück, wenn yourObject ein JSONObject ist. Gleiches gilt für JSONArray.

Dies ist die einfache Lösung, die ich unter Android verwende:

JSONObject json = new JSONObject(jsonString);

if (json.has("data")) {

    JSONObject dataObject = json.optJSONObject("data");

    if (dataObject != null) {

        //Do things with object.

    } else {

        JSONArray array = json.optJSONArray("data");

        //Do things with array
    }
} else {
    // Do nothing or throw exception if "data" is a mandatory field
}

Einen anderen Weg präsentieren:

if(server_response.trim().charAt(0) == '[') {
    Log.e("Response is : " , "JSONArray");
} else if(server_response.trim().charAt(0) == '{') {
    Log.e("Response is : " , "JSONObject");
}

Hier server_responseist eine Antwortzeichenfolge, die vom Server kommt

Ein grundlegenderer Weg, dies zu tun, ist der folgende.

JsonArrayist von Natur aus eine Liste

JsonObjectist von Natur aus eine Karte

if (object instanceof Map){
    JSONObject jsonObject = new JSONObject();
    jsonObject.putAll((Map)object);
    ...
    ...
}
else if (object instanceof List){
    JSONArray jsonArray = new JSONArray();
    jsonArray.addAll((List)object);
    ...
    ...
}

Instanz von

Object.getClass (). GetName ()

Für diejenigen, die dieses Problem in JavaScript angehen, hat das Folgende die Arbeit für mich erledigt (nicht sicher, wie effizient es ist).

if(object.length != undefined) {
   console.log('Array found. Length is : ' + object.length); 
} else {
 console.log('Object found.'); 
}

Mein Ansatz wäre eine totale Abstraktion davon. Vielleicht findet das jemand nützlich ...

import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Map;

import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;

public class SimpleJSONObject extends JSONObject {


    private static final String FIELDNAME_NAME_VALUE_PAIRS = "nameValuePairs";


    public SimpleJSONObject(String string) throws JSONException {
        super(string);
    }


    public SimpleJSONObject(JSONObject jsonObject) throws JSONException {
        super(jsonObject.toString());
    }


    @Override
    public JSONObject getJSONObject(String name) throws JSONException {

        final JSONObject jsonObject = super.getJSONObject(name);

        return new SimpleJSONObject(jsonObject.toString());
    }


    @Override
    public JSONArray getJSONArray(String name) throws JSONException {

        JSONArray jsonArray = null;

        try {

            final Map<String, Object> map = this.getKeyValueMap();

            final Object value = map.get(name);

            jsonArray = this.evaluateJSONArray(name, value);

        } catch (Exception e) {

            throw new RuntimeException(e);

        }

        return jsonArray;
    }


    private JSONArray evaluateJSONArray(String name, final Object value) throws JSONException {

        JSONArray jsonArray = null;

        if (value instanceof JSONArray) {

            jsonArray = this.castToJSONArray(value);

        } else if (value instanceof JSONObject) {

            jsonArray = this.createCollectionWithOneElement(value);

        } else {

            jsonArray = super.getJSONArray(name);

        }
        return jsonArray;
    }


    private JSONArray createCollectionWithOneElement(final Object value) {

        final Collection<Object> collection = new ArrayList<Object>();
        collection.add(value);

        return (JSONArray) new JSONArray(collection);
    }


    private JSONArray castToJSONArray(final Object value) {
        return (JSONArray) value;
    }


    private Map<String, Object> getKeyValueMap() throws NoSuchFieldException, IllegalAccessException {

        final Field declaredField = JSONObject.class.getDeclaredField(FIELDNAME_NAME_VALUE_PAIRS);
        declaredField.setAccessible(true);

        @SuppressWarnings("unchecked")
        final Map<String, Object> map = (Map<String, Object>) declaredField.get(this);

        return map;
    }


}

Und jetzt dieses Verhalten für immer loswerden ...

...
JSONObject simpleJSONObject = new SimpleJSONObject(jsonObject);
...