Qual è il metodo preferito per restituire valori null in JSON? Esiste una preferenza diversa per i primitivi?

Ad esempio, se il mio oggetto sul server ha un numero intero chiamato "myCount" senza valore, il JSON più corretto per quel valore sarebbe:

{}

o

{
    "myCount": null
}

o

{
    "myCount": 0
}

Stessa domanda per le stringhe - se ho una stringa null "myString" sul server, è il JSON migliore:

{}

o

{
    "myString": null
}

o

{
    "myString": ""
}

o (signore aiutami)

{
    "myString": "null"
}

Mi piace che la convenzione per le raccolte sia rappresentata nel JSON come raccolta vuota http://jtechies.blogspot.nl/2012/07/item-43-return-empty-arrays-or.html

Un array vuoto sarebbe rappresentato:

{
    "myArray": []
}

Riepilogo EDIT

L'argomento delle "preferenze personali" sembra realistico, ma poco lungimirante in quanto, come comunità, consumeremo un numero sempre maggiore di servizi / fonti disparate. Le convenzioni per la struttura JSON aiuterebbero a normalizzare il consumo e il riutilizzo di tali servizi. Per quanto riguarda la definizione di uno standard, suggerirei di adottare la maggior parte delle convenzioni di Jackson con alcune eccezioni:

• Gli oggetti sono preferiti rispetto alle primitive.
• Le raccolte vuote sono preferite rispetto a null.
• Gli oggetti senza valore sono rappresentati come null.
• I primitivi restituiscono il loro valore.

Se si restituisce un oggetto JSON con valori prevalentemente nulli, è possibile che si abbia un candidato per il refactoring in più servizi.

{

    "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

}

Il JSON sopra è stato generato dalla seguente classe Java.

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 String text1;

        public String text2 = "hello";

        public int intValue;

        public List<Object> myList = new ArrayList<Object>();

        public List<Object> myEmptyList;

        public Boolean boolean1;

        public boolean littleboolean;

    }

    public static void main(String[] args) throws Exception {
        ObjectMapper mapper = new ObjectMapper();
        System.out.println(mapper.writeValueAsString(new Data()));
    }
}

Dipendenza da Maven:

<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-core</artifactId>
    <version>2.3.0</version>
</dependency>

Valutiamo l'analisi di ciascuno:

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

var json1 = '{}';
var json2 = '{"myCount": null}';
var json3 = '{"myCount": 0}';
var json4 = '{"myString": ""}';
var json5 = '{"myString": "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)); // {myString: ""}
console.log(JSON.parse(json5)); // {myString: "null"}
console.log(JSON.parse(json6)); // {myArray: []}

Il tl; dr qui:

Il frammento nella variabile json2 è il modo in cui le specifiche JSON indicano che nulldovrebbero essere rappresentate. Ma come sempre, dipende da cosa stai facendo - a volte il modo "giusto" di farlo non sempre funziona per la tua situazione. Usa il tuo giudizio e prendi una decisione informata.

JSON1 {}

Questo restituisce un oggetto vuoto. Non ci sono dati lì, e ti dirà solo che qualunque chiave tu stia cercando (che sia myCounto qualcos'altro) è di tipo undefined.

JSON2 {"myCount": null}

In questo caso, in myCountrealtà è definito, anche se il suo valore è null. Questo non è lo stesso di entrambi "no undefinede non null" e se si eseguisse il test per una condizione o per l'altra, ciò potrebbe avere esito positivo mentre JSON1 fallirebbe.

Questo è il modo definitivo di rappresentare nullsecondo le specifiche JSON .

JSON3 {"myCount": 0}

In questo caso, myCount è 0. Non è lo stesso di null, e non è lo stesso di false. Se la tua dichiarazione condizionale viene valutata myCount > 0, potrebbe essere utile farlo. Inoltre, se stai eseguendo calcoli basati sul valore qui, 0 potrebbe essere utile. Se stai provando a provare nullcomunque, questo in realtà non funzionerà affatto.

JSON4 {"myString": ""}

In questo caso, ricevi una stringa vuota. Ancora una volta, come con JSON2, è definito, ma è vuoto. Potresti provare per if (obj.myString == "")ma non puoi testare per nullo undefined.

JSON5 {"myString": "null"}

Questo probabilmente ti metterà nei guai, perché stai impostando il valore della stringa su null; in questo caso, obj.myString == "null"tuttavia è non == null .

JSON6 {"myArray": []}

Questo ti dirà che il tuo array myArrayesiste, ma è vuoto. Questo è utile se stai cercando di eseguire un conteggio o una valutazione myArray. Ad esempio, supponiamo che tu voglia valutare il numero di foto pubblicate da un utente - potresti farlo myArray.lengthe tornerebbe 0: definito, ma nessuna foto pubblicata.

nullnon è zero. Di per sé non è un valore: è un valore esterno al dominio della variabile che indica i dati mancanti o sconosciuti.

C'è solo un modo per rappresentare nullin JSON. Secondo le specifiche ( RFC 4627 e json.org ):

2.1. Valori

Un valore JSON DEVE essere un oggetto, un array, un numero o una stringa o uno di
i seguenti tre nomi letterali:

  false null true

C'è solo un modo per rappresentare null; quello è con 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

Vale a dire; se uno dei client che consumano la tua rappresentazione JSON utilizza l' ===operatore; potrebbe essere un problema per loro.

nessun valore

Se vuoi comunicare di avere un oggetto il cui attributo myCountnon ha valore:

{ "myCount": null }

nessun attributo / attributo mancante

Cosa succede se si comunica che si dispone di un oggetto senza attributi:

{}

Il codice client tenterà di accedere myCounte ottenere undefined; Non è lì.

raccolta vuota

Che cosa succede se si comunica che si dispone di un oggetto con un attributo myCountche è un elenco vuoto:

{ "myCount": [] }

Vorrei nullmostrare che non esiste alcun valore per quella chiave particolare. Ad esempio, utilizzare nullper indicare che "il numero di dispositivi in ​​casa si connette a Internet" è sconosciuto.

D'altra parte, utilizzare {}se quella particolare chiave non è applicabile. Ad esempio, non si dovrebbe mostrare un conteggio, anche se null, alla domanda "numero di auto con connessione Internet attiva" viene posta a qualcuno che non possiede alcuna macchina.

Eviterei di default qualsiasi valore a meno che quel default non abbia senso. Sebbene tu possa decidere di utilizzare nullper non rappresentare alcun valore, certamente non utilizzarlo mai "null"per farlo.

Sceglierei "default" per il tipo di dati della variabile ( nullper stringhe / oggetti, 0per i numeri), ma in effetti verificherei quale codice consumerà l'oggetto. Non dimenticare che a volte esiste una distinzione tra null/ default e "non presente".

Scopri il modello di oggetti null - a volte è meglio passare qualche oggetto speciale invece di null(cioè []array invece che nullper array o ""per stringhe).

Questa è una scelta personale e situazionale. La cosa importante da ricordare è che la stringa vuota e il numero zero sono concettualmente distinti danull .

Nel caso di a countprobabilmente vuoi sempre un numero valido (a meno che non countsia sconosciuto o indefinito), ma nel caso di stringhe, chi lo sa? La stringa vuota potrebbe significare qualcosa nella tua applicazione. O forse no. Sta a te decidere.

Secondo le specifiche JSON , il contenitore più esterno non deve essere un dizionario (o 'oggetto') come implicito nella maggior parte dei commenti sopra. Può anche essere un elenco o un valore non elaborato (ovvero stringa, numero, valore booleano o null). Se si desidera rappresentare un valore null in JSON, l'intera stringa JSON (escluse le virgolette contenenti la stringa JSON) è semplicemente null. Senza parentesi graffe, senza parentesi, senza virgolette. È possibile specificare un dizionario contenente una chiave con un valore null ( {"key1":null}) o un elenco con un valore null ( [null]), ma questi non sono valori null stessi - sono dizionari ed elenchi appropriati. Allo stesso modo, un dizionario vuoto ( {}) o un elenco vuoto ( []) vanno benissimo, ma non sono nulli.

In 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