File size: 4,393 Bytes
780c9fe |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 |
---
title: Object.isFrozen()
short-title: isFrozen()
slug: Web/JavaScript/Reference/Global_Objects/Object/isFrozen
page-type: javascript-static-method
browser-compat: javascript.builtins.Object.isFrozen
sidebar: jsref
---
The **`Object.isFrozen()`** static method determines if an object is
{{jsxref("Object/freeze", "frozen", "", 1)}}.
{{InteractiveExample("JavaScript Demo: Object.isFrozen()")}}
```js interactive-example
const object = {
foo: 42,
};
console.log(Object.isFrozen(object));
// Expected output: false
Object.freeze(object);
console.log(Object.isFrozen(object));
// Expected output: true
```
## Syntax
```js-nolint
Object.isFrozen(obj)
```
### Parameters
- `obj`
- : The object which should be checked.
### Return value
A {{jsxref("Boolean")}} indicating whether or not the given object is frozen.
## Description
An object is frozen if and only if it is not [extensible](/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/isExtensible), all its properties are non-configurable, and all its data
properties (that is, properties which are not accessor properties with getter or setter
components) are non-writable.
## Examples
### Using Object.isFrozen
```js
// A new object is extensible, so it is not frozen.
Object.isFrozen({}); // false
// An empty object which is not extensible
// is vacuously frozen.
const vacuouslyFrozen = Object.preventExtensions({});
Object.isFrozen(vacuouslyFrozen); // true
// A new object with one property is also extensible,
// ergo not frozen.
const oneProp = { p: 42 };
Object.isFrozen(oneProp); // false
// Preventing extensions to the object still doesn't
// make it frozen, because the property is still
// configurable (and writable).
Object.preventExtensions(oneProp);
Object.isFrozen(oneProp); // false
// Deleting that property makes the object vacuously frozen.
delete oneProp.p;
Object.isFrozen(oneProp); // true
// A non-extensible object with a non-writable
// but still configurable property is not frozen.
const nonWritable = { e: "plep" };
Object.preventExtensions(nonWritable);
Object.defineProperty(nonWritable, "e", {
writable: false,
}); // make non-writable
Object.isFrozen(nonWritable); // false
// Changing that property to non-configurable
// then makes the object frozen.
Object.defineProperty(nonWritable, "e", {
configurable: false,
}); // make non-configurable
Object.isFrozen(nonWritable); // true
// A non-extensible object with a non-configurable
// but still writable property also isn't frozen.
const nonConfigurable = { release: "the kraken!" };
Object.preventExtensions(nonConfigurable);
Object.defineProperty(nonConfigurable, "release", {
configurable: false,
});
Object.isFrozen(nonConfigurable); // false
// Changing that property to non-writable
// then makes the object frozen.
Object.defineProperty(nonConfigurable, "release", {
writable: false,
});
Object.isFrozen(nonConfigurable); // true
// A non-extensible object with a configurable
// accessor property isn't frozen.
const accessor = {
get food() {
return "yum";
},
};
Object.preventExtensions(accessor);
Object.isFrozen(accessor); // false
// When we make that property non-configurable it becomes frozen.
Object.defineProperty(accessor, "food", {
configurable: false,
});
Object.isFrozen(accessor); // true
// But the easiest way for an object to be frozen
// is if Object.freeze has been called on it.
const frozen = { 1: 81 };
Object.isFrozen(frozen); // false
Object.freeze(frozen);
Object.isFrozen(frozen); // true
// By definition, a frozen object is non-extensible.
Object.isExtensible(frozen); // false
// Also by definition, a frozen object is sealed.
Object.isSealed(frozen); // true
```
### Non-object argument
In ES5, if the argument to this method is not an object (a primitive), then it will cause a {{jsxref("TypeError")}}. In ES2015, it will return `true` without any errors if a non-object argument is passed, since primitives are, by definition, immutable.
```js
Object.isFrozen(1);
// TypeError: 1 is not an object (ES5 code)
Object.isFrozen(1);
// true (ES2015 code)
```
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- {{jsxref("Object.freeze()")}}
- {{jsxref("Object.preventExtensions()")}}
- {{jsxref("Object.isExtensible()")}}
- {{jsxref("Object.seal()")}}
- {{jsxref("Object.isSealed()")}}
|