Déterminer si JSON est un JSONObject ou JSONArray

Je vais recevoir un objet JSON ou un tableau du serveur, mais je n'ai aucune idée de ce que ce sera. J'ai besoin de travailler avec le JSON, mais pour ce faire, j'ai besoin de savoir s'il s'agit d'un objet ou d'un tableau.

Je travaille avec Android.

Quelqu'un a-t-il un bon moyen de faire cela?

J'ai trouvé un meilleur moyen de déterminer:

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 est capable de renvoyer plus de types: http://developer.android.com/reference/org/json/JSONTokener.html#nextValue ()

Vous pouvez procéder de plusieurs manières:

1. Vous pouvez vérifier le caractère à la première position de la chaîne (après avoir coupé les espaces, comme cela est autorisé dans un JSON valide). Si c'est un {, vous avez affaire à un JSONObject, si c'est un [, vous avez affaire à un JSONArray.
2. Si vous avez affaire à JSON (an Object), vous pouvez effectuer une instanceofvérification. yourObject instanceof JSONObject. Cela retournera true si votreObjet est un JSONObject. La même chose s'applique à JSONArray.

Voici la solution simple que j'utilise sur Android:

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
}

Présenter d'une autre manière:

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

Voici server_responseune chaîne de réponse provenant du serveur

Une manière plus fondamentale de procéder est la suivante.

JsonArrayest intrinsèquement une liste

JsonObjectest intrinsèquement une carte

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);
    ...
    ...
}

exemple de

Object.getClass (). GetName ()

Pour ceux qui s'attaquent à ce problème en JavaScript, ce qui suit a fait le travail pour moi (je ne suis pas sûr de son efficacité).

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

Mon approche en serait une abstraction totale. Peut-être que quelqu'un trouve cela utile ...

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;
    }


}

Et maintenant débarrassez-vous de ce comportement pour toujours ...

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