Fix: undefined, NaN, and Infinity in JSON

The Problem: Not All JS Values Are Valid JSON

JSON only supports these value types: string, number (finite decimal), object, array, true, false, and null. The following are all illegal in JSON:

JSON.stringify() Behaviour in Detail

// 1. undefined as object property — silently omitted
JSON.stringify({ a: 1, b: undefined });
// → '{"a":1}'   ← 'b' is gone!

// 2. undefined in array — becomes null
JSON.stringify([1, undefined, 3]);
// → '[1,null,3]'

// 3. NaN and Infinity — both become null
JSON.stringify({ score: NaN, limit: Infinity });
// → '{"score":null,"limit":null}'

// 4. Calling JSON.stringify(undefined) directly
JSON.stringify(undefined);
// → undefined  (not the string "undefined", actual undefined)

// 5. BigInt — throws
JSON.stringify({ id: 9007199254740993n });
// TypeError: Do not know how to serialize a BigInt

How to Detect Silent Data Loss

The silent conversion is the dangerous part. Use a custom replacer to surface these values explicitly:

function strictStringify(value, indent = 2) {
  return JSON.stringify(
    value,
    (key, val) => {
      if (val === undefined) throw new TypeError(`Key "${key}" is undefined`);
      if (typeof val === "number" && !isFinite(val)) {
        throw new TypeError(`Key "${key}" has non-finite value: ${val}`);
      }
      return val;
    },
    indent
  );
}

// Now errors are explicit, not silent
strictStringify({ score: NaN });
// TypeError: Key "score" has non-finite value: NaN

Receiving Invalid JSON with These Values

If you receive a string like {"score": NaN} from a server or legacy system that emits pseudo-JSON, JSON.parse() will throw. The only fix is to sanitise the string before parsing:

function sanitizeJSON(str) {
  // Replace bare NaN, Infinity, -Infinity with null
  return str
    .replace(/:\s*NaN/g, ": null")
    .replace(/:\s*-?Infinity/g, ": null")
    .replace(/:\s*undefined/g, ": null");
}

const raw = '{"score": NaN, "limit": Infinity}';
JSON.parse(sanitizeJSON(raw));
// → { score: null, limit: null }

Note: string replacement is fragile. A proper parser that handles JSON5/pseudo-JSON is safer for production use.