2013-08-25

Protecting objects in JavaScript

This blog post is a quick refresher of how objects can be protected in JavaScript. There are three levels of protection:
  1. Preventing extensions is the weakest level,
  2. sealing is stronger,
  3. freezing is strongest.

Preventing extension

    Object.preventExtensions(obj)
makes it impossible to add properties to obj. Example:
    var obj = { foo: 'a' };
    Object.preventExtensions(obj);
Now adding a propert fails silently in sloppy mode:
    > obj.bar = 'b';
    > obj.bar
    undefined
And throws an error in strict mode [1], which we switch to via an IIFE [2].
    > (function () { 'use strict'; obj.bar = 'b' }());
    TypeError: Can't add property bar, object is not extensible
You can still delete properties, though.
    > delete obj.foo
    true
    > obj.foo
    undefined

Checking whether an object is extensible

    Object.isExtensible(obj)
checks whether obj is extensible:
    > Object.isExtensible(obj)
    false

Sealing

    Object.seal(obj)
prevents extensions and makes all properties “unconfigurable”. The latter means that the attributes [3] of properties can’t be changed, any more. Read-only properties stay read-only, enumerable properties stay enumerable, etc.

(As an aside, JavaScript does allow you to change an unconfigurable property from writable to read-only, due to historical reasons.)

The following example demonstrates that sealing makes all properties unconfigurable.

    > var obj = { foo: 'a' };

    > Object.getOwnPropertyDescriptor(obj, 'foo')  // before sealing
    { value: 'a',
      writable: true,
      enumerable: true,
      configurable: true }

    > Object.seal(obj)

    > Object.getOwnPropertyDescriptor(obj, 'foo')  // after sealing
    { value: 'a',
      writable: true,
      enumerable: true,
      configurable: false }
You can still change the property foo:
    > obj.foo = 'b';
    'b'
    > obj.foo
    'b'
But you can’t change its attributes:
    > Object.defineProperty(obj, 'foo', { enumerable: false });
    TypeError: Cannot redefine property: foo
Additionally, obj is not extensible, any more.

Checking whether an object is sealed

    Object.isSealed(obj)
checks whether obj is sealed:
    > Object.isSealed(obj)
    true

Freezing

    Object.freeze(obj)
makes all properties non-writable and seals obj. That is, obj is not extensible, all properties are read-only and there is no way to change that.
    var point = { x: 17, y: -5 };
    Object.freeze(point);
Once again, you get silent failures in sloppy mode:
    > point.x = 2;  // no effect, point.x is read-only
    > point.x
    17

    > point.z = 123;  // no effect, point is not extensible
    > point
    { x: 17, y: -5 }
And errors in strict mode:
    > (function () { 'use strict'; point.x = 2 }());
    TypeError: Cannot assign to read-only property 'x'

    > (function () { 'use strict'; point.z = 123 }());
    TypeError: Can't add property z, object is not extensible

Checking whether an object is frozen

    Object.isFrozen(obj)
checks whether obj is frozen:
    > Object.isFrozen(point)
    true

References

  1. JavaScript’s strict mode: a summary
  2. JavaScript variable scoping and its pitfalls
  3. Object properties in JavaScript

1 comment:

Axel Rauschmayer said...

Why would we do that? Just because we can? What are the applications of using such? Thanks.