Es gibt die const-Definition in Exploring ES6 von Dr. Axel Rauschmayer:

constfunktioniert wie let, aber die von Ihnen deklarierte Variable muss sofort initialisiert werden, mit einem Wert, der danach nicht mehr geändert werden kann . […]

const bar = 123;
bar = 456;  // TypeError: `bar` is read-only

und dann schreibt er

Fallstricke: const macht den Wert nicht unveränderlich

const bedeutet nur, dass eine Variable immer den gleichen Wert hat, aber nicht, dass der Wert selbst unveränderlich ist oder wird.

Ich bin wenig verwirrt mit dieser Falle. Kann jemand das constmit dieser Falle klar definieren ?

MDN fasst es gut zusammen:

Die const-Deklaration erstellt einen schreibgeschützten Verweis auf einen Wert. Dies bedeutet nicht, dass der darin enthaltene Wert unveränderlich ist, sondern dass die Variablenkennung nicht neu zugewiesen werden kann. Wenn der Inhalt beispielsweise ein Objekt ist, bedeutet dies, dass das Objekt selbst noch geändert werden kann.

Genauer gesagt: const erstellt eine unveränderliche Bindung.

Mit anderen Worten: const gibt Ihnen wie var einen veränderlichen Speicherblock, in dem Sie etwas speichern. Const schreibt jedoch vor, dass Sie sich weiterhin auf denselben Speicherabschnitt beziehen müssen. Sie können die Variable keinem anderen Speicherabschnitt zuweisen, da die Variablenreferenz konstant ist.

Um etwas wirklich konstant und unveränderlich zu machen, nachdem Sie es deklariert haben, müssen Sie so etwas wie verwenden Object.freeze(). Dies ist jedoch flach und funktioniert nur bei Schlüssel / Wert-Paaren. Das Einfrieren eines gesamten Objekts erfordert etwas mehr Aufwand. Dies immer wieder auf performante Weise zu tun, ist noch schwieriger. Wenn Sie das wirklich brauchen, würde ich empfehlen, sich etwas wie Immutable.js anzuschauen

Wenn Sie etwas constin JavaScript erstellen, können Sie die Variable selbst nicht neu zuweisen, um auf etwas anderes zu verweisen. Die Variable kann jedoch weiterhin auf ein veränderbares Objekt verweisen.

const x = {a: 123};

// This is not allowed.  This would reassign `x` itself to refer to a
// different object.
x = {b: 456};

// This, however, is allowed.  This would mutate the object `x` refers to,
// but `x` itself hasn't been reassigned to refer to something else.
x.a = 456;

Bei Grundelementen wie Zeichenfolgen und Zahlen constist dies einfacher zu verstehen, da Sie die Werte nicht mutieren, sondern der Variablen stattdessen einen neuen Wert zuweisen.

Nachbinden

constund letDeklarationen steuern, ob Neubindungen (auch als Neuzuweisungen bezeichnet) zwischen Bezeichnern und Werten zulässig sind:

const x = "initial value";
let y = "initial value";

// rebinding/reassignment

try { x = "reassignment" } catch(e) { console.log(x) } // fails

y = "reassignment"; // succeeds
console.log(y);

Unveränderlichkeit

Die Unveränderlichkeit wird auf Typebene kontrolliert. Objectist ein veränderlicher Typ, während Stringes sich um einen unveränderlichen Typ handelt:

const o = {mutable: true};
const x = "immutable";

// mutations

o.foo = true; // succeeds
x[0] = "I"; // fails

console.log(o); // {mutable: true, foo: true}
console.log(x); // immutable

const bedeutet: Sie können den ursprünglich zugewiesenen Wert nicht ändern.

Definieren Sie zunächst, was ein Wert in js ist. Der Wert kann sein: Boolesche Werte, Zeichenfolgen, Zahlen, Objekte, Funktionen und undefinierte Werte.

Wie: Leute rufen dich mit deinem Namen an, es ändert sich nicht. Sie ziehen sich jedoch um. Die Bindung zwischen den Menschen und Ihnen ist Ihr Name. Der Rest kann sich ändern. Entschuldigung für das seltsame Beispiel.

Lassen Sie mich einige Beispiele nennen:

// boolean
const isItOn = true;
isItOn = false;           // error

// number
const counter = 0;
counter++;                // error

// string
const name = 'edison';
name = 'tesla';           // error

// objects
const fullname = {
  name: 'albert',
  lastname: 'einstein'
};

fullname = {              // error
  name: 'werner',
  lastname: 'heisenberg'
};

// NOW LOOK AT THIS:
//
// works because, you didn't change the "value" of fullname
// you changed the value inside of it!
fullname.name = 'hermann';

const increase = aNumber => ++aNumber;
increase = aNumber => aNumber + 1;      // error

// NOW LOOK AT THIS:
//
// no error because now you're not changing the value
// which is the decrease function itself. function is a
// value too.
let anotherNumber = 3;
const decrease = () => --anotherNumber;

anotherNumber = 10;             // no error
decrease();                     // outputs 9

const chaos = undefined;
chaos = 'let there be light'    // error

const weird = NaN;
weird = 0                       // error

Wie Sie sehen können , ist dies kein Fehler , es sei denn, Sie ändern den "ersten" zugewiesenen Wert nicht in eine Konstante. Wenn Sie versuchen, den ersten zugewiesenen Wert in einen anderen zu ändern, wird er wütend und gibt einen Fehler aus.

Dies ist also das zweite, was Sie bei der Verwendung wissen könnten const. Das heißt, es sollte auf einen Wert in seiner Deklaration initialisiert werden, sonst wird es wütend.

const orphan;                    // error
const rich = 0;                  // no error

ES6/ ES2015 constSchlüsselwort:

Das constSchlüsselwort wird verwendet, um eine Variable mit Blockbereich zu deklarieren (wie beim Deklarieren mit let). Der Unterschied zwischen der Deklaration einer Variablen mit constund letist folgender:

1. Eine deklarierte Variable constkann nicht neu zugewiesen werden .
2. Eine mit deklarierte Variable const muss zugewiesen , wenn erklärt . Dies ist eine logische Konsequenz des vorherigen Punktes, da eine mit deklarierte Variable constnicht neu zugewiesen werden kann. Deshalb müssen wir sie genau einmal zuweisen, wenn wir die Variable deklarieren .

Beispiel:

// we declare variable myVariable
let myVariable;

// first assignment
myVariable = 'First assingment';
// additional assignment
myVariable = 'Second assignment';

// we have to declare AND initialize the variable at the same time
const myConstant = 3.14;

// This will throw an error
myConstant = 12;

Im obigen Beispiel können wir Folgendes beobachten:

1. Die mit myVariabledeklarierte Variable letkann zuerst deklariert und dann zugewiesen werden.
2. Die Variable myConstant deklarierteconst muss gleichzeitig deklariert und zugewiesen werden.
3. Wenn wir versuchen, die Variable neu zuzuweisen myConstant zuzuweisen, wird der folgende Fehler angezeigt:

Nicht erfasster TypeError: Zuordnung zur konstanten Variablen

Vorsichtsmaßnahme: Die mit zugewiesene Variable const ist weiterhin veränderbar:

Eine mit consteinfach deklarierte Variable kann nicht neu zugewiesen werden, sie ist jedoch weiterhin veränderbar . Veränderbar zu sein bedeutet, dass die Datenvariable (Objekt, Array, Karte usw.), die der constVariablen zugewiesen wurde, noch geändert (dh mutiert) werden kann. Beispiele für Mutationen sind:

1. Hinzufügen / Löschen / Ändern einer Eigenschaft eines Objekts
2. Ändern des Werts eines Arrays an einem bestimmten Array-Index

Wenn Sie wirklich möchten, dass ein Objekt nicht veränderbar ist, müssen Sie so etwas wie verwenden Object.freeze() . Dies ist eine Methode, die ein Objekt einfriert. Ein eingefrorenes Objekt kann nicht mehr geändert und es können keine neuen Eigenschaften hinzugefügt werden.

Beispiel:

const obj = {prop1: 1};

obj.prop1 = 2;
obj.prop2 = 2;

console.log(obj);

// We freeze the object here
Object.freeze(obj);

obj.prop1 = 5;
delete obj.prop2;

// The object was frozen and thus not mutated
console.log(obj);