कीवर्ड 'कॉन्स्ट' मूल्य को अपरिवर्तनीय नहीं बनाता है। इसका क्या मतलब है?

Question

नहीं है स्थिरांक परिभाषा में ES6 तलाश डॉ एक्सल Rauschmayer द्वारा:

constलेट की तरह काम करता है, लेकिन आपके द्वारा घोषित वैरिएबल को तुरंत इनिशियलाइज़ किया जाना चाहिए, ऐसे मान के साथ जिसे बाद में बदला नहीं जा सकता । [...]

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

और फिर वह लिखते हैं

नुकसान: कास्ट मूल्य अपरिवर्तनीय नहीं करता है

const केवल इसका मतलब है कि एक चर का हमेशा एक ही मूल्य होता है, लेकिन इसका यह अर्थ नहीं है कि मूल्य स्वयं है या अपरिवर्तनीय है।

मैं इस गड्ढे से थोड़ा भ्रमित हूं। क्या कोई भी constइस नुकसान के साथ स्पष्ट रूप से परिभाषित कर सकता है ?

Comments

MDN स्पष्टीकरण स्पष्ट है: "स्थिरांक घोषणा एक मूल्य के केवल पढ़ने के लिए संदर्भ बनाता है यह मतलब नहीं है कि मूल्य इसे रखती है, अपरिवर्तनीय है सिर्फ इतना है कि चर पहचानकर्ता पुन: असाइन नहीं किया जा सकता उदाहरण के लिए, मामले में सामग्री एक है।। वस्तु , इसका मतलब है कि वस्तु को अभी भी बदला जा सकता है । " (जोर मेरा)

— गेरार्डो फर्टाडो

इसका अर्थ है कि यदि मूल्य परिवर्तनशील है, (उदाहरण के लिए यदि यह एक वस्तु है) तो आप अभी भी उस वस्तु को बदल सकते हैं (उदाहरण के लिए, गुण जोड़ें, निकालें)।

— फेलिक्स क्लिंग

const x = "immutable"अपरिवर्तनीय है, क्योंकि Stringअपरिवर्तनीय है। constकेवल आश्वासन पर रोक लगाता है।

@ibrahimmahrir: गुजर एक संदर्भ (जावास्क्रिप्ट वस्तुओं के लिए क्या करता है) पास के समान नहीं है द्वारा संदर्भ (जो बाइंडिंग बीच संबंध का वर्णन, मूल्य अप्रासंगिक है)।

— फेलिक्स क्लिंग

@ibrahimmahrir: हाँ, यह मुद्दा है। पास-दर-संदर्भ शब्द का एक बहुत विशिष्ट अर्थ है ।

— फेलिक्स क्लिंग

Answer 1

MDN इसे अच्छी तरह से गाता है:

कॉन्स्ट डिक्लेरेशन एक वैल्यू का रीड-ओनली रेफरेंस बनाता है। इसका मतलब यह नहीं है कि यह जो मूल्य रखता है वह अपरिवर्तनीय है, बस यह कि चर पहचानकर्ता को आश्वस्त नहीं किया जा सकता है। उदाहरण के लिए, यदि सामग्री एक वस्तु है, तो इसका अर्थ है कि वस्तु को अभी भी बदला जा सकता है।

अधिक संक्षेप में: कास्ट एक अपरिवर्तनीय बंधन बनाता है।

दूसरे शब्दों में: const, var की तरह, आपको स्मृति का एक परस्पर चंक देता है जिसमें आप कुछ स्टोर कर रहे हैं। हालाँकि, कॉन्स्टेक्ट यह बताता है कि आपको मेमोरी के उसी चंक का जिक्र करते रहना चाहिए - आप वेरिएबल को मेमोरी के एक अलग चंक पर फिर से असाइन नहीं कर सकते, क्योंकि वेरिएबल रेफरेंस स्थिर है।

इसे घोषित करने के बाद वास्तव में कुछ स्थिर और अपरिवर्तनीय बनाने के लिए, आपको कुछ का उपयोग करने की आवश्यकता है Object.freeze()। हालांकि, यह उथला है और केवल कुंजी / मूल्य जोड़े पर काम करता है। किसी संपूर्ण वस्तु को खाली करने में थोड़ा अधिक प्रयास करना पड़ता है। एक प्रदर्शनकारी तरीके से बार-बार ऐसा करना अभी तक अधिक चुनौतीपूर्ण है। यदि आपको वास्तव में इसके लिए कोई आवश्यकता है, तो मैं Immutable.js जैसी किसी चीज़ की जांच करने की सलाह दूंगा

Comments

C के संदर्भ में: यदि एक सामान्य var xहै a struct Object *x, a const xहै struct Object *const x। सूचक को बदला नहीं जा सकता है; वह जिस चीज की ओर इशारा कर रहा है।

— निधि मोनिका का मुकदमा

Answer 2

जब आप constजावास्क्रिप्ट में कुछ बनाते हैं , तो आप कुछ और का संदर्भ देने के लिए चर को फिर से असाइन नहीं कर सकते हैं। हालाँकि, चर अभी भी एक परिवर्तनशील वस्तु को संदर्भित कर सकता है।

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;

इस तरह के तार और संख्याओं के रूप में आदिम के मामले में, constसमझने में आसान है, क्योंकि आप मूल्यों को नहीं बदलते हैं, बल्कि चर को एक नया मूल्य प्रदान करते हैं।

Comments

यह उत्तर स्वीकृत की तुलना में बहुत बेहतर है। अधिक संक्षिप्त और वास्तविक उदाहरण कोड शामिल हैं। (दूसरे शब्दों में, इस बिंदु पर पहुँच जाता है ।) +1

— jpmc26

Answer 3

rebinding

constऔर letघोषणाओं को नियंत्रित करता है कि पहचानकर्ताओं और मूल्यों के बीच विद्रोह (उर्फ आश्वासन) की अनुमति है या नहीं:

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);

अचल स्थिति

अपरिवर्तनशीलता को प्रकार के स्तर पर नियंत्रित किया जाता है। Objectएक परिवर्तनशील प्रकार है, जबकि Stringएक अपरिवर्तनीय प्रकार है:

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

Answer 4

const का अर्थ है: आप प्रारंभ में दिए गए मान को बदल नहीं सकते।

सबसे पहले, परिभाषित करें, जेएस में एक मूल्य क्या है । मूल्य हो सकते हैं: बूलियन, स्ट्रिंग्स, संख्या, ऑब्जेक्ट, फ़ंक्शन और अपरिभाषित मान।

जैसे: लोग आपको अपने नाम से बुला रहे हैं, यह नहीं बदल रहा है। हालांकि, आप अपने कपड़े बदलते हैं। लोगों और आप के बीच का बंधन आपका नाम है। बाकी बदल सकते हैं। अजीब उदाहरण के लिए क्षमा करें।

तो, मैं आपको कुछ उदाहरण देता हूं:

// 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

जब तक आप देख सकते हैं, जब तक कि आप "पहले" असाइन किए गए मान को एक कास्ट में नहीं बदल रहे हैं , कोई त्रुटि नहीं है। जब भी आप पहले असाइन किए गए मान को किसी और चीज़ में बदलने की कोशिश करते हैं, तो यह क्रोधित हो जाता है, और यह एक त्रुटि देता है।

तो, यह दूसरी बात है जिसका आप उपयोग करते समय जान सकते हैं const। जो है, उसे इसकी घोषणा पर एक मूल्य के लिए आरंभीकृत किया जाना चाहिए या यह गुस्सा होगा।

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

Answer 5

ES6/ ES2015 constकीवर्ड:

constकीवर्ड (साथ की घोषणा की तरह एक ब्लॉक दायरे वाले चर घोषित करने के लिए प्रयोग किया जाता है let)। के साथ एक चर घोषित करने के बीच का अंतर constऔर letवह इस प्रकार है:

1. घोषित चर को पुन: असाइनconst नहीं किया जा सकता है ।
2. एक चर के साथ घोषित constकिया जाना है सौंपा जब घोषित । यह पिछले बिंदु का एक तार्किक परिणाम है क्योंकि घोषित किए गए एक चर constको पुन: असाइन नहीं किया जा सकता है, इसीलिए हमें इसे एक बार ठीक उसी समय असाइन करना होगा जब हम चर घोषित करते हैं ।

उदाहरण:

// 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;

उपरोक्त उदाहरण में हम निम्नलिखित देख सकते हैं:

1. के myVariableसाथ घोषित चर letपहले घोषित किया जा सकता है और फिर सौंपा जा सकता है।
2. इसके myConstantसाथ घोषित चर constको उसी समय घोषित और असाइन किया जाना है।
3. जब हम चर को पुनः myConstantप्राप्त करने का प्रयास करते हैं तो हमें निम्न त्रुटि मिलती है:

अनियोजित टाइपरोर: निरंतर चर के लिए असाइनमेंट

कैविएट: चर के साथ सौंपा constअभी भी परिवर्तनशील है:

एक चर के साथ घोषित किया constजा सकता है, यह अभी भी पारस्परिक नहीं है । परिवर्तनशील होने का मतलब है कि डेटा संरचना (ऑब्जेक्ट, सरणी, मैप, आदि) जो constअभी भी चर को सौंपा गया था, उसे बदला जा सकता है (यानी उत्परिवर्तित)। उत्परिवर्तन के उदाहरण हैं:

1. किसी वस्तु की संपत्ति को जोड़ना / हटाना / बदलना
2. किसी विशिष्ट सरणी इंडेक्स पर किसी सरणी का मान बदलना

अगर वास्तव में कोई वस्तु आपस में मेल नहीं खाती है तो आपको कुछ उपयोग करना होगा Object.freeze()। यह एक विधि है जो एक वस्तु को जमा देती है। एक जमी हुई वस्तु को अब बदला नहीं जा सकता है और कोई नई संपत्ति नहीं जोड़ी जा सकती है।

उदाहरण:

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);