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

La solution choisie ne fonctionne pas pour moi parce que je suis un

     "Unexpected Token <" 

erreur dans Chrome. C'est parce que l'erreur est lancée dès que l'analyse tombe et caractère inconnu. Cependant, il y a un moyen de contourner cela si vous retournez seulement des valeurs de chaîne par ajax (ce qui peut être assez utile si vous utilisez PHP ou ASPX pour traiter les requêtes ajax et pourrait ou ne pourrait pas retourner JSON selon les conditions)

la solution est assez simple, vous pouvez faire ce qui suit pour vérifier si c'était 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 pour si vous retournez du matériel de type string à partir de votre requête AJAX ou si vous retournez du matériel de type mixte.

la meilleure façon de valider qu'un objet est de type JSON ou array 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 de 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"]

Même un simple opérateur Booléen ou un entier peut être considéré comme valide dans la syntaxe JSON. Cela nous mènerait alors à bien d'autres validations. Par conséquent, la façon la plus pratique de vérifier si quelque chose a une syntaxe JSON serait:

Solution 3 (populaire)

function isJSON (something) {
    if (typeof something != 'string')
        something = JSON.stringify(something);

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

vous pouvez l'utiliser:

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

AJAX / JQuery (recommended)

si vous utilisez JQuery pour apporter des informations via AJAX. Je vous recommande de mettre dans le "dataType" attribuent la valeur "json", de cette façon si vous obtenez un JSON ou non, JQuery Le Valider pour vous et le faire connaître à travers leurs fonctions" succès "et"erreur". 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) {}
});

si vous avez jQuery, utilisez isPlainObject .

if ($.isPlainObject(my_var)) {}

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

puisque c'est juste false et JSON object, pourquoi ne pas vérifier si c'est false, sinon ça doit être json.

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

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 le trouvera 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];
}

var data = 'json string ?';
var jdata = null;
try
{
    jdata = $.parseJSON(data);  
}catch(e)
{}

if(jdata)
{
//use jdata
}else
{
//use data
}

si vous voulez tester explicitement pour JSON valide (par opposition à l'absence de la valeur retournée false ), alors vous pouvez utiliser une approche d'analyse comme décrit ici .

Je n'aime pas vraiment la réponse acceptée. D'abord et avant tout, il nécessite jQuery, qui n'est pas toujours disponible ou nécessaire. Deuxièmement, il fait une stringification complète de l'objet qui pour moi est exagérée. Voici une fonction simple qui détecte minutieusement si une valeur est semblable à JSON, en utilisant rien de plus que 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 en npm comme un paquet: https://npmjs.com/package/is-json-object . Utilisez-le avec quelque chose comme Webpack pour entrer dans le navigateur.

Espérons que cela aide quelqu'un!

j'utilise ceci pour valider L'objet JSON

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

j'utilise ceci pour valider la chaîne JSON

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

vous devez retourner json toujours , mais changer son statut , ou dans l'exemple suivant le code de responsabilité propriété:

if(callbackResults.ResponseCode!="200"){
    /* Some error, you can add a message too */
} else {
    /* All fine, proceed with code */
};