JSON — parse, stringify আর structuredClone

১ · JSON কী — প্রোগ্রামেরা যে লেখায় কথা বলে

একটি দৃশ্য ভাবুন। তানভীর একটি অনলাইন মুদি দোকানের ওয়েবসাইট বানাচ্ছেন। ক্রেতা ব্রাউজারে অর্ডার দেন, সার্ভার (হয়তো Java বা Python-এ লেখা) অর্ডারটি ডেটাবেসে রাখে, আর ডেলিভারি অ্যাপ (হয়তো Kotlin-এ লেখা) সেটি পড়ে রাইডারকে দেখায়। চারটি আলাদা প্রোগ্রাম, চারটি আলাদা ভাষা, আলাদা মেমরি। ব্রাউজারের মেমরিতে থাকা একটি JavaScript object সার্ভার সরাসরি দেখতে পায় না — মাঝখানে আছে নেটওয়ার্ক, আর নেটওয়ার্ক দিয়ে যায় শুধু byte, মানে লেখা।

তাই প্রোগ্রামগুলোকে একটি সাধারণ লেখার নিয়মে একমত হতে হয়: “একজন ডেটা এই আকারে লিখে পাঠাবে, অন্যজন ঠিক এই আকারে পড়ে নেবে।” আজকের ওয়েবে সেই সবচেয়ে প্রচলিত নিয়মটির নাম JSON — JavaScript Object Notation. নামে JavaScript থাকলেও এটি কোনো এক ভাষার সম্পত্তি নয়; Python, Java, Go, PHP, C# — প্রায় সব ভাষায় JSON পড়া-লেখার ব্যবস্থা আছে।

এই প্রক্রিয়ার নাম serialization — মেমরির কাঠামোকে একটি ধারাবাহিক লেখা বা byte-সারিতে সাজানো; উল্টো কাজটি হলো deserialization. JavaScript-এ দুই কাজের জন্য আছে built-in JSON object-এর দুটি method: JSON.stringify(value) আর JSON.parse(text). ES5 (২০০৯) থেকে এগুলো ভাষার অংশ; তার আগে আলাদা library লাগত।

JSON কোথায় কোথায় দেখবেন? প্রায় সব ওয়েব API-র উত্তর (পর্ব ৩৫-এ fetch দিয়ে এগুলো আনবেন), package.json আর tsconfig.json-এর মতো config ফাইল, MongoDB বা PostgreSQL-এর jsonb কলামের মতো ডেটাবেস, ব্রাউজারের localStorage (পর্ব ৪০), মোবাইল অ্যাপ আর সার্ভারের কথোপকথন — এমনকি AI মডেলের কাছ থেকে কাঠামোবদ্ধ উত্তর চাওয়ার সময়ও।

২ · JSON-এর ব্যাকরণ — JavaScript object-এর চেয়ে কড়া

JSON-এর পুরো ব্যাকরণ এক পাতায় ধরে যায়, আর এটাই তার শক্তি। মান হতে পারে মাত্র ছয় ধরনের: string, number, boolean (true/false), null, array আর object. ব্যস। এর বাইরে কিছু নেই — না undefined, না Date, না function. একটি সাধারণ অর্ডার দেখতে এরকম:

{
  "orderId": "A-1017",
  "customer": { "name": "রিনা আক্তার", "phone": null },
  "items": [
    { "name": "চা পাতা", "price": 25000, "qty": 2 },
    { "name": "চিনি", "price": 13500, "qty": 1 }
  ],
  "paid": true,
  "note": "সন্ধ্যার পর ডেলিভারি \u09A6\u09BF\u09A8"
}

শেষ লাইনের \u09A6\u09BF\u09A8 হলো Unicode escape sequence — পড়ার সময় হয়ে যায় “দিন”. JSON-এ যেকোনো অক্ষর \uXXXX আকারে লেখা যায়; ইমোজির মতো বড় অক্ষর লাগে দুটি \u দিয়ে (surrogate pair, পর্ব ০৯)। তবে বাংলা সরাসরি লিখলেও কোনো সমস্যা নেই — RFC 8259 বলে, প্রোগ্রামের বাইরে আদান-প্রদানের JSON হবে UTF-8, আর JSON.stringify বাংলা অক্ষর escape না করে যেমন আছে তেমনই রাখে।

কিছু প্রশ্ন প্রায়ই আসে। শুধু একটি সংখ্যা বা string কি বৈধ JSON? হ্যাঁ — 42, "হ্যালো", null সবই বৈধ JSON লেখা (২০০৬ সালের পুরোনো RFC 4627 বাইরের স্তরে শুধু object বা array চাইত, পরের সংস্করণে সেই শর্ত উঠে গেছে)। Key-এর ক্রম কি অর্থবহ? মানদণ্ডে না — object হলো ক্রমহীন key-value জোড়া। JavaScript সাধারণত লেখার ক্রম রাখে, কিন্তু অন্য ভাষার library ক্রম বদলাতে পারে, তাই ক্রমের ওপর নির্ভর করবেন না।

৩ · JSON.parse — লেখা থেকে মান, ভুল ধরা আর reviver

JSON.parse(text) একটি string নেয়, অক্ষর ধরে ধরে ব্যাকরণ মিলিয়ে দেখে, আর মিললে নতুন JavaScript মান বানায়: JSON object থেকে সাধারণ object, array থেকে array, বাকিগুলো primitive. একটি অক্ষরও নিয়ম ভাঙলে পুরো কাজ বাতিল — ফল আসে না, ছোড়া হয় SyntaxError. মাঝামাঝি কোনো “যতটুকু পারলাম” ফল নেই।

বাস্তবে ভাঙা JSON খুব সাধারণ ঘটনা। সার্ভার ভুল করে HTML error পাতা পাঠায় (<html>502 Bad Gateway…), নেটওয়ার্কে উত্তর মাঝপথে কেটে যায়, কেউ হাতে config লিখে শেষে কমা রেখে দেয়, বা localStorage-এ পুরোনো সংস্করণের অন্য ফরম্যাটের ডেটা থেকে যায়। JSON.parse তখন exception ছোড়ে, আর ধরা না হলে পুরো script থেমে যায় — ব্যবহারকারী দেখেন সাদা পাতা। তাই নিয়ম একটাই: বাইরে থেকে আসা লেখা try/catch-এর ভেতরে parse করুন (error নিয়ে বিস্তারিত পর্ব ২৯-এ)।

Error বার্তাগুলো engine-ভেদে আলাদা। Edge/Chrome আর Node.js দুটোই V8 engine, তবু সংস্করণভেদে বার্তা একটু বদলায় — যেমন শেষে বাড়তি কমার জন্য Node 20 বলে:

SyntaxError: Expected double-quoted property name in JSON at position 10

আর নতুন Edge/Chrome আর Node-এর নতুন সংস্করণ (যেমন Node 24) একই বার্তার শেষে যোগ করে (line 1 column 11) — বড় ফাইলে ভুলের জায়গা খুঁজতে খুব কাজের। Firefox-এর বার্তা পুরো আলাদা ভাষায় লেখা। তাই কোডে কখনো error-এর বার্তা মিলিয়ে সিদ্ধান্ত নেবেন না; দেখুন e.name === "SyntaxError" বা e instanceof SyntaxError.

Reviver — parse-এর সময় মান বদলে দেওয়া

JSON-এ তারিখের কোনো টাইপ নেই, তাই তারিখ আসে string হয়ে — সাধারণত ISO 8601 আকারে: "2026-10-19T04:30:00.000Z". Parse করার পর এটি string-ই থাকে; order.placedAt.getFullYear() লিখলে TypeError. সমাধান হলো JSON.parse-এর দ্বিতীয় argument — reviver function. Parser প্রতিটি key-value জোড়ার জন্য একে ডাকে, আর reviver যা ফেরত দেয়, ফলাফলে সেটিই বসে (undefined ফেরত দিলে সেই key বাদ পড়ে)। ডাকার ক্রমটি মজার — ভেতর থেকে বাইরে। ধাপে ধাপে দেখুন:

1const text = '{"id":"A-17","placedAt":"2026-10-19T04:30:00.000Z","items":[{"qty":2}]}';2const order = JSON.parse(text, (key, value) => {3  if (key.endsWith("At")) return new Date(value);4  return value;5});6console.log(order.placedAt instanceof Date);

এবার একটি বাস্তব অর্ডার API-র উত্তর parse করি — reviver দিয়ে তারিখ ফেরাই, মোট দাম গুনি (দাম পয়সায়, পর্ব ১০-এর নিয়মে), আর কয়েকটি ভাঙা লেখা নিরাপদে সামলাই:

const text = `{
  "orderId": "9007199254740993",
  "placedAt": "2026-10-19T04:30:00.000Z",
  "items": [
    { "name": "চা পাতা", "price": 25000, "qty": 2 },
    { "name": "চিনি", "price": 13500, "qty": 1 }
  ]
}`;
const reviver = (key, value) =>
  key.endsWith("At") && typeof value === "string" ? new Date(value) : value;
const order = JSON.parse(text, reviver);
const total = order.items.reduce((sum, it) => sum + it.price * it.qty, 0);
console.log(order.orderId, order.placedAt instanceof Date);
console.log(order.placedAt.getUTCDate(), "মোট পয়সা:", total);

function safeParse(s) {
  try { return { ok: true, data: JSON.parse(s) }; }
  catch (e) { return { ok: false, error: e.name + ": " + e.message }; }
}
console.log(safeParse('{"qty": 2}'));
console.log(safeParse('{"qty": 2,}').error);
console.log(safeParse("{'qty': 2}").error);
console.log(safeParse("<html>502 Bad Gateway</html>").error);

৪ · JSON.stringify — সুন্দর করে সাজানো, replacer আর toJSON

উল্টো দিকের কাজ JSON.stringify(value, replacer, space). শুধু প্রথম argument দিলে ফল আসে এক লাইনে, কোনো বাড়তি ফাঁকা ছাড়া — নেটওয়ার্কে পাঠানোর জন্য আদর্শ, কারণ প্রতিটি byte-এর দাম আছে। মানুষের পড়ার জন্য তৃতীয় argument-এ indentation দিন:

const settings = { theme: "dark", fontSize: 18, lang: ["bn", "en"] };

JSON.stringify(settings);
// '{"theme":"dark","fontSize":18,"lang":["bn","en"]}'

JSON.stringify(settings, null, 2);
// {
//   "theme": "dark",
//   "fontSize": 18,
//   "lang": [
//     "bn",
//     "en"
//   ]
// }

space-এ সংখ্যা দিলে ততগুলো ফাঁকা (সর্বোচ্চ ১০), string দিলে (যেমন "\t") সেটিই প্রতিটি স্তরে বসে। কার্টের সেটিংস localStorage-এ রাখা, log ফাইলে লেখা বা config ফাইল বানানো — সবই এই এক লাইনের কাজ। আর একটি বিষয়: string মানের ভেতরের double quote, backslash আর newline stringify নিজেই escape করে ("\"", "\\", "\n") — হাতে string জোড়া দিয়ে JSON বানালে ঠিক এই কাজটিই ভুল হয় (অংশ ৮)।

Replacer — কোন জিনিস লেখায় যাবে, ঠিক করা

দ্বিতীয় argument replacer দুই রকম হতে পারে। Array দিলে শুধু সেই key-গুলো লেখায় যায় — একটি allow-list. Function দিলে প্রতিটি key-value-এর জন্য ডাকা হয় (প্রথম ডাক খালি key "" দিয়ে মূল মানের জন্য), আর যা ফেরত দেয় তা-ই লেখা হয়; undefined ফেরত দিলে key বাদ। সবচেয়ে চেনা ব্যবহার: log-এ বা ব্যবহারকারীর কাছে পাঠানোর আগে গোপন তথ্য সরানো।

const user = { name: "রিনা", email: "rina@example.com", password: "secret123", token: "abc" };

const SECRET = new Set(["password", "token"]);
JSON.stringify(user, (key, value) => (SECRET.has(key) ? undefined : value));
// '{"name":"রিনা","email":"rina@example.com"}'

JSON.stringify(user, ["name", "email"]);   // allow-list — একই ফল

দুটির মধ্যে নিরাপত্তার দিক থেকে allow-list বেশি নিরাপদ. Function-এ আপনি “কী লুকাব” তালিকা রাখেন — কাল কেউ object-এ otp বা nidNumber নামে নতুন field যোগ করলে সেটি নীরবে log-এ চলে যাবে। Array-তে “কী দেখাব” তালিকা — নতুন field নিজে থেকে বাইরে যায় না। খেয়াল করুন, array-replacer ভেতরের স্তরের key-তেও প্রযোজ্য, তাই nested object-এর key-গুলোও তালিকায় রাখতে হয়।

toJSON — নিজের class-এর লেখার রূপ নিজে ঠিক করা

কোনো object-এ toJSON() method থাকলে stringify object-টির বদলে সেই method-এর ফেরত মান লেখে। Date ঠিক এভাবেই কাজ করে — Date.prototype.toJSON ভেতরে toISOString() ডাকে, তাই Date লেখায় যায় ISO string হয়ে। নিজের class-এও একই কৌশল চলে:

class Money {
  #paisa;                                   // private — stringify দেখতে পায় না
  constructor(paisa) { this.#paisa = paisa; }
  toJSON() { return { amount: this.#paisa / 100, currency: "BDT" }; }
}
JSON.stringify({ total: new Money(52000) });
// '{"total":{"amount":520,"currency":"BDT"}}'

এখানে দুটি শিক্ষা আছে। এক, #private field (পর্ব ২৬) stringify দেখতে পায় না — toJSON না থাকলে লেখা হতো শুধু {}. দুই, toJSON লেখার রূপ ঠিক করে, কিন্তু parse করলে Money ফেরত আসে না — আসে সাধারণ { amount, currency }. ফেরাতে চাইলে reviver-এ নিজে new Money(…) বানাতে হবে। stringify-এর ক্রম মনে রাখুন: আগে toJSON, তারপর replacer.

৫ · Round trip-এ কী হারায় — undefined, Date, Map, BigInt আর চক্র

JSON মাত্র ছয় ধরনের মান চেনে, অথচ JavaScript-এ মান আছে অনেক রকম। তাহলে বাকিদের কী হয়? stringify তাদের তিনভাবে সামলায় — নীরবে বাদ দেয়, নীরবে বদলে দেয়, অথবা error ছোড়ে. প্রথম দুটি বিপজ্জনক, কারণ কেউ কিছু টের পায় না। একটি পণ্যের object ধরে প্রতিটি field-এর ভাগ্য দেখুন:

1const item = {2  name: "চা পাতা",3  price: NaN,4  note: undefined,5  date: new Date("2026-10-19T04:30:00Z"),6  tags: new Set(["organic", "eid"])7};8console.log(JSON.stringify(item));

যেখানে stringify হার মানে — BigInt আর চক্র

দুই ক্ষেত্রে stringify নীরব থাকে না, TypeError ছোড়ে। প্রথমটি BigInt — JSON.stringify({ id: 10n }) দেয় TypeError: Do not know how to serialize a BigInt (V8-এর বার্তা)। কারণ JSON-এর number অন্য ভাষায় সাধারণত double হিসেবে পড়া হয়, তাই BigInt-কে নীরবে number বানালে নির্ভুলতা হারাত — ভাষা তাই ইচ্ছা করে থামিয়ে দেয়। BigInt পাঠাতে string বানান (id.toString()), বা replacer-এ typeof value === "bigint" ? value.toString() : value.

দ্বিতীয়টি circular reference — যখন একটি object ঘুরে নিজেকেই দেখায়। যেমন কার্টের প্রতিটি item-এ item.cart = cart রাখলে cart → items → item → cart → … অন্তহীন চক্র। লেখায় এটি প্রকাশ করার কোনো উপায় নেই, তাই V8 বলে:

TypeError: Converting circular structure to JSON
    --> starting at object with constructor 'Object'
    --- property 'self' closes the circle

বার্তাটি এমনকি চক্রটি কোথায় বন্ধ হলো, সেটাও দেখায় — DOM element বা বড় framework object ভুল করে stringify করলে প্রায়ই এই error আসে। সমাধান: পাঠানোর আগে ফিরতি-reference সরান (শুধু ID রাখুন: cartId: "C-9"), বা replacer-এ একটি WeakSet দিয়ে আগে দেখা object বাদ দিন।

বড় সংখ্যা — নীরব সবচেয়ে বড় বিপদ

পর্ব ১০-এ দেখেছেন, number হুবহু থাকে কেবল 2⁵³ − 1 পর্যন্ত (safe integer). অনেক ডেটাবেস ৬৪-বিট ID ব্যবহার করে। এমন ID JSON-এ সংখ্যা হয়ে এলে JSON.parse('{"id": 9007199254740993}').id দেয় 9007199254740992 — শেষ অঙ্ক নীরবে বদলে গেল, আর আপনি ভুল অর্ডার খুললেন। এজন্যই অনেক বড় API ID পাঠায় string হিসেবে (Twitter-এর পুরোনো API-তে id-এর পাশে আলাদা id_str থাকত)। নিয়ম: যে সংখ্যা দিয়ে হিসাব হয় না — ID, ফোন নম্বর, অ্যাকাউন্ট নম্বর — তা string. নতুন ব্রাউজারে reviver-এর তৃতীয় argument-এ মূল লেখাটি (context.source) পাওয়ার ব্যবস্থা এসেছে, কিন্তু Node 20-এর মতো পুরোনো পরিবেশে নেই — তাই string-ই সবচেয়ে বহনযোগ্য সমাধান।

৬ · কপি করা — shallow, JSON-কৌশল আর structuredClone

পর্ব ১৪-এ দেখেছেন, variable-এ object রাখলে আসলে রাখা হয় তার reference. তাই const copy = cart কোনো কপি নয় — একই কার্টের দ্বিতীয় নাম। ধরুন ক্রেতা চেকআউট পাতায় কার্ট এডিট করছেন, কিন্তু “বাতিল” চাপলে আগের অবস্থায় ফিরতে হবে। এর জন্য দরকার একটি সত্যিকারের, আলাদা কপি। তিনটি পরিচিত পথ আছে, আর তিনটির আচরণ আলাদা:

cart ──► { owner: "রিনা",
           createdAt: ──► Date(2026-10-19)
           items: ──────► [ ──► { name: "খাতা", qty: 2 } ]
           coupons: ────► Set { "EID10" }
           discount: NaN, note: undefined }

shallow ──► { owner: "রিনা", (নিজের কপি)
              createdAt: ─┐
              items: ─────┼──► মূলের একই Date, একই array, একই Set!
              coupons: ───┘ }
shallow.items[0].qty = 5   →   cart.items[0].qty === 5

viaJson ──► { owner: "রিনা",
              createdAt: "2026-10-19T04:30:00.000Z"  ← string
              items: [ { name: "খাতা", qty: 2 } ]      ← নতুন ✓
              coupons: {}                            ← Set গেল
              discount: null }                       ← note উধাও

clone ──► { owner: "রিনা",
            createdAt: ──► নতুন Date
            items: ──────► নতুন array ──► নতুন object
            coupons: ────► নতুন Set { "EID10" }
            discount: NaN, note: undefined }   ← সব আছে
clone.items[0].qty = 9   →   cart বদলায় না

                 ভেতরের object  Date/Map/Set  NaN/undefined  চক্র   function
{ ...x }         ভাগাভাগি       ভাগাভাগি       ✓              ✓      ✓ (একই)
JSON-কৌশল        নতুন           হারায়         হারায়          Error  বাদ
structuredClone  নতুন           ✓              ✓              ✓      Error

নিজে চালিয়ে তিন পদ্ধতির পার্থক্য দেখুন — চেকআউটে এডিট শুরুর আগে কার্টের কপি:

const cart = {
  owner: "রিনা",
  createdAt: new Date("2026-10-19T04:30:00Z"),
  items: [{ name: "খাতা", qty: 2 }],
  coupons: new Set(["EID10"]),
  discount: NaN,
  note: undefined,
};
const shallow = { ...cart };
const viaJson = JSON.parse(JSON.stringify(cart));
const clone = structuredClone(cart);

shallow.items[0].qty = 5;                  // কপিতে বদল...
console.log("মূল কার্ট:", cart.items[0].qty); // ...মূলেও বদল!
console.log(typeof viaJson.createdAt, viaJson.coupons, viaJson.discount, "note" in viaJson);
console.log(clone.createdAt instanceof Date, clone.coupons.has("EID10"), clone.discount, "note" in clone);
clone.items[0].qty = 9;
console.log(cart.items[0].qty, clone.items[0].qty);

try { structuredClone({ total() { return 0; } }); }
catch (e) { console.log(e.name + ": " + e.message); }

structuredClone যা পারে না

• Function কপি হয় না: কোনো property-তে function থাকলে পুরো কাজ DataCloneError দিয়ে থামে — JSON-এর মতো নীরবে বাদ দেয় না।
• DOM node কপি হয় না: structuredClone(document.body) DataCloneError দেয়। DOM কপি করতে আছে node.cloneNode(true) (পর্ব ৩৭)।
• Class-এর পরিচয় হারায়: class instance কপি হয় সাধারণ object হয়ে — নিজস্ব field থাকে, কিন্তু prototype (পর্ব ২৫) হয় সাধারণ Object.prototype, তাই method আর getter থাকে না, instanceof দেয় false. #private field-ও কপি হয় না।
• Getter-এর মান, setter নয়: getter থাকলে কপির সময় তার মান পড়ে সাধারণ property হিসেবে রাখা হয়; property descriptor, Object.freeze-এর অবস্থা ইত্যাদি হারায়।

৭ · বিশ্বাস নয়, যাচাই — validation, নিরাপত্তা, localStorage আর NDJSON

JSON.parse সফল হলো মানে শুধু এটুকু নিশ্চিত যে লেখাটির ব্যাকরণ ঠিক ছিল। ভেতরের ডেটা আপনার প্রত্যাশামতো কি না — সেটা সে জানে না, জানার কথাও না। API আপনাকে {"items": [...]} দেওয়ার কথা, কিন্তু নতুন সংস্করণে হয়তো দিল {"data": {"items": [...]}}; price number হওয়ার কথা, এলো "250" string; কোনো item-এ qty নেই। Parse ঠিকঠাক, কিন্তু পরের লাইনে undefined-এর ওপর .reduce — অথবা আরও খারাপ, "250" * 2 চুপচাপ ৫০০ দেয় আর "250" + 1 দেয় "2501".

তাই parse-এর ঠিক পরে একটি সীমান্ত-চৌকি বসান — যেমন বিমানবন্দরে ইমিগ্রেশন: পাসপোর্ট “দেখতে ঠিক” হলেই হয় না, প্রতিটি তথ্য মিলিয়ে দেখা হয়। ছোট ক্ষেত্রে হাতে যাচাই:

function parseOrder(text) {
  const data = JSON.parse(text);                       // SyntaxError → ডাকার জায়গায় ধরুন
  if (typeof data !== "object" || data === null || !Array.isArray(data.items)) {
    throw new TypeError("অর্ডারের আকার ঠিক নেই");
  }
  for (const it of data.items) {
    if (typeof it.name !== "string" || !Number.isSafeInteger(it.price) ||
        !Number.isSafeInteger(it.qty) || it.qty <= 0) {
      throw new TypeError("ভুল item: " + JSON.stringify(it));
    }
  }
  return data;
}

বড় প্রজেক্টে এই কাজ হাতে লেখা ক্লান্তিকর আর ভুলপ্রবণ, তাই schema validation library ব্যবহার হয় — ডেটার “আকার” একবার বর্ণনা করেন, library যাচাই করে স্পষ্ট error দেয়। জনপ্রিয় একটি হলো Zod (npm থেকে ইনস্টল করতে হয়, পর্ব ৪৬; তাই নিচের কোড এখানে চালানো যাবে না):

import { z } from "zod";

const Order = z.object({
  orderId: z.string(),
  placedAt: z.coerce.date(),                           // ISO string → Date
  items: z.array(z.object({
    name: z.string(),
    price: z.number().int().nonnegative(),
    qty: z.number().int().positive(),
  })).min(1),
});

const result = Order.safeParse(JSON.parse(text));
if (!result.success) console.log(result.error.issues); // কোন field, কী সমস্যা
else useOrder(result.data);                            // এখানে ডেটা বিশ্বাসযোগ্য

ভাষা-নিরপেক্ষ বিকল্প হলো JSON Schema — schema নিজেই একটি JSON ফাইল, যা সার্ভার আর ক্লায়েন্ট দুজনেই পড়তে পারে। TypeScript (পর্ব ৪৭) শিখলে মনে রাখবেন: TypeScript-এর টাইপ শুধু compile-এর সময় থাকে, চলার সময় API কী পাঠাল সেটা যাচাই করে না — JSON.parse-এর ফল তাই runtime-এ যাচাই করতেই হয়।

নিরাপত্তা ১ — JSON কখনো eval করবেন না

JSON.parse আসার আগে (২০০৯-এর আগের ব্রাউজারে) অনেকে লিখত eval("(" + text + ")") — কারণ JSON তো JavaScript-এরই অংশ। কিন্তু eval লেখাটিকে কোড হিসেবে চালায়. সার্ভার বা মাঝপথের কেউ ডেটার জায়গায় কোড ঢোকালে সেটি আপনার পাতায়, আপনার ব্যবহারকারীর লগইনসহ চলবে — XSS-এর দরজা খোলা। JSON.parse শুধু ব্যাকরণ পড়ে, কোনো কোড চালায় না, কোনো function বানায় না — তাই এটিই একমাত্র ঠিক পথ।

নিরাপত্তা ২ — “__proto__” key আর prototype pollution

একটি সূক্ষ্ম বিপদ আছে, যা অনেক বড় npm library-তেও ধরা পড়েছে। JSON.parse('{"__proto__": {"isAdmin": true}}') নিজে নিরাপদ — সে "__proto__" নামে একটি সাধারণ নিজস্ব property বানায়, কারও prototype বদলায় না। বিপদ আসে পরে, যখন এই ডেটা কোনো সরল “deep merge” function দিয়ে অন্য object-এ মেশানো হয়:

// ভুল নকশা — দেখানোর জন্য
function naiveMerge(target, src) {
  for (const key in src) {
    if (typeof src[key] === "object" && src[key] !== null) {
      target[key] = naiveMerge(target[key] ?? {}, src[key]);  // key === "__proto__" হলে?
    } else target[key] = src[key];
  }
  return target;
}
naiveMerge({}, JSON.parse('{"__proto__": {"isAdmin": true}}'));
console.log({}.isAdmin);   // true — প্রোগ্রামের সব object এখন "admin"!

কী ঘটল? target["__proto__"] পড়লে পাওয়া যায় Object.prototype — সব সাধারণ object-এর সাধারণ পূর্বপুরুষ। Merge তার ভেতরে isAdmin = true লিখে দিল। ফলে প্রোগ্রামের যেকোনো object, যার নিজের isAdmin নেই, এখন prototype থেকে true পায় — if (user.isAdmin) ধরনের যাচাই ভেঙে পড়ে। একে বলে prototype pollution. প্রতিরক্ষা:

• নিজে deep merge লিখলে "__proto__", "constructor" আর "prototype" key বাদ দিন, আর শুধু Object.hasOwn(src, key) সত্য এমন key নিন
• Key যেখানে বাইরে থেকে আসে (যেমন ব্যবহারকারীর দেওয়া নাম), সেখানে সাধারণ object-এর বদলে Map (পর্ব ১৮) বা Object.create(null) ব্যবহার করুন
• Merge-এর আগে schema দিয়ে যাচাই করুন — অচেনা key ফেলে দিন
• পরিচিত, রক্ষণাবেক্ষণ করা library-র হালনাগাদ সংস্করণ ব্যবহার করুন; npm audit নিয়মিত দেখুন

আরেকটি সূক্ষ্মতা: spread ({ ...parsed }) নিজস্ব property হিসেবেই "__proto__" কপি করে, কিন্তু Object.assign({}, parsed) setter ব্যবহার করে বলে নতুন object-এর prototype বদলে দেয় — পুরো প্রোগ্রাম নয়, তবু অপ্রত্যাশিত। বিস্তারিত ওয়েব-নিরাপত্তা পর্ব ৪৩-এ।

localStorage — শুধু string রাখে

ব্রাউজারের localStorage (পর্ব ৪০) শুধু string রাখতে পারে। Object সরাসরি দিলে রাখা হয় "[object Object]" — ডেটা শেষ। তাই কার্টের সেটিংস রাখতে JSON-ই ভরসা (এই কোড পাতার ভেতরের sandbox-এ চলবে না, নিজের ব্রাউজারের console-এ চেষ্টা করুন):

const prefs = { theme: "dark", currency: "BDT", savedAt: new Date() };
localStorage.setItem("cartPrefs", JSON.stringify(prefs));

function loadPrefs() {
  try {
    return JSON.parse(localStorage.getItem("cartPrefs")) ?? { theme: "light" };
  } catch {
    return { theme: "light" };     // পুরোনো বা ভাঙা ডেটা — ডিফল্টে ফিরুন
  }
}

এখানে একটি ছোট কৌশল লুকিয়ে আছে: key না থাকলে getItem দেয় null, আর JSON.parse(null) আগে null-কে "null" লেখায় রূপান্তর করে, ফল দেয় null — error নয়। তারপর ?? ডিফল্ট বসায়। আর savedAt ফেরত আসবে string হয়ে — reviver ছাড়া Date নয়।

NDJSON — এক লাইনে এক JSON

পুরো ফাইল একটি বড় JSON array হলে, শেষ ] না আসা পর্যন্ত parse করা যায় না — লাখো log লাইন বা ধীরে ধীরে আসা stream-এর জন্য অসুবিধা। সমাধান NDJSON (newline-delimited JSON, যাকে JSON Lines-ও বলে): প্রতিটি লাইনে একটি সম্পূর্ণ JSON মান। text.trim().split("\n").map(line => JSON.parse(line)) — প্রতিটি লাইন আলাদাভাবে parse হয়, একটি ভাঙা লাইন বাকিগুলোকে নষ্ট করে না, আর নতুন লাইন শুধু শেষে জুড়ে দিলেই হয়। Log সিস্টেম, ডেটা export আর বেশ কিছু streaming API এই ফরম্যাট ব্যবহার করে; stream পড়ার কৌশল পর্ব ৪৯-এ।

৮ · AI-এর যুগে — JSON কোডে AI-এর চেনা ভুল

JSON নিয়ে AI-এর লেখা কোড সাধারণত “happy path”-এ নিখুঁত চলে — সার্ভার ঠিক উত্তর দিলে, ডেটায় Date বা Set না থাকলে। সমস্যা দেখা দেয় বাস্তবের ধাক্কায়: ভাঙা উত্তর, বদলে যাওয়া API, বিশেষ অক্ষর। AI যে কোটি কোটি লাইন কোড থেকে শিখেছে, তার বড় অংশ পুরোনো অভ্যাসে লেখা — তাই সে আত্মবিশ্বাসের সাথে সেই পুরোনো ভুলগুলোই দেয়।

AI-এর লেখা JSON কোড — যাচাইয়ের চেকলিস্ট

• বাইরের প্রতিটি JSON.parse try/catch-এর ভেতরে, আর ব্যর্থ হলে ব্যবহারকারী একটি বোধগম্য বার্তা বা ডিফল্ট পান
• কোথাও string জোড়া দিয়ে JSON বানানো হয়নি, কোথাও eval বা new Function নেই
• Parse-এর পর আকার আর টাইপ যাচাই হয়েছে (হাতে বা schema দিয়ে); ID string হিসেবে আছে
• Date, Map, Set, BigInt, NaN পাঠানোর আগে স্পষ্টভাবে রূপান্তর হয়েছে, আর পড়ার পর ফেরানো হয়েছে
• Deep copy-তে structuredClone; JSON-কৌশল থাকলে কেন, সেটা লেখা আছে
• Log বা ক্লায়েন্টে পাঠানোর আগে পাসওয়ার্ড, token, OTP allow-list replacer দিয়ে বাদ পড়েছে
• নিজে অন্তত তিনটি খারাপ ইনপুট চালিয়ে দেখেছি: ভাঙা JSON, ভুল আকার আর ভুল টাইপ