For freezing all properties in an object deeply (ES2015+):

// Function to freeze an object recursively
const deepFreeze = x => {
  Object.freeze(x)
  Object.values(x).forEach(deepFreeze)
}

In case of circular references:

// Function to freeze an object with circular references recursively
const deepFreeze = x => {
  Object.freeze(x)
  Object.values(x).filter(x => !Object.isFrozen(x)).forEach(deepFreeze)
}

If you also need to freeze shallow-frozen objects (might be slower):

// Recursively deep freeze an object with circular references and frozen objects
const deepFreeze = (x, frozen = []) => {
  if (frozen.includes(x)) return null
  frozen.push(x)
  Object.freeze(x)
  Object.values(x).forEach(x => deepFreeze(x, frozen))
}

In short; two-liner version:

const deepFreeze = (x, frozen = []) => frozen.includes(x) ||
  frozen.push(Object.freeze(x)) && Object.values(x).forEach(x => deepFreeze(x, frozen))

This code snippet showcases a recursive function called deepFreeze that utilizes Object.freeze() to make an object and its nested properties immutable. It prevents any modifications to the object after freezing it.

function deepFreeze(object) {
  // Get all property names of the object
  const propNames = Reflect.ownKeys(object);

  // Freeze object properties before freezing the object itself  
  for (const name of propNames) {
    const value = object[name];

    if ((value && typeof value === "object") || typeof value === "function") {
      deepFreeze(value);
    }
  }

  return Object.freeze(object);
}

let exampleObj = { arr: [1,2,3]}; 
deepFreeze(exampleObj);
exampleObj.arr.push(4); // This would throw a TypeError since the object is frozen

Appreciate your attention to this code :)

Take a look at deep-freeze, a tool that performs recursive Object.freeze() on objects.

This is how they have implemented it:

function deepFreeze (o) {
  Object.freeze(o);

  Object.getOwnPropertyNames(o).forEach(function (prop) {
    if (o.hasOwnProperty(prop)
    && o[prop] !== null
    && (typeof o[prop] === "object" || typeof o[prop] === "function")
    && !Object.isFrozen(o[prop])) {
      deepFreeze(o[prop]);
    }
  });

  return o;
};

When referring to MDN, you may come across a function that hints at deepFreeze functionality, but it lacks stack safety. Personally, I have an ES5 version for asynchronous iteration. For ES6, the following code snippet might be useful, although I haven't extensively tested it:

function deepFreeze(o,promises,oldestParent){
    promises = promises || [];
    oldestParent = oldestParent || o;
    promises.push(
        Promise.resolve().then(function(){
            Object.values(Object.freeze(o)).forEach(function(d,i){
                typeof d === "object" && deepFreeze(d,promises,oldestParent);
            });
            return oldestParent;
        })
    );
    return Promise.all(promises).then((a)=>a[0]);
}

var o = {a:3,b:{test:1,test2:2},c:1};
deepFreeze(o).then(function(x){console.log(x)}); //o is deep frozen

Important Note: This code assumes that the properties of your object are enumerable. If they are not, consider using getOwnPropertyNames instead.

One way to achieve immutability in objects is by utilizing a Proxy object. Rather than directly freezing the object, you can create a proxy that restricts any attempts to modify it:

const makeImmutable = obj => {
  if (obj === null || typeof obj !== 'object') return obj
  return new Proxy(obj, {
    get(target, property) {
      return makeImmutable(target[property])
    },
    set() {
      throw new Error(`Cannot modify property of immutable object`)
    }
  })
}

If you're looking to explore new options, why not check out immer? It's a fantastic tool for constructing immutable JavaScript data structures.

For your specific situation, you could try the following:

const a = produce({ arr: [1,2,3] }, () => {})

The use of () => {} is crucial here because produce requires a function that modifies the initial parameter, even though no changes are needed in this case.

If your goal is simply to freeze a few data structures and immutability isn't a priority elsewhere, it may not be necessary to add another external library like immer. The solutions mentioned above should suffice.

In my opinion, none of the existing answers here or in the related question offer a solution that achieves both accuracy and efficiency simultaneously.

I have customized the approach based on MDN's documentation of Object.freeze() to handle circular references seamlessly.

function deepFreeze(object) {
  const occurrences = new WeakSet();

  function deepFreezeCircularlySafe(object) {
    if (occurrences.has(object)) {
      return object;
    }
    occurrences.add(object);

    // Get the property names defined on the object
    const propNames = Reflect.ownKeys(object);

    // Freeze properties before freezing the object itself
    for (const name of propNames) {
      const value = object[name];

      if ((value && typeof value === "object") || typeof value === "function") {
        deepFreezeCircularlySafe(value);
      }
    }

    return Object.freeze(object);
  }

  return deepFreezeCircularlySafe(object);
}

The commonly recommended solution using Object.isFrozen() may produce incorrect results when some nodes were already frozen prior to invoking deepFreeze(). Therefore, it cannot guarantee complete freezing of all sub-nodes.