जावास्क्रिप्ट का ऑब्जेक्ट कई उपयोगी तरीकों से भरा हुआ है जो डेवलपर्स को आसानी से ऑब्जेक्ट में हेरफेर करने में मदद करता है। आइए संक्षिप्त स्पष्टीकरण और उदाहरणों के साथ कुछ सबसे महत्वपूर्ण बातों पर चलते हैं

1. ऑब्जेक्ट.क्रिएट()
2. ऑब्जेक्ट.असाइन()
3. ऑब्जेक्ट.कीज़()
4. ऑब्जेक्ट.मान()
5. Object.entries()
6. ऑब्जेक्ट.फ़्रीज़()
7. ऑब्जेक्ट.सील()
8. Object.preventExtensions()
9. Object.getPrototypeOf()
10. Object.setPrototypeOf()
11. Object.defineProperty()
12. Object.defineProperties()
13. Object.getOwnPropertyDescriptor()
14. Object.getOwnPropertyDescriptors()
15. Object.getOwnPropertyNames()
16. Object.is()
17. Object.isFrozen()
18. Object.isSealed()
19. Object.isExtensible()
20. Object.fromEntries()
21. Object.hasOwnProperty()
22. Object.hasOwn()
23. Object.groupBy() (प्रस्तावित सुविधा, पूरी तरह से उपलब्ध नहीं हो सकती है)

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

const personPrototype = {
  greet() {
    console.log(`Hello, my name is ${this.name}`);
  }
};

const john = Object.create(personPrototype);
john.name = "John";
john.greet();  // Output: Hello, my name is John

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

const target = { a: 1 };
const source = { b: 2, c: 3 };
const result = Object.assign(target, source);
console.log(result);  // Output: { a: 1, b: 2, c: 3 }
console.log(target);  // Output: { a: 1, b: 2, c: 3 } (target is also modified)

Object.keys()
ऑब्जेक्ट की अपनी गणना योग्य संपत्ति नामों (कुंजियाँ) की एक सरणी लौटाता है

const obj = { a: 1, b: 2, c: 3 };
console.log(Object.keys(obj));  // Output: ['a', 'b', 'c']

ऑब्जेक्ट.मान()
ऑब्जेक्ट की अपनी गणना योग्य संपत्ति मानों की एक सरणी लौटाता है

const obj = { a: 1, b: 2, c: 3 };
console.log(Object.values(obj));  // Output: [1, 2, 3]

Object.entries()
ऑब्जेक्ट की अपनी गणना योग्य संपत्ति की एक सरणी लौटाता है [कुंजी, मूल्य] जोड़े

const obj = { a: 1, b: 2, c: 3 };
console.log(Object.entries(obj));  // Output: [['a', 1], ['b', 2], ['c', 3]]

ऑब्जेक्ट.फ़्रीज़()
ऑब्जेक्ट को फ़्रीज़ करता है, नए गुणों को जोड़ने या मौजूदा गुणों को बदलने या हटाए जाने से रोकता है

const obj = { a: 1 };
Object.freeze(obj);
obj.a = 2;  // No effect, because the object is frozen
console.log(obj.a);  // Output: 1

ऑब्जेक्ट.सील()
ऑब्जेक्ट को सील कर देता है, नए गुणों को जोड़ने से रोकता है, लेकिन मौजूदा गुणों को संशोधित करने की अनुमति देता है।

const obj = { a: 1 };
Object.seal(obj);
obj.a = 2;  // Allowed
delete obj.a;  // Not allowed
console.log(obj.a);  // Output: 2

Object.preventExtensions()
किसी भी नए गुण को ऑब्जेक्ट में जोड़े जाने से रोकता है, लेकिन मौजूदा गुणों में संशोधन और हटाने की अनुमति देता है

const obj = { a: 1 };
Object.preventExtensions(obj);
obj.b = 2;  // Not allowed
console.log(obj.b);  // Output: undefined

Object.getPrototypeOf()
निर्दिष्ट ऑब्जेक्ट का प्रोटोटाइप (यानी, आंतरिक [[प्रोटोटाइप]]) लौटाता है

const obj = {};
const proto = Object.getPrototypeOf(obj);
console.log(proto);  // Output: {} (the default Object prototype)

Object.setPrototypeOf()
किसी निर्दिष्ट ऑब्जेक्ट का प्रोटोटाइप सेट करता है।

const proto = { greet() { console.log('Hello!'); } };
const obj = {};
Object.setPrototypeOf(obj, proto);
obj.greet();  // Output: 'Hello!'

Object.defineProperty()
किसी ऑब्जेक्ट पर एक नई प्रॉपर्टी को परिभाषित करता है या किसी मौजूदा प्रॉपर्टी को संशोधित करता है, प्रॉपर्टी डिस्क्रिप्टर के लिए अतिरिक्त विकल्पों के साथ (उदाहरण के लिए, लिखने योग्य, कॉन्फ़िगर करने योग्य)।

const obj = {};
Object.defineProperty(obj, 'a', {
  value: 42,
  writable: false,  // Cannot modify the value
});
obj.a = 100;  // No effect because writable is false
console.log(obj.a);  // Output: 42

Object.defineProperties()
प्रॉपर्टी डिस्क्रिप्टर के साथ किसी ऑब्जेक्ट पर एकाधिक प्रॉपर्टी को परिभाषित करता है।

const obj = {};
Object.defineProperties(obj, {
  a: { value: 42, writable: false },
  b: { value: 100, writable: true }
});
console.log(obj.a);  // Output: 42
console.log(obj.b);  // Output: 100

Object.getOwnPropertyDescriptor()
किसी वस्तु की संपत्ति के लिए विवरणक लौटाता है।

const obj = { a: 1 };
const descriptor = Object.getOwnPropertyDescriptor(obj, 'a');
console.log(descriptor);  
// Output: { value: 1, writable: true, enumerable: true, configurable: true }

Object.getOwnPropertyDescriptors()
एक ऑब्जेक्ट लौटाता है जिसमें किसी ऑब्जेक्ट के स्वयं के गुणों के लिए सभी प्रॉपर्टी डिस्क्रिप्टर शामिल होते हैं

const obj = { a: 1 };
const descriptors = Object.getOwnPropertyDescriptors(obj);
console.log(descriptors);
// Output: { a: { value: 1, writable: true, enumerable: true, configurable: true } }

Object.getOwnPropertyNames()
किसी ऑब्जेक्ट पर सीधे पाए जाने वाले सभी गुणों (गैर-गणना योग्य गुणों सहित) की एक सरणी लौटाता है।

const obj = { a: 1 };
Object.defineProperty(obj, 'b', { value: 2, enumerable: false });
console.log(Object.getOwnPropertyNames(obj));  // Output: ['a', 'b']

Object.is()
यदि दो मान समान हैं तो तुलना करें (जैसे === लेकिन NaN जैसे विशेष मामलों को संभालता है)

console.log(Object.is(NaN, NaN));  // Output: true
console.log(Object.is( 0, -0));    // Output: false

Object.isFrozen()
जाँचता है कि क्या कोई वस्तु जमी हुई है

const obj = Object.freeze({ a: 1 });
console.log(Object.isFrozen(obj));  // Output: true

Object.isSealed()
जाँचता है कि कोई वस्तु सील है या नहीं।

const obj = Object.seal({ a: 1 });
console.log(Object.isSealed(obj));  // Output: true

Object.isExtensible()
जाँचता है कि क्या किसी ऑब्जेक्ट में नए गुण जोड़े जा सकते हैं।

const obj = { a: 1 };
Object.preventExtensions(obj);
console.log(Object.isExtensible(obj));  // Output: false

Object.fromEntries()
कुंजी-मूल्य जोड़े की एक सरणी को एक ऑब्जेक्ट में परिवर्तित करता है

const entries = [['a', 1], ['b', 2]];
const obj = Object.fromEntries(entries);
console.log(obj);  // Output: { a: 1, b: 2 }

Object.hasOwnProperty()
जाँचता है कि क्या किसी वस्तु की निर्दिष्ट संपत्ति उसकी अपनी है (विरासत में नहीं मिली)

const obj = { a: 1 };
console.log(obj.hasOwnProperty('a'));  // Output: true

Object.hasOwn()
object.hasOwn(), object.hasOwnProperty() के विकल्प के रूप में ES2022 में पेश की गई एक नई विधि है। यह जांचता है कि प्रोटोटाइप श्रृंखला को देखे बिना, किसी ऑब्जेक्ट में निर्दिष्ट कुंजी के साथ प्रत्यक्ष (स्वयं) संपत्ति है या नहीं।

const obj = {
  name: 'Alice',
  age: 25
};

console.log(Object.hasOwn(obj, 'name'));  // true
console.log(Object.hasOwn(obj, 'gender'));  // false

Object.groupBy
ऑब्जेक्ट.ग्रुपबाय ईसीएमएस्क्रिप्ट 2024 में जावास्क्रिप्ट के लिए प्रस्तावित एक अपेक्षाकृत नई सुविधा है जो आपको एक सामान्य मानदंड के आधार पर वस्तुओं को समूहित करने की अनुमति देती है। यह अभी तक सभी परिवेशों में व्यापक रूप से उपलब्ध नहीं है, इसलिए यह पूरी तरह से लागू होने तक कई ब्राउज़रों या जावास्क्रिप्ट इंजनों में काम नहीं कर सकता है।

const array = [
  { name: 'Alice', age: 25 },
  { name: 'Bob', age: 30 },
  { name: 'Charlie', age: 25 },
  { name: 'David', age: 30 },
];

// Group objects by age
const groupedByAge = Object.groupBy(array, item => item.age);

console.log(groupedByAge);

/*
Expected Output:
{
  25: [
    { name: 'Alice', age: 25 },
    { name: 'Charlie', age: 25 }
  ],
  30: [
    { name: 'Bob', age: 30 },
    { name: 'David', age: 30 }
  ]
}
*/