Native objects in JavaScript are already immutable as in you can not change them, only create new objects. Const will not make your object immutable! Try this:

  const foo = {bar: 1}
  foo.bar = 2;

It will only avoid having the pointer re-pointed to another object. It's better to just try avoiding global variables, and use a naming convention like uppercase and/or underscore for constants and global variables.

Const is probably only meant for constants like the name suggests.

I think something like this is pretty safe from reassigning:

  {
    let foo = 1
    ...
  }
  ...

If you want more control over your properties, you can use the ES5 feature "defineproperty" where you can set writeable: false

You can call `Object.freeze()` if you want immutable properties.

    const foo = {bar: 1}

The only thing const about it is the reference `foo` cannot be reassigned:

    foo = something_else; // error

Unlike `const` in C++, `const` in javascript in not very useful in my opinion. `let` is shorter and more readable.

Even that is only true for shallow objects

All true. But what I said was,

> it can help you write stateless code if you assume immutability

> const vs let is an "immutable by default" vs "mutable by default" type of difference

Sorta. I mean you're right but at the same time if you're using const for an object or array then it doesn't really matter without `object.freeze()` because it's not immutable only the reference is and I don't think most JavaScript developers understand that (at least not most of the ones I've run into).

Note that Object.freeze only works for shallow objects