validator - swagger comment json




I commenti possono essere usati in JSON? (20)

DICHIARAZIONE DI NON RESPONSABILITÀ: LA VOSTRA GARANZIA È ANNULLATA

Come è stato sottolineato, questo hack sfrutta l'implementazione delle specifiche. Non tutti i parser JSON comprenderanno questo tipo di JSON. In particolare i parser di streaming soffocheranno.

È una curiosità interessante, ma non dovresti davvero usarla per niente . Di seguito è la risposta originale.

Ho trovato un piccolo trucco che consente di inserire commenti in un file JSON che non influirà sull'analisi o alterare i dati rappresentati in alcun modo.

Sembra che quando si dichiara un oggetto letterale è possibile specificare due valori con la stessa chiave, e l'ultimo ha la precedenza. Che ci crediate o no, risulta che i parser JSON funzionano allo stesso modo. Quindi possiamo usarlo per creare commenti nel JSON di origine che non sarà presente in una rappresentazione oggetto parsed.

({a: 1, a: 2});
// => Object {a: 2}
Object.keys(JSON.parse('{"a": 1, "a": 2}')).length; 
// => 1

Se applichiamo questa tecnica, il tuo file JSON commentato potrebbe assomigliare a questo:

{
  "api_host" : "The hostname of your API server. You may also specify the port.",
  "api_host" : "hodorhodor.com",

  "retry_interval" : "The interval in seconds between retrying failed API calls",
  "retry_interval" : 10,

  "auth_token" : "The authentication token. It is available in your developer dashboard under 'Settings'",
  "auth_token" : "5ad0eb93697215bc0d48a7b69aa6fb8b",

  "favorite_numbers": "An array containing my all-time favorite numbers",
  "favorite_numbers": [19, 13, 53]
}

Il codice sopra è JSON valido . Se lo analizzi, otterrai un oggetto come questo:

{
    "api_host": "hodorhodor.com",
    "retry_interval": 10,
    "auth_token": "5ad0eb93697215bc0d48a7b69aa6fb8b",
    "favorite_numbers": [19,13,53]
}

Il che significa che non c'è traccia dei commenti e che non avranno effetti collaterali strani.

Happy hacking!

Posso usare commenti all'interno di un file JSON? Se é cosi, come?


Dipende dalla tua libreria JSON. Json.NET supporta i commenti in stile JavaScript, /* commment */.

Vedi un'altra domanda di overflow dello stack .


Ecco cosa ho trovato nella documentazione di Google Firebase che ti consente di inserire commenti in JSON:

{
  "//": "Some browsers will use this to enable push notifications.",
  "//": "It is the same for all projects, this is not your project's sender ID",
  "gcm_sender_id": "1234567890"
}

Ho appena incontrato questo per i file di configurazione. Non voglio usare il formato XML (verboso, graficamente, brutto, difficile da leggere), o "ini" (nessuna gerarchia, nessun vero standard, ecc.) O Java "Proprietà" (come .ini).

JSON può fare tutto ciò che può fare, ma è molto meno prolisso e più leggibile dall'uomo - e i parser sono facili e onnipresenti in molte lingue. È solo un albero di dati. Ma i commenti fuori banda sono spesso necessari per documentare configurazioni "predefinite" e simili. Le configurazioni non devono mai essere "documenti completi", ma alberi di dati salvati che possono essere leggibili dall'uomo quando necessario.

Immagino che si possa usare "#": "comment" , per "valido" JSON.


I commenti sono stati rimossi da JSON in base alla progettazione.

Ho rimosso i commenti da JSON perché vedevo che le persone li utilizzavano per contenere direttive di analisi, una pratica che avrebbe distrutto l'interoperabilità. So che la mancanza di commenti rende alcune persone tristi, ma non dovrebbe.

Supponiamo che tu stia usando JSON per mantenere i file di configurazione, che vorresti annotare. Vai avanti e inserisci tutti i commenti che ti piacciono. Quindi collegalo a JSMin prima di passarlo al parser JSON.

Fonte: plus.google.com/118095276221607585885/posts/RK8qyGVaGSr


JSON non supporta i commenti in modo nativo, ma è possibile creare il proprio decodificatore o almeno il preprocessore per eliminare i commenti, ciò è perfettamente corretto (basta che ignori i commenti e non li usi per guidare il modo in cui l'applicazione deve elaborare i dati JSON ).

JSON non ha commenti. Un codificatore JSON NON DEVE inviare commenti. Un decodificatore JSON PU MAY accettare e ignorare i commenti.

I commenti non dovrebbero mai essere usati per trasmettere qualcosa di significativo. Ecco a cosa serve JSON.

Cfr: Douglas Crockford, autore di JSON spec .


L'idea alla base di JSON è quella di fornire un semplice scambio di dati tra le applicazioni. Questi sono in genere basati sul Web e la lingua è JavaScript.

In realtà non consente commenti in quanto tali, tuttavia, il passaggio di un commento come una delle coppie nome / valore nei dati funzionerebbe sicuramente, anche se i dati avrebbero ovviamente bisogno di essere ignorati o gestiti in modo specifico dal codice di analisi.

Detto questo, non è intenzione che il file JSON contenga commenti nel senso tradizionale. Dovrebbero essere solo i dati.

Dai un'occhiata al sito web JSON per maggiori dettagli.


No.

I JSON dovrebbero essere tutti dati e, se includi un commento, saranno anche i dati.

Potresti avere un elemento dati designato chiamato "_comment" (o qualcosa) che verrebbe ignorato dalle app che usano i dati JSON.

Probabilmente sarebbe meglio avere il commento nei processi che genera / riceve il JSON, poiché si suppone che sappiano quali saranno i dati JSON in anticipo o almeno la loro struttura.

Ma se hai deciso di:

{
   "_comment": "comment text goes here...",
   "glossary": {
      "title": "example glossary",
      "GlossDiv": {
         "title": "S",
         "GlossList": {
            "GlossEntry": {
               "ID": "SGML",
               "SortAs": "SGML",
               "GlossTerm": "Standard Generalized Markup Language",
               "Acronym": "SGML",
               "Abbrev": "ISO 8879:1986",
               "GlossDef": {
                  "para": "A meta-markup language, used to create markup languages such as DocBook.",
                  "GlossSeeAlso": ["GML", "XML"]
               },
               "GlossSee": "markup"
            }
         }
      }
   }
}

Prendi in considerazione l'utilizzo di YAML. È quasi un superset di JSON (praticamente tutto JSON valido è YAML valido) e consente commenti.


Se il tuo file di testo, che è una stringa JSON, verrà letto da qualche programma, quanto sarebbe difficile rimuovere i commenti in stile C o C ++ prima di usarlo?

Risposta: Sarebbe un solo rivestimento. Se lo fai, allora i file JSON potrebbero essere usati come file di configurazione.


Se stai usando Jackson come parser JSON, questo è il modo in cui lo abiliti per consentire i commenti:

ObjectMapper mapper = new ObjectMapper().configure(Feature.ALLOW_COMMENTS, true);

Quindi puoi avere commenti come questo:

{
  key: "value" // Comment
}

E puoi anche avere commenti che iniziano con # impostando:

mapper.configure(Feature.ALLOW_YAML_COMMENTS, true);

Ma in generale (come risposta prima) le specifiche non consentono commenti.


Sospiro. Perché non aggiungere solo campi, ad es

{
    "note1" : "This demonstrates the provision of annotations within a JSON file",
    "field1" : 12,
    "field2" : "some text",

    "note2" : "Add more annotations as necessary"
}

Assicurati solo che i tuoi nomi "notex" non siano in conflitto con nessun campo reale.


Includere i commenti se si sceglie; spogliarli con un minificatore prima di analizzare o trasmettere.

Ho appena rilasciato JSON.minify() che rimuove i commenti e gli spazi bianchi da un blocco di JSON e lo rende JSON valido che può essere analizzato. Quindi, potresti usarlo come:

JSON.parse(JSON.minify(my_str));

Quando l'ho rilasciato, ho avuto un enorme contraccolpo di persone che non erano d'accordo nemmeno con l'idea, quindi ho deciso di scrivere un post completo sul perché i commenti hanno senso in JSON . Include questo commento notevole del creatore di JSON:

Supponiamo che tu stia usando JSON per mantenere i file di configurazione, che vorresti annotare. Vai avanti e inserisci tutti i commenti che ti piacciono. Quindi collegalo a JSMin prima di passarlo al parser JSON. - plus.google.com/118095276221607585885/posts/RK8qyGVaGSr

Speriamo che questo sia utile a coloro che non sono d'accordo sul perché JSON.minify () potrebbe essere utile.


JSON non è un protocollo con frame . È un formato linguistico gratuito . Quindi il formato di un commento non è definito per JSON.

Come molte persone hanno suggerito, ci sono alcuni trucchi, ad esempio, chiavi duplicate o una chiave specifica _commentche è possibile utilizzare. Tocca a voi.


JSON ha molto senso per i file di configurazione e altri usi locali perché è onnipresente e perché è molto più semplice di XML.

Se le persone hanno forti motivi per non avere commenti in JSON quando comunicano i dati (validi o meno), allora forse JSON potrebbe essere diviso in due:

  • JSON-COM: JSON sul filo o regole applicabili quando si comunicano i dati JSON.
  • JSON-DOC: documento JSON, o JSON nei file o localmente. Regole che definiscono un documento JSON valido.

JSON-DOC consentirà commenti e potrebbero esistere altre differenze minori come la gestione degli spazi bianchi. I parser possono facilmente convertire da una specifica all'altra.

Per quanto riguarda l' plus.google.com/118095276221607585885/posts/RK8qyGVaGSr fatte da Douglas Crockford su questi problemi (a cui fa riferimento @Artur Czajka)

Supponiamo che tu stia usando JSON per mantenere i file di configurazione, che vorresti annotare. Vai avanti e inserisci tutti i commenti che ti piacciono. Quindi collegalo a JSMin prima di passarlo al parser JSON.

Stiamo parlando di un problema generico di file di configurazione (cross language / platform) e sta rispondendo con un'utilità specifica di JS!

Certo, un minisito specifico JSON può essere implementato in qualsiasi lingua, ma standardizzarlo in modo che diventi onnipresente in tutti i parser in tutte le lingue e piattaforme in modo che le persone smettano di sprecare il loro tempo senza la funzionalità perché hanno buoni casi d'uso, esaminando il problema in forum online e far dire alla gente che è una cattiva idea o suggerire che è facile implementare i commenti di rimozione dai file di testo.

L'altro problema è l'interoperabilità. Supponiamo che tu abbia una libreria o API o qualsiasi tipo di sottosistema con alcuni file di configurazione o dati associati. E questo sottosistema è accessibile da diverse lingue. Poi vai a dire alla gente: a proposito, non dimenticare di togliere i commenti dai file JSON prima di passarli al parser!


Per tagliare un elemento JSON in parti, aggiungo le righe "dummy comment":

{

"#############################" : "Part1",

"data1"             : "value1",
"data2"             : "value2",

"#############################" : "Part2",

"data4"             : "value3",
"data3"             : "value4"

}

C'è una buona soluzione (hack), che è JSON valido. Basta fare la stessa chiave due volte (o più). Per esempio:

{
  "param" : "This is the comment place",
  "param" : "This is value place",
}

Quindi JSON lo capirà come:

{
  "param" : "This is value place",
}

Il toolkit JavaScript Dojo Toolkit (almeno dalla versione 1.4) consente di includere commenti nel JSON. I commenti possono essere di /* */formato. Dojo Toolkit consuma il JSON tramite la dojo.xhrGet()chiamata.

Altri toolkit JavaScript potrebbero funzionare in modo simile.

Questo può essere utile quando si sperimentano strutture dati alternative (o anche liste di dati) prima di scegliere un'opzione finale.


Questa è una domanda "puoi" . Ed ecco una risposta "si" .

No, non si dovrebbero usare membri duplicativi degli oggetti per inserire dati del canale laterale in una codifica JSON. (Vedi "I nomi all'interno di un oggetto DOVREBBE essere unico" nella RFC ).

E sì, si potrebbe inserire commenti in tutto il JSON , che si potrebbe analizzare fuori.

Ma se vuoi un modo per inserire ed estrarre dati arbitrari sul canale laterale su un JSON valido, ecco una risposta. Traiamo vantaggio dalla rappresentazione non univoca dei dati in una codifica JSON. Questo è permesso * nella sezione due della RFC sotto "spazio bianco è consentito prima o dopo uno qualsiasi dei sei caratteri strutturali".

* La RFC indica solo "lo spazio bianco è consentito prima o dopo uno qualsiasi dei sei caratteri strutturali", senza menzionare esplicitamente stringhe, numeri, "false", "true" e "null". Questa omissione viene ignorata in TUTTE le implementazioni.

Innanzitutto, canonicalizza il tuo JSON minimizzandolo:

$jsonMin = json_encode(json_decode($json));

Quindi codifica il tuo commento in binario:

$hex = unpack('H*', $comment);
$commentBinary = base_convert($hex[1], 16, 2);

Quindi steg tuo binario:

$steg = str_replace('0', ' ', $commentBinary);
$steg = str_replace('1', "\t", $steg);

Ecco il tuo risultato:

$jsonWithComment = $steg . $jsonMin;

Se si utilizza JSON5 è possibile includere commenti.

JSON5 è un'estensione proposta per JSON che mira a rendere più facile per gli esseri umani scrivere e mantenere a mano. Lo fa aggiungendo alcune funzioni di sintassi minimale direttamente da ECMAScript 5.





comments