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




ecmascript-6 const (5)

Dr.

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

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

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

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

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

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

https://code.i-harness.com


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


ES6 / ES2015 कीवर्ड:

const कीवर्ड का इस्तेमाल ब्लॉक स्कोपेड वैरिएबल (जैसे let साथ घोषित करना) घोषित करने के letconst और 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 को पहले से घोषित किया जा सकता है और फिर असाइन किया जा सकता है।
  2. myConstant साथ घोषित चर myConstant को उसी समय घोषित और असाइन किया जाना है।
  3. जब हम चर myConstant को पुन: सौंपने का प्रयास करते हैं तो हमें निम्नलिखित त्रुटि मिलती है:

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

कैविएट: कास्ट के साथ दिया गया वैरिएबल अभी भी म्यूट है:

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

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

यदि वास्तव में कोई वस्तु Object.freeze() नहीं है तो आपको ऑब्जेक्ट.फ्रीज 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);


जब आप जावास्क्रिप्ट में कुछ 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