Object.seal()

One of three levels of lock-down. preventExtensions blocks additions; seal also blocks deletions; freeze also blocks writes. Seal is the one people reach for least and confuse most.

Object static methodES5 (2009)Live demo
Common call
Object.seal(obj)
Returns
the same object, sealed
Replaces
nothing; it sits between preventExtensions and freeze
Watch out
values are still writable — sealed is NOT frozen
Object.seal(objectobject — The object to seal. Primitives are returned unchanged and report as sealed, as with freeze.type: any · required)
→ object

Demo

Live evaluation
Try:
Inputs
jsonstringa JSON object
Output
(o => [Object.isSealed(o), Object.isFrozen(o)])(Object.seal(JSON.parse('{"a":1,"n":{"x":1}}')))
[true, false]

The pair shows sealed and frozen side by side. For an object with properties the answer is [true, false] — sealed, because nothing can be added or removed, but not frozen, because those properties can still be assigned to. The empty-object case returns [true, true], which looks like a bug and is not: an object with no properties has no writable properties, so sealing it satisfies the definition of frozen vacuously. Any predicate you write over possibly-empty objects has to account for that.

Parameters

NameTypeRequiredDescription
objectanyyesThe object to seal. Primitives are returned unchanged and report as sealed, as with freeze.

Return value

object — The SAME object, sealed — no properties can be added or deleted, but existing ones can still be written to.

Common patterns

Fix the shape, allow updates
Typos become errors; legitimate writes still work.
const state = Object.seal({count: 0, name: ""});
Block additions only
The weakest of the three — deletes still allowed.
Object.preventExtensions(obj);
Choose the right rung
Each adds a restriction to the previous one.
Object.preventExtensions(o);  // no adds
Object.seal(o);               // no adds, no deletes
Object.freeze(o);             // no adds, deletes or writes

Examples

1. Write still allowed
const o = Object.seal({a: 1}); o.a = 2; o.a
Returns
2
2. Add blocked (strict)
"use strict"; const o = Object.seal({a: 1}); o.b = 2
Returns
TypeError: Cannot add property b, object is not extensible
3. Sealed is not frozen
Object.isFrozen(Object.seal({a: 1}))
Returns
false
4. Frozen IS sealed
Object.isSealed(Object.freeze({a: 1}))
Returns
true
5. Empty sealed is frozen
Object.isFrozen(Object.seal({}))
Returns
true
6. preventExtensions allows writes
const o = Object.preventExtensions({a: 1}); o.a = 2; o.a
Returns
2

Pitfalls

1. Sealed does not mean read-only
The most common confusion with freeze. Every existing property stays writable, so a sealed configuration object can have all its values changed — only its set of keys is fixed.
Value changed
const o = Object.seal({a: 1});
o.a = 99;
o.a
99
Freeze for read-only
const o = Object.freeze({a: 1});
writes blocked
2. An empty sealed object reports as frozen
Vacuously true — there is nothing writable to block. A guard like isFrozen(x) to decide whether an object is safely immutable answers yes for {} regardless of what you actually did to it.
Misleading true
Object.isFrozen(Object.seal({}))
true
Ask what you mean
Object.isSealed(o) && Object.keys(o).length > 0
explicit
3. Silent failure outside strict mode
Identical to freeze — adding a property to a sealed object in sloppy mode does nothing and reports nothing. Modules and classes are strict, so this mostly appears in scripts and consoles.
Silent
const o = Object.seal({a: 1});
o.b = 2;
o.b
undefined
Strict throws
"use strict";
Object.seal({}).b = 2
TypeError
4. It is shallow, like freeze
Nested objects are neither sealed nor frozen. Sealing the top level of a config says nothing about anything below it.
Nested open
const o = Object.seal({n: {}});
o.n.added = 1;
o.n
{added: 1}
Seal recursively
Object.values(o).forEach(v => typeof v === "object" && Object.seal(v));
one more level

When to use

Use it
  • Fixing an object shape while allowing values to change — state containers
  • Catching typo-ed property names, which would otherwise silently create a new key
  • A middle ground where freeze would be too strict
Reach for something else
  • You want read-only → freeze
  • You only need to block additions → preventExtensions
  • Nested data matters → neither is deep
  • You want immutable updates → build new objects instead

Notes

Complexity
O(n) in the number of own properties
Return
The same object reference, non-extensible with every property non-configurable
CPython impl
V8: Builtins-object-seal
Memory
No allocation
Thread-safe
Single-threaded; sealing is permanent

FAQ

A ladder. preventExtensions blocks new properties but allows deleting and writing. seal adds a block on deletion. freeze adds a block on writing. Every frozen object is sealed and non-extensible; the reverse does not hold.

Object.preventExtensions(o);  // no adds
Object.seal(o);               // + no deletes
Object.freeze(o);             // + no writes

History

ES5
seal, freeze, preventExtensions and the three predicates added together.