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




ecmascript-6 const (4)

Dr.

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

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

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

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

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

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


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 orphan;                    // error
const rich = 0;                  // no error

rebinding

कॉन्स्टेंट और मानों के बीच विद्रोह (उर्फ पुनर्मूल्यांकन) की अनुमति देते हैं

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


जब आप जावास्क्रिप्ट में कुछ 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 को समझना आसान है, क्योंकि आप मूल्यों को म्यूट नहीं करते हैं, बल्कि वेरिएबल को एक नया मान देते हैं।


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

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

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

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

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





const