Représentant null dans JSON

Quelle est la méthode préférée pour renvoyer des valeurs NULL dans JSON? Y a-t-il une préférence différente pour les primitives?

Par exemple, si mon object sur le serveur a un entier appelé “myCount” sans valeur, le JSON le plus correct pour cette valeur serait:

{} 

ou

 { "myCount": null } 

ou

 { "myCount": 0 } 

Même question pour Ssortingngs – si j’ai une chaîne vide “mySsortingng” sur le serveur, est le meilleur JSON:

 {} 

ou

 { "mySsortingng": null } 

ou

 { "myStrung": "" } 

ou (Seigneur aide moi)

 { "mySsortingng": "null" } 

J’aime la convention pour que les collections soient représentées dans le JSON en tant que collection vide http://jtechies.blogspot.nl/2012/07/item-43-return-empty-arrays-or.html

Un tableau vide serait représenté:

 { "myArray": [] } 

Résumé de l’EDIT

L’argument de la «préférence personnelle» semble réaliste, mais la communauté consumra un plus grand nombre de services / sources disparates. Les conventions pour la structure JSON aideraient à normaliser la consommation et la réutilisation desdits services. En ce qui concerne l’établissement d’une norme, je suggérerais d’adopter la plupart des conventions de Jackson à quelques exceptions près:

  • Les objects sont préférés aux primitives.
  • Les collections vides sont préférables à null.
  • Les objects sans valeur sont représentés par la valeur null.
  • Les primitifs renvoient leur valeur.

Si vous retournez un object JSON avec des valeurs essentiellement nulles, vous pouvez avoir un candidat pour le refactoring en plusieurs services.

 { "value1": null, "value2": null, "text1": null, "text2": "hello", "intValue": 0, //use primitive only if you are absolutely sure the answer is 0 "myList": [], "myEmptyList": null, //NOT BEST PRACTICE - return [] instead "boolean1": null, //use primitive only if you are absolutely sure the answer is true/false "littleboolean": false } 

Le JSON ci-dessus a été généré à partir de la classe Java suivante.

 package jackson; import java.util.ArrayList; import java.util.List; import com.fasterxml.jackson.databind.ObjectMapper; public class JacksonApp { public static class Data { public Integer value1; public Integer value2; public Ssortingng text1; public Ssortingng text2 = "hello"; public int intValue; public List myList = new ArrayList(); public List myEmptyList; public Boolean boolean1; public boolean littleboolean; } public static void main(Ssortingng[] args) throws Exception { ObjectMapper mapper = new ObjectMapper(); System.out.println(mapper.writeValueAsSsortingng(new Data())); } } 

Dépendance Maven:

  com.fasterxml.jackson.core jackson-core 2.3.0  

    Évaluons l’parsing de chacun:

    http://jsfiddle.net/brandonscript/Y2dGv/

     var json1 = '{}'; var json2 = '{"myCount": null}'; var json3 = '{"myCount": 0}'; var json4 = '{"mySsortingng": ""}'; var json5 = '{"mySsortingng": "null"}'; var json6 = '{"myArray": []}'; console.log(JSON.parse(json1)); // {} console.log(JSON.parse(json2)); // {myCount: null} console.log(JSON.parse(json3)); // {myCount: 0} console.log(JSON.parse(json4)); // {mySsortingng: ""} console.log(JSON.parse(json5)); // {mySsortingng: "null"} console.log(JSON.parse(json6)); // {myArray: []} 

    Le tl; dr ici:

    JSON2 est la manière dont la spécification JSON indique que null doit être représenté. Mais comme toujours, cela dépend de ce que vous faites – parfois, la «bonne» façon de le faire ne fonctionne pas toujours dans votre situation. Utilisez votre jugement et prenez une décision éclairée.


    JSON1 {}

    Cela retourne un object vide. Il n’y a pas de données et cela ne vous dira que quelle que soit la clé que vous cherchiez (que ce soit myCount ou autre), elle est de type undefined .


    JSON2 {"myCount": null}

    Dans ce cas, myCount est effectivement défini, bien que sa valeur soit null . Ce n’est pas la même chose que “pas undefined et non null “, et si vous testiez une condition ou l’autre, cela pourrait réussir alors que JSON1 échouerait.

    C’est la manière définitive de représenter null selon la spécification JSON .


    JSON3 {"myCount": 0}

    Dans ce cas, myCount est égal à 0. Ce n’est pas la même chose que null et ce n’est pas la même chose que false . Si votre instruction conditionnelle évalue myCount > 0 , cela peut être intéressant. De plus, si vous effectuez des calculs basés sur la valeur ici, 0 pourrait être utile. Si vous essayez de tester null , cela ne fonctionnera pas du tout.


    JSON4 {"mySsortingng": ""}

    Dans ce cas, vous obtenez une chaîne vide. Encore une fois, comme avec JSON2, il est défini, mais il est vide. Vous pourriez tester if (obj.mySsortingng == "") mais vous ne pouviez pas tester null ou undefined .


    JSON5 {"mySsortingng": "null"}

    Cela va probablement vous causer des problèmes, car vous définissez la valeur de chaîne sur null; dans ce cas, obj.mySsortingng == "null" mais ce n’est pas == null .


    JSON6 {"myArray": []}

    Cela vous dira que votre tableau myArray existe, mais il est vide. Ceci est utile si vous essayez d’effectuer un décompte ou une évaluation sur myArray . Par exemple, supposons que vous vouliez évaluer le nombre de photos myArray.length un utilisateur – vous pouvez faire myArray.length , qui renvoie 0 : défini, mais pas de photos postées.

    null n’est pas nul. Ce n’est pas une valeur en soi : c’est une valeur en dehors du domaine de la variable indiquant des données manquantes ou inconnues.

    Il n’y a qu’une seule façon de représenter null dans JSON. Selon les spécifications ( RFC 4627 et json.org ):

      2.1.  Valeurs
    
     Une valeur JSON DOIT être un object, un tableau, un nombre ou une chaîne, ou l'un des
     les trois noms littéraux suivants:
    
       false null true
    

    entrer la description de l'image ici

    Il n’y a qu’une seule façon de représenter null ; c’est avec null .

     console.log(null === null); // true console.log(null === true); // false console.log(null === false); // false console.log(null === 'null'); // false console.log(null === "null"); // false console.log(null === ""); // false console.log(null === []); // false console.log(null === 0); // false 

    C’est-à-dire; si l’un des clients qui consumnt votre représentation JSON utilise l’opérateur === ; cela pourrait être un problème pour eux.

    aucune valeur

    Si vous voulez myCount que vous avez un object dont l’atsortingbut myCount n’a aucune valeur:

     { "myCount": null } 

    aucun atsortingbut / atsortingbut manquant

    Que faire si vous transmettez que vous avez un object sans atsortingbuts:

     {} 

    Le code client essaiera d’accéder à myCount et myCount undefined . Ce n’est pas là.

    collection vide

    Que faire si vous transmettez que vous avez un object avec un atsortingbut myCount qui est une liste vide:

     { "myCount": [] } 

    J’utiliserais null pour montrer qu’il n’y a pas de valeur pour cette clé particulière. Par exemple, utiliser null pour indiquer que “le nombre d’appareils de votre foyer se connecte à Internet” est inconnu.

    D’un autre côté, utilisez {} si cette clé particulière n’est pas applicable. Par exemple, vous ne devez pas afficher un nombre, même null , à la question “Nombre de voitures ayant une connexion Internet active” est demandé à une personne qui ne possède aucune voiture.

    J’éviterais de faire défaut à n’importe quelle valeur à moins que ce défaut ait un sens. Bien que vous puissiez décider d’utiliser null pour ne représenter aucune valeur, n’utilisez certainement jamais "null" pour le faire.

    Je choisirais “default” pour le type de données de la variable ( null pour les chaînes / objects, 0 pour les nombres), mais vérifiez en effet quel code consumra l’object attendu. N’oubliez pas qu’il y a parfois une distinction entre null / default et “not present”.

    Vérifiez le modèle d’object nul – il est parfois préférable de passer un object spécial au lieu de null (c’est-à-dire un tableau [] au lieu de null pour les tableaux ou "" pour les chaînes).

    C’est un choix personnel et situationnel. La chose importante à retenir est que la chaîne vide et le nombre zéro sont conceptuellement distincts de null .

    Dans le cas d’un count vous voudrez probablement toujours un nombre valide (sauf si le count est inconnu ou non défini), mais dans le cas des chaînes, qui sait? La chaîne vide pourrait signifier quelque chose dans votre application. Ou peut-être que non. C’est à vous de décider.

    Selon la spécification JSON , le conteneur le plus externe ne doit pas nécessairement être un dictionnaire (ou un «object»), comme l’indique la plupart des commentaires ci-dessus. Il peut également s’agir d’une liste ou d’une valeur nue (par exemple, chaîne, nombre, valeur booléenne ou null). Si vous souhaitez représenter une valeur nulle dans JSON, la chaîne JSON entière (à l’exclusion des guillemets contenant la chaîne JSON) est simplement null . Pas d’accolades, pas de crochets, pas de guillemets. Vous pouvez spécifier un dictionnaire contenant une clé avec une valeur nulle ( {"key1":null} ), ou une liste avec une valeur nulle ( [null] ), mais ce ne sont pas des valeurs NULL elles-mêmes. De même, un dictionnaire vide ( {} ) ou une liste vide ( [] ) sont parfaitement corrects, mais ne sont pas non plus nuls.

    En Python:

     >>> print json.loads('{"key1":null}') {u'key1': None} >>> print json.loads('[null]') [None] >>> print json.loads('[]') [] >>> print json.loads('{}') {} >>> print json.loads('null') None