Como testar se uma string é JSON ou não?

Eu tenho uma chamada AJAX simples e o servidor retornará uma sequência JSON com dados úteis ou uma sequência de mensagens de erro produzida pela função PHP mysql_error(). Como posso testar se esses dados são uma string JSON ou a mensagem de erro.

Seria bom usar uma função chamada, isJSONassim como você pode usá-la instanceofpara testar se algo é uma matriz.

É isso que eu quero:

if (isJSON(data)){
    //do some data stuff
}else{
    //report the error
    alert(data);
}

Use JSON.parse

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

Este código é JSON.parse(1234)ou JSON.parse(0)ou JSON.parse(false)ou JSON.parse(null)todos retornarão true.

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

Então, eu reescrevi o código desta maneira:

function isJson(item) {
    item = typeof item !== "string"
        ? JSON.stringify(item)
        : item;

    try {
        item = JSON.parse(item);
    } catch (e) {
        return false;
    }

    if (typeof item === "object" && item !== null) {
        return true;
    }

    return false;
}

Resultado do teste:

resultado do teste isJson

Vamos recapitular isso (para 2019+).

Argumento : Valores tais como true, false, nullsão válidos JSON (?)

FATO : Esses valores primitivos são analisáveis ​​por JSON, mas não são estruturas JSON bem formadas . A especificação JSON indica que o JSON se baseia em duas estruturas: Uma coleção de pares nome / valor (objeto) ou uma lista ordenada de valores (matriz).

Argumento : O tratamento de exceções não deve ser usado para fazer o esperado.
(Este é um comentário com mais de 25 votos positivos!)

FATO : Não! Definitivamente, é legal usar try / catch, especialmente em um caso como este. Caso contrário, você precisará fazer muitas coisas de análise de string, como operações de tokenizing / regex; o que teria um desempenho terrível.

hasJsonStructure()

Isso é útil se seu objetivo é verificar se alguns dados / texto possuem o formato de intercâmbio JSON adequado.

function hasJsonStructure(str) {
    if (typeof str !== 'string') return false;
    try {
        const result = JSON.parse(str);
        const type = Object.prototype.toString.call(result);
        return type === '[object Object]' 
            || type === '[object Array]';
    } catch (err) {
        return false;
    }
}

Uso:

hasJsonStructure('true')             // —» false
hasJsonStructure('{"x":true}')       // —» true
hasJsonStructure('[1, false, null]') // —» true

safeJsonParse()

E isso é útil se você quiser ter cuidado ao analisar alguns dados para um valor JavaScript.

function safeJsonParse(str) {
    try {
        return [null, JSON.parse(str)];
    } catch (err) {
        return [err];
    }
}

Uso:

const [err, result] = safeJsonParse('[Invalid JSON}');
if (err) {
    console.log('Failed to parse JSON: ' + err.message);
} else {
    console.log(result);
}

Se o servidor estiver respondendo com JSON, ele terá um application/jsontipo de conteúdo; se estiver respondendo com uma mensagem de texto sem formatação, deverá ter um text/plaintipo de conteúdo. Verifique se o servidor está respondendo com o tipo de conteúdo correto e teste-o.

ao usar jQuery $.ajax()a resposta terá a responseJSONpropriedade se a resposta for JSON, isso pode ser verificado assim:

if (xhr.hasOwnProperty('responseJSON')) {}

Eu gosto da melhor resposta, mas se for uma string vazia, ela retornará true. Então, aqui está uma correção:

function isJSON(MyTestStr){
    try {
        var MyJSON = JSON.stringify(MyTestStr);
        var json = JSON.parse(MyJSON);
        if(typeof(MyTestStr) == 'string')
            if(MyTestStr.length == 0)
                return false;
    }
    catch(e){
        return false;
    }
    return true;
}

var parsedData;

try {
    parsedData = JSON.parse(data)
} catch (e) {
    // is not a valid JSON string
}

No entanto, sugerirei que sua chamada / serviço http sempre retorne dados no mesmo formato. Portanto, se você tiver um erro, deverá ter um objeto JSON que envolva esse erro:

{"error" : { "code" : 123, "message" : "Foo not supported" } } 

E talvez use, além do status HTTP, um código 5xx.

Bem ... Depende da maneira como você está recebendo seus dados. Eu acho que o servidor está respondendo com uma string formatada em JSON (usando json_encode () no PHP, por exemplo). Se você estiver usando a postagem do JQuery e definir os dados de resposta para um formato JSON e for um JSON malformado, isso produzirá um erro:

$.ajax({
  type: 'POST',
  url: 'test2.php',
  data: "data",
  success: function (response){

        //Supposing x is a JSON property...
        alert(response.x);

  },
  dataType: 'json',
  //Invalid JSON
  error: function (){ alert("error!"); }
});

Mas, se você estiver usando a resposta de tipo como texto, precisará usar $ .parseJSON. De acordo com o site jquery: "A transmissão de uma string JSON malformada pode resultar no lançamento de uma exceção". Assim, seu código será:

$.ajax({
  type: 'POST',
  url: 'test2.php',
  data: "data",
  success: function (response){

        try {
            parsedData = JSON.parse(response);
        } catch (e) {
            // is not a valid JSON string
        }

  },
  dataType: 'text',
});

Provavelmente, existem testes que você pode fazer, por exemplo, se você sabe que o JSON retornado sempre será cercado {e, em }seguida, você pode testar esses caracteres ou algum outro método hacky. Ou você pode usar a biblioteca JS json.org para tentar analisá-la e testar se ela foi bem-sucedida.

No entanto, eu sugeriria uma abordagem diferente. Seu script PHP atualmente retorna JSON se a chamada for bem-sucedida, mas outra coisa se não for. Porque nem sempre retornar JSON?

Por exemplo

Chamada bem sucedida:

{ "status": "success", "data": [ <your data here> ] }

Chamada incorreta:

{ "status": "error", "error": "Database not found" }

Isso tornaria muito mais fácil escrever o JS do lado do cliente - tudo o que você precisa fazer é verificar o membro "status" e agir de acordo.

Eu uso apenas 2 linhas para fazer isso:

var isValidJSON = true;
try { JSON.parse(jsonString) } catch { isValidJSON = false }

Isso é tudo!

Mas lembre-se de que existem 2 traps:
1. JSON.parse(null)retorna null
2. Qualquer número ou string pode ser analisado com o JSON.parse()método.
   JSON.parse("5")retorna 5
   JSON.parse(5)retorna5

Vamos jogar alguns códigos:

// TEST 1
var data = '{ "a": 1 }'

// Avoiding 'null' trap! Null is confirmed as JSON.
var isValidJSON = data ? true : false
try { JSON.parse(data) } catch(e) { isValidJSON = false }

console.log("data isValidJSON: ", isValidJSON);
console.log("data isJSONArray: ", isValidJSON && JSON.parse(data).length ? true : false);

Console outputs:
data isValidJSON:  true
data isJSONArray:  false


// TEST 2
var data2 = '[{ "b": 2 }]'

var isValidJSON = data ? true : false
try { JSON.parse(data2) } catch(e) { isValidJSON = false }

console.log("data2 isValidJSON: ", isValidJSON);
console.log("data2 isJSONArray: ", isValidJSON && JSON.parse(data2).length ? true : false);

Console outputs:
data2 isValidJSON:  true
data2 isJSONArray:  true


// TEST 3
var data3 = '[{ 2 }]'

var isValidJSON = data ? true : false
try { JSON.parse(data3) } catch(e) { isValidJSON = false }

console.log("data3 isValidJSON: ", isValidJSON);
console.log("data3 isJSONArray: ", isValidJSON && JSON.parse(data3).length ? true : false);

Console outputs:
data3 isValidJSON:  false
data3 isJSONArray:  false


// TEST 4
var data4 = '2'

var isValidJSON = data ? true : false
try { JSON.parse(data4) } catch(e) { isValidJSON = false }

console.log("data4 isValidJSON: ", isValidJSON);
console.log("data4 isJSONArray: ", isValidJSON && JSON.parse(data4).length ? true : false);


Console outputs:
data4 isValidJSON:  true
data4 isJSONArray:  false


// TEST 5
var data5 = ''

var isValidJSON = data ? true : false
try { JSON.parse(data5) } catch(e) { isValidJSON = false }

console.log("data5 isValidJSON: ", isValidJSON);
console.log("data5 isJSONArray: ", isValidJSON && JSON.parse(data5).length ? true : false);


Console outputs:
data5 isValidJSON:  false
data5 isJSONArray:  false

// TEST 6
var data6; // undefined

var isValidJSON = data ? true : false
try { JSON.parse(data6) } catch(e) { isValidJSON = false }

console.log("data6 isValidJSON: ", isValidJSON);
console.log("data6 isJSONArray: ", isValidJSON && JSON.parse(data6).length ? true : false);

Console outputs:
data6 isValidJSON:  false
data6 isJSONArray:  false

Você pode tentar decodificá-lo e capturar a exceção (nativo ou json2.js ):

try {
  newObj = JSON.parse(myJsonString);
} catch (e) {
  console.log('Not JSON');
}

No entanto, sugiro que a resposta seja sempre JSON válida. Se você receber um erro de volta da sua consulta MySQL, basta enviar de volta o JSON com o erro:

{"error":"The MySQL error string."}

E depois:

if (myParsedJSON.error) {
  console.log('An error occurred: ' + myParsedJSON.error);
}

Aviso: Para métodos baseados em JSON.parse- matrizes e strings entre aspas também passarão (isto é console.log(JSON.parse('[3]'), JSON.parse('"\uD800"'))) .

Para evitar todas as primitivas JSON que não são objetos (booleano, nulo, matriz, número, cadeia de caracteres), sugiro o seguinte:

/* Validate a possible object ie. o = { "a": 2 } */
const isJSONObject = (o) => 
  !!o && (typeof o === 'object') && !Array.isArray(o) && 
  (() => { try { return Boolean(JSON.stringify(o)); } catch { return false } })()

/* Validate a possible JSON object represented as string ie. s = '{ "a": 3 }' */
function isJSONObjectString(s) {
    try {
        const o = JSON.parse(s);
        return !!o && (typeof o === 'object') && !Array.isArray(o)
    } catch {
        return false
    }
}

Código Explicação

• !! o - Não é falso (exclui null, que é registrado como tipo de 'objeto')
• (typeof o === 'object') - Exclui booleano, número e string
• ! Array.isArray (o) - Excluir matrizes (que são registradas como tipo de 'objeto')
• try ... JSON.stringify / JSON.parse - Solicita ao mecanismo JavaScript para determinar se JSON válido

Por que não usar a resposta hasJsonStructure ()?

Confiar toString()não é uma boa ideia. Isso ocorre porque diferentes mecanismos JavaScript podem retornar uma representação de sequência diferente. Em geral, os métodos que dependem disso podem falhar em ambientes diferentes ou podem estar sujeitos a falhas posteriormente, caso o mecanismo altere o resultado da string

Por que pegar uma exceção não é um hack?

Foi levantado que capturar uma exceção para determinar a validade de algo nunca é o caminho certo a seguir. Geralmente, esse é um bom conselho, mas nem sempre. Nesse caso, é provável que a captura de exceções seja a melhor rota, pois depende da implementação do mecanismo JavaScript de validar dados JSON.

Confiar no mecanismo JS oferece as seguintes vantagens:

1. Mais completo e atualizado à medida que as especificações JSON mudam
2. É provável que corra mais rápido (como é o código de nível inferior)

Quando tiver a oportunidade de usar o mecanismo JavaScript, sugiro fazê-lo. Particularmente nesse caso. Embora possa parecer hacky capturar uma exceção, você está realmente apenas lidando com dois possíveis estados de retorno de um método externo.

Aqui está um código com algumas pequenas modificações na resposta de Bourne. Como JSON.parse (number) funciona bem sem nenhuma exceção, o isNaN adicionado.

function isJson(str) {
    try {
        JSON.parse(str);
    } catch (e) {
        return false;
    }
    return isNaN(str);
}

Todas as strings json começam com '{' ou '[' e terminam com o correspondente '}' ou ']', portanto, verifique isso.

Veja como o Angular.js faz isso:

var JSON_START = /^\[|^\{(?!\{)/;
var JSON_ENDS = {
  '[': /]$/,
  '{': /}$/
};

function isJsonLike(str) {
    var jsonStart = str.match(JSON_START);
    return jsonStart && JSON_ENDS[jsonStart[0]].test(str);
}

https://github.com/angular/angular.js/blob/v1.6.x/src/ng/http.js

Eu sugiro no modo TypeScript:

export function stringify(data: any): string {
    try {
         return JSON.stringify(data)
    } catch (e) {
         return 'NOT_STRINGIFIABLE!'
    }
}

Eu usei este (tipo de mistura de respostas diferentes, mas de qualquer maneira):

const isJSON = str => {
  if (typeof str === 'string'){
    try {
      JSON.parse(str)
      return true
    } catch(e){
    }
  }
  return false
}



[null, undefined, false, true, [], {}, 
 '', 'asdf', '{}', '[]', "{\"abc\": 2}","{\"abc\": \"2\"}"]
  .map(el => {
      console.log(`[>${el}<] - ${isJSON(el)}`)
})

console.log('-----------------')

Você pode tentar o seguinte, porque também valida número, nulo, sequência, mas a resposta acima marcada não está funcionando corretamente, é apenas uma correção da função acima:

function isJson(str) {
  try {
      const obj = JSON.parse(str);
      if (obj && typeof obj === `object`) {
        return true;
      }
    } catch (err) {
      return false;
    }
   return false;
}

Além das respostas anteriores, no caso de você precisar validar um formato JSON como "{}", você pode usar o seguinte código:

const validateJSON = (str) => {
  try {
    const json = JSON.parse(str);
    if (Object.prototype.toString.call(json).slice(8,-1) !== 'Object') {
      return false;
    }
  } catch (e) {
    return false;
  }
  return true;
}

Exemplos de uso:

validateJSON('{}')
true
validateJSON('[]')
false
validateJSON('')
false
validateJSON('2134')
false
validateJSON('{ "Id": 1, "Name": "Coke" }')
true