• Skip to main content
  • Skip to search
  • Skip to select language
HTML

Structure of content on the web

  • Web APIs

    Interfaces for building web applications

  • Learn
    • CSS

      Learn to style content using CSS

    • Overview

      A customized MDN experience

    • FAQ

      Frequently asked questions about MDN Plus

  • HTTP Observatory

    Scan a website for free

  • JavaScript
  • freeze()
      • Deutsch
      • Español
      • Français
      • 日本語
      • 한국어
      • Português (do Brasil)
      • Русский
      • 中文 (简体)
      • 正體中文 (繁體)

    In this article

    • Try it
    • Syntax
    • Description
    • Examples
    • Specifications
    • Browser compatibility
    • See also
    1. assign()
    2. entries()
    3. getOwnPropertyDescriptors()
    4. groupBy()
    5. isFrozen()
    6. seal()
    7. __defineGetter__() Deprecated
    8. __defineSetter__() Deprecated
    9. __lookupGetter__() Deprecated
    10. __lookupSetter__() Deprecated
    11. toLocaleString()
    12. __proto__ Deprecated
    13. bind()
    14. displayName Non-standard
    15. arguments Non-standard Deprecated
    16. caller Non-standard Deprecated
  • Instance methods
    1. __defineGetter__() Deprecated
    2. __defineSetter__() Deprecated
    3. __lookupGetter__() Deprecated
    4. __lookupSetter__() Deprecated
    5. toLocaleString()
    6. __proto__ Deprecated
    7. prevents extensions and makes existing properties non-writable and non-configurable. A frozen object can no longer be changed: new properties cannot be added, existing properties cannot be removed, their enumerability, configurability, writability, or value cannot be changed, and the object's prototype cannot be re-assigned. freeze() returns the same object that was passed in.

      Freezing an object is the highest integrity level that JavaScript provides.

  • Try it

    const obj = {
      prop: 42,
    };
    
    Object.freeze(obj);
    
    obj.prop = 33;
    / Throws an error in strict mode
    
    console.log(obj.prop);
    / Expected output: 42
    

    Syntax

    js
    Object.freeze(obj)
    

    Parameters

    obj

    The object to freeze.

    Return value

    The object that was passed to the function.

    Description

    Freezing an object is equivalent to strict mode).

    For data properties of a frozen object, their values cannot be changed since the writable and configurable attributes are set to false. Accessor properties (getters and setters) work the same — the property value returned by the getter may still change, and the setter can still be called without throwing errors when setting the property. Note that values that are objects can still be modified, unless they are also frozen. As an object, an array can be frozen; after doing so, its elements cannot be altered and no elements can be added to or removed from the array.

    Private elements are not properties and do not have the concept of property descriptors. Freezing an object with private elements does not prevent the values of these private elements from being changed. (Freezing objects is usually meant as a security measure against external code, but external code cannot access private elements anyway.) Private elements cannot be added or removed from the object, whether the object is frozen or not.

    freeze() returns the same object that was passed into the function. It does not create a frozen copy.

    A TypeError, as they are views over memory and will definitely cause other possible issues:

    js
    Object.freeze(new Uint8Array(0)); / No elements
    / Uint8Array []
    
    Object.freeze(new Uint8Array(1)); / Has elements
    / TypeError: Cannot freeze array buffer views with elements
    
    Object.freeze(new DataView(new ArrayBuffer(32))); / No elements
    / DataView {}
    
    Object.freeze(new Float64Array(new ArrayBuffer(64), 63, 0)); / No elements
    / Float64Array []
    
    Object.freeze(new Float64Array(new ArrayBuffer(64), 32, 2)); / Has elements
    / TypeError: Cannot freeze array buffer views with elements
    

    Note that as the standard three properties (buf.byteLength, buf.byteOffset and buf.buffer) are read-only (as are those of an SharedArrayBuffer), there is no reason for attempting to freeze these properties.

    Unlike Object.seal(), existing properties in objects frozen with Object.freeze() are made immutable and data properties cannot be re-assigned.

    Examples

    Freezing objects

    js
    const obj = {
      prop() {},
      foo: "bar",
    };
    
    / Before freezing: new properties may be added,
    / and existing properties may be changed or removed
    obj.foo = "baz";
    obj.lumpy = "woof";
    delete obj.prop;
    
    / Freeze.
    const o = Object.freeze(obj);
    
    / The return value is just the same object we passed in.
    o === obj; / true
    
    / The object has become frozen.
    Object.isFrozen(obj); / === true
    
    / Now any changes will fail
    obj.foo = "quux"; / silently does nothing
    / silently doesn't add the property
    obj.quaxxor = "the friendly duck";
    
    / In strict mode such attempts will throw TypeErrors
    function fail() {
      "use strict";
      obj.foo = "sparky"; / throws a TypeError
      delete obj.foo; / throws a TypeError
      delete obj.quaxxor; / returns true since attribute 'quaxxor' was never added
      obj.sparky = "arf"; / throws a TypeError
    }
    
    fail();
    
    / Attempted changes through Object.defineProperty;
    / both statements below throw a TypeError.
    Object.defineProperty(obj, "ohai", { value: 17 });
    Object.defineProperty(obj, "foo", { value: "eit" });
    
    / It's also impossible to change the prototype
    / both statements below will throw a TypeError.
    Object.setPrototypeOf(obj, { x: 20 });
    obj.__proto__ = { x: 20 };
    

    Freezing arrays

    js
    const a = [0];
    Object.freeze(a); / The array cannot be modified now.
    
    a[0] = 1; / fails silently
    
    / In strict mode such attempt will throw a TypeError
    function fail() {
      "use strict";
      a[0] = 1;
    }
    
    fail();
    
    / Attempted to push
    a.push(2); / throws a TypeError
    

    The object being frozen is immutable. However, it is not necessarily constant. The following example shows that a frozen object is not constant (freeze is shallow).

    js
    const obj1 = {
      internal: {},
    };
    
    Object.freeze(obj1);
    obj1.internal.a = "aValue";
    
    obj1.internal.a; / 'aValue'
    

    To be a constant object, the entire reference graph (direct and indirect references to other objects) must reference only immutable frozen objects. The object being frozen is said to be immutable because the entire object state (values and references to other objects) within the whole object is fixed. Note that strings, numbers, and booleans are always immutable and that Functions and Arrays are objects.

    Deep freezing

    The result of calling Object.freeze(object) only applies to the immediate properties of object itself and will prevent future property addition, removal or value re-assignment operations only on object. If the value of those properties are objects themselves, those objects are not frozen and may be the target of property addition, removal or value re-assignment operations.

    js
    const employee = {
      name: "Mayank",
      designation: "Developer",
      address: {
        street: "Rohini",
        city: "Delhi",
      },
    };
    
    Object.freeze(employee);
    
    employee.name = "Dummy"; / fails silently in non-strict mode
    employee.address.city = "Noida"; / attributes of child object can be modified
    
    console.log(employee.address.city); / "Noida"
    

    To make an object immutable, recursively freeze each non-primitive property (deep freeze). Use the pattern on a case-by-case basis based on your design when you know the object contains no cycles in the reference graph, otherwise an endless loop will be triggered. For example, functions created with the arrow functions, can still be frozen.

    An enhancement to deepFreeze() would be to store the objects it has already visited, so you can suppress calling deepFreeze() recursively when an object is in the process of being made immutable. For one example, see window.

    js
    function deepFreeze(object) {
      / Retrieve the property names defined on object
      const propNames = Reflect.ownKeys(object);
    
      / Freeze properties before freezing self
      for (const name of propNames) {
        const value = object[name];
    
        if ((value && typeof value === "object") || typeof value === "function") {
          deepFreeze(value);
        }
      }
    
      return Object.freeze(object);
    }
    
    const obj2 = {
      internal: {
        a: null,
      },
    };
    
    deepFreeze(obj2);
    
    obj2.internal.a = "anotherValue"; / fails silently in non-strict mode
    obj2.internal.a; / null
    

    Specifications

    Specification
    ECMAScript® 2026 Language Specification
    # sec-object.freeze

    Browser compatibility

    See also

    • Object.isFrozen()
    • Object.preventExtensions()
    • Object.isExtensible()
    • Object.seal()
    • Object.isSealed()

    Help improve MDN

    Follow Lee on X/Twitter - Father, Husband, Serial builder creating AI, crypto, games & web tools. We are friends :) AI Will Come To Life!

    Check out: eBank.nz (Art Generator) | Netwrck.com (AI Tools) | Text-Generator.io (AI API) | BitBank.nz (Crypto AI) | ReadingTime (Kids Reading) | RewordGame | BigMultiplayerChess | WebFiddle | How.nz | Helix AI Assistant