JavaScript const Keyword

2019-01-18 14:05发布

Does the const keyword in JavaScript create an immutable reference to immutable data structures? [I'm assuming that immutable data structures exist in JavaScript.]

For string it appears to do so:

var x = "asdf";
const constantX = x;

alert("before mutation: " + constantX);
x = "mutated"
alert("after mutation: " + constantX);

output:

before mutation: asdf

after mutation: asdf

http://jsfiddle.net/hVJ2a/

8条回答
爱情/是我丢掉的垃圾
2楼-- · 2019-01-18 14:50

Yes that is right. A const would only declare a read-only named constant. Changing its value will have no effect.

Reference for const on MDN:

Const creates a constant that can be global or local to the function in which it is declared. Constants follow the same scope rules as variables.

The value of a constant cannot change through re-assignment, and a constant cannot be re-declared. Because of this, although it is possible to declare a constant without initializing it, it would be useless to do so.

A constant cannot share its name with a function or a variable in the same scope.

Here's the browser compatibility matrix.

查看更多
Summer. ? 凉城
3楼-- · 2019-01-18 14:50

For example:

const basket = [1,2,3];

//Even though the variable is declared as const this one works
basket[0] = 1111;
console.log(basket);

//This one throws an error
basket = "Other primitive type."

查看更多
手持菜刀,她持情操
4楼-- · 2019-01-18 14:52

first you aren't mutating the string, you're reassigning the reference.

You're right that const isn't available in all common browsers. But even if it were, it is not sufficient. const will prevent the reference from being reassigned - but if you have a const reference to a mutable object, you haven't accomplished very much.

const var o = { foo: 'bar' };
o = { foo: 'baz'}; // throws
o.foo = 'baz'; // allowed

So that brings us to your question, does js even have immutable data structures? No, js does not come with them. Immutable datastructures can be coded as a library - and assignment is not even defined, so o.foo = 'baz' doesn't even make sense. You have to write it as const var o2 = o.assoc('foo', 'baz') which will return a brand new object o2 instead of mutating o

But immutable data structures as a library doesn't mean much if nobody uses them. E.g. if angular uses regular javascript datastructures, you have to use them too. Otherwise you'd have to convert between mutable and immutable at the boundary between your code and angular.

opinion follows:

IMO your only practical options for doing real functional programming for production browser apps is to wait around for something like ClojureScript to mature. ClojureScript reboots the library ecosystem, so as libraries get written, they use immutable datastructures by default.

You can of course do half-baked functional programming in javascript using tools like underscore.js and Facebook React, which is what I do for the production webapps I build. But you have to establish immutability by convention, and people are going to mutate things on accident or because they don't know any better and you have to deal with those challenges.

查看更多
别忘想泡老子
5楼-- · 2019-01-18 14:57

You can create CONST like values using ES5 Object.defineProperty. The crummy part is that it must be bound to an object

CONSTS = {};
Object.defineProperty(CONSTS, 'FOO', {
    value: 'bar'
});

CONSTS.FOO = 'derp' // Will throw error in strict mode
delete CONSTS.FOO // will throw error in strict mode
查看更多
别忘想泡老子
6楼-- · 2019-01-18 15:01

const is a proposed feature of ECMAScript(together with a properly block-scoped let it is supposed to replace var and implicit global). ECMAScript Harmony is a grab-bag of ideas for the next versions of ECMAScript.

If you looking for read only variable, you can do like this

var constants = new (function() {
  var x = 200;
  this.getX = function() { return x; };
 })();

You can use like this

constants.getX()
查看更多
贪生不怕死
7楼-- · 2019-01-18 15:03

Wrong. It is not immutable, from the MDN:

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/const

The const declaration creates a read-only reference to a value. It does not mean the value it holds is immutable, just that the variable identifier cannot be reassigned.

查看更多
登录 后发表回答