it-swarm-es.com

¿Se pueden usar los comentarios en JSON?

¿Puedo usar comentarios dentro de un archivo JSON? ¿Si es así, cómo?

6844
Michael Gundlach

No. 

El JSON debe ser todos datos, y si incluye un comentario, también lo será.

Podría tener un elemento de datos designado llamado "_comment" (o algo) que las aplicaciones que usan los datos JSON ignorarían.

Probablemente sería mejor tener el comentario en los procesos que generan/reciben el JSON, ya que se supone que deben saber de antemano cuáles serán los datos de JSON, o al menos su estructura. 

Pero si decides:

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

No , los comentarios del formulario //… o /*…*/ no están permitidos en JSON. Esta respuesta se basa en:

  • http://www.json.org
  • RFC 4627 : El application/json Tipo de medio para la notación de objetos de JavaScript (JSON)
  • RFC 7159 El formato de intercambio de datos de la notación de objetos JavaScript (JSON) - Obsoletos: 4627, 7158
1640
stakx

Incluir comentarios si lo desea; Elimínelos con un minificador antes de analizarlos o transmitirlos.

Acabo de lanzarJSON.MINIFY ()que elimina los comentarios y espacios en blanco de un bloque de JSON y lo convierte en JSON válido que se puede analizar. Entonces, podrías usarlo como: 

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

Cuando lo publiqué, tuve un gran contragolpe de personas que no estaban de acuerdo con la idea, así que decidí escribir un blog completo sobre por qué los comentarios tienen sentido en JSON . Incluye este notable comentario del creador de JSON:

Supongamos que está utilizando JSON para mantener los archivos de configuración, que le gustaría anotar. Anímate e inserta todos los comentarios que quieras. Luego colóquelo en JSMin antes de entregárselo a su analizador JSON. - Douglas Crockford, 2012

Esperemos que sea útil para aquellos que no están de acuerdo con por qué JSON.minify () podría ser útil.

720
Kyle Simpson

Los comentarios fueron eliminados de JSON por diseño.

Eliminé los comentarios de JSON porque vi que la gente los estaba usando para mantener directivas de análisis, una práctica que habría destruido la interoperabilidad. Sé que la falta de comentarios entristece a algunas personas, pero no debería. 

Supongamos que está utilizando JSON para mantener los archivos de configuración, que le gustaría anotar. Anímate e inserta todos los comentarios que quieras. Luego colóquelo en JSMin antes de entregárselo a su analizador JSON.

Fuente: Declaración pública de Douglas Crockford sobre G +

393
Artur Czajka

DESCARGO DE RESPONSABILIDAD: SU GARANTÍA IS VACÍO

Como se ha señalado, este truco aprovecha la implementación de la especificación. No todos los analizadores JSON entenderán este tipo de JSON. Los analizadores de streaming en particular se ahogarán.

Es una curiosidad interesante, pero usted realmente no debería usarla para nada en absoluto . A continuación se muestra la respuesta original.


He encontrado un pequeño truco que le permite colocar comentarios en un archivo JSON que no afectará el análisis o alterará los datos que se representan de alguna manera.

Parece que al declarar un objeto literal puede especificar dos valores con la misma clave, y el último tiene prioridad. Lo creas o no, resulta que los analizadores JSON funcionan de la misma manera. Por lo tanto, podemos usar esto para crear comentarios en el JSON de origen que no estarán presentes en una representación del objeto analizado. 

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

Si aplicamos esta técnica, su archivo JSON comentado podría verse así:

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

El código anterior es JSON válido . Si lo analizas, obtendrás un objeto como este:

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

Lo que significa que no hay rastro de los comentarios, y no tendrán efectos secundarios extraños.

¡Feliz piratería!

198
Ped

JSON no admite comentarios. Tampoco fue pensado para ser utilizado para archivos de configuración donde se necesitarían comentarios.

Hjson es un formato de archivo de configuración para humanos. Sintaxis relajada, menos errores, más comentarios.

 Hjson intro

Consulte hjson.org para las bibliotecas de JavaScript, Java, Python, PHP, Rust, Go, Ruby y C #.

140
laktak

Usted no puede Al menos esa es mi experiencia de un rápido vistazo a json.org .

JSON tiene su sintaxis visualizada en esa página. No hay ninguna nota sobre los comentarios.

97
Cheery

Considera usar YAML. Es casi un superconjunto de JSON (prácticamente todos los JSON válidos son YAML válidos) y permite comentarios.

95

Debería escribir un esquema JSON en su lugar. El esquema JSON es actualmente una propuesta de especificación de borrador de Internet. Además de la documentación, el esquema también se puede utilizar para validar sus datos JSON.

Ejemplo:

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

Puede proporcionar documentación utilizando el atributo description schema.

58
raffel

Si está utilizando Jackson como su analizador JSON, así es como lo habilita para permitir comentarios:

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

Entonces puedes tener comentarios como este:

{
  key: "value" // Comment
}

Y también puede tener comentarios que comiencen con # configurando:

mapper.configure(Feature.ALLOW_YAML_COMMENTS, true);

Pero en general (como se respondió antes) la especificación no permite comentarios.

56
Andrejs

Los comentarios no son una norma oficial. Aunque algunos analizadores admiten comentarios de estilo C Uno que uso es JsonCpp . En los ejemplos hay 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 }
}

jsonlint no valida esto. Así que los comentarios son una extensión específica del analizador y no estándar.

Otro analizador es JSON5 .

Una alternativa a JSON TOML .

53
schoetbi

Esto es lo que encontré en la documentación de Google Firebase que le permite poner comentarios en 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"
}
44
mana

Lo sentimos, no podemos usar comentarios en JSON ... Ver el diagrama de sintaxis para JSON en JSON.org .

Douglas Crockford dice " por qué eliminó los comentarios en JSON y brindó una forma alternativa de hacerlo ":

Eliminé los comentarios de JSON porque vi que la gente los estaba usando para mantener Directivas de análisis, una práctica que habría destruido La interoperabilidad. Sé que la falta de comentarios hace que algunas personas Estén tristes, pero no debería.

Supongamos que está utilizando JSON para mantener los archivos de configuración, que Le gustaría anotar. Continúe e inserte todos los comentarios que desee. Luego, canalícelo a través de JSMin antes de entregarlo a su analizador JSON.

40
NavaRajan

Si su archivo de texto, que es una cadena JSON, será leído por algún programa, ¿qué tan difícil sería eliminar los comentarios de estilo C o C++ antes de usarlo?

Respuesta: Sería un forro. Si lo hace, entonces los archivos JSON podrían usarse como archivos de configuración.

37
John T. Vonachen

Si está utilizando la biblioteca Newtonsoft.Json con ASP.NET para leer/deserializar, puede usar comentarios en el contenido JSON:

// "nombre": "cadena"

//"Yo dint

o

/* Esto es un

ejemplo de comentario * /

PS: Los comentarios de una sola línea solo son compatibles con las versiones 6+ de Newtonsoft Json.

Nota adicional para las personas que no pueden pensar fuera de la caja: Yo uso el formato JSON para la configuración básica en una aplicación web ASP.NET que hice. Leí el archivo, lo convertí en el objeto de configuración con la biblioteca de Newtonsoft y lo uso cuando es necesario.

Prefiero escribir comentarios sobre cada configuración individual en el propio archivo JSON, y realmente no me importa la integridad del formato JSON, siempre y cuando la biblioteca que uso esté de acuerdo.

Creo que esta es una forma 'más fácil de usar/entender' que crear un archivo 'settings.README' separado y explicar la configuración en él.

Si tienes un problema con este tipo de uso; Lo siento, el genio está fuera de la lámpara. La gente encontraría otros usos para el formato JSON, y no hay nada que puedas hacer al respecto.

33
dvdmn

La idea detrás de JSON es proporcionar un intercambio de datos simple entre aplicaciones. Estos son típicamente basados ​​en la web y el lenguaje es JavaScript.

Sin embargo, realmente no permite comentarios como tales, sin embargo, pasar un comentario como uno de los pares nombre/valor en los datos funcionaría, aunque obviamente los datos deberían ser ignorados o manejados específicamente por el código de análisis.

Dicho todo esto, no es la intención que el archivo JSON contenga comentarios en el sentido tradicional. Solo deben ser los datos.

Eche un vistazo a la página web de JSON para más detalles.

28
Neil Albrock

Acabo de encontrar esto para los archivos de configuración. No quiero usar el formatoXML(detallado, gráfico, feo, difícil de leer) o el formato "ini" (sin jerarquía, no hay un estándar real, etc.) o el formato "Propiedades" de Java (como .ini).

JSON puede hacer todo lo que puede hacer, pero es mucho menos detallado y más legible para los humanos, y los analizadores son fáciles y ubicuos en muchos idiomas. Es sólo un árbol de datos. Pero los comentarios fuera de banda son a menudo una necesidad para documentar configuraciones "por defecto" y similares. Las configuraciones nunca deben ser "documentos completos", sino árboles de datos guardados que pueden ser leídos por humanos cuando sea necesario.

Supongo que uno podría usar "#": "comment", para JSON "válido".

27
peterk

JSON no admite comentarios de forma nativa, pero puede crear su propio decodificador o al menos un preprocesador para eliminar los comentarios, eso está perfectamente bien (siempre que solo ignore los comentarios y no los use para guiar cómo su aplicación debe procesar los datos JSON). ).

JSON no tiene comentarios. Un codificador JSON NO DEBE emitir comentarios. Un decodificador JSON PUEDE aceptar e ignorar comentarios.

Los comentarios nunca deben usarse para transmitir algo significativo. Eso es Para lo que JSON es.

Cf: Douglas Crockford, autor de JSON spec .

26
gaborous

Depende de tu biblioteca JSON. Json.NET admite comentarios de estilo JavaScript, /* commment */.

Ver otra pregunta de desbordamiento de pila .

26
AZ.

JSON tiene mucho sentido para los archivos de configuración y otros usos locales porque es ubicuo y porque es mucho más simple que XML. 

Si las personas tienen fuertes razones para no tener comentarios en JSON al comunicar datos (ya sean válidos o no), posiblemente JSON podría dividirse en dos:

  • JSON-COM: JSON en el cable, o reglas que se aplican al comunicar datos JSON.
  • JSON-DOC: documento JSON o JSON en archivos o localmente. Reglas que definen un documento JSON válido.

JSON-DOC permitirá comentarios, y pueden existir otras pequeñas diferencias, como el manejo de espacios en blanco. Los analizadores pueden convertir fácilmente de una especificación a la otra. 

Con respecto a la observación hecha por Douglas Crockford sobre este tema (referenciada por @Artur Czajka)

Supongamos que está utilizando JSON para mantener los archivos de configuración, que le gustaría anotar. Anímate e inserta todos los comentarios que quieras. Luego colóquelo en JSMin antes de entregárselo a su analizador JSON.

Estamos hablando de un problema de archivo de configuración genérico (idioma/plataforma), ¡y está respondiendo con una utilidad específica de JS!

Claro que se puede implementar una minificación específica de JSON en cualquier idioma, Pero estandarizar esto para que se convierta en omnipresente en todos los analizadores en todos los idiomas y plataformas para que las personas dejen de perder su tiempo sin la característica porque tienen buenos casos de uso. buscar el problema en los foros en línea y hacer que la gente les diga que es una mala idea o sugerir que es fácil implementar comentarios de eliminación de archivos de texto.

El otro tema es la interoperabilidad. Supongamos que tiene una biblioteca o API o cualquier tipo de subsistema que tenga asociados algunos archivos de configuración o de datos. Y este subsistema es Al que se puede acceder desde diferentes idiomas. Luego vas a decirle a la gente: por cierto ¡No olvides eliminar los comentarios de los archivos JSON antes de pasarlos al analizador!

23
Basel Shishani

Si usa JSON5 puede incluir comentarios.


JSON5 es una extensión propuesta para JSON que apunta a facilitar que los humanos escriban y mantengan a mano. Lo hace agregando algunas características de sintaxis mínima directamente desde ECMAScript 5.

20
Smit Johnth

El kit de herramientas de JavaScript de Dojo Toolkit (al menos a partir de la versión 1.4) le permite incluir comentarios en su JSON. Los comentarios pueden ser de formato /* */. Dojo Toolkit consume el JSON a través de la llamada dojo.xhrGet().

Otros kits de herramientas de JavaScript pueden funcionar de manera similar.

Esto puede ser útil cuando se experimenta con estructuras de datos alternativas (o incluso listas de datos) antes de elegir una opción final.

20
David

JSON no es un protocolo enmarcado . Es un formato libre de idioma . Así que el formato de un comentario no está definido para JSON.

Como muchas personas han sugerido, hay algunos trucos, por ejemplo, claves duplicadas o una clave específica _comment que puedes usar. Tu decides.

17
Manish Shrivastava

Usted puede tiene comentarios en JSONP , pero no en JSON puro. Acabo de pasar una hora intentando que mi programa funcione con este ejemplo de Highcharts: http://www.highcharts.com/samples/data/jsonp.php?filename=aapl-c.json&callback=?

Si sigues el enlace, verás

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

Dado que tenía un archivo similar en mi carpeta local, no hubo problemas con la política Same-Origin , así que decidí usar JSON puro ... y, por supuesto, $.getJSON estaba fallando silenciosamente debido a los comentarios.

Finalmente, acabo de enviar una solicitud HTTP manual a la dirección anterior y me di cuenta de que el tipo de contenido era text/javascript ya que, bueno, JSONP devuelve JavaScript puro. En este caso, los comentarios están permitidos . Pero mi aplicación devolvió el tipo de contenido application/json, así que tuve que eliminar los comentarios.

17
osa

Esta es una pregunta "puedes" . Y aquí hay un "sí" respuesta.

No, no debe usar miembros de objetos duplicados para rellenar los datos del canal lateral en una codificación JSON. (Consulte "Los nombres dentro de un objeto DEBEN ser únicos" en el RFC ).

Y sí, podría insertar comentarios alrededor el JSON , que podría analizar.

Pero si desea una manera de insertar y extraer datos de canal lateral arbitrarios a un JSON válido, aquí hay una respuesta. Aprovechamos la representación no única de datos en una codificación JSON. Esto esta permitido* en la sección dos de la RFC bajo "Se permite el espacio en blanco antes o después de cualquiera de los seis caracteres estructurales".

*El RFC solo indica "se permite el espacio en blanco antes o después de cualquiera de los seis caracteres estructurales", sin mencionar explícitamente cadenas, números, "falso", "verdadero" y "nulo". Esta omisión es ignorada en TODAS las implementaciones.


Primero, canonicaliza tu JSON reduciéndolo:

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

Luego codifica tu comentario en binario:

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

Entonces steg tu binario:

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

Aquí está tu salida:

$jsonWithComment = $steg . $jsonMin;
16
William Entriken

Estamos utilizando strip-json-comments para nuestro proyecto. Es compatible con algo como:

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

Simplemente npm install --save strip-json-comments para instalarlo y usarlo como:

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

Hay una buena solución (hack), que es JSON válido. Simplemente haz la misma clave dos veces (o más). Por ejemplo: 

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

Entonces JSON entenderá esto como:

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

Para cortar un artículo JSON en partes, agrego líneas de "comentario ficticio":

{

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

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

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

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

}
10
Chris

JSON solía admitir comentarios, pero fueron abusados ​​y eliminados de la norma.

Del creador de JSON:

Eliminé los comentarios de JSON porque vi que la gente los estaba usando para mantener directivas de análisis, una práctica que habría destruido la interoperabilidad. Sé que la falta de comentarios entristece a algunas personas, pero no debería. - Douglas Crockford, 2012

El sitio oficial de JSON está en JSON.org . JSON se define como estándar por ECMA International. Siempre hay un proceso de petición para revisar las normas. Es poco probable que las anotaciones se agreguen al estándar JSON por varias razones.

JSON por diseño es una alternativa a XML fácilmente diseñada por ingeniería inversa (análisis humano). Se simplifica incluso hasta el punto de que las anotaciones son innecesarias. Ni siquiera es un lenguaje de marcas. El objetivo es la estabilidad y la interoperabilidad.

Cualquier persona que entienda la relación "has-a" de la orientación a objetos puede entender cualquier estructura JSON, ese es el punto. Es solo un gráfico acíclico dirigido (DAG) con etiquetas de nodo (pares clave/valor), que es una estructura de datos casi universal.

Esta única anotación requerida podría ser "// Estas son etiquetas DAG". Los nombres clave pueden ser tan informativos como sea necesario.

Cualquier plataforma puede analizar JSON con solo unas pocas líneas de código. XML requiere bibliotecas complejas OO que no son viables en muchas plataformas.

Las anotaciones solo harían que JSON sea menos interoperable. Simplemente no hay nada más que agregar, a menos que lo que realmente necesite sea un lenguaje de marcado (XML), y no le importe si sus datos persistentes se analizan fácilmente.

9
Dominic Cerisano

El autor de JSON quiere que incluyamos comentarios en el JSON, pero los eliminamos antes de analizarlos (ver enlace proporcionado por Michael Burr). Si JSON debería tener comentarios, ¿por qué no estandarizarlos y dejar que el analizador JSON haga el trabajo? No estoy de acuerdo con la lógica allí, pero, ay, esa es la norma. Usar una solución YAML como lo sugieren otros es bueno, pero requiere una dependencia de la biblioteca.

Si desea eliminar los comentarios, pero no quiere tener una dependencia de biblioteca, aquí hay una solución de dos líneas, que funciona para comentarios de estilo C++, pero que puede adaptarse a otros:

var comments = new RegExp("//.*", 'mg');
data = JSON.parse(fs.readFileSync(sample_file, 'utf8').replace(comments, ''));

Tenga en cuenta que esta solución solo se puede utilizar en los casos en que puede estar seguro de que los datos JSON no contienen el iniciador de comentarios, por ejemplo. ('//').

Otra forma de lograr el análisis JSON, la eliminación de comentarios y no una biblioteca adicional, es evaluar el JSON en un intérprete de JavaScript. La advertencia con este enfoque, por supuesto, es que solo querría evaluar los datos no contaminados (no la entrada del usuario no confiable). Este es un ejemplo de este enfoque en Node.js: otra advertencia, el siguiente ejemplo solo leerá los datos una vez y luego se almacenará en caché:

data = require(fs.realpathSync(doctree_fp));
9

Suspiro. ¿Por qué no solo agregar campos, por ejemplo?.

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

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

Solo asegúrate de que tus nombres "notex" no entren en conflicto con ningún campo real.

7
Steve Thomas

Puede usar JSON con comentarios, si lo carga como un archivo de texto y luego elimina los comentarios.

Puedes usar decomment library para eso. A continuación se muestra un ejemplo completo.

Entrada JSON (archivo input.js):

/*
* multi-line comments
**/
{
    "value": 123 // one-line comment
}

Aplicación de prueba:

var decomment = require('decomment');
var fs = require('fs');

fs.readFile('input.js', 'utf8', function (err, data) {
    if (err) {
        console.log(err);
    } else {
        var text = decomment(data); // removing comments
        var json = JSON.parse(text); // parsing JSON
        console.log(json);
    }
});

Salida:

{ value: 123 }

Ver también: gulp-decomment , grunt-decomment

7
vitaly-t

Acabo de encontrar " grunt-strip-json-comments ".

"Strip comentarios de JSON. ¡Te permite usar comentarios en tus archivos JSON!

{
    // Rainbows
    "Unicorn": /* ❤ */ "cake"
}

Si su contexto es la configuración de Node.js, podría considerar JavaScript a través de module.exports como una alternativa a JSON:

module.exports = {
    "key": "value",

    // And with comments!
    "key2": "value2"
};

La sintaxis de require seguirá siendo la misma. Siendo JavaScript, la extensión del archivo debe ser .js.

4
Nick

En mi caso, necesito usar comentarios para fines de depuración, antes de la salida de la estructura JSON. Así que decidí usar la información de depuración en el encabezado HTTP, para evitar romper el cliente:

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

 Enter image description here

4
WilliamK

Puede utilizar un preprocesamiento simple a través de expresiones regulares. Por ejemplo, la siguiente función decodificará JSON comentado en PHP:

function json_decode_commented ($data, $objectsAsArrays = false, $maxDepth = 512, $opts) {
  $data = preg_replace('~
    (" (?:[^"\\\\] | \\\\\\\\ | \\\\")*+ ") | \# [^\v]*+ | // [^\v]*+ | /\* .*? \*/
  ~xs', '$1', $data);

  return json_decode($data, $objectsAsArrays, $maxDepth, $opts);
}

Es compatible con todos los comentarios de estilo PHP:/*, #, //. Los literales de cuerdas se conservan como están.

3
Alexander Shostak

JSON no permite comentarios, per se. El razonamiento es absolutamente tonto, porque puedes usar JSON en sí mismo para crear comentarios, lo que obvia el razonamiento por completo, y carga el espacio de datos del analizador sin ninguna buena razón. para exactamente el mismo resultado y posibles problemas, como son: un archivo JSON con comentarios.

Si intenta poner comentarios en (usando // o /* */ o # por ejemplo), algunos analizadores fallarán porque esto no es Estrictamente dentro de la especificación JSON. Así que deberías nunca hacer eso.

Aquí hay un ejemplo, donde mi sistema de manipulación de imágenes ha guardado notaciones de imagen y alguna información básica en formato (comentario) relacionada con ellas (en la 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."
    }
}
3
fyngyrz

Si está utilizando PHP, puede usar esta función para buscar y eliminar los comentarios de tipo ///* de la cadena JSON antes de analizarlos en un objeto/matriz:

function json_clean_decode($json, $assoc = true, $depth = 512, $options = 0) {
       // search and remove comments like /* */ and //
       $json = preg_replace("#(/\*([^*]|[\r\n]|(\*+([^*/]|[\r\n])))*\*+/)|([\s\t]//.*)|(^//.*)#", '', $json);

       if(version_compare(phpversion(), '5.4.0', '>=')) {
           $json = json_decode($json, $assoc, $depth, $options);
       }
       elseif(version_compare(phpversion(), '5.3.0', '>=')) {
           $json = json_decode($json, $assoc, $depth);
       }
       else {
           $json = json_decode($json, $assoc);
       }

       return $json;
   }

¡Espero que esto ayude!

2
Meru-kun

Como muchas respuestas ya han señalado, JSON no tiene comentarios de forma nativa. Por supuesto que a veces los quieres de todos modos. Para Python , hay dos formas de hacerlo con commentjson (# y // para Python 2 solamente) o json_tricks (# o // para Python 2 y Python 3), que tiene varias otras características Descargo de responsabilidad: hice json_tricks.

2
Mark

La respuesta práctica para los usuarios de VSCode en 2019 es usar la extensión 'jsonc'.

Práctico, porque esa es la extensión reconocida por VSCode para indicar "JSON con comentarios". Por favor, hágamelo saber acerca de otros editores/IDE en los comentarios a continuación.

Sería bueno si VSCode y otros editores también agregaran soporte nativo para 'json5', pero por ahora VSCode solo incluye soporte para 'jsonc'.

(Busqué en todas las respuestas antes de publicar esto y ninguna menciona 'jsonc').

1
Tom

Claro que puedes comentar JSON. Para leer un archivo JSON comentado desde javascript, puede eliminar los comentarios antes de analizarlos (consulte el código a continuación). Estoy seguro de que este código puede mejorarse, pero es fácil de entender para aquellos que usan regexp.

Utilizo archivos JSON comentados para especificar formas de neuronas para mis sistemas de reflejo sintético. También uso JSON comentado para almacenar estados intermedios para un sistema neuronal en ejecución. Es muy conveniente tener comentarios. No escuches los hechos que te dicen que son una mala idea.

fetch(filename).then(function(response) {
    return response.text();
}).then(function(commented) {
    return commented.
        replace(/\/\*[\s\S]*?\*\/|([^\\:]|^)\/\/.*$/gm, '$1').
        replace(/\r/,"\n").
        replace(/\n[\n]+/,"\n");
}).then(function(clean) {
    return JSON.parse(clean);
}).then(function(json) {
    // Do what you want with the JSON object.
});
1
jlettvin

Sí, puedes tener comentarios. Pero no voy a recomendar ninguna razón mencionada anteriormente.

Hice una investigación y descubrí que todos los métodos de JSON requieren el uso del método JSON.parse. Así que llegué a una solución: podemos anular o hacer parches de mono en JSON.parse.

Nota: probado solo en Node.js ;-)

var oldParse = JSON.parse;
JSON.parse = parse;
function parse(json){
    json = json.replace(/\/\*.+\*\//, function(comment){
        console.log("comment:", comment);
        return "";
    });
    return oldParse(json)
}

Archivo JSON:

{
  "test": 1
  /* Hello, babe */
}
1
xdeepakv

Puede usar JSON-LD y el comentario schema.org type para escribir comentarios correctamente: 

{
    "https://schema.org/comment": "this is a comment"
}
0
MovGP0

Los archivos * .json se usan generalmente como archivos de configuración o datos estáticos, por lo tanto, la necesidad de comentarios. Algunos editores como NetBeans aceptan jcomments en *.

El problema es analizar el contenido de un objeto. La solución es aplicar siempre una función de limpieza (servidor o cliente).

PHP

 $rgx_arr = ["/\/\/[^\n]*/sim", "/\/\*.*?\*\//sim", "/[\n\r\t]/sim"];
 $valid_json_str = \preg_replace($rgx_arr, '', file_get_contents(path . '*.json'));

JavaScript

valid_json_str = json_str.replace(/\/\/[^\n]*/gim.'').replace(/\/\*.*?\*\//gim,'')
0
bortunac

Hay otras bibliotecas que son compatibles con JSON, que admiten comentarios.

Un ejemplo notable es el "Hashcorp Language" (HCL) " . Está escrito por las mismas personas que hicieron Vagrant, packer, cónsul y bóveda.

0
spuder

Todo este hilo supone que agregar comentarios es la única mejora que se debe realizar en JSON. Si alguien no quiere comentarios en JSON porque debe usarse para la serialización, simplemente omita los comentarios. Lo mismo ocurre con los espacios en blanco. Pero ¿por qué detenerse allí? ¿Por qué son comillas requeridas en JSON? No agregan nada útil.

La única razón por la que puedo pensar que JSON es tan rígido es si el análisis es difícil. Pero no lo es. Casi cualquier programador puede escribir un analizador JSON, en cualquier dirección.

Quiero que JSON sea legible y eficiente (breve) y útil para la transmisión de datos, archivos de configuración y mucho más. Ambos de estos requisitos se satisfacen con el siguiente ejemplo:

{stringA: stringB, stringC: stringD, [stringE, stringF]}

Más corto que cualquier especificación JSON existente, pero igual de legible y más eficiente.

¿Necesita incluir comillas, apóstrofes, comas o paréntesis en una propiedad o valor? Solo enciérrelos en signos de interrogación o apóstrofes (con escape de barra invertida), como en JavaScript.

Pero por favor haga comillas opcionales. ¿Por qué? Debido a que JSON no puede contener nombres de funciones o variables (para evitar ataques de inyección), las comillas no proporcionan ninguna desambiguación. Ya sabemos que todos los datos son cadenas. Entonces, por favor, deje las comillas ya, a menos que sean realmente necesarias.

0
David Spector

Encontré este problema en mi proyecto actual, ya que tengo un poco de JSON que requiere algunos comentarios para que las cosas sean fáciles de recordar.

He usado esta simple función de Python para reemplazar comentarios y usar json.loads para convertirlo en una dict:

import json, re

def parse_json(data_string):
  result = []
  for line in data_string.split("\n"):
    line = line.strip()
    if len(line) < 1 or line[0:2] == "//":
      continue
    if line[-1] not in "\,\"\'":
      line = re.sub("\/\/.*?$", "", line)
    result.append(line)
  return json.loads("\n".join(result))

print(parse_json("""
{
  // This is a comment
  "name": "value" // so is this
  // "name": "value"
  // the above line gets removed
}
"""))
0
LogicalBranch