JavaScript
वस्तुओं

वाक्य - विन्यास

• वस्तु = {}
• वस्तु = नई वस्तु ()
• ऑब्जेक्ट = Object.create (प्रोटोटाइप [, propertiesObject])
• object.key = मान
• वस्तु ["कुंजी"] = मूल्य
• वस्तु [प्रतीक ()] = मूल्य
• ऑब्जेक्ट = {key1: value1, "key2": value2, 'key3': value3}
• ऑब्जेक्ट = {conciseMethod () {…}}
• ऑब्जेक्ट = {[गणना () + "कुंजी"]: मूल्य}
• Object.defineProperty (obj, propertyName, propertyDescriptor)
• property_desc = Object.getOwnPropertyDescriptor (obj, propertyName)
• Object.freeze (obj)
• Object.seal (obj)

पैरामीटर

टिप्पणियों

Object.keys

var obj = {
    a: "hello",
    b: "this is",
    c: "javascript!"
};

var keys = Object.keys(obj);

console.log(keys); // ["a", "b", "c"]

उथला क्लोनिंग

const existing = { a: 1, b: 2, c: 3 };

const clone = Object.assign({}, existing);

ऑब्जेक्ट बाकी / फैल विनाशकारी जो वर्तमान में एक चरण 3 का प्रस्ताव है वस्तु उद्देश्य के उथले क्लोन बनाने के लिए एक भी सरल तरीका प्रदान करता है:

const existing = { a: 1, b: 2, c: 3 };

const { ...clone } = existing;

आप जावास्क्रिप्ट के पुराने संस्करणों का समर्थन की जरूरत है, एक वस्तु क्लोन करने के लिए सबसे संगत रास्ता मैन्युअल रूप से उसके गुण से अधिक पुनरावृत्ति और का उपयोग कर विरासत में मिला है लोगों को छान कर है .hasOwnProperty() ।

var existing = { a: 1, b: 2, c: 3 };

var clone = {};
for (var prop in existing) {
  if (existing.hasOwnProperty(prop)) {
    clone[prop] = existing[prop];
  }
}

Object.defineProperty

var obj = { };

Object.defineProperty(obj, 'foo', { value: 'foo' });

console.log(obj.foo);

कंसोल आउटपुट

foo

Object.defineProperty को निम्नलिखित विकल्पों के साथ बुलाया जा सकता है:

Object.defineProperty(obj, 'nameOfTheProperty', {
  value: valueOfTheProperty, 
  writable: true, // if false, the property is read-only
  configurable : true, // true means the property can be changed later
  enumerable : true // true means property can be enumerated such as in a for..in loop
});

Object.defineProperties आपको एक बार में कई गुणों को परिभाषित करने की अनुमति देता है।

var obj = {};
Object.defineProperties(obj, {
  property1: {
    value: true,
    writable: true
  },
  property2: {
    value: 'Hello',
    writable: false
  }      
});

पढ़ें- केवल संपत्ति

प्रॉपर्टी डिस्क्रिप्टर में writable संपत्ति इंगित करती है कि उस संपत्ति को बदला जा सकता है या नहीं।

var a  = { };

Object.defineProperty(a, 'foo', { value: 'original', writable: false });

a.foo = 'new';

console.log(a.foo);

कंसोल आउटपुट

मूल

गैर-संपत्ति

प्रॉपर्टी डिस्क्रिप्टर की enumerable संपत्ति बताती है कि ऑब्जेक्ट के गुणों के माध्यम से लूप करते समय उस संपत्ति की गणना की जाएगी या नहीं।

var obj = { };

Object.defineProperty(obj, "foo", { value: 'show', enumerable: true });
Object.defineProperty(obj, "bar", { value: 'hide', enumerable: false });

for (var prop in obj) {
    console.log(obj[prop]);
}

कंसोल आउटपुट

प्रदर्शन

संपत्ति का विवरण लॉक करें

प्रॉपर्टी डिस्क्रिप्टर की configurable संपत्ति का उपयोग डिस्क्रिप्टर पर किसी भी आगे के बदलाव को रोकने के लिए किया जाता है।

var obj = {};

// Define 'foo' as read only and lock it
Object.defineProperty(obj, "foo", { 
    value: "original value", 
    writable: false, 
    configurable: false
});
 
Object.defineProperty(obj, "foo", {writable: true});

यह त्रुटि डाली जाएगी:

टाइपर्रर: संपत्ति को फिर से परिभाषित नहीं कर सकता: फू

और संपत्ति अभी भी केवल पढ़ी जाएगी।

obj.foo = "new value";
console.log(foo);

कंसोल आउटपुट

असली कीमत

Accesor गुण (प्राप्त करें और सेट करें)

get संपत्ति वर्णनकर्ता की संपत्ति एक समारोह है कि संपत्ति से मान प्राप्त करने के लिए बुलाया जाएगा।

set प्रॉपर्टी भी एक फ़ंक्शन है, यह तब कहा जाएगा जब संपत्ति को एक मूल्य सौंपा गया हो, और नए मूल्य को एक तर्क के रूप में पारित किया जाएगा।

आप get या set डिस्क्रिप्टर के लिए value या writable नहीं दे सकते

var person = { name: "John", surname: "Doe"};
Object.defineProperty(person, 'fullName', { 
    get: function () { 
        return this.name + " " + this.surname;
    },
    set: function (value) {
        [this.name, this.surname] = value.split(" ");
    }
});

console.log(person.fullName); // -> "John Doe"

person.surname = "Hill";
console.log(person.fullName); // -> "John Hill"

person.fullName = "Mary Jones";
console.log(person.name) // -> "Mary"

विशेष वर्ण या आरक्षित शब्दों के साथ गुण

जबकि ऑब्जेक्ट प्रॉपर्टी नोटेशन आमतौर पर myObject.property रूप में लिखा जाता है, यह केवल उन पात्रों को अनुमति देगा जो सामान्य रूप से जावास्क्रिप्ट चर नामों में पाए जाते हैं, जो मुख्य रूप से अक्षर, संख्या और अंडरस्कोर ( _ ) है।

यदि आपको अंतरिक्ष,, या उपयोगकर्ता द्वारा प्रदान की गई सामग्री जैसे विशेष वर्णों की आवश्यकता है, तो [] ब्रैकेट नोटेशन का उपयोग करना संभव है।

myObject['special property ☺'] = 'it works!'
console.log(myObject['special property ☺'])

सभी अंकों के गुण:

विशेष वर्णों के अलावा, सभी नाम वाले गुण नाम को ब्रैकेट नोटेशन की आवश्यकता होगी। हालांकि, इस मामले में संपत्ति को एक स्ट्रिंग के रूप में लिखने की आवश्यकता नहीं है।

myObject[123] = 'hi!' // number 123 is automatically converted to a string
console.log(myObject['123']) // notice how using string 123 produced the same result
console.log(myObject['12' + '3']) // string concatenation
console.log(myObject[120 + 3]) // arithmetic, still resulting in 123 and producing the same result
console.log(myObject[123.0]) // this works too because 123.0 evaluates to 123
console.log(myObject['123.0']) // this does NOT work, because '123' != '123.0'

हालांकि, अग्रणी शून्य की सिफारिश नहीं की जाती है क्योंकि इसकी व्याख्या ऑक्टल नोटेशन के रूप में की जाती है। (TODO, हमें ऑक्टल, हेक्साडेसिमल और एक्सपोनेंट नोटेशन का वर्णन करने वाले एक उदाहरण के लिए उत्पादन और लिंक करना चाहिए)

इसे भी देखें: [Arrays ऑब्जेक्ट हैं] उदाहरण।

गतिशील / परिवर्तनशील गुण नाम

कभी-कभी संपत्ति नाम को एक चर में संग्रहीत करने की आवश्यकता होती है। इस उदाहरण में, हम उपयोगकर्ता से पूछते हैं कि किस शब्द को देखने की आवश्यकता है, और फिर मैंने जिस ऑब्जेक्ट का नाम dictionary रखा है, उसका परिणाम प्रदान करें।

var dictionary = {
    lettuce: 'a veggie',
    banana: 'a fruit',
    tomato: 'it depends on who you ask',
    apple: 'a fruit',
    Apple: 'Steve Jobs rocks!' // properties are case-sensitive
}

var word = prompt('What word would you like to look up today?')
var definition = dictionary[word]
alert(word + '\n\n' + definition)

ध्यान दें कि हम word नाम के चर को देखने के लिए कैसे [] ब्रैकेट संकेतन का उपयोग कर रहे हैं; अगर हम पारंपरिक का उपयोग करने के लिए थे . अंकन, तब यह शाब्दिक रूप से मूल्य लेगा, इसलिए:

console.log(dictionary.word)  // doesn't work because word is taken literally and dictionary has no field named `word`
console.log(dictionary.apple) // it works! because apple is taken literally

console.log(dictionary[word]) // it works! because word is a variable, and the user perfectly typed in one of the words from our dictionary when prompted
console.log(dictionary[apple]) // error! apple is not defined (as a variable)

आप एक स्ट्रिंग 'apple' साथ परिवर्तनीय word को बदलकर [] संकेतन के साथ शाब्दिक मान भी लिख सकते हैं। देखें [विशेष वर्ण या आरक्षित शब्दों के साथ गुण] उदाहरण।

आप ब्रैकेट सिंटैक्स के साथ गतिशील गुण भी सेट कर सकते हैं:

var property="test";
var obj={
 [property]=1;
};

console.log(obj.test);//1

यह वैसा ही करता है:

var property="test";
var obj={};
obj[property]=1;

सरणी वस्तुएं हैं

अस्वीकरण: सरणी-जैसी वस्तुओं का निर्माण करने की अनुशंसा नहीं की जाती है। हालांकि, यह समझना उपयोगी है कि वे कैसे काम करते हैं, खासकर जब डोम के साथ काम करते हैं। यह बताएगा कि नियमित सरणी संचालन DOM ऑब्जेक्ट्स पर काम क्यों नहीं करते हैं जो कई DOM document फ़ंक्शन से लौटे हैं। (यानी querySelectorAll , form.elements )

मान लें कि हमने निम्नलिखित ऑब्जेक्ट बनाया है जिसमें कुछ गुण हैं जो आप एक ऐरे में देखने की उम्मीद करेंगे।

var anObject = {
    foo: 'bar',
    length: 'interesting',
    '0': 'zero!',
    '1': 'one!'
};

फिर हम एक सरणी बनाएंगे।

var anArray = ['zero.', 'one.'];

अब, ध्यान दें कि हम उसी तरह से ऑब्जेक्ट और ऑब्जेक्ट दोनों का निरीक्षण कैसे कर सकते हैं।

console.log(anArray[0], anObject[0]); // outputs: zero.  zero!
console.log(anArray[1], anObject[1]); // outputs: one.  one!
console.log(anArray.length, anObject.length); // outputs: 2 interesting
console.log(anArray.foo, anObject.foo); // outputs: undefined bar

चूंकि anArray वास्तव में एक वस्तु है, जैसे है anObject , हम भी करने के लिए कस्टम शब्दों वाले गुण जोड़ सकते हैं anArray

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

anArray.foo = 'it works!';
console.log(anArray.foo);

हम एक length जोड़कर एक सरणी जैसी वस्तु होने के लिए भी anObject बना सकते हैं।

anObject.length = 2;

तो फिर तुम सी-शैली का उपयोग कर सकते for अधिक पुनरावृति करने के पाश anObject बस के रूप में अगर यह किसी सरणी थे। ऐरे इटरेशन देखें

ध्यान दें कि anObject केवल एक सरणी जैसी ऑब्जेक्ट है। (यह भी एक सूची के रूप में जाना जाता है) यह एक सच्चे ऐरे नहीं है। यह महत्वपूर्ण है, क्योंकि push और forEach (या Array.prototype में पाया गया कोई भी सुविधा फ़ंक्शन) Array.prototype फ़ंक्शन सरणी जैसी वस्तुओं पर डिफ़ॉल्ट रूप से काम नहीं करेंगे।

डोम में से कई document कार्यों एक सूची वापस आ जाएगी (यानी querySelectorAll , form.elements ) जो के समान है सरणी की तरह anObject हम ऊपर बनाया। Arreays के लिए ऐरे-जैसी वस्तुओं को परिवर्तित करना देखें

console.log(typeof anArray == 'object', typeof anObject == 'object'); // outputs: true  true
console.log(anArray instanceof Object, anObject instanceof Object); // outputs: true  true
console.log(anArray instanceof Array, anObject instanceof Array); // outputs: true  false
console.log(Array.isArray(anArray), Array.isArray(anObject)); // outputs: true  false

Object.freeze

जब तक कि कोड सख्त मोड में नहीं चल रहा है, फ्रीज के बाद की कार्रवाई चुपचाप विफल हो जाएगी। यदि कोड सख्त मोड में है, तो TypeError को फेंक दिया जाएगा।

var obj = {
  foo: 'foo',
  bar: [1, 2, 3],
  baz: {
    foo: 'nested-foo'
  }
};

Object.freeze(obj);

// Cannot add new properties
obj.newProperty = true;

// Cannot modify existing values or their descriptors
obj.foo = 'not foo';
Object.defineProperty(obj, 'foo', {
    writable: true
});

// Cannot delete existing properties
delete obj.foo;

// Nested objects are not frozen
obj.bar.push(4);
obj.baz.foo = 'new foo';

Object.seal

var obj = { foo: 'foo', bar: function () { return 'bar'; } };

Object.seal(obj)

obj.newFoo = 'newFoo';
obj.bar = function () { return 'foo' };

obj.newFoo; // undefined
obj.bar(); // 'foo'

// Can't make foo an accessor property
Object.defineProperty(obj, 'foo', { 
    get: function () { return 'newFoo'; }
}); // TypeError

// But you can make it read only
Object.defineProperty(obj, 'foo', { 
    writable: false
}); // TypeError

obj.foo = 'newFoo';
obj.foo; // 'foo';

(function () {
    'use strict';

    var obj = { foo: 'foo' };

    Object.seal(obj);

    obj.newFoo = 'newFoo'; // TypeError
}());

एक Iterable ऑब्जेक्ट बनाना

var myIterableObject = {};
// An Iterable object must define a method located at the Symbol.iterator key:
myIterableObject[Symbol.iterator] = function () {
  // The iterator should return an Iterator object
  return {
    // The Iterator object must implement a method, next()
    next: function () {
      // next must itself return an IteratorResult object 
      if (!this.iterated) {
        this.iterated = true;
        // The IteratorResult object has two properties
        return {
          // whether the iteration is complete, and
          done: false,
          // the value of the current iteration
          value: 'One'
        };
      }
      return {
        // When iteration is complete, just the done property is needed
        done: true
      };
    },
    iterated: false
  };
};

for (var c of myIterableObject) {
  console.log(c); 
}

ऑब्जेक्ट रेस्ट / स्प्रेड (...)

let obj = { a: 1 };

let obj2 = { ...obj, b: 2, c: 3 };

console.log(obj2); // { a: 1, b: 2, c: 3 };

let obj3 = { ...obj, b: { c: 2 } };

console.log(obj3); // { a: 1, b: { c: 2 } };

डिस्क्रिप्टर्स और नामांकित गुण

गुण किसी वस्तु के सदस्य होते हैं। प्रत्येक नामित संपत्ति (नाम, विवरणकर्ता) की एक जोड़ी है। नाम एक स्ट्रिंग है जो एक्सेस की अनुमति देता है (डॉट नोटेशन object['propertyName'] का उपयोग करके object.propertyName या स्क्वायर ब्रैकेट्स नोटेशन object['propertyName'] )। डिस्क्रिप्टर संपत्ति के बेवहोर को परिभाषित करने वाले क्षेत्रों का एक रिकॉर्ड है जब इसे एक्सेस किया जाता है (संपत्ति का क्या होता है और इसे एक्सेस करने से लौटाया गया मूल्य क्या है)। द्वारा और बड़ी, एक संपत्ति एक नाम को एक व्यवहार से जोड़ती है (हम एक ब्लैक बॉक्स के रूप में व्यवहार के बारे में सोच सकते हैं)।

नामित गुणों के दो प्रकार हैं:

1. डेटा प्रॉपर्टी : प्रॉपर्टी का नाम एक मूल्य के साथ जुड़ा हुआ है।
2. एक्सेसर प्रॉपर्टी : प्रॉपर्टी का नाम एक या दो एक्सेसर फ़ंक्शंस से जुड़ा होता है।

प्रदर्शन:

obj.propertyName1 = 5; //translates behind the scenes into
                       //either assigning 5 to the value field* if it is a data property
                //or calling the set function with the parameter 5 if accessor property


//*actually whether an assignment would take place in the case of a data property
//also depends on the presence and value of the writable field - on that later on

संपत्ति का प्रकार उसके विवरणकर्ता के क्षेत्रों द्वारा निर्धारित किया जाता है, और एक संपत्ति दोनों प्रकार की नहीं हो सकती है।

डेटा विवरणक -

• आवश्यक फ़ील्ड: value या writable या दोनों
• वैकल्पिक फ़ील्ड: configurable , enumerable

नमूना:

{
   value: 10,
   writable: true;
}

गौण वर्णनकर्ता -

• आवश्यक फ़ील्ड: get या set या दोनों
• वैकल्पिक फ़ील्ड: configurable , enumerable

नमूना:

{
    get: function () {
        return 10;
    },
    enumerable: true
}

खेतों और उनके चूक का अर्थ

• ये कुंजियाँ सभी डिफ़ॉल्ट रूप से false ।
• configurable है true है, तो और इस संपत्ति वर्णनकर्ता के प्रकार बदला जा सकता है केवल यदि और संपत्ति इसी वस्तु से हटाई जा सकती है।
• enumerable true अगर और केवल अगर यह संपत्ति इसी वस्तु पर गुणों की गणना के दौरान दिखाती है।
• writable है true यदि और केवल यदि संपत्ति के साथ जुड़े मूल्य एक काम ऑपरेटर के साथ बदला जा सकता है।

get और set :

• ये कुंजी undefined करने के लिए डिफ़ॉल्ट हैं।
• get एक ऐसा फंक्शन है जो प्रॉपर्टी के लिए एक गटर के रूप में कार्य करता है, या यदि कोई गेटर न हो तो undefined होता है। फ़ंक्शन रिटर्न का उपयोग संपत्ति के मूल्य के रूप में किया जाएगा।
• set एक फ़ंक्शन है जो संपत्ति के लिए एक सेटर के रूप में कार्य करता है, या यदि कोई सेटर नहीं है तो undefined है। यह फ़ंक्शन केवल तर्क के रूप में प्राप्त होगा कि नया मान संपत्ति को सौंपा जा रहा है।

value :

• यह कुंजी undefined ।
• संपत्ति से जुड़ा मूल्य। कोई भी मान्य JavaScript मान (संख्या, ऑब्जेक्ट, फ़ंक्शन, आदि) हो सकता है।

उदाहरण:

    var obj = {propertyName1: 1}; //the pair is actually ('propertyName1', {value:1,
                                                                    // writable:true,
                                                                    // enumerable:true,
                                                                    // configurable:true})
    Object.defineProperty(obj, 'propertyName2', {get: function() {
                                                    console.log('this will be logged ' + 
                                 'every time propertyName2 is accessed to get its value');
                                                },
                                            set: function() {
                                                    console.log('and this will be logged ' + 
                                'every time propertyName2\'s value is tried to be set')
                      //will be treated like it has enumerable:false, configurable:false
                                                }});
//propertyName1 is the name of obj's data property 
//and propertyName2 is the name of its accessor property





obj.propertyName1 = 3;
console.log(obj.propertyName1); //3

obj.propertyName2 = 3; //and this will be logged every time propertyName2's value is tried to be set
console.log(obj.propertyName2); //this will be logged every time propertyName2 is accessed to get its value 

Object.getOwnPropertyDescriptor

किसी वस्तु में किसी विशिष्ट गुण का वर्णन प्राप्त करें।

var sampleObject = {
    hello: 'world'
};

Object.getOwnPropertyDescriptor(sampleObject, 'hello');
// Object {value: "world", writable: true, enumerable: true, configurable: true}

वस्तु क्लोनिंग

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

var existing = { a: 1, b: { c: 2 } };
var copy = JSON.parse(JSON.stringify(existing));
existing.b.c = 3; // copy.b.c will not change

गहरी क्लोन बनाने के लिए जावास्क्रिप्ट में कोई अंतर्निहित फ़ंक्शन नहीं है, और सामान्य रूप से कई कारणों से हर वस्तु के लिए गहरे क्लोन बनाना संभव नहीं है। उदाहरण के लिए,

• ऑब्जेक्ट में गैर-गणना योग्य और छिपी गुण हो सकते हैं जो पता नहीं लगा सकते हैं।
• ऑब्जेक्ट गेटर्स और सेटर्स को कॉपी नहीं किया जा सकता है।
• वस्तुओं में चक्रीय संरचना हो सकती है।
• फ़ंक्शन गुण एक छिपे हुए दायरे में राज्य पर निर्भर कर सकते हैं।

यह मानते हुए कि आपके पास एक "अच्छा" ऑब्जेक्ट है, जिसके गुणों में केवल आदिम मूल्य, दिनांक, सरणियाँ या अन्य "अच्छा" ऑब्जेक्ट शामिल हैं, तो निम्न फ़ंक्शन का उपयोग गहरी क्लोन बनाने के लिए किया जा सकता है। यह एक पुनरावर्ती कार्य है जो चक्रीय संरचना के साथ वस्तुओं का पता लगा सकता है और ऐसे मामलों में एक त्रुटि फेंक देगा।

function deepClone(obj) {
    function clone(obj, traversedObjects) {
        var copy;
        // primitive types
        if(obj === null || typeof obj !== "object") {
            return obj;
        }

        // detect cycles
        for(var i = 0; i < traversedObjects.length; i++) {
            if(traversedObjects[i] === obj) {
                throw new Error("Cannot clone circular object.");
            }
        }

        // dates
        if(obj instanceof Date) {
            copy = new Date();
            copy.setTime(obj.getTime());
            return copy;
        }
        // arrays
        if(obj instanceof Array) {
            copy = [];
            for(var i = 0; i < obj.length; i++) {
                copy.push(clone(obj[i], traversedObjects.concat(obj)));
            }
            return copy;
        }
        // simple objects
        if(obj instanceof Object) {
            copy = {};
            for(var key in obj) {
                if(obj.hasOwnProperty(key)) {
                    copy[key] = clone(obj[key], traversedObjects.concat(obj));
                }
            }
            return copy;
        }
        throw new Error("Not a cloneable object.");
    }

    return clone(obj, []);
}

Object.assign

Object.assign () विधि का उपयोग एक या एक से अधिक स्रोत ऑब्जेक्ट से सभी एन्यूमरेबल स्वयं के गुणों के मानों को किसी लक्ष्य ऑब्जेक्ट पर कॉपी करने के लिए किया जाता है। यह लक्ष्य वस्तु को लौटा देगा।

किसी मौजूदा ऑब्जेक्ट के मान निर्दिष्ट करने के लिए इसका उपयोग करें:

var user = {
    firstName: "John"
};

Object.assign(user, {lastName: "Doe", age:39});
console.log(user); // Logs: {firstName: "John", lastName: "Doe", age: 39} 

या किसी वस्तु की उथली प्रतिलिपि बनाने के लिए:

var obj = Object.assign({}, user);

console.log(obj); // Logs: {firstName: "John", lastName: "Doe", age: 39} 

या कई वस्तुओं को एक से कई वस्तुओं में मिला दें:

var obj1 = {
    a: 1
};
var obj2 = {
    b: 2
};
var obj3 = {
    c: 3
};
var obj = Object.assign(obj1, obj2, obj3);

console.log(obj); // Logs: { a: 1, b: 2, c: 3 }
console.log(obj1); // Logs: { a: 1, b: 2, c: 3 }, target object itself is changed

प्राथमिकताओं को लपेटा जाएगा, अशक्त और अपरिभाषित को अनदेखा किया जाएगा:

var var_1 = 'abc';
var var_2 = true;
var var_3 = 10;
var var_4 = Symbol('foo');

var obj = Object.assign({}, var_1, null, var_2, undefined, var_3, var_4);
console.log(obj); // Logs: { "0": "a", "1": "b", "2": "c" }

ध्यान दें, केवल स्ट्रिंग रैपरों के पास स्वयं के असंख्य गुण हो सकते हैं

इसे reducer के रूप में उपयोग करें: (किसी ऑब्जेक्ट में किसी सरणी को मर्ज करता है)

return users.reduce((result, user) => Object.assign({}, {[user.id]: user})

वस्तु गुण पुनरावृति

आप प्रत्येक संपत्ति तक पहुँच सकते हैं जो इस लूप के साथ एक ऑब्जेक्ट से संबंधित है

for (var property in object) {
    // always check if an object has a property
    if (object.hasOwnProperty(property)) {
        // do stuff
    }
}

आपको hasOwnProperty लिए अतिरिक्त चेक शामिल करना चाहिए क्योंकि किसी ऑब्जेक्ट में गुण हो सकते हैं जो ऑब्जेक्ट के बेस क्लास से विरासत में मिले हैं। इस चेक का प्रदर्शन न करना त्रुटियों को बढ़ा सकता है।

var obj = { 0: 'a', 1: 'b', 2: 'c' };

Object.keys(obj).map(function(key) {
    console.log(key);
}); 
// outputs: 0, 1, 2

किसी वस्तु से गुण को पुनः प्राप्त करना

गुणों की विशेषताएं:

ऐसे गुण जो किसी वस्तु से प्राप्त किए जा सकते हैं उनमें निम्नलिखित विशेषताएं हो सकती हैं,

• गणनीय
• गैर - अनगिनत
• अपना

Object.defineProperty (ies) का उपयोग करके गुण बनाते समय, हम "स्वयं" को छोड़कर इसकी विशेषताओं को निर्धारित कर सकते हैं। वे गुण जो किसी वस्तु के प्रोटोटाइप स्तर ( __proto__ ) में प्रत्यक्ष स्तर में उपलब्ध नहीं होते हैं, उन्हें स्वयं के गुण कहा जाता है।

और जो ऑब्जेक्ट Object.defindProperty(ies) का उपयोग किए बिना किसी ऑब्जेक्ट में जोड़े जाते हैं, उनकी शानदार विशेषता नहीं होगी। इसका मतलब है कि इसे सच माना जाए।

गणना का उद्देश्य:

एक संपत्ति के लिए असंख्य विशेषताओं को स्थापित करने का मुख्य उद्देश्य विभिन्न प्रोग्रामेटिक तरीकों का उपयोग करके अपनी वस्तु से इसे प्राप्त करते समय विशेष संपत्ति की उपलब्धता बनाना है। उन विभिन्न तरीकों पर गहराई से चर्चा की जाएगी।

गुण प्राप्त करने के तरीके:

किसी वस्तु से गुण निम्नलिखित विधियों द्वारा प्राप्त किए जा सकते हैं,

1. for..in लूप

   यह लूप किसी ऑब्जेक्ट से अनगिनत गुण प्राप्त करने में बहुत उपयोगी है। इसके अतिरिक्त यह लूप अपने स्वयं के गुणों को भी प्राप्त कर लेगा और साथ ही यह प्रोटोटाइप श्रृंखला के माध्यम से ट्रैवर्सिंग द्वारा एक ही पुनर्प्राप्ति करेगा जब तक कि यह प्रोटोटाइप को शून्य के रूप में नहीं देखता।

   //Ex 1 : Simple data
   var x = { a : 10 , b : 3} , props = [];
   
   for(prop in x){
     props.push(prop);
   }
   
   console.log(props); //["a","b"]
   
   //Ex 2 : Data with enumerable properties in prototype chain
   var x = { a : 10 , __proto__ : { b : 10 }} , props = [];
   
   for(prop in x){
     props.push(prop);
   }
   
   console.log(props); //["a","b"]
   
   //Ex 3 : Data with non enumerable properties
   var x = { a : 10 } , props = [];
   Object.defineProperty(x, "b", {value : 5, enumerable : false});
   
   for(prop in x){
     props.push(prop);
   }
   
   console.log(props); //["a"]
   

2. Object.keys() फ़ंक्शन

   इस फ़ंक्शन का एक्मास्क्रिप्ट 5 के एक भाग के रूप में अनावरण किया गया था। इसका उपयोग किसी वस्तु से असंख्य गुणों को प्राप्त करने के लिए किया जाता है। संयोजन के द्वारा एक वस्तु से खुद गुण पुनः प्राप्त किये अपनी रिहाई लोगों से पहले for..in पाश और Object.prototype.hasOwnProperty() समारोह।

   //Ex 1 : Simple data
   var x = { a : 10 , b : 3} , props;
   
   props = Object.keys(x);
   
   console.log(props); //["a","b"]
   
   //Ex 2 : Data with enumerable properties in prototype chain
   var x = { a : 10 , __proto__ : { b : 10 }} , props;
   
   props = Object.keys(x);
   
   console.log(props); //["a"]
   
   //Ex 3 : Data with non enumerable properties
   var x = { a : 10 } , props;
   Object.defineProperty(x, "b", {value : 5, enumerable : false});
   
   props = Object.keys(x);
   
   console.log(props); //["a"]
   

3. Object.getOwnProperties() फ़ंक्शन

   यह फ़ंक्शन किसी ऑब्जेक्ट से enumerable और non enumerable, खुद के गुण दोनों को पुनः प्राप्त करेगा। इसे EcmaScript 5 के एक भाग के रूप में भी जारी किया गया था।

   //Ex 1 : Simple data
   var x = { a : 10 , b : 3} , props;
   
   props = Object.getOwnPropertyNames(x);
   
   console.log(props); //["a","b"]
   
   //Ex 2 : Data with enumerable properties in prototype chain
   var x = { a : 10 , __proto__ : { b : 10 }} , props;
   
   props = Object.getOwnPropertyNames(x);
   
   console.log(props); //["a"]
   
   //Ex 3 : Data with non enumerable properties
   var x = { a : 10 } , props;
   Object.defineProperty(x, "b", {value : 5, enumerable : false});
   
   props = Object.getOwnPropertyNames(x);
   
   console.log(props); //["a", "b"]
   

विविध :

किसी ऑब्जेक्ट से सभी (स्वयं, गणना योग्य, गैर गणना योग्य, सभी प्रोटोटाइप स्तर) गुणों को प्राप्त करने के लिए एक तकनीक नीचे दी गई है,

function getAllProperties(obj, props = []){
  return obj == null ? props :
           getAllProperties(Object.getPrototypeOf(obj),
               props.concat(Object.getOwnPropertyNames(obj)));
}

var x = {a:10, __proto__ : { b : 5, c : 15 }};

//adding a non enumerable property to first level prototype
Object.defineProperty(x.__proto__, "d", {value : 20, enumerable : false});

console.log(getAllProperties(x)); ["a", "b", "c", "d", "...other default core props..."]

और यह उन ब्राउज़रों द्वारा समर्थित होगा जो EcmaScript 5 का समर्थन करते हैं।

ऑब्जेक्ट के मानों को सरणी में बदलें

इस वस्तु को दिया:

var obj = {
    a: "hello",
    b: "this is",
    c: "javascript!",
};

आप इसके मानों को किसी सरणी में बदलकर कर सकते हैं:

var array = Object.keys(obj)
    .map(function(key) {
        return obj[key];
    });

console.log(array); // ["hello", "this is", "javascript!"]

ऑब्जेक्ट प्रविष्टियों पर इरेटिंग - Object.entries ()

const obj = {
    one: 1,
    two: 2,
    three: 3
};

Object.entries(obj);

[
    ["one", 1],
    ["two", 2],
    ["three", 3]
]

for(const [key, value] of Object.entries(obj)) {
    console.log(key); // "one", "two" and "three"
    console.log(value); // 1, 2 and 3
}

Object.values ()

var obj = { 0: 'a', 1: 'b', 2: 'c' };
console.log(Object.values(obj)); // ['a', 'b', 'c']