Bisakah komentar digunakan di JSON?

Bisakah saya menggunakan komentar di dalam file JSON? Jika ya, bagaimana caranya?

Tidak.

Semua JSON harus berupa data, dan jika Anda memasukkan komentar, maka itu juga akan menjadi data.

Anda bisa memiliki elemen data yang ditunjuk yang disebut "_comment"(atau sesuatu) yang akan diabaikan oleh aplikasi yang menggunakan data JSON.

Anda mungkin akan lebih baik memiliki komentar dalam proses yang menghasilkan / menerima JSON, karena mereka seharusnya tahu apa yang akan menjadi data JSON di muka, atau setidaknya struktur itu.

Tetapi jika Anda memutuskan untuk:

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

Tidak , komentar formulir //…atau /*…*/tidak diizinkan di JSON. Jawaban ini didasarkan pada:

• http://www.json.org
• RFC 4627 : application/jsonJenis Media untuk Notasi Objek JavaScript (JSON)
• RFC 8259 Format Interchange Data Notasi JavaScript (JSON) (menggantikan RFC 4627, 7158, 7159)

Sertakan komentar jika Anda memilih; strip mereka dengan minifier sebelum parsing atau mentransmisikan.

Saya baru saja merilis JSON.minify () yang menghapus komentar dan spasi putih dari blok JSON dan menjadikannya JSON yang valid yang dapat diuraikan. Jadi, Anda dapat menggunakannya seperti:

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

Ketika saya merilisnya, saya mendapat reaksi besar dari orang-orang yang tidak setuju bahkan dengan gagasan itu, jadi saya memutuskan bahwa saya akan menulis posting blog yang komprehensif tentang mengapa komentar masuk akal di JSON . Ini termasuk komentar penting dari pencipta JSON:

Misalkan Anda menggunakan JSON untuk menyimpan file konfigurasi, yang ingin Anda anotasi. Silakan masukkan semua komentar yang Anda suka. Kemudian pipa melalui JSMin sebelum menyerahkannya ke parser JSON Anda. - Douglas Crockford, 2012

Semoga bermanfaat bagi mereka yang tidak setuju mengapa JSON.minify () dapat bermanfaat.

Komentar dihapus dari JSON oleh desain.

Saya menghapus komentar dari JSON karena saya melihat orang menggunakannya untuk memegang arahan parsing, sebuah praktik yang akan menghancurkan interoperabilitas. Saya tahu bahwa kurangnya komentar membuat beberapa orang sedih, tetapi seharusnya tidak.

Misalkan Anda menggunakan JSON untuk menyimpan file konfigurasi, yang ingin Anda anotasi. Silakan masukkan semua komentar yang Anda suka. Kemudian pipa melalui JSMin sebelum menyerahkannya ke parser JSON Anda.

Sumber: Pernyataan publik oleh Douglas Crockford tentang G +

PENOLAKAN: GARANSI ANDA TIDAK BISA

Seperti yang telah ditunjukkan, peretasan ini mengambil keuntungan dari implementasi spesifikasi. Tidak semua parser JSON akan memahami JSON semacam ini. Pengurai aliran secara khusus akan tersedak.

Ini merupakan keingintahuan yang menarik, tetapi Anda seharusnya tidak menggunakannya untuk apa pun . Di bawah ini adalah jawaban asli.

Saya telah menemukan hack kecil yang memungkinkan Anda untuk menempatkan komentar di file JSON yang tidak akan memengaruhi parsing, atau mengubah data yang diwakili dengan cara apa pun.

Tampaknya ketika mendeklarasikan objek literal Anda dapat menentukan dua nilai dengan kunci yang sama, dan yang terakhir diutamakan. Percaya atau tidak, ternyata parser JSON bekerja dengan cara yang sama. Jadi kita dapat menggunakan ini untuk membuat komentar di JSON sumber yang tidak akan hadir dalam representasi objek yang diuraikan.

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

Jika kami menerapkan teknik ini, file JSON Anda yang dikomentari mungkin terlihat seperti ini:

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

Kode di atas adalah JSON yang valid . Jika Anda menguraikannya, Anda akan mendapatkan objek seperti ini:

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

Yang berarti tidak ada jejak komentar, dan mereka tidak akan memiliki efek samping yang aneh.

Selamat melakukan peretasan!

JSON tidak mendukung komentar. Itu juga tidak pernah dimaksudkan untuk digunakan untuk file konfigurasi di mana komentar akan diperlukan.

Hjson adalah format file konfigurasi untuk manusia. Sintaks santai, lebih sedikit kesalahan, lebih banyak komentar.

Lihat hjson.org untuk perpustakaan JavaScript, Java, Python, PHP, Rust, Go, Ruby dan C #.

Pertimbangkan untuk menggunakan YAML. Ini hampir superset dari JSON (hampir semua JSON yang valid adalah YAML yang valid) dan memungkinkan komentar.

Kamu tidak bisa Setidaknya itulah pengalaman saya dari pandangan sekilas di json.org .

JSON memiliki sintaksis yang divisualisasikan pada halaman itu. Tidak ada catatan tentang komentar.

Komentar bukanlah standar resmi, meskipun beberapa parser mendukung komentar gaya C ++. Salah satu yang saya gunakan adalah JsonCpp . Dalam contohnya ada yang ini:

// 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 tidak memvalidasi ini. Jadi komentar adalah ekstensi spesifik parser dan bukan standar.

Parser lain adalah JSON5 .

Alternatif untuk JSON TOML .

Alternatif selanjutnya adalah jsonc .

Anda harus menulis skema JSON sebagai gantinya. Skema JSON saat ini merupakan spesifikasi rancangan Internet yang diusulkan. Selain dokumentasi, skema ini juga dapat digunakan untuk memvalidasi data JSON Anda.

Contoh:

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

Anda dapat memberikan dokumentasi dengan menggunakan atribut skema deskripsi .

Jika Anda menggunakan Jackson sebagai parser JSON, maka inilah cara Anda mengaktifkannya untuk mengizinkan komentar:

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

Maka Anda dapat memiliki komentar seperti ini:

{
  key: "value" // Comment
}

Dan Anda juga dapat memiliki komentar yang dimulai dengan #menetapkan:

mapper.configure(Feature.ALLOW_YAML_COMMENTS, true);

Tetapi secara umum (seperti yang dijawab sebelumnya) spesifikasi tidak mengizinkan komentar.

Inilah yang saya temukan dalam dokumentasi Google Firebase yang memungkinkan Anda untuk memberikan komentar di 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"
}

TIDAK . JSON digunakan untuk mendukung komentar, tetapi mereka dilecehkan dan dihapus dari standar.

Dari pencipta JSON:

Saya menghapus komentar dari JSON karena saya melihat orang menggunakannya untuk memegang arahan parsing, sebuah praktik yang akan menghancurkan interoperabilitas. Saya tahu bahwa kurangnya komentar membuat beberapa orang sedih, tetapi seharusnya tidak. - Douglas Crockford, 2012

Situs resmi JSON ada di JSON.org . JSON didefinisikan sebagai standar oleh ECMA International. Selalu ada proses petisi untuk merevisi standar. Kecil kemungkinan bahwa anotasi akan ditambahkan ke standar JSON karena beberapa alasan.

JSON by design adalah alternatif XML yang mudah direkayasa ulang (diurai manusia). Ini disederhanakan bahkan ke titik bahwa penjelasan tidak perlu. Itu bahkan bukan bahasa markup. Tujuannya adalah stabilitas dan interoperablilty.

Siapa pun yang memahami hubungan orientasi objek "has-a" dapat memahami setiap struktur JSON - itulah intinya. Ini hanya grafik asiklik terarah (DAG) dengan tag node (pasangan kunci / nilai), yang merupakan struktur data hampir universal.

Anotasi ini hanya diperlukan mungkin "// Ini adalah tag DAG". Nama-nama kunci dapat informatif seperti yang diperlukan, memungkinkan arity semantik sewenang-wenang.

Platform apa pun dapat mengurai JSON hanya dengan beberapa baris kode. XML membutuhkan pustaka OO kompleks yang tidak dapat dijalankan pada banyak platform.

Penjelasan hanya akan membuat JSON membuat lebih sedikit interoperable. Tidak ada hal lain untuk ditambahkan, kecuali apa yang benar-benar Anda butuhkan adalah bahasa markup (XML), dan tidak peduli jika data Anda yang bertahan mudah diurai.

TETAPI seperti yang diamati oleh pembuat JSON, selalu ada dukungan pipeline JS untuk komentar:

Silakan masukkan semua komentar yang Anda suka. Kemudian pipa melalui JSMin sebelum menyerahkannya ke parser JSON Anda. - Douglas Crockford, 2012

Jika file teks Anda, yang merupakan string JSON, akan dibaca oleh beberapa program, seberapa sulitkah untuk menghapus komentar gaya C atau C ++ sebelum menggunakannya?

Jawaban: Itu akan menjadi satu liner. Jika Anda melakukannya, file JSON dapat digunakan sebagai file konfigurasi.

Jika Anda menggunakan pustaka Newtonsoft.Json dengan ASP.NET untuk membaca / deserialize Anda dapat menggunakan komentar dalam konten JSON:

// "nama": "string"

// "id": int

atau

/* Ini adalah sebuah

contoh komentar * /

PS: Komentar single-line hanya didukung dengan 6+ versi Newtonsoft Json.

Catatan tambahan untuk orang-orang yang tidak bisa berpikir di luar kotak: Saya menggunakan format JSON untuk pengaturan dasar dalam aplikasi web ASP.NET yang saya buat. Saya membaca file, mengubahnya menjadi objek pengaturan dengan pustaka Newtonsoft dan menggunakannya saat diperlukan.

Saya lebih suka menulis komentar tentang masing-masing pengaturan individu dalam file JSON itu sendiri, dan saya benar-benar tidak peduli tentang integritas format JSON selama perpustakaan yang saya gunakan tidak masalah.

Saya pikir ini adalah cara yang 'lebih mudah digunakan / dipahami' daripada membuat file 'settings.README' yang terpisah dan menjelaskan pengaturan di dalamnya.

Jika Anda memiliki masalah dengan penggunaan seperti ini; maaf, jin sudah keluar dari lampu. Orang akan menemukan penggunaan lain untuk format JSON, dan tidak ada yang dapat Anda lakukan untuk itu.

Gagasan di balik JSON adalah untuk menyediakan pertukaran data sederhana antar aplikasi. Ini biasanya berbasis web dan bahasanya adalah JavaScript.

Itu tidak benar-benar memungkinkan untuk komentar seperti itu, namun, memberikan komentar sebagai salah satu pasangan nama / nilai dalam data pasti akan berfungsi, meskipun data itu jelas perlu diabaikan atau ditangani secara khusus oleh kode parsing.

Semua yang dikatakan, itu bukan maksud bahwa file JSON harus mengandung komentar dalam arti tradisional. Seharusnya hanya data.

Lihat situs web JSON untuk detail lebih lanjut.

Saya hanya menemukan ini untuk file konfigurasi. Saya tidak ingin menggunakan XML (verbose, grafis, jelek, sulit dibaca), atau "ini" (tidak ada hierarki, tidak ada standar nyata, dll.) Atau format Java "Properties" (seperti .ini).

JSON dapat melakukan semua yang dapat mereka lakukan, tetapi cara ini lebih tidak jelas dan lebih dapat dibaca manusia - dan parser mudah dan ada di mana-mana dalam banyak bahasa. Itu hanya sebatang data. Tetapi komentar out-of-band sering diperlukan untuk mendokumentasikan konfigurasi "default" dan sejenisnya. Konfigurasi tidak pernah menjadi "dokumen lengkap", tetapi pohon data yang disimpan yang dapat dibaca manusia saat dibutuhkan.

Saya kira orang bisa menggunakan "#": "comment", untuk JSON "valid".

JSON tidak mendukung komentar secara native, tetapi Anda dapat membuat dekoder sendiri atau setidaknya preprocessor untuk menghapus komentar, itu baik-baik saja (selama Anda mengabaikan komentar dan tidak menggunakannya untuk memandu bagaimana aplikasi Anda harus memproses data JSON ).

JSON tidak memiliki komentar. Encoder JSON TIDAK HARUS menampilkan komentar. Dekoder JSON DAPAT menerima dan mengabaikan komentar.

Komentar tidak boleh digunakan untuk mengirimkan sesuatu yang bermakna. Untuk itulah JSON diperuntukkan.

Cf: Douglas Crockford, penulis spec JSON .

Itu tergantung pada perpustakaan JSON Anda. Json.NET mendukung komentar gaya JavaScript,/* commment */ ,.

Lihat pertanyaan Stack Overflow lainnya .

JSON sangat masuk akal untuk file konfigurasi dan penggunaan lokal lainnya karena ini ada di mana-mana dan karena itu jauh lebih sederhana daripada XML.

Jika orang memiliki alasan kuat untuk tidak memiliki komentar di JSON saat berkomunikasi data (apakah valid atau tidak), maka kemungkinan JSON dapat dibagi menjadi dua:

• JSON-COM: JSON on the wire, atau aturan yang berlaku saat mengkomunikasikan data JSON.
• JSON-DOC: dokumen JSON, atau JSON dalam file atau secara lokal. Aturan yang menentukan dokumen JSON yang valid.

JSON-DOC akan memungkinkan komentar, dan perbedaan kecil lainnya mungkin ada seperti menangani spasi. Parser dapat dengan mudah mengkonversi dari satu spec ke yang lainnya.

Berkenaan dengan komentar yang dibuat oleh Douglas Crockford tentang masalah ini (dirujuk oleh @Artur Czajka)

Misalkan Anda menggunakan JSON untuk menyimpan file konfigurasi, yang ingin Anda anotasi. Silakan masukkan semua komentar yang Anda suka. Kemudian pipa melalui JSMin sebelum menyerahkannya ke parser JSON Anda.

Kita berbicara tentang masalah file konfigurasi umum (lintas bahasa / platform), dan dia menjawab dengan utilitas khusus JS!

Tentu saja minify khusus JSON dapat diimplementasikan dalam bahasa apa pun, tetapi distandarisasi ini sehingga menjadi di mana-mana di parser dalam semua bahasa dan platform sehingga orang berhenti membuang-buang waktu mereka kekurangan fitur karena mereka memiliki kasus penggunaan yang baik untuk itu, mencari masalah di forum online, dan membuat orang memberi tahu mereka bahwa itu adalah ide yang buruk atau menyarankan itu mudah untuk menerapkan pengupasan komentar dari file teks.

Masalah lainnya adalah interoperabilitas. Misalkan Anda memiliki perpustakaan atau API atau jenis subsistem apa pun yang memiliki beberapa file konfigurasi atau data yang terkait dengannya. Dan subsistem ini harus diakses dari berbagai bahasa. Lalu, apakah Anda memberi tahu orang-orang: omong-omong jangan lupa menghapus komentar dari file JSON sebelum meneruskannya ke parser!

Jika Anda menggunakan JSON5 Anda dapat memasukkan komentar.

JSON5 adalah ekstensi yang diusulkan ke JSON yang bertujuan untuk memudahkan manusia menulis dan memelihara dengan tangan. Ini dilakukan dengan menambahkan beberapa fitur sintaks minimal langsung dari ECMAScript 5.

Toolkit JavaScript Dojo Toolkit (setidaknya pada versi 1.4), memungkinkan Anda untuk memasukkan komentar dalam JSON Anda. Komentar dapat dalam /* */format. Dojo Toolkit mengkonsumsi JSON melalui dojo.xhrGet()panggilan.

Toolkit JavaScript lainnya dapat bekerja dengan cara yang sama.

Ini dapat membantu ketika bereksperimen dengan struktur data alternatif (atau bahkan daftar data) sebelum memilih opsi final.

JSON bukan protokol berbingkai . Ini adalah format bebas bahasa . Jadi format komentar tidak ditentukan untuk JSON.

Seperti yang disarankan banyak orang, ada beberapa trik, misalnya, kunci duplikat atau kunci tertentu _commentyang dapat Anda gunakan. Terserah kamu.

Anda dapat memiliki komentar di JSONP , tetapi tidak di JSON murni. Saya baru saja menghabiskan satu jam mencoba untuk membuat program saya bekerja dengan contoh ini dari Highcharts: http://www.highcharts.com/samples/data/jsonp.php?filename=aapl-c.json&callback=?

Jika Anda mengikuti tautan, Anda akan melihat

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

Karena saya memiliki file serupa di folder lokal saya, tidak ada masalah dengan kebijakan asal-sama , jadi saya memutuskan untuk menggunakan JSON murni ... dan, tentu saja,$.getJSON gagal diam-diam karena komentar.

Akhirnya saya baru saja mengirim permintaan HTTP manual ke alamat di atas dan menyadari bahwa tipe konten text/javascriptsejak itu , yah, JSONP mengembalikan JavaScript murni. Dalam hal ini komentar diperbolehkan . Tetapi aplikasi saya mengembalikan tipe konten application/json, jadi saya harus menghapus komentar.

Ini adalah pertanyaan "bisakah kamu" . Dan inilah jawaban "ya" .

Tidak, Anda tidak boleh menggunakan anggota objek duplikat untuk memasukkan data saluran sisi ke dalam pengkodean JSON. (Lihat "Nama-nama dalam suatu objek HARUS unik" di RFC ).

Dan ya, Anda bisa menyisipkan komentar di sekitar JSON , yang dapat Anda uraikan.

Tetapi jika Anda ingin cara memasukkan dan mengekstrak data saluran samping sewenang-wenang ke JSON yang valid, berikut ini jawabannya. Kami mengambil keuntungan dari representasi data yang tidak unik dalam penyandian JSON. Ini diperbolehkan ^* di bagian dua RFC di bawah "spasi putih diizinkan sebelum atau setelah salah satu dari enam karakter struktural".

^* RFC hanya menyatakan "spasi putih diizinkan sebelum atau sesudah salah satu dari enam karakter struktural", tidak secara eksplisit menyebutkan string, angka, "false", "true", dan "null". Kelalaian ini diabaikan dalam SEMUA implementasi.

Pertama, dikanonisasi JSON Anda dengan mengecilkannya:

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

Kemudian, enkode komentar Anda dalam biner:

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

Kemudian hentikan biner Anda:

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

Ini output Anda:

$jsonWithComment = $steg . $jsonMin;

DISCLAIMER: INI SILLY

Sebenarnya ada cara untuk menambahkan komentar, dan tetap dalam spesifikasi (tidak perlu parser tambahan). Itu tidak akan menghasilkan komentar yang dapat dibaca manusia tanpa semacam parsing sekalipun.

Anda dapat menyalahgunakan yang berikut ini:

Ruang kosong yang tidak signifikan diizinkan sebelum atau setelah token apa pun. Whitespace adalah urutan dari satu atau lebih poin kode berikut: tabulasi karakter (U + 0009), umpan baris (U + 000A), carriage return (U + 000D), dan spasi (U + 0020).

Dengan cara meretas, Anda dapat menyalahgunakan ini untuk menambahkan komentar. Misalnya: mulai dan akhiri komentar Anda dengan sebuah tab. Encode komentar di base3 dan gunakan karakter spasi putih lain untuk mewakili mereka. Contohnya.

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

( hello base threedalam ASCII) Tetapi alih-alih menggunakan 0 ruang, untuk 1 menggunakan umpan baris dan untuk 2 menggunakan carriage return.

Ini hanya akan meninggalkan Anda dengan banyak ruang kosong yang tidak dapat dibaca (kecuali jika Anda membuat plugin IDE untuk menyandikan / mendekodekannya dengan cepat).

Saya bahkan tidak pernah mencoba ini, untuk alasan yang jelas dan Anda juga tidak.

Kami menggunakan strip-json-commentsuntuk proyek kami. Ini mendukung sesuatu seperti:

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

Cukup npm install --save strip-json-commentsuntuk menginstal dan menggunakannya seperti:

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

Dalam kasus saya, saya perlu menggunakan komentar untuk keperluan debug, sebelum output dari struktur JSON. Jadi saya memutuskan untuk menggunakan informasi debug di header HTTP, untuk menghindari pemecahan klien:

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

JSON tidak mengizinkan komentar. Penalarannya benar-benar bodoh, karena Anda dapat menggunakan JSON sendiri untuk membuat komentar, yang sepenuhnya meniadakan penalaran, dan memuat ruang data parser tanpa alasan yang baik sama sekali untuk hasil dan potensi masalah yang persis sama, seperti: JSON file dengan komentar.

Jika Anda mencoba memasukkan komentar (menggunakan //atau /* */atau #misalnya), maka beberapa parser akan gagal karena ini benar-benar tidak dalam spesifikasi JSON. Jadi Anda tidak boleh melakukan itu.

Sebagai contoh, di mana sistem manipulasi gambar saya telah menyimpan notasi gambar dan beberapa informasi dasar yang diformat (komentar) yang terkait dengannya (di bagian bawah):

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

Untuk memotong item JSON menjadi beberapa bagian, saya menambahkan baris "komentar tiruan":

{

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

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

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

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

}