Why would I need to freeze an object in JavaScript?

Question

It is not clear to me when anyone would need to use Object.freeze in JavaScript. MDN and MSDN don't give real life examples when it is useful. I get it that an attempt to change such an object at runtime means a crash. The question is rather, when would I appreciate this crash?

To me the immutability is a design time constraint which is supposed to be guaranteed by the type checker.

So is there any point in having a runtime crash in a dynamically typed language, besides detecting a violation better later than never?

Answer 1

In a library things can break easily if people modify core things not intended to be modified, here an example in a 3d library:

export const O  =new Vec3(0,0,0)
export const Z  =new Vec3(0,0,1)
export const Y  =new Vec3(0,1,0)
export const YZ =new Vec3(0,1,1)
export const X  =new Vec3(1,0,0)
export const XY =new Vec3(1,1,0)
export const ZX =new Vec3(1,0,1)
export const XYZ=new Vec3(1,1,1)

const N1=X.cross(Y) // this operation would add Y in X
console.log(Y) //=> Vec3(0,1,0)
console.log(X) //=> Vec3(1,1,0)
const N2=Vec3.add(X,Y) // this operation would add X and Y but on a new vector
console.log(N2) //=> Vec3(1,2,0)

Any of those vector are set as const but it's actually possible to alter their properties, by volontary or involontary means, also those vectors are reused everywhere in this type of libraries, freezing them is a way to prevent such involontary modifications or mainly to throw if you try to modify them and so the library can stay consistent.

Answer 2

All the other answers pretty much answer the question.

I just wanted to summarise everything here along with an example.

• Use Object.freeze when you need utmost surety regarding its state in the future. You need to make sure that other developers or users of your code do not change internal/public properties. Alexander Mills's answer
• Object.freeze has better performance since 19th June, 2019, ever since V8 v7.6 released. Philippe's answer. Also take a look at the V8 docs.

Here is what Object.freeze does, and it should clear out doubts for people who only have surface level understanding of Object.freeze.

const obj = {
  name: "Fanoflix"
};

const mutateObject = (testObj) => {
  testObj.name = 'Arthas' // NOT Allowed if parameter is frozen
}

obj.name = "Lich King" // Allowed
obj.age = 29; // Allowed
mutateObject(obj) // Allowed
 
Object.freeze(obj) // ==========  Freezing obj ========== 

mutateObject(obj) // passed by reference NOT Allowed
obj.name = "Illidan" // mutation NOT Allowed
obj.age = 25; // addition NOT Allowed
delete obj.name // deletion NOT Allowed

Answer 3

Object.freeze() mainly using in Functional Programming (Immutability)

Immutability is a central concept of functional programming because without it, the data flow in your program is lossy. State history is abandoned, and strange bugs can creep into your software.

In JavaScript, it’s important not to confuse const, with immutability. const creates a variable name binding which can’t be reassigned after creation. const does not create immutable objects. You can’t change the object that the binding refers to, but you can still change the properties of the object, which means that bindings created with const are mutable, not immutable.

Immutable objects can’t be changed at all. You can make a value truly immutable by deep freezing the object. JavaScript has a method that freezes an object one-level deep.

const a = Object.freeze({
 foo: 'Hello',
 bar: 'world',
 baz: '!'
});

Answer 4

With the V8 release v7.6 the performance of frozen/sealed arrays is greatly improved. Therefore, one reason you would like to freeze an object is when your code is performance-critical.

Answer 5

What is a practical situation when you might want to freeze an object? One example, on application startup you create an object containing app settings. You may pass that configuration object around to various modules of the application. But once that settings object is created you want to know that it won't be changed.

Answer 6

Don't know if this helps, but I use it to create simple enumerations. It allows me to hopefully not get duff data in a database, by knowing the source of the data has been attempted to be unchangeable without purposefully trying to break the code. From a statically typed perspective, it allows for reasoning over code construction.

Answer 7

This is an old question, but I think I have a good case where freeze might help. I had this problem today.

---

The problem

class Node {
    constructor() {
        this._children = [];
        this._parent = undefined;
    }

    get children() { return this._children; }
    get parent() { return this._parent; }

    set parent(newParent) {
        // 1. if _parent is not undefined, remove this node from _parent's children
        // 2. set _parent to newParent
        // 3. if newParent is not undefined, add this node to newParent's children
    }

    addChild(node) { node.parent = this; }
    removeChild(node) { node.parent === this && (node.parent = undefined); }
    ...
}

As you can see, when you change the parent, it automatically handles the connection between these nodes, keeping children and parent in sync. However, there is one problem here:

let newNode = new Node();
myNode.children.push(newNode);

Now, myNode has newNode in its children, but newNode does not have myNode as its parent. So you've just broken it.

(OFF-TOPIC) Why are you exposing the children anyway?

Yes, I could just create lots of methods: countChildren(), getChild(index), getChildrenIterator() (which returns a generator), findChildIndex(node), and so on... but is it really a better approach than just returning an array, which provides an interface all javascript programmers already know?

1. You can access its length to see how many children it has;
2. You can access the children by their index (i.e. children[i]);
3. You can iterate over it using for .. of;
4. And you can use some other nice methods provided by an Array.

Note: returning a copy of the array is out of question! It costs linear time, and any updates to the original array do not propagate to the copy!

---

The solution

    get children() { return Object.freeze(Object.create(this._children)); }

    // OR, if you deeply care about performance:
    get children() {
        return this._PUBLIC_children === undefined
            ? (this._PUBLIC_children = Object.freeze(Object.create(this._children)))
            : this._PUBLIC_children;
    }

Done!

1. Object.create: we create an object that inherits from this._children (i.e. has this._children as its __proto__). This alone solves almost the entire problem:
   • It's simple and fast (constant time)
   • You can use anything provided by the Array interface
   • If you modify the returned object, it does not change the original!
2. Object.freeze: however, the fact that you can modify the returned object BUT the changes do not affect the original array is extremely confusing for the user of the class! So, we just freeze it. If he tries to modify it, an exception is thrown (assuming strict mode) and he knows he can't (and why). It's sad no exception is thrown for myFrozenObject[x] = y if you are not in strict mode, but myFrozenObject is not modified anyway, so it's still not-so-weird.

Of course the programmer could bypass it by accessing __proto__, e.g:

someNode.children.__proto__.push(new Node());

But I like to think that in this case they actually know what they are doing and have a good reason to do so.

IMPORTANT: notice that this doesn't work so well for objects: using hasOwnProperty in the for .. in will always return false.

---

UPDATE: using Proxy to solve the same problem for objects

Just for completion: if you have an object instead of an Array you can still solve this problem by using Proxy. Actually, this is a generic solution that should work with any kind of element, but I recommend against (if you can avoid it) due to performance issues:

    get myObject() { return Object.freeze(new Proxy(this._myObject, {})); }

This still returns an object that can't be changed, but keeps all the read-only functionality of it. If you really need, you can drop the Object.freeze and implement the required traps (set, deleteProperty, ...) in the Proxy, but that takes extra effort, and that's why the Object.freeze comes in handy with proxies.

Answer 8

When you're writing a library/framework in JS and you don't want some developer to break your dynamic language creation by re-assigning "internal" or public properties. This is the most obvious use case for immutability.

Answer 9

In my nodejs server environment, I use freeze for the same reason I use 'use strict'. If I have an object that I do not want being extended or modified, I will freeze it. If something attempts to extend or modify my frozen object, I WANT my app to throw an error.

To me this relates to consistent, quality, more secure code.

Also, Chrome is showing significant performance increases working with frozen objects.

Edit: In my most recent project, I'm sending/receiving encrypted data between a government entity. There are a lot of configuration values. I'm using frozen object(s) for these values. Modification of these values could have serious, adverse side effects. Additionally, as I linked previously, Chrome is showing performance advantages with frozen objects, I assume nodejs does as well.

For simplicity, an example would be:

var US_COIN_VALUE = {
        QUARTER: 25,
        DIME: 10,
        NICKEL: 5,
        PENNY: 1
    };

return Object.freeze( US_COIN_VALUE );

There is no reason to modify the values in this example. And enjoy the benefits of speed optimizations.

Answer 10

The only practical use for Object.freeze is during development. For production code, there is absolutely no benefit for freezing/sealing objects.

Silly Typos

It could help you catch this very common problem during development:

if (myObject.someProp = 5) {
    doSomething();
}

In strict mode, this would throw an error if myObject was frozen.

Enforce Coding Protocol / Restriction

It would also help in enforcing a certain protocol in a team, especially with new members who may not have the same coding style as everyone else.

A lot of Java guys like to add a lot of methods to objects to make JS feel more familiar. Freezing objects would prevent them from doing that.

Answer 11

I can think of several places that Object.freeze would come in very handy.

The first real world implementation that could use freeze is when developing an application that requires 'state' on the server to match what's in the browser. For instance, imagine you need to add in a level of permissions to your function calls. If you are working in an application there may be places where a Developer could easily change or overwrite the permission settings without even realizing it (especially if the object were being passed through by reference!). But permissions by and large can never change and error'ing when they are changed is preferred. So in this case, the permissions object could be frozen, thereby limiting developer from mistakenly 'setting' permissions erroneously. The same could be said for user-like data like a login name or email address. These things can be mistakenly or maliciously broken with bad code.

Another typical solution would be in a game loop code. There are many settings of game state that you would want to freeze to retain that the state of the game is kept in sync with the server.

Think of Object.freeze as a way to make an object as a Constant. Anytime you would want to have variable constant, you could have an object constant with freeze for similar reasons.

There are also times where you want to pass immutable objects through functions and data passing, and only allow updating the original object with setters. This can be done by cloning and freezing the object for 'getters' and only updating the original with 'setters'.

Are any of these not valid things? It can also be said that frozen objects could be more performant due to the lack of dynamic variables, but I haven't seen any proof of that yet.

Answer 12

You can use this when you have an object representing a logically immutable data structure, especially if:

• Changing the properties of the object or altering its "duck type" could lead to bad behavior elsewhere in your application
• The object is similar to a mutable type or otherwise looks mutable, and you want programmers to be warned on attempting to change it rather than obtain undefined behavior.

As an API author, this may be exactly the behavior you want. For example, you may have an internally cached structure that represents a canonical server response that you provide to the user of your API by reference but still use internally for a variety of purposes. Your users can reference this structure, but altering it may result in your API having undefined behavior. In this case, you want an exception to be thrown if your users attempt to modify it.

Answer 13

I could see this being useful when you're working with an interactive tool. Rather than:

if ( ! obj.isFrozen() ) {
    obj.x = mouse[0];
    obj.y = mouse[1];
}

You could simply do:

obj.x = mouse[0];
obj.y = mouse[1];

Properties will only update if the object isn't frozen.

Answer 14

The Object.freeze function does the following:

• Makes the object non-extensible, so that new properties cannot be added to it.
• Sets the configurable attribute to false for all properties of the object. When - configurable is false, the property attributes cannot be changed and the property cannot be deleted.
• Sets the writable attribute to false for all data properties of the object. When writable is false, the data property value cannot be changed.

That's the what part, but why would anyone do this?

Well, in the object-oriented paradigm, the notion exists that an existing API contains certain elements that are not intended to be extended, modified, or re-used outside of their current context. The final keyword in various languages is the most suitable analogy of this. Even in languages that are not compiled and therefore easily modified, it still exists, i.e. PHP, and in this case, JavaScript.