Os comentários podem ser usados ​​no JSON?

Posso usar comentários dentro de um arquivo JSON? Se sim, como?

Não.

O JSON deve ser todos dados, e se você incluir um comentário, também serão dados.

Você pode ter um elemento de dados designado chamado "_comment"(ou algo assim) que seria ignorado pelos aplicativos que usam os dados JSON.

Você provavelmente seria melhor ter o comentário nos processos que geram / recebem o JSON, pois eles devem saber quais serão os dados JSON com antecedência, ou pelo menos a estrutura deles.

Mas se você decidiu:

{
   "_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"
            }
         }
      }
   }
}

Não , comentários do formulário //…ou /*…*/não são permitidos no JSON. Esta resposta é baseada em:

• http://www.json.org
• RFC 4627 : O application/jsontipo de mídia para JavaScript Object Notation (JSON)
• RFC 8259 O formato de intercâmbio de dados da JavaScript Object Notation (JSON) (substitui as RFCs 4627, 7158, 7159)

Inclua comentários se você escolher; retire-os com um minificador antes de analisar ou transmitir.

Acabei de lançar o JSON.minify (), que retira comentários e espaços em branco de um bloco de JSON e torna JSON válido que pode ser analisado. Então, você pode usá-lo como:

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

Quando o libertei, recebi uma enorme reação das pessoas que discordavam até da ideia, então decidi escrever um post abrangente sobre por que os comentários fazem sentido no JSON . Inclui este comentário notável do criador do JSON:

Suponha que você esteja usando JSON para manter os arquivos de configuração que você gostaria de anotar. Vá em frente e insira todos os comentários que você gosta. Em seguida, passe-o pelo JSMin antes de entregá-lo ao seu analisador JSON. - Douglas Crockford, 2012

Espero que seja útil para aqueles que discordam do porquê JSON.minify () poderia ser útil.

Os comentários foram removidos do JSON por design.

Eu removi os comentários do JSON porque vi que as pessoas os estavam usando para manter diretivas de análise, uma prática que teria destruído a interoperabilidade. Sei que a falta de comentários deixa algumas pessoas tristes, mas não deveria.

Suponha que você esteja usando JSON para manter os arquivos de configuração que você gostaria de anotar. Vá em frente e insira todos os comentários que você gosta. Em seguida, passe-o pelo JSMin antes de entregá-lo ao seu analisador JSON.

Fonte: declaração pública de Douglas Crockford no G +

AVISO LEGAL: SUA GARANTIA É ANULADA

Como foi apontado, esse hack tira vantagem da implementação das especificações. Nem todos os analisadores JSON entenderão esse tipo de JSON. Os analisadores de streaming, em particular, engasgam.

É uma curiosidade interessante, mas você realmente não deve usá-lo para nada . Abaixo está a resposta original.

Eu encontrei um pequeno truque que permite colocar comentários em um arquivo JSON que não afetará a análise ou alterará os dados que estão sendo representados de qualquer forma.

Parece que, ao declarar um literal de objeto, você pode especificar dois valores com a mesma chave, e o último tem precedência. Acredite ou não, verifica-se que os analisadores JSON funcionam da mesma maneira. Portanto, podemos usar isso para criar comentários no JSON de origem que não estarão presentes em uma representação de objeto analisada.

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

Se aplicarmos essa técnica, seu arquivo JSON comentado poderá ser assim:

{
  "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]
}

O código acima é JSON válido . Se você analisá-lo, obterá um objeto como este:

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

O que significa que não há vestígios nos comentários e eles não terão efeitos colaterais estranhos.

Feliz hacking!

JSON não suporta comentários. Também nunca foi planejado para ser usado em arquivos de configuração nos quais seriam necessários comentários.

Hjson é um formato de arquivo de configuração para humanos. Sintaxe relaxada, menos erros, mais comentários.

Veja hjson.org para bibliotecas JavaScript, Java, Python, PHP, Rust, Go, Ruby e C #.

Considere usar o YAML. É quase um superconjunto de JSON (praticamente todo JSON válido é YAML válido) e permite comentários.

Você não pode. Pelo menos essa é a minha experiência de uma rápida olhada no json.org .

JSON tem sua sintaxe visualizada nessa página. Não há nenhuma observação sobre comentários.

Os comentários não são um padrão oficial, embora alguns analisadores suportem comentários no estilo C ++. Um que eu uso é JsonCpp . Nos exemplos, há este:

// Configuration options
{
    // Default encoding for text
    "encoding" : "UTF-8",

    // Plug-ins loaded at start-up
    "plug-ins" : [
        "python",
        "c++",
        "ruby"
        ],

    // Tab indent size
    "indent" : { "length" : 3, "use_space": true }
}

O jsonlint não valida isso. Portanto, os comentários são uma extensão específica do analisador e não são padrão.

Outro analisador é JSON5 .

Uma alternativa ao JSON TOML .

Uma outra alternativa é jsonc .

Você deve escrever um esquema JSON . O esquema JSON é atualmente uma especificação de rascunho proposta na Internet. Além da documentação, o esquema também pode ser usado para validar seus dados JSON.

Exemplo:

{
    "description":"A person",
    "type":"object",
    "properties":
        {
            "name":
                {
                    "type":"string"
                },
            "age":
                {
                    "type":"integer",
                    "maximum":125
                }
        }
}

Você pode fornecer documentação usando o atributo do esquema de descrição .

Se você estiver usando Jackson como seu analisador JSON, é assim que você permite que ele permita comentários:

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

Então você pode ter comentários como este:

{
  key: "value" // Comment
}

E você também pode ter comentários começando com a #configuração:

mapper.configure(Feature.ALLOW_YAML_COMMENTS, true);

Mas, em geral (como respondido anteriormente), a especificação não permite comentários.

Aqui está o que encontrei na documentação do Google Firebase que permite que você coloque comentários no 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"
}

NÃO . O JSON costumava dar suporte aos comentários, mas eles foram abusados ​​e removidos do padrão.

Do criador do JSON:

Eu removi os comentários do JSON porque vi que as pessoas os estavam usando para manter diretivas de análise, uma prática que teria destruído a interoperabilidade. Eu sei que a falta de comentários deixa algumas pessoas tristes, mas não deveria. - Douglas Crockford, 2012

O site oficial do JSON está em JSON.org . JSON é definido como padrão pela ECMA International. Sempre existe um processo de petição para revisar os padrões. É improvável que as anotações sejam adicionadas ao padrão JSON por vários motivos.

JSON por design é uma alternativa de engenharia reversa facilmente (analisada por humanos) ao XML. É simplificado até ao ponto de que as anotações são desnecessárias. Nem sequer é uma linguagem de marcação. O objetivo é estabilidade e interoperabilidade.

Qualquer pessoa que entenda o relacionamento "has-a" de orientação a objetos pode entender qualquer estrutura JSON - esse é o ponto principal. É apenas um gráfico acíclico direcionado (DAG) com tags de nó (pares chave / valor), que é uma estrutura de dados quase universal.

Essa única anotação necessária pode ser "// Estas são as tags do DAG". Os nomes das chaves podem ser tão informativos quanto necessário, permitindo aridade semântica arbitrária.

Qualquer plataforma pode analisar JSON com apenas algumas linhas de código. O XML requer bibliotecas OO complexas que não são viáveis ​​em muitas plataformas.

As anotações apenas tornariam o JSON menos interoperável. Simplesmente não há mais nada a acrescentar, a menos que você realmente precise de uma linguagem de marcação (XML) e não se importe se seus dados persistentes são analisados ​​com facilidade.

MAS, como o criador do JSON também observou, sempre houve suporte ao pipeline do JS para comentários:

Vá em frente e insira todos os comentários que você gosta. Em seguida, passe-o pelo JSMin antes de entregá-lo ao seu analisador JSON. - Douglas Crockford, 2012

Se o seu arquivo de texto, que é uma string JSON, for lido por algum programa, quão difícil seria remover os comentários no estilo C ou C ++ antes de usá-lo?

Resposta: Seria uma linha. Se você fizer isso, os arquivos JSON poderão ser usados ​​como arquivos de configuração.

Se você estiver usando a biblioteca Newtonsoft.Json com o ASP.NET para ler / desserializar, poderá usar comentários no conteúdo JSON:

// "nome": "string"

//"eu não fiz

ou

/* Isto é um

exemplo de comentário * /

PS: Comentários de linha única são suportados apenas com mais de 6 versões do Newtonsoft Json.

Nota adicional para pessoas que não conseguem pensar fora da caixa: Eu uso o formato JSON para configurações básicas em um aplicativo Web ASP.NET que criei. Eu leio o arquivo, converto-o no objeto de configurações da biblioteca Newtonsoft e o uso quando necessário.

Prefiro escrever comentários sobre cada configuração individual no próprio arquivo JSON e realmente não me importo com a integridade do formato JSON, desde que a biblioteca que eu use esteja de acordo.

Eu acho que essa é uma maneira 'mais fácil de usar / entender' do que criar um arquivo 'settings.README' separado e explicar as configurações nele.

Se você tiver um problema com esse tipo de uso; desculpe, o gênio está fora da lâmpada. As pessoas encontrariam outros usos para o formato JSON e não há nada que você possa fazer sobre isso.

A idéia por trás do JSON é fornecer uma troca simples de dados entre aplicativos. Normalmente, eles são baseados na Web e o idioma é JavaScript.

Realmente não permite comentários como tais, no entanto, transmitir um comentário como um dos pares de nome / valor nos dados certamente funcionaria, embora esses dados precisassem obviamente ser ignorados ou manipulados especificamente pelo código de análise.

Tudo isso dito, não é a intenção que o arquivo JSON contenha comentários no sentido tradicional. Devem ser apenas os dados.

Dê uma olhada no site JSON para mais detalhes.

Acabei de encontrar isso para arquivos de configuração. Não quero usar o formato XML (detalhado, gráfico, feio, difícil de ler) ou "ini" (sem hierarquia, padrão real etc.) ou o formato "Propriedades" do Java (como .ini).

O JSON pode fazer tudo o que pode, mas é muito menos detalhado e mais legível para humanos - e os analisadores são fáceis e onipresentes em muitos idiomas. É apenas uma árvore de dados. Porém, comentários fora da banda são frequentemente necessários para documentar configurações "padrão" e coisas do gênero. As configurações nunca devem ser "documentos completos", mas árvores de dados salvos que podem ser legíveis por humanos quando necessário.

Eu acho que alguém poderia usar "#": "comment", para JSON "válido".

O JSON não suporta comentários de forma nativa, mas você pode criar seu próprio decodificador ou pelo menos pré-processador para remover os comentários, tudo bem (desde que você ignore os comentários e não os use para orientar como seu aplicativo deve processar os dados JSON )

JSON não tem comentários. Um codificador JSON NÃO DEVE emitir comentários. Um decodificador JSON PODE aceitar e ignorar comentários.

Os comentários nunca devem ser usados ​​para transmitir algo significativo. É para isso que serve o JSON.

Cf: Douglas Crockford, autor da especificação JSON .

Depende da sua biblioteca JSON. O Json.NET suporta comentários no estilo JavaScript /* commment */,.

Veja outra pergunta sobre estouro de pilha .

O JSON faz muito sentido para arquivos de configuração e outros usos locais porque é onipresente e muito mais simples que XML.

Se as pessoas tiverem motivos fortes para não comentar no JSON ao comunicar dados (válidos ou não), possivelmente JSON poderá ser dividido em dois:

• JSON-COM: JSON na ligação ou regras que se aplicam ao comunicar dados JSON.
• JSON-DOC: documento JSON ou JSON em arquivos ou localmente. Regras que definem um documento JSON válido.

O JSON-DOC permitirá comentários e outras pequenas diferenças podem existir, como lidar com espaços em branco. Os analisadores podem facilmente converter de uma especificação para outra.

Com relação à observação feita por Douglas Crockford sobre esse assunto (referenciada por @Artur Czajka)

Suponha que você esteja usando JSON para manter os arquivos de configuração que você gostaria de anotar. Vá em frente e insira todos os comentários que você gosta. Em seguida, passe-o pelo JSMin antes de entregá-lo ao seu analisador JSON.

Estamos falando de um problema genérico de arquivo de configuração (cross language / plataforma), e ele está respondendo com um utilitário específico do JS!

Certifique-se de que um minify específico do JSON possa ser implementado em qualquer idioma, mas padronize isso para que se torne onipresente entre os analisadores em todos os idiomas e plataformas, para que as pessoas parem de perder tempo sem o recurso porque possuem bons casos de uso, procurando o problema em fóruns on-line e levar as pessoas a dizerem que é uma má ideia ou sugerir que é fácil implementar a remoção de comentários de arquivos de texto.

A outra questão é a interoperabilidade. Suponha que você tenha uma biblioteca ou API ou qualquer tipo de subsistema que tenha alguns arquivos de configuração ou dados associados. E este subsistema deve ser acessado de diferentes idiomas. Então você continua dizendo às pessoas: a propósito, não esqueça de remover os comentários dos arquivos JSON antes de passá-los para o analisador!

Se você usa JSON5, pode incluir comentários.

O JSON5 é uma extensão proposta para o JSON que visa tornar mais fácil para os humanos escrever e manter manualmente. Isso é feito adicionando alguns recursos mínimos de sintaxe diretamente do ECMAScript 5.

O kit de ferramentas JavaScript do Dojo Toolkit (pelo menos a partir da versão 1.4) permite incluir comentários em seu JSON. Os comentários podem ter /* */formato. O Dojo Toolkit consome o JSON por meio da dojo.xhrGet()chamada.

Outros kits de ferramentas JavaScript podem funcionar de maneira semelhante.

Isso pode ser útil ao experimentar estruturas de dados alternativas (ou mesmo listas de dados) antes de escolher uma opção final.

JSON não é um protocolo emoldurado . É um formato livre de idioma . Portanto, o formato de um comentário não está definido para JSON.

Como muitas pessoas sugeriram, existem alguns truques, por exemplo, chaves duplicadas ou uma chave específica _commentque você pode usar. Você decide.

Você pode ter comentários em JSONP , mas não em JSON puro. Passei uma hora tentando fazer meu programa funcionar com este exemplo da Highcharts: http://www.highcharts.com/samples/data/jsonp.php?filename=aapl-c.json&callback=?

Se você seguir o link, verá

?(/* AAPL historical OHLC data from the Google Finance API */
[
/* May 2006 */
[1147651200000,67.79],
[1147737600000,64.98],
...
[1368057600000,456.77],
[1368144000000,452.97]
]);

Como eu tinha um arquivo semelhante na minha pasta local, não havia problemas com a política de mesma origem , então decidi usar JSON puro ... e, é claro, $.getJSONestava falhando silenciosamente por causa dos comentários.

Eventualmente, acabei de enviar uma solicitação HTTP manual para o endereço acima e percebi que o tipo de conteúdo era text/javascriptporque, bem, JSONP retorna JavaScript puro. Nesse caso, comentários são permitidos . Mas meu aplicativo retornou o tipo de conteúdo application/json, então tive que remover os comentários.

Esta é uma pergunta "você pode" . E aqui está um "sim" resposta .

Não, você não deve usar membros duplicados do objeto para inserir dados do canal lateral em uma codificação JSON. (Veja "Os nomes dentro de um objeto devem ser únicos" no RFC ).

E sim, você pode inserir comentários em torno do JSON , que você pode analisar.

Mas se você deseja inserir e extrair dados arbitrários do canal lateral em um JSON válido, aqui está uma resposta. Aproveitamos a representação não exclusiva de dados em uma codificação JSON. Isso é permitido ^* na seção dois da RFC em "espaço em branco permitido antes ou depois de qualquer um dos seis caracteres estruturais".

^* O RFC apenas declara "espaço em branco é permitido antes ou depois de qualquer um dos seis caracteres estruturais", sem mencionar explicitamente cadeias, números, "false", "true" e "null". Essa omissão é ignorada em TODAS as implementações.

Primeiro, canonize seu JSON minimizando-o:

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

Em seguida, codifique seu comentário em binário:

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

Então steg seu binário:

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

Aqui está a sua saída:

$jsonWithComment = $steg . $jsonMin;

AVISO LEGAL: ISSO É TOLO

Na verdade, existe uma maneira de adicionar comentários e permanecer dentro das especificações (nenhum analisador adicional é necessário). Não resultará em comentários legíveis por humanos sem qualquer tipo de análise.

Você pode abusar do seguinte:

Espaço em branco insignificante é permitido antes ou depois de qualquer token. Espaço em branco é qualquer sequência de um ou mais dos seguintes pontos de código: tabulação de caracteres (U + 0009), avanço de linha (U + 000A), retorno de carro (U + 000D) e espaço (U + 0020).

De uma maneira hacky, você pode abusar disso para adicionar um comentário. Por exemplo: inicie e termine seu comentário com uma guia. Codifique o comentário na base3 e use os outros caracteres de espaço em branco para representá-los. Por exemplo.

010212 010202 011000 011000 011010 001012 010122 010121 011021 010202 001012 011022 010212 011020 010202 010202

( hello base threeem ASCII) Mas, em vez de 0, use espaço, para 1 uso de alimentação de linha e 2 para uso de retorno de carro.

Isso deixará você com muito espaço em branco ilegível (a menos que você crie um plug-in IDE para codificá-lo / decodificá-lo rapidamente).

Eu nunca tentei isso, por razões óbvias e você também não deveria.

Estamos usando strip-json-commentspara o nosso projeto. Ele suporta algo como:

/*
 * Description 
*/
{
    // rainbows
    "unicorn": /* ❤ */ "cake"
}

Simplesmente npm install --save strip-json-commentspara instalar e usar como:

var strip_json_comments = require('strip-json-comments')
var json = '{/*rainbows*/"unicorn":"cake"}';
JSON.parse(strip_json_comments(json));
//=> {unicorn: 'cake'}

No meu caso, preciso usar comentários para fins de depuração, antes da saída da estrutura JSON. Então, decidi usar as informações de depuração no cabeçalho HTTP, para evitar a quebra do cliente:

header("My-Json-Comment: Yes, I know it's a workaround ;-) ");

JSON não permite comentários, por si só. O raciocínio é totalmente tolo, porque você pode usar o próprio JSON para criar comentários, o que evita completamente o raciocínio e carrega o espaço de dados do analisador sem nenhuma boa razão para exatamente o mesmo resultado e possíveis problemas, como eles são: um JSON arquivo com comentários.

Se você tentar inserir comentários (usando //ou /* */ou #por exemplo), alguns analisadores falharão porque isso não está estritamente dentro da especificação JSON. Então você nunca deve fazer isso.

Aqui está um exemplo, em que meu sistema de manipulação de imagens salvou notações de imagens e algumas informações básicas formatadas (comentários) relacionadas a elas (na parte inferior):

{
    "Notations": [
        {
            "anchorX": 333,
            "anchorY": 265,
            "areaMode": "Ellipse",
            "extentX": 356,
            "extentY": 294,
            "opacity": 0.5,
            "text": "Elliptical area on top",
            "textX": 333,
            "textY": 265,
            "title": "Notation 1"
        },
        {
            "anchorX": 87,
            "anchorY": 385,
            "areaMode": "Rectangle",
            "extentX": 109,
            "extentY": 412,
            "opacity": 0.5,
            "text": "Rect area\non bottom",
            "textX": 98,
            "textY": 385,
            "title": "Notation 2"
        },
        {
            "anchorX": 69,
            "anchorY": 104,
            "areaMode": "Polygon",
            "extentX": 102,
            "extentY": 136,
            "opacity": 0.5,
            "pointList": [
                {
                    "i": 0,
                    "x": 83,
                    "y": 104
                },
                {
                    "i": 1,
                    "x": 69,
                    "y": 136
                },
                {
                    "i": 2,
                    "x": 102,
                    "y": 132
                },
                {
                    "i": 3,
                    "x": 83,
                    "y": 104
                }
            ],
            "text": "Simple polygon",
            "textX": 85,
            "textY": 104,
            "title": "Notation 3"
        }
    ],
    "imageXW": 512,
    "imageYW": 512,
    "imageName": "lena_std.ato",
    "tinyDocs": {
        "c01": "JSON image notation data:",
        "c02": "-------------------------",
        "c03": "",
        "c04": "This data contains image notations and related area",
        "c05": "selection information that provides a means for an",
        "c06": "image gallery to display notations with elliptical,",
        "c07": "rectangular, polygonal or freehand area indications",
        "c08": "over an image displayed to a gallery visitor.",
        "c09": "",
        "c10": "X and Y positions are all in image space. The image",
        "c11": "resolution is given as imageXW and imageYW, which",
        "c12": "you use to scale the notation areas to their proper",
        "c13": "locations and sizes for your display of the image,",
        "c14": "regardless of scale.",
        "c15": "",
        "c16": "For Ellipses, anchor is the  center of the ellipse,",
        "c17": "and the extents are the X and Y radii respectively.",
        "c18": "",
        "c19": "For Rectangles, the anchor is the top left and the",
        "c20": "extents are the bottom right.",
        "c21": "",
        "c22": "For Freehand and Polygon area modes, the pointList",
        "c23": "contains a series of numbered XY points. If the area",
        "c24": "is closed, the last point will be the same as the",
        "c25": "first, so all you have to be concerned with is drawing",
        "c26": "lines between the points in the list. Anchor and extent",
        "c27": "are set to the top left and bottom right of the indicated",
        "c28": "region, and can be used as a simplistic rectangular",
        "c29": "detect for the mouse hover position over these types",
        "c30": "of areas.",
        "c31": "",
        "c32": "The textx and texty positions provide basic positioning",
        "c33": "information to help you locate the text information",
        "c34": "in a reasonable location associated with the area",
        "c35": "indication.",
        "c36": "",
        "c37": "Opacity is a value between 0 and 1, where .5 represents",
        "c38": "a 50% opaque backdrop and 1.0 represents a fully opaque",
        "c39": "backdrop. Recommendation is that regions be drawn",
        "c40": "only if the user hovers the pointer over the image,",
        "c41": "and that the text associated with the regions be drawn",
        "c42": "only if the user hovers the pointer over the indicated",
        "c43": "region."
    }
}

Para cortar um item JSON em partes, adiciono linhas "comentários fictícios":

{

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

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

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

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

}