प्रॉपर्टी डिस्क्रिप्टर

ऑब्जेक्ट प्रॉपर्टी के साथ आपके ज़्यादातर इंटरैक्शन की सरफ़ेस-लेवल, जिसमें ऑब्जेक्ट लिटरल बनाना, सेटिंग और ऐक्सेस करना शामिल है प्रॉपर्टी की वैल्यू सेट करने के लिए करते हैं. हालांकि, आप इसकी किसी भी प्रॉपर्टी को उन प्रॉपर्टी को ऐक्सेस करने के तरीके पर बारीकी से कंट्रोल करने के लिए एक ऑब्जेक्ट, बदला हुआ और परिभाषित किया गया है. हर ऑब्जेक्ट प्रॉपर्टी में, न दिखने वाले एट्रिब्यूट का एक सेट होता है जिसमें उस प्रॉपर्टी से जुड़ा मेटाडेटा शामिल है, जिसे "प्रॉपर्टी" कहा जाता है डिस्क्रिप्टर."

किसी भी प्रॉपर्टी के साथ दो तरह के डिस्क्रिप्टर जुड़े होते हैं: डेटा डिस्क्रिप्टर और ऐक्सेसर डिस्क्रिप्टर. डेटा डिस्क्रिप्टर में शामिल है वे कुंजी और वैल्यू पेयर जिनमें किसी प्रॉपर्टी की वैल्यू होती है. भले ही, वह पेयर में वैल्यू ऐसी होती है जिसे लिखा जा सकता है, कॉन्फ़िगर किया जा सकता है या उसकी गिनती की जा सकती है. ऐक्सेसर डिस्क्रिप्टर में यह शामिल है फ़ंक्शन, जो किसी प्रॉपर्टी को सेट करने, बदलने या ऐक्सेस करने पर काम करते हैं.

इनमें से हर प्रॉपर्टी उसी शॉर्टहैंड का इस्तेमाल करती है जो [[Prototype]] करता है. इससे पता चलता है कि कि इन प्रॉपर्टी को सीधे ऐक्सेस नहीं किया जाना चाहिए. इसके बजाय, किसी प्रॉपर्टी की प्रॉपर्टी को तय करने या उसमें बदलाव करने के लिए, Object.defineProperty() स्टैटिक तरीका ऑब्जेक्ट है. Object.defineProperty() तीन आर्ग्युमेंट स्वीकार करता है: कार्रवाई करने के लिए ऑब्जेक्ट, बनाई जाने वाली या संशोधित की जाने वाली प्रॉपर्टी कुंजी और एक ऑब्जेक्ट जिसमें बनाई या बदली जा रही प्रॉपर्टी से जुड़े डिस्क्रिप्टर.

डिफ़ॉल्ट रूप से, Object.defineProperty() का इस्तेमाल करके बनाई गई प्रॉपर्टी लिखने, गिनती करने या कॉन्फ़िगर करने लायक नहीं होते. हालांकि, आपने जो प्रॉपर्टी बनाई हैं या तो लिटरल वैल्यू वाले ऑब्जेक्ट के हिस्से के रूप में या डॉट या ब्रैकेट नोटेशन का इस्तेमाल करके लिखने लायक, गिने जा सकने वाले, और कॉन्फ़िगर किए जा सकने वाले होने चाहिए.

const myObj = {};

Object.defineProperty(myObj, 'myProperty', {
  value: true,
  writable: false
});

myObj.myProperty;
> true

myObj.myProperty = false;

myObj.myProperty;
> true

उदाहरण के लिए, जब [[Writable]] में false वैल्यू होती है, तो नई वैल्यू सेट करने की कोशिश की जाती है संबद्ध प्रॉपर्टी के लिए चुपचाप सख्त मोड के बाहर विफल हो जाता है और एक स्ट्रिक्ट मोड में गड़बड़ी:

{
    const myObj = {};

    Object.defineProperty(myObj, 'myProperty', {
    value: true,
    writable: false
    });

    myObj.myProperty = false;
    myObj.myProperty;
}
> true

(function () {
    "use strict";
    const myObj = {};

    Object.defineProperty(myObj, 'myProperty', {
    value: true,
    writable: false
    });

    myObj.myProperty = false;
    myObj.myProperty;
}());\
> Uncaught TypeError: "myProperty" is read-only

डिस्क्रिप्टर का असरदार तरीके से इस्तेमाल करना काफ़ी ऐडवांस कॉन्सेप्ट है, लेकिन किसी ऑब्जेक्ट के अंदरूनी स्ट्रक्चर को समझने के लिए, वे सिंटैक्स होते हैं जो ऑब्जेक्ट के साथ ज़्यादा सामान्य तरीकों से काम करते हैं. उदाहरण के लिए, Object.create() स्टैटिक तरीके का इस्तेमाल करने पर, ये कॉन्सेप्ट लागू होते हैं जो आपको नए डाइग्नोस्टिक टूल से जुड़े किसी भी प्रोटोटाइप पर पूरा कंट्रोल देता है ऑब्जेक्ट है.

Object.create() किसी मौजूदा ऑब्जेक्ट का इस्तेमाल करके, एक नया ऑब्जेक्ट बनाता है प्रोटोटाइप बनाना चाहिए. इससे नया ऑब्जेक्ट दूसरे ऑब्जेक्ट से प्रॉपर्टी और मेथड इनहेरिट करता है उपयोगकर्ता के तय किए गए ऑब्जेक्ट की तरह ही ऑब्जेक्ट से प्रॉपर्टी इनहेरिट की जाती हैं JavaScript का बिल्ट-इन Object प्रोटोटाइप. जब आप इसके साथ Object.create() शुरू करते हैं एक तर्क के रूप में है, तो यह पास किए गए ऑब्जेक्ट के साथ एक रिक्त ऑब्जेक्ट बनाता है उसका प्रोटोटाइप.

const myCustomPrototype = {
  'myInheritedProp': 10
};

const newObject = Object.create( myCustomPrototype );

newObject;
> Object {  }
<prototype>: Object { myInheritedProp: 10 }
  myInheritedProp: 10
  <prototype>: Object { … }

Object.create नया बनाया गया ऑब्जेक्ट जो Object.defineProperty() से मिलते-जुलते सिंटैक्स का इस्तेमाल करके बनाया गया है— यानी, डिस्क्रिप्टर एट्रिब्यूट के सेट के लिए ऑब्जेक्ट मैपिंग की:

const myCustomPrototype = {
  'myInheritedProp': 10
};

const myObj = Object.create( myCustomPrototype, {
        myProperty: {
            value: "The new property value.",
            writable: true,
            configurable: true
        }
  });

myObj;
> Object { … }
    myProperty: "The new property value."
    <prototype>: Object { myInheritedProp: 10 }

इस उदाहरण में, नया ऑब्जेक्ट (myObj) एक लिटरल ऑब्जेक्ट का इस्तेमाल करता है (myCustomPrototype) इसका प्रोटोटाइप है, जिसमें इनहेरिट की गई Object.prototype की वजह से, इनहेरिट किए गए प्रोटोटाइप की एक सीरीज़ तैयार होती है. इस सीरीज़ को प्रोटोटाइप चेन. हर ऑब्जेक्ट का एक प्रोटोटाइप होता है, चाहे वह असाइन किया गया हो या इनहेरिट किया गया हो, जिसका खुद का एक असाइन किया गया या इनहेरिट किया गया प्रोटोटाइप है. यह चेन null का प्रोटोटाइप, जिसका अपना कोई प्रोटोटाइप नहीं है.

const myPrototype = {
  'protoProp': 10
};

const newObject = Object.setPrototypeOf( { 'objProp' : true }, myPrototype );

newObject;
> Object { objProp: true }
    objProp: true
    <prototype>: Object { protoProp: 10 }
        protoProp: 10
        <prototype>: Object { … }

वैल्यू के प्रोटोटाइप में शामिल प्रॉपर्टी, "टॉप लेवल" पर उपलब्ध होती हैं इनमें, सीधे प्रोटोटाइप प्रॉपर्टी को ऐक्सेस करने की ज़रूरत नहीं होती:

const objectLiteral = {
    "value" : true
};

objectLiteral;
> Object { value: true }
    value: true
    <prototype>: Object { … }

objectLiteral.toString();
"[object Object]"

यह पैटर्न, ऑब्जेक्ट: प्रॉपर्टी को ऐक्सेस करते समय, अनुवादक प्रॉपर्टी ऊपर से नीचे तक, प्रोटोटाइप चेन पर, और प्रॉपर्टी ढूंढ लेता है या चेन खत्म हो जाती है:

const myCustomPrototype = {
  'protoProp': "Prototype property value."
};

const myObj = Object.create( myCustomPrototype, {
    myProperty: {
        value: "Top-level property value.",
        writable: true,
        configurable: true
    }
});

myObj.protoProp;
> "Prototype property value."

देखें कि आपको कितना समझ आया है