Wie kann ich überprüfen, ob ein Wert ein JSON-Objekt ist?

Mein serverseitiger Code gibt einen Wert zurück, der bei Erfolg ein JSON-Objekt und bei einem Fehler eine Zeichenfolge 'false' ist. Wie kann ich nun überprüfen, ob der zurückgegebene Wert ein JSON-Objekt ist?

jQuery.parseJSON () sollte ein Objekt vom Typ "object" zurückgeben, wenn die Zeichenfolge JSON war, sodass Sie nur den Typ mit überprüfen müssen 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
  }
}

Die gewählte Lösung funktioniert bei mir eigentlich nicht, weil ich eine bekomme

     "Unexpected Token <" 

Fehler in Chrome. Dies liegt daran, dass der Fehler ausgelöst wird, sobald die Analyse auf ein unbekanntes Zeichen stößt. Es gibt jedoch eine Möglichkeit, dies zu umgehen, wenn Sie nur Zeichenfolgenwerte über Ajax zurückgeben (was sehr nützlich sein kann, wenn Sie PHP oder ASPX zum Verarbeiten von Ajax-Anforderungen verwenden und JSON je nach Bedingungen möglicherweise zurückgeben oder nicht).

Die Lösung ist recht einfach. Sie können Folgendes tun, um zu überprüfen, ob es sich um eine gültige JSON-Rückgabe handelt

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

Wie ich bereits sagte, ist dies die Lösung, wenn Sie entweder Zeichenfolgentyp von Ihrer AJAX-Anforderung zurückgeben oder wenn Sie gemischten Typ zurückgeben.

Lösung 3 (schnellster Weg)

/**
 * @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;
    }
}

Du kannst es benutzen:

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

Der beste Weg, um zu überprüfen, ob ein Objekt vom Typ JSON oder Array ist, ist wie folgt:

var a = [],
    o = {};

Lösung 1

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

Lösung 2

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

Genau genommen ist ein Array jedoch Teil einer JSON-Syntax. Daher sind die folgenden zwei Beispiele Teil einer JSON-Antwort:

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

Und:

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

AJAX / JQuery (empfohlen)

Wenn Sie JQuery verwenden, um Informationen über AJAX zu bringen. Ich empfehle, dass Sie im Attribut "dataType" den Wert "json" eingeben. Wenn Sie also einen JSON erhalten oder nicht, überprüft JQuery ihn für Sie und macht ihn durch die Funktionen "success" und "error" bekannt. Beispiel:

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

Wenn Sie über jQuery verfügen, verwenden Sie 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

Da es sich nur um ein falsches und ein json-Objekt handelt, überprüfen Sie nicht, ob es falsch ist. Andernfalls muss es sich um ein json-Objekt handeln.

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

Ich weiß, dass dieser Thread bereits beantwortet wurde, aber hierher zu kommen hat meine Probleme nicht wirklich gelöst. Ich habe diese Funktion woanders gefunden. Vielleicht wird jemand, der hierher kommt, feststellen, dass es für ihn von Nutzen ist.

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
}

Wenn Sie explizit auf gültigen JSON testen möchten (im Gegensatz zum Fehlen des zurückgegebenen Werts false), können Sie einen hier beschriebenen Parsing-Ansatz verwenden .

Ich mag die akzeptierte Antwort nicht wirklich. In erster Linie erfordert es jQuery, das nicht immer verfügbar oder erforderlich ist. Zweitens führt es eine vollständige Stringifizierung des Objekts durch, was für mich übertrieben ist. Hier ist eine einfache Funktion, die gründlich erkennt, ob ein Wert JSON-ähnlich ist, und aus Gründen der Allgemeinheit nur einige Teile der lodash- Bibliothek verwendet.

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
}

Ich habe mir sogar die Zeit genommen, es in npm als Paket zu veröffentlichen: https://npmjs.com/package/is-json-object . Verwenden Sie es zusammen mit etwas wie Webpack , um es in den Browser zu bekommen.

Hoffe das hilft jemandem!

Ich verwende dies, um JSON-Objekt zu validieren

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

Ich benutze dies, um JSON String zu validieren

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

Ich habe alle vorgeschlagenen Antworten ausprobiert, nichts hat bei mir funktioniert, also musste ich verwenden

jQuery.isEmptyObject()

Hacke, die jemand anderem bei diesem Problem hilft

Sie sollten json immer zurückgeben , aber seinen Status ändern oder im folgenden Beispiel die ResponseCode- Eigenschaft:

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