Como posso verificar se um valor é um objeto json?

Meu código do lado do servidor retorna um valor que é um objeto json em caso de sucesso e uma string 'false' em caso de falha. Agora, como posso verificar se o valor retornado é um objeto json?

jQuery.parseJSON () deve retornar um objeto do tipo "objeto", se a string for JSON, então você só precisa verificar o tipo com 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
  }
}

A solução escolhida realmente não funciona para mim porque recebo um

     "Unexpected Token <" 

erro no Chrome. Isso ocorre porque o erro é lançado assim que a análise encontra um caractere desconhecido. No entanto, há uma maneira de contornar isso se você estiver retornando apenas valores de string por meio de ajax (o que pode ser bastante útil se você estiver usando PHP ou ASPX para processar solicitações de ajax e pode ou não retornar JSON dependendo das condições)

A solução é bastante simples, você pode fazer o seguinte para verificar se era um retorno JSON válido

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

Como eu disse antes, esta é a solução para se você estiver retornando coisas do tipo string de sua solicitação AJAX ou se estiver retornando tipo misto.

Solução 3 (caminho mais rápido)

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

Você pode usar isso:

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

A melhor maneira de validar se um objeto é do tipo JSON ou array é a seguinte:

var a = [],
    o = {};

Solução 1

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

Solução 2

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

Mas, estritamente falando, um array faz parte de uma sintaxe JSON. Portanto, os dois exemplos a seguir fazem parte de uma resposta JSON:

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

E:

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

AJAX / JQuery (recomendado)

Se você usa JQuery para trazer informações via AJAX. Recomendo que você coloque no atributo "dataType" o valor "json", dessa forma se você pegar um JSON ou não, o JQuery valide para você e divulgue através de suas funções "sucesso" e "erro". Exemplo:

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

Se você tiver jQuery, use 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

Já que é apenas um objeto falso e json, por que você não verifica se é falso, caso contrário, deve ser json.

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

Eu sei que este tópico já foi respondido, mas vir aqui não resolveu realmente meus problemas, eu encontrei esta função em outro lugar. talvez alguém que venha aqui descubra que é de alguma utilidade para eles;

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
}

Se quiser testar explicitamente o JSON válido (em oposição à ausência do valor retornado false), você pode usar uma abordagem de análise conforme descrito aqui .

Eu realmente não gosto da resposta aceita. Em primeiro lugar, requer jQuery, que nem sempre está disponível ou é obrigatório. Em segundo lugar, faz uma estringificação completa do objeto que para mim é um exagero. Aqui está uma função simples que detecta completamente se um valor é semelhante a JSON, usando nada mais do que algumas partes da biblioteca lodash para genericidade.

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
}

Até reservei um tempo para colocá-lo no npm como um pacote: https://npmjs.com/package/is-json-object . Use-o junto com algo como Webpack para colocá-lo no navegador.

Espero que isso ajude alguém!

Estou usando isso para validar objeto JSON

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

Estou usando isso para validar a string JSON

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

tentei todas as respostas sugeridas, nada funcionou para mim, então tive que usar

jQuery.isEmptyObject()

enxada que ajuda outra pessoa com este problema

Você deve retornar json sempre , mas alterar seu status ou, no exemplo a seguir, a propriedade ResponseCode :

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