Comment tester si une chaîne est JSON ou non?

J'ai un simple appel AJAX et le serveur renverra soit une chaîne JSON avec des données utiles, soit une chaîne de message d'erreur produite par la fonction PHP mysql_error(). Comment puis-je tester si ces données sont une chaîne JSON ou le message d'erreur.

Ce serait bien d'utiliser une fonction appelée isJSONcomme vous pouvez utiliser la fonction instanceofpour tester si quelque chose est un tableau.

C'est ce que je veux:

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

Utilisez JSON.parse

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

Ce code est JSON.parse(1234)ou JSON.parse(0)ou JSON.parse(false)ou JSON.parse(null)tout retournera vrai.

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

J'ai donc réécrit le code de cette manière:

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;
}

Résultat du test:

résultat du test isJson

Récapitulons ceci (pour 2019+).

Argument : Les valeurs telles que true, false, nullsont valables JSON (?)

FAIT : Ces valeurs primitives sont analysables par JSON mais ce ne sont pas des structures JSON bien formées . La spécification JSON indique que JSON repose sur deux structures: une collection de paires nom / valeur (objet) ou une liste ordonnée de valeurs (tableau).

Argument : la gestion des exceptions ne doit pas être utilisée pour faire quelque chose d'attendu.
(Ceci est un commentaire qui a plus de 25 votes positifs!)

FAIT : Non! Il est tout à fait légal d'utiliser try / catch, surtout dans un cas comme celui-ci. Sinon, vous devrez effectuer de nombreuses analyses de chaînes telles que des opérations de tokenisation / regex; ce qui aurait des performances terribles.

hasJsonStructure()

Ceci est utile si votre objectif est de vérifier si certaines données / textes ont le format d'échange JSON approprié.

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;
    }
}

Usage:

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

safeJsonParse()

Et cela est utile si vous voulez être prudent lors de l'analyse de certaines données en une valeur JavaScript.

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

Usage:

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

Si le serveur répond avec JSON, il aura un application/jsontype de contenu, s'il répond avec un message en texte brut, il doit avoir un text/plaintype de contenu. Assurez-vous que le serveur répond avec le type de contenu correct et testez-le.

lors de l'utilisation de jQuery $.ajax()la réponse aura la responseJSONpropriété si la réponse était JSON, cela pourrait être vérifié comme ceci:

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

J'aime la meilleure réponse, mais s'il s'agit d'une chaîne vide, elle renvoie true. Alors, voici une solution:

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
}

Cependant, je vais vous suggérer que votre appel / service http doit toujours renvoyer une donnée dans le même format. Donc, si vous avez une erreur, vous devriez avoir un objet JSON qui encapsule cette erreur:

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

Et peut-être utiliser ainsi que l'état HTTP un code 5xx.

Eh bien ... Cela dépend de la façon dont vous recevez vos données. Je pense que le serveur répond avec une chaîne au format JSON (en utilisant json_encode () en PHP, par exemple). Si vous utilisez JQuery post et définissez les données de réponse au format JSON et qu'il s'agit d'un JSON malformé, cela produira une erreur:

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

Mais, si vous utilisez la réponse de type sous forme de texte, vous devez utiliser $ .parseJSON. Selon le site jquery: "La transmission d'une chaîne JSON mal formée peut entraîner la levée d'une exception". Ainsi votre code sera:

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

Il y a probablement des tests que vous pouvez faire, par exemple si vous savez que le JSON retourné sera toujours entouré par {et que }vous pourriez alors tester ces caractères, ou une autre méthode hacky. Ou vous pouvez utiliser le json.org bibliothèque JS pour essayer de l'analyser et tester si elle réussit.

Je suggérerais cependant une approche différente. Votre script PHP renvoie actuellement JSON si l'appel réussit, mais autre chose si ce n'est pas le cas. Pourquoi ne pas toujours renvoyer JSON?

Par exemple

Appel réussi:

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

Appel erroné:

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

Cela rendrait l'écriture de votre JS côté client beaucoup plus facile - tout ce que vous avez à faire est de vérifier le membre "status" et d'agir en conséquence.

J'utilise juste 2 lignes pour effectuer cela:

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

C'est tout!

Mais gardez à l'esprit qu'il y a 2 pièges:
1. JSON.parse(null)renvoie null
2. N'importe quel nombre ou chaîne peut être analysé avec la JSON.parse()méthode.
   JSON.parse("5")retourne 5
   JSON.parse(5)retours5

Jouons un peu sur le code:

// 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

Vous pouvez essayer de le décoder et d'attraper l' exception (native ou json2.js ):

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

Cependant, je suggérerais que la réponse soit toujours JSON valide. Si vous obtenez une erreur de votre requête MySQL, renvoyez simplement JSON avec l'erreur:

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

Puis:

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

Attention: pour les méthodes reposant sur JSON.parse- Les tableaux et les guillemets entourés de chaînes passeront également (ie.console.log(JSON.parse('[3]'), JSON.parse('"\uD800"')) )

Pour éviter toutes les primitives JSON non-objet (booléenne, null, tableau, nombre, chaîne), je suggère d'utiliser ce qui suit:

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

Explication du code

• !! o - Non faux (exclut null, qui s'enregistre comme typeof 'object')
• (typeof o === 'objet') - Exclut le booléen, le nombre et la chaîne
• ! Array.isArray (o) - Exclut les tableaux (qui s'inscrivent comme typeof 'object')
• try ... JSON.stringify / JSON.parse - Demande au moteur JavaScript de déterminer si JSON valide

Pourquoi ne pas utiliser la réponse hasJsonStructure ()?

Reposant sur toString() n'est pas une bonne idée. En effet, différents moteurs JavaScript peuvent renvoyer une représentation sous forme de chaîne différente. En général, les méthodes qui reposent sur cela peuvent échouer dans différents environnements ou peuvent être sujettes à l'échec plus tard si le moteur change le résultat de la chaîne

Pourquoi attraper une exception n'est-il pas un hack?

On a évoqué le fait qu'attraper une exception pour déterminer la validité de quelque chose n'est jamais la bonne voie à suivre. C'est généralement un bon conseil, mais pas toujours. Dans ce cas, la capture d'exceptions est probablement la meilleure voie, car elle repose sur l'implémentation du moteur JavaScript pour valider les données JSON.

S'appuyer sur le moteur JS offre les avantages suivants:

1. Plus complet et continuellement à jour à mesure que les spécifications JSON changent
2. Probablement plus rapide (car il s'agit d'un code de niveau inférieur)

Lorsqu'on me donne la possibilité de s'appuyer sur le moteur JavaScript, je suggère de le faire. Surtout dans ce cas. Bien qu'il puisse se sentir hacky pour attraper une exception, vous êtes vraiment manipuler juste deux états de retour possible d'une méthode externe.

Voici un code avec quelques modifications mineures dans la réponse de Bourne. Comme JSON.parse (nombre) fonctionne bien sans aucune exception, il a donc été ajouté isNaN.

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

Toutes les chaînes json commencent par '{' ou '[' et se terminent par le '}' ou ']' correspondant, alors vérifiez simplement cela.

Voici comment Angular.js le fait:

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

Je suggère en mode Typescript:

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

J'ai utilisé celui-ci (sorte de mélange de réponses différentes, mais de toute façon):

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('-----------------')

Vous pouvez essayer la suivante car elle valide également nombre, null, chaîne, mais la réponse indiquée ci-dessus ne fonctionne pas correctement, c'est juste une correction de la fonction ci-dessus:

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

En plus des réponses précédentes, au cas où vous auriez besoin de valider un format JSON tel que "{}", vous pouvez utiliser le code suivant:

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;
}

Exemples d'utilisation:

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