JSON.stringify Drops undefined: Keep Intentional Null Fields

Identify what disappeared#

The ECMAScript serialization rules distinguish three positions. An object property with an undefined value is omitted. An array element becomes null. A root undefined produces the JavaScript value undefined, rather than JSON text.

The fixture below verifies these boundaries and the proposed conversion. For a plain object whose undefined fields should all become null, use a strict comparison in the replacer:

1
const form = { nickname: undefined, active: false, retries: 0, note: '' };
2
const body = JSON.stringify(form, (_key, value) =>
3
  value === undefined ? null : value);
4
console.log(body);
5
// {"nickname":null,"active":false,"retries":0,"note":""}

This deliberately changes the data contract: after parsing, nickname is null. It does not restore undefined. An absent key is still absent because the replacer cannot supply fields that serialization never visits.

Avoid value || null. In this example, it also changes false, 0, and '' to null. Those values may carry the reader’s intended update just as much as a nonempty string does.

Reproduce the request-body boundary#

Save this as json-fields.mjs and run node json-fields.mjs. The exact fixture was executed during article preparation on macOS with Node.js 24.13.0 on October 9, 2026. It uses assertions and no external endpoint or package.

1
import assert from 'node:assert/strict';
2

3
const input = { nickname: undefined, active: false, retries: 0, note: '' };
4
const omitted = JSON.stringify(input);
5
const explicit = JSON.stringify(input, (_key, value) =>
6
  value === undefined ? null : value);
7
assert.equal(omitted, '{"active":false,"retries":0,"note":""}');
8
assert.equal(explicit, '{"nickname":null,"active":false,"retries":0,"note":""}');
9
assert.equal(Object.hasOwn(JSON.parse(omitted), 'nickname'), false);
10
assert.equal(JSON.parse(explicit).nickname, null);
11
console.log(`object default: ${omitted}`);
12
console.log(`object replacer: ${explicit}`);
13

14
const array = JSON.stringify([undefined, null, false, 0, '']);
15
assert.equal(array, '[null,null,false,0,""]');
16
assert.equal(JSON.stringify(undefined), undefined);
17
assert.equal(JSON.stringify(undefined, (_key, value) =>
18
  value === undefined ? null : value), 'null');
19
assert.equal(JSON.stringify({}, (_key, value) =>
20
  value === undefined ? null : value), '{}');
21
console.log(`array default: ${array}`);
22
console.log(`root default type: ${typeof JSON.stringify(undefined)}`);
23
console.log('missing key with replacer: {}');
24

25
const bad = JSON.stringify(input, (_key, value) => value || null);
26
assert.equal(bad, '{"nickname":null,"active":null,"retries":null,"note":null}');
27
console.log(`falsy replacer: ${bad}`);
28

29
function nicknamePatch(form) {
30
  if (!Object.hasOwn(form, 'nickname')) return {};
31
  const value = form.nickname;
32
  if (value === undefined || value === null || value === '') {
33
    return { nickname: null };
34
  }
35
  if (typeof value !== 'string') throw new TypeError('nickname must be a string');
36
  return { nickname: value };
37
}
38
for (const [form, expected] of [
39
  [{}, '{}'],
40
  [{ nickname: undefined }, '{"nickname":null}'],
41
  [{ nickname: null }, '{"nickname":null}'],
42
  [{ nickname: '' }, '{"nickname":null}'],
43
  [{ nickname: 'Ada' }, '{"nickname":"Ada"}'],
44
]) {
45
  const body = JSON.stringify(nicknamePatch(form));
46
  assert.equal(body, expected);
47
  console.log(`patch: ${body}`);
48
}
49
assert.throws(() => nicknamePatch({ nickname: false }), TypeError);
50
assert.equal(Object.hasOwn(input, 'nickname'), true);
51
console.log('all assertions passed');

Expected output:

1
object default: {"active":false,"retries":0,"note":""}
2
object replacer: {"nickname":null,"active":false,"retries":0,"note":""}
3
array default: [null,null,false,0,""]
4
root default type: undefined
5
missing key with replacer: {}
6
falsy replacer: {"nickname":null,"active":null,"retries":null,"note":null}
7
patch: {}
8
patch: {"nickname":null}
9
patch: {"nickname":null}
10
patch: {"nickname":null}
11
patch: {"nickname":"Ada"}
12
all assertions passed

Object.hasOwn() checks whether the parsed object contains the field. Reading only parsed.nickname would return undefined both for an absent property and for an own property whose value is undefined. The assertion on the input also confirms that serialization did not delete its original property.

Make null a field decision#

The nicknamePatch() function implements an illustrative endpoint contract: omission leaves the nickname untouched, null requests clearing it, and a string replaces it. These meanings are application choices, not behavior imposed by JSON.stringify() or by the HTTP method.

Each row is exercised in the fixture. The helper treats an empty string as a clearing request and accepts whitespace as a string; change those choices if the endpoint’s validation differs. The object must be supplied by the caller; this helper does not validate an entire request schema.

Use this field policy when only selected nullable fields should be converted. A global replacer would convert every encountered undefined value, including nested ones, and could send null to fields that reject it. Verify the endpoint’s accepted body and clearing semantics before applying either approach.

Inspect the serialized body before debugging the server#

Compare the form object, the actual JSON text, and Object.hasOwn(JSON.parse(body), 'nickname'). If the text lacks the field, inspect the object builder and serializer first. If the text contains "nickname":null but the stored value remains unchanged, the local fixture cannot establish why: check request validation and the endpoint’s update contract.

MDN documents the replacer and toJSON() hooks. A custom toJSON() runs before the replacer, so it may already have removed information. A replacer is not a general repair for every missing property.

This article’s executed examples cover plain objects, arrays, a root undefined value, and the field helper. The published fixture does not exercise custom serialization hooks, browser transport, a deployed API, or database updates. For a response that arrives but fails HTTP or JSON checks, use the separate fetch status and parsing diagnosis.

Define the request meaning at the field boundary, then assert on the JSON text. Explicit null preserves a clearing signal only when your endpoint defines that signal.

References:

• ECMAScript: JSON.stringify and serialization algorithms
• MDN: JSON.stringify()