const with Objects and Arrays in JavaScript

const with Objects and Arrays in JavaScript

A common misconception: const makes objects and arrays immutable. It does not. const only prevents reassignment of the variable binding.

What const Prevents

const obj = { a: 1 };
obj = { b: 2 }; // TypeError: Assignment to constant variable
``
You cannot reassign `obj` to a new object. The binding is fixed.

### What `const` Does NOT Prevent

```js
const obj = { a: 1 };
obj.a = 2;       // OK (mutating a property)
obj.b = 3;       // OK (adding a property)
delete obj.a;    // OK (removing a property)

const arr = [1, 2, 3];
arr.push(4);     // OK
arr[0] = 99;     // OK
arr.pop();       // OK
``
Mutating the object or array is allowed. `const` is about the binding, not the value.

### `Object.freeze` for Shallow Immutability

```js
const obj = Object.freeze({ a: 1 });
obj.a = 2;       // silently fails (or throws in strict mode)
obj.b = 3;       // silently fails
console.log(obj); // { a: 1 }
``
`Object.freeze` prevents property changes, additions, and deletions. But it is **shallow**: nested objects can still be mutated.

```js
const obj = Object.freeze({ nested: { a: 1 } });
obj.nested.a = 2; // OK (freeze is shallow)
console.log(obj.nested.a); // 2
``
### Deep Freeze

For deep immutability, recursively freeze:

```js
function deepFreeze(obj) {
  Object.keys(obj).forEach(key => {
    if (typeof obj[key] === "object" && obj[key] !== null) {
      deepFreeze(obj[key]);
    }
  });
  return Object.freeze(obj);
}
``
### `const` + `Object.freeze` Together

```js
const config = Object.freeze({
  apiUrl: "https://api.example.com",
  timeout: 5000,
});
``
This prevents both reassignment (`const`) and mutation (`freeze`). It is a common pattern for configuration objects.

### The Takeaway

`const` prevents reassignment of the binding, not mutation of the value. Objects and arrays can still be mutated. Use `Object.freeze` for shallow immutability, or a deep freeze for nested structures. Use `const` + `freeze` for configuration that should never change.