web-dev-qa-db-fra.com

Comment puis-je vérifier si une valeur est un objet JSON?

Mon code côté serveur renvoie une valeur qui est un objet json en cas de succès et une chaîne 'false' en cas d'échec. Maintenant, comment puis-je vérifier si la valeur renvoyée est un objet JSON?

jqueryjsonobject
96
bart

jQuery.parseJSON () doit renvoyer un objet de type "objet", si la chaîne est JSON. Il suffit donc de vérifier le type avec typeof.

var response=jQuery.parseJSON('response from server');
if(typeof response =='object')
{
  // It is JSON
}
else
{
  if(response ===false)
  {
     // the response was a string "false", parseJSON will convert it to boolean false
  }
  else
  {
    // the response was something else
  }
}
95
Dr.Molle

La solution choisie ne fonctionne pas vraiment pour moi parce que je reçois un 

     "Unexpected Token <"

erreur dans Chrome. Cela est dû au fait que l'erreur est renvoyée dès que l'analyse rencontre un caractère inconnu. Cependant, il existe un moyen de contourner ce problème si vous ne renvoyez que des valeurs de chaîne via ajax (ce qui peut s'avérer très utile si vous utilisez PHP ou ASPX pour traiter les requêtes ajax et qu'il est possible que le code JSON ne soit pas rendu, en fonction des conditions).

La solution est assez simple, vous pouvez procéder comme suit pour vérifier s’il s’agit d’un retour JSON valide.

       var IS_JSON = true;
       try
       {
               var json = $.parseJSON(msg);
       }
       catch(err)
       {
               IS_JSON = false;
       }

Comme je l’ai déjà dit, c’est la solution si vous renvoyez des éléments de type chaîne à partir de votre demande AJAX ou si vous renvoyez des types mélangés. 

140
Serguei Fedorov

Solution 3 (moyen le plus rapide)

/**
 * @param Object
 * @returns boolean
 */
function isJSON (something) {
    if (typeof something != 'string')
        something = JSON.stringify(something);

    try {
        JSON.parse(something);
        return true;
    } catch (e) {
        return false;
    }
}

Tu peux l'utiliser:

var myJson = [{"user":"chofoteddy"}, {"user":"bart"}];
isJSON(myJson); // true

La meilleure façon de valider qu'un objet est de type JSON ou de tableau est la suivante:

var a = [],
    o = {};

Solution 1

toString.call(o) === '[object Object]'; // true
toString.call(a) === '[object Array]'; // true

Solution 2

a.constructor.name === 'Array'; // true
o.constructor.name === 'Object'; // true

Mais, à proprement parler, un tableau fait partie d'une syntaxe JSON. Par conséquent, les deux exemples suivants font partie d'une réponse JSON:

console.log(response); // {"message": "success"}
console.log(response); // {"user": "bart", "id":3}

Et:

console.log(response); // [{"user":"chofoteddy"}, {"user":"bart"}]
console.log(response); // ["chofoteddy", "bart"]

AJAX/JQuery (recommandé)

Si vous utilisez JQuery pour apporter des informations via AJAX. Je vous recommande de mettre dans l'attribut "dataType" la valeur "json". Ainsi, si vous obtenez un JSON ou non, JQuery le valide pour vous et le communique via ses fonctions "success" et "error". Exemple:

$.ajax({
    url: 'http://www.something.com',
    data: $('#formId').serialize(),
    method: 'POST',
    dataType: 'json',
    // "sucess" will be executed only if the response status is 200 and get a JSON
    success: function (json) {},
    // "error" will run but receive state 200, but if you miss the JSON syntax
    error: function (xhr) {}
});
15
Chofoteddy

Si vous avez jQuery, utilisez isPlainObject .

if ($.isPlainObject(my_var)) {}
12
thnee
var checkJSON = function(m) {

   if (typeof m == 'object') { 
      try{ m = JSON.stringify(m); }
      catch(err) { return false; } }

   if (typeof m == 'string') {
      try{ m = JSON.parse(m); }
      catch (err) { return false; } }

   if (typeof m != 'object') { return false; }
   return true;

};


checkJSON(JSON.parse('{}'));      //true
checkJSON(JSON.parse('{"a":0}')); //true
checkJSON('{}');                  //true
checkJSON('{"a":0}');             //true
checkJSON('x');                   //false
checkJSON('');                    //false
checkJSON();                      //false
6
luizhp

Puisque c’est juste false et json objet, pourquoi ne pas vérifier si c’est faux, sinon ce doit être json.

if(ret == false || ret == "false") {
    // json
}
4
Andreas Wong

Je sais que ce fil a déjà été répondu, mais venir ici n'a pas vraiment résolu mes problèmes, j'ai trouvé cette fonction ailleurs… .. peut-être que quelqu'un qui vient ici trouvera cela utile pour eux;

function getClass(obj) {
  if (typeof obj === "undefined")
    return "undefined";
  if (obj === null)
    return "null";
  return Object.prototype.toString.call(obj)
    .match(/^\[object\s(.*)\]$/)[1];
}
2
pythonian29033
var data = 'json string ?';
var jdata = null;
try
{
    jdata = $.parseJSON(data);  
}catch(e)
{}

if(jdata)
{
//use jdata
}else
{
//use data
}
1
Firas Abd Alrahman

Si vous souhaitez tester explicitement un JSON valide (par opposition à l'absence de la valeur renvoyée false), vous pouvez utiliser une approche d'analyse telle que décrite ici .

0
Ken Redler

Je n'aime pas vraiment la réponse acceptée. Tout d'abord, il nécessite jQuery, qui n'est pas toujours disponible ni requis. Deuxièmement, il crée une chaîne complète de l'objet, ce qui pour moi est excessif. Voici une fonction simple qui détecte de manière approfondie si une valeur est de type JSON, en utilisant uniquement quelques parties de la bibliothèque lodash pour la généricité.

import * as isNull from 'lodash/isNull'
import * as isPlainObject from 'lodash/isPlainObject'
import * as isNumber from 'lodash/isNumber'
import * as isBoolean from 'lodash/isBoolean'
import * as isString from 'lodash/isString'
import * as isArray from 'lodash/isArray'

function isJSON(val) {
  if (isNull(val)
   || isBoolean(val)
   || isString(val))
    return true;
  if (isNumber(val)) 
     return !isNaN(val) && isFinite(val)
  if (isArray(val))
    return Array.prototype.every.call(val, isJSON)
  if (isPlainObject(val)) {
    for (const key of Object.keys(val)) {
      if (!isJSON(val[key]))
        return false
    }
    return true
  }
  return false
}

J'ai même pris le temps de le mettre dans npm sous la forme d'un paquet: https://npmjs.com/package/is-json-object . Utilisez-le avec quelque chose comme Webpack pour le faire apparaître dans le navigateur.

J'espère que cela aide quelqu'un!

0
samvv

Je l'utilise pour valider un objet JSON 

function isJsonObject(obj) {
    try {
        JSON.parse(JSON.stringify(obj));
    } catch (e) {
        return false;
    }
    return true;
}

Je l'utilise pour valider JSON String 

function isJsonString(str) {
    try {
        JSON.parse(str);
    } catch (e) {
        return false;
    }
    return true;
}
0
Abhishek Goel