JavaScript Property Exists but Is undefined: Use Object.hasOwn

Reproduce the difference with one record#

The following fixture was executed on macOS with Node.js 24.13.0 during article preparation on October 27, 2026. It compares the same keys with five checks, then exercises two failures of calling record.hasOwnProperty() directly. Save it as presence-check.mjs and run node presence-check.mjs.

The ECMAScript Object.hasOwn algorithm checks ownership after converting the key to a property key. The fixture uses string and symbol keys on ordinary objects; it does not rely on truthiness to decide membership.

1
import assert from 'node:assert/strict';
2
const record = Object.create({ inherited: 7 });
3
Object.assign(record, { unset: undefined, zero: 0, disabled: false, empty: '', nil: null });
4
Object.defineProperty(record, 'hidden', { value: 9 });
5
const token = Symbol('token');
6
record[token] = 11;
7
const cases = [
8
  ['absent', 'absent', [false, false, false, false, false]],
9
  ['undefined', 'unset', [true, true, false, false, true]],
10
  ['zero', 'zero', [true, true, false, true, true]],
11
  ['false', 'disabled', [true, true, false, true, true]],
12
  ['empty string', 'empty', [true, true, false, true, true]],
13
  ['null', 'nil', [true, true, false, true, true]],
14
  ['inherited', 'inherited', [false, true, true, true, false]],
15
  ['non-enumerable', 'hidden', [true, true, true, true, false]],
16
  ['symbol', token, [true, true, true, true, false]],
17
];
18
for (const [label, key, expected] of cases) {
19
  const actual = [Object.hasOwn(record, key), key in record,
20
    Boolean(record[key]), record[key] !== undefined,
21
    Object.keys(record).includes(key)];
22
  assert.deepEqual(actual, expected, label);
23
  console.log(`${label}: ${actual.map(Number).join(' ')}`);
24
}
25
const dictionary = Object.create(null);
26
dictionary.name = 'Ada';
27
assert.throws(() => dictionary.hasOwnProperty('name'), TypeError);
28
assert.equal(Object.hasOwn(dictionary, 'name'), true);
29
const shadowed = { hasOwnProperty: false, name: 'Ada' };
30
assert.throws(() => shadowed.hasOwnProperty('name'), TypeError);
31
assert.equal(Object.hasOwn(shadowed, 'name'), true);
32
assert.equal(Object.prototype.hasOwnProperty.call(shadowed, 'name'), true);
33
assert.throws(() => Object.hasOwn(null, 'name'), TypeError);
34
assert.throws(() => Object.hasOwn(undefined, 'name'), TypeError);
35
let reads = 0;
36
const accessor = { get name() { reads++; return 'Ada'; } };
37
assert.equal(Object.hasOwn(accessor, 'name'), true);
38
assert.equal(reads, 0);
39
assert.equal(accessor.name, 'Ada');
40
assert.equal(reads, 1);
41
console.log('dictionary, shadowing, nullish, and getter checks passed');

Expected output uses 1 for true and 0 for false. Columns are own, in, truthy, not undefined, and in Object.keys, in that order:

1
absent: 0 0 0 0 0
2
undefined: 1 1 0 0 1
3
zero: 1 1 0 1 1
4
false: 1 1 0 1 1
5
empty string: 1 1 0 1 1
6
null: 1 1 0 1 1
7
inherited: 0 1 1 1 0
8
non-enumerable: 1 1 1 1 0
9
symbol: 1 1 1 1 0
10
dictionary, shadowing, nullish, and getter checks passed

The inherited row is deliberately truthy. It exposes a bug that an undefined-only example would miss: reading a useful-looking value does not prove the object owns it. The own undefined row exposes the reverse error: no useful value does not mean no property.

Match the check to the question#

MDN’s ownership guide separates ownership, enumerability, and key type. Those are independent properties, which is why the last two rows differ from a normal enumerable string key.

Do not replace a field’s validation with an ownership test. For example, Object.hasOwn(record, 'nil') is true here, but the value is null. If a field must contain a number, check both presence and the accepted numeric range. Conversely, if false or zero is allowed, a truthiness test would reject valid input.

Use in when inherited properties intentionally count. It is appropriate for that different question; switching every in expression to Object.hasOwn() would change the contract.

Avoid calling a method supplied by the record#

MDN recommends Object.hasOwn over a direct hasOwnProperty() call. In the fixture, a null-prototype dictionary has no inherited method, while the second record supplies a boolean with that method’s name. Both direct calls throw TypeError; the static method succeeds.

If your target runtime lacks Object.hasOwn, Object.prototype.hasOwnProperty.call(record, key) is the older borrowed-method form. Its result is asserted for the shadowed record above. The published execution covers Node.js 24.13.0, not an older runtime or a browser compatibility matrix; check your actual target before adopting the static API.

The null-prototype dictionary is an object. A null or undefined receiver is a different input: Object.hasOwn(null, key) and Object.hasOwn(undefined, key) throw, as the assertions confirm. Validate an optional receiver before making the call. Optional chaining on a value read would suppress that access error but still would not answer the ownership question.

Keep presence separate from reading and transport#

The getter counter demonstrates another useful boundary. On the ordinary accessor object in the fixture, Object.hasOwn(accessor, 'name') reports presence without running the getter. Reading accessor.name then increments the counter. These checks do not establish behavior for proxies, framework reactive wrappers, custom key coercion, or objects that mutate during inspection.

Presence can also change across serialization. An own undefined object field disappears from ordinary JSON output; see the separate JSON.stringify undefined-field diagnosis before assuming an in-memory membership check describes a received request body.

For a record-membership bug, add an assertion for an own undefined property and one for an inherited property. If the first must pass and the second must fail, Object.hasOwn() expresses that requirement directly. Assert the value separately when its type or contents matter.

References:

• ECMAScript: Object.hasOwn
• ECMAScript: Object.keys
• MDN: Object.hasOwn()
• MDN: in operator
• MDN: Enumerability and ownership of properties