Object static methods

What it is and why it exists

Object static methods are object operations attached to the Object constructor, such as Object.keys(value), Object.assign(target, source), and Object.freeze(value). They aren’t instance methods that every object can safely call; the first argument names the object to inspect or change.

JavaScript objects store data under property keys. A key is either a string or a Symbol, and a property may belong to the object itself or come from its prototype chain , with metadata such as whether it is enumerable. “Get every field” is therefore incomplete until the caller defines which property categories count.

These methods solve four recurring problems: projecting an object into a key-value list, constructing an object from key-value pairs, reading or defining exact property behavior, and restricting whether an object can gain, lose, or rewrite properties. You meet them in configuration merging, API projections, library boundaries, and diagnostic tools.

The APIs don’t share one universal meaning of “copy an object.” Copying plain data, retaining accessors, retaining a prototype, and duplicating an entire object graph are different contracts. Pick the wrong method and a new-looking object can lose metadata, invoke a getter, or continue sharing nested objects with its source.

Property removal still uses the delete operator, prototype-chain membership uses in, and a uniform reflection interface comes from Reflect. These features sit beside Object methods but don’t replace one another.

How it works

Three selection axes

Enumeration APIs mainly filter properties along three axes: whether a property is own or inherited, whether it is enumerable, and whether its key is a string or Symbol. Write down those conditions before guessing from a method name.

“Non-enumerable keys” in the table means that the operation can include that category. Object.values() and Object.entries() select the same keys as Object.keys() and only change the result shape. Even an enumerable Symbol property is omitted by all three methods.

Object.hasOwn(object, key) answers whether one key is an own property, regardless of enumerability, and it accepts Symbols. It is safer than object.hasOwnProperty(key) because the target may override that method or have no Object.prototype at all.

Property descriptors control behavior

Every own property has a property descriptor . A data descriptor uses value and writable; an accessor descriptor uses get and set. Both forms can use enumerable and configurable, but one descriptor cannot specify data and accessor fields together.

Properties created by an object literal or ordinary assignment are normally writable, enumerable, and configurable. Omitted fields in Object.defineProperty() have very different defaults: unspecified Boolean flags are false. Writing only { value: 1 } creates a non-writable, non-enumerable, non-configurable property.

Object.getOwnPropertyDescriptor() returns a descriptor snapshot; changing the returned object does not alter the property. Object.getOwnPropertyDescriptors() returns descriptors for every own string and Symbol key. It can be combined with Object.create() to build a new outer object with the same own-property behavior and prototype.

Copies and transformations stay shallow

Object.assign(target, ...sources) reads each source’s enumerable own string and Symbol keys from left to right, then writes their values to the target. A later source overwrites an earlier source’s same-named key. The target is changed in place and is also the return value.

This operation produces a shallow copy . When a property value is an object, only the reference to that same object is copied; nested objects aren’t merged recursively. If a source property is a getter, copying executes it and puts the resulting value in the target instead of preserving its descriptor.

Object.entries() projects an object into an array of string-keyed pairs for filtering or mapping with array methods. Object.fromEntries(iterable) constructs an ordinary object from pairs. The combination is useful for data transformations, but it isn’t a lossless round trip: Object.entries() omits Symbols, non-enumerable properties, descriptors, and the prototype.

Integrity levels constrain one layer

Object.preventExtensions(), Object.seal(), and Object.freeze() all modify and return the supplied object. They progressively restrict the object’s own structure but don’t recurse into objects referenced by property values.

seal() makes every own property non-configurable; freeze() also makes own data properties non-writable. Accessor properties don’t have a writable flag, so getters still run on a frozen object and an existing setter may still change other state. “Frozen” is therefore an integrity state for one object, not immutability for an arbitrary object graph.

When direct assignment or delete conflicts with an integrity restriction, strict mode throws TypeError while a non-strict script may fail silently. Reflect.set() and Reflect.deleteProperty() report these ordinary failures as Booleans, making their result explicit in examples.

Examples

These four examples successively verify property selection, key-value transformation, descriptor copying, and integrity levels. Every output shown here came from local Node 24.14.0.

Selecting the exact property set

This object has an inherited property, a non-enumerable property, and a Symbol property. Putting every category in one sample makes the boundaries of the common APIs visible.

Object.keys() returns only name, not because the other properties don’t exist but because they don’t satisfy all three conditions: own, enumerable, and string-keyed. in follows the prototype chain, which is why the last two lines give different answers for the same key.

At a boundary with an allowlist, don’t begin with “every key” and delete a list of known dangerous fields. Read the permitted names directly and use Object.hasOwn() to distinguish missing fields from inherited ones; that contract remains stable as the input grows.

Transforming and merging plain data

The first transformation removes an internal field. The configuration merge then demonstrates two independent facts: later sources overwrite earlier keys, and the nested limits object is replaced as a unit rather than merged recursively.

const flags = {
  checkout: true,
  internalNote: 'remove',
  retries: 0,
};

const publicFlags = Object.fromEntries(
  Object.entries(flags).filter(([key]) => !key.startsWith('internal')),
);
console.log(JSON.stringify(publicFlags));

const defaults = { theme: 'light', limits: { requests: 100 } };
const input = { theme: 'dark', limits: { burst: 10 } };
const merged = Object.assign({}, defaults, input);

console.log(JSON.stringify(merged));
console.log(merged === defaults, merged.limits === input.limits);

const nestedMerge = {
  ...defaults,
  ...input,
  limits: { ...defaults.limits, ...input.limits },
};
console.log(JSON.stringify(nestedMerge));

{"checkout":true,"retries":0}
{"theme":"dark","limits":{"burst":10}}
false true
{"theme":"dark","limits":{"requests":100,"burst":10}}

Using an empty object as the Object.assign() target avoids changing defaults, but it doesn’t make nested values independent. The true on the third output line proves that merged.limits and input.limits still refer to the same object.

Explicitly spreading limits works for configuration with a known shape. A generic “deep merge” needs separate policies for arrays, cycles, accessors, dangerous keys, and different object types; those policies don’t follow naturally from Object.assign().

Defining and retaining property descriptors

This example first exposes the defaults used by defineProperty(), then compares value copying with descriptor copying. A source getter’s read count makes the side effect visible.

'use strict';

const account = {};
Object.defineProperty(account, 'id', {
  value: 'A-17',
  enumerable: true,
});

const idDescriptor = Object.getOwnPropertyDescriptor(account, 'id');
console.log(JSON.stringify({
  writable: idDescriptor.writable,
  enumerable: idDescriptor.enumerable,
  configurable: idDescriptor.configurable,
}));

let reads = 0;
Object.defineProperty(account, 'balance', {
  get() {
    reads += 1;
    return 42;
  },
  enumerable: true,
  configurable: true,
});

const assigned = Object.assign({}, account);
const exact = Object.create(
  Object.getPrototypeOf(account),
  Object.getOwnPropertyDescriptors(account),
);

console.log(assigned.balance, reads);
console.log(typeof Object.getOwnPropertyDescriptor(assigned, 'balance').get);
console.log(typeof Object.getOwnPropertyDescriptor(exact, 'balance').get);

{"writable":false,"enumerable":true,"configurable":false}
42 1
undefined
function

Object.assign() runs the balance getter once to obtain its value and creates an ordinary data property on the target. Object.getOwnPropertyDescriptors() reads the accessor function itself, so creating exact does not run the getter again.

Here exact only means that the outer prototype and own property descriptors are retained. Property values still share references, and built-ins or class instances with internal slots or private fields cannot be turned into universal exact clones with this combination.

Comparing the three integrity levels

Using Reflect exposes whether each operation succeeds without depending on strict-mode error text. The last two lines also verify that freezing affects only the outer object.

const extensible = { count: 1 };
Object.preventExtensions(extensible);
console.log(
  Reflect.set(extensible, 'count', 2),
  Reflect.set(extensible, 'extra', true),
  Reflect.deleteProperty(extensible, 'count'),
);

const sealed = Object.seal({ count: 1 });
console.log(
  Reflect.set(sealed, 'count', 2),
  Reflect.set(sealed, 'extra', true),
  Reflect.deleteProperty(sealed, 'count'),
);

const preferences = { theme: 'light' };
const frozen = Object.freeze({ count: 1, preferences });
console.log(
  Reflect.set(frozen, 'count', 2),
  Reflect.deleteProperty(frozen, 'count'),
  Object.isFrozen(frozen),
);

preferences.theme = 'dark';
console.log(frozen.preferences.theme);
console.log(Object.isFrozen(frozen.preferences));

true false true
true false false
false false true
dark
false

A non-extensible object still permits changes to and deletion of existing properties. A sealed object still permits writes to originally writable values; a frozen object refuses those writes too. None of the three operations follows the preferences reference, so the nested object remains mutable.

Object.isFrozen() answers only whether its argument is frozen. If a contract claims that an entire input graph is immutable, tests must continue through every relevant nested object or the design must establish explicit ownership of immutable data.

Pitfalls

Treating Object.keys() as every property

Fix: choose a key set from the requirement. Use Reflect.ownKeys() for every own key, Object.hasOwn() for one own-key test, and an explicit, filtered for...in only when prototype-chain enumeration is intentional.

Letting Object.assign() mutate shared defaults

Fix: merge plain data into a fresh target, as in Object.assign({}, defaults, input), and handle nested fields separately. For untrusted input, construct an allowlisted result instead of writing every enumerable key into an ordinary object.

Mistaking a shallow copy for an independent copy

Fix: state which levels require independent identity and copy only those levels. When a general object graph must be copied, use a mechanism with a contract matching the data types, then test shared references, cycles, and unsupported values instead of applying a JSON round trip.

Forgetting descriptor defaults

Fix: spell out every flag the business behavior depends on and assert the result with Object.getOwnPropertyDescriptor(). Making a property non-configurable is a strong one-way decision; confirm that later code won’t need to redefine or delete it.

Assuming freeze recurses or disables accessors

Fix: describe freezing as an outer integrity constraint and test nested identity and accessor side effects. Before implementing recursive freezing, define how to handle cycles, Symbol keys, accessors, proxies, typed arrays, and instances with private state.

Further reading

• MDN: Object
• MDN: Enumerability and ownership of properties
• MDN: Object.defineProperty()
• MDN: Object.freeze()
• ECMAScript language specification: Object Objects