1. चरों की अदला-बदली के लिए डिस्ट्रक्चरिंग का उपयोग करें

let a = 1, b = 2;
[a, b] = [b, a];
console.log(a, b); // 2 1

क्यों: अस्थायी चर के बिना परिवर्तनीय मानों को स्वैप करने का एक साफ, एक-पंक्ति तरीका प्रदान करता है।

2. स्ट्रिंग इंटरपोलेशन के लिए टेम्पलेट शाब्दिक का उपयोग करें

const name = "Alice";
console.log(`Hello, ${name}!`); // Hello, Alice!

क्यों: पारंपरिक तरीकों की तुलना में स्ट्रिंग संयोजन को अधिक पठनीय और कम त्रुटि-प्रवण बनाता है।

3. डिफ़ॉल्ट मानों के लिए शून्य सहसंयोजक ऑपरेटर (??) का उपयोग करें

const value = null;
const defaultValue = value ?? "Default";
console.log(defaultValue); // "Default"

क्यों: शून्य या अपरिभाषित मानों को संभालने का एक संक्षिप्त तरीका प्रदान करता है, जो 0 या खाली स्ट्रिंग जैसे झूठे मानों से अलग होता है।

4. सुरक्षित संपत्ति पहुंच के लिए वैकल्पिक चेनिंग (?.) का उपयोग करें

const obj = { nested: { property: "value" } };
console.log(obj?.nested?.property); // "value"
console.log(obj?.nonexistent?.property); // undefined

क्यों: नेस्टेड संपत्तियों तक पहुंचने में त्रुटियों को रोकता है जो मौजूद नहीं हो सकते हैं, वर्बोज़ जांच की आवश्यकता को कम करते हैं।

5. सरणी हेरफेर के लिए स्प्रेड ऑपरेटर (...) का उपयोग करें

const arr1 = [1, 2, 3];
const arr2 = [4, 5, 6];
const combined = [...arr1, ...arr2];
console.log(combined); // [1, 2, 3, 4, 5, 6]

क्यों: संयोजन, प्रतिलिपि बनाने या तत्वों को जोड़ने जैसे सरणी संचालन को सरल बनाता है, कोड को अधिक संक्षिप्त और पठनीय बनाता है।

6. सरणी-जैसी वस्तुओं से सरणी बनाने के लिए Array.from() का उपयोग करें

const arrayLike = { 0: "a", 1: "b", 2: "c", length: 3 };
const newArray = Array.from(arrayLike);
console.log(newArray); // ["a", "b", "c"]

क्यों: सरणी जैसी वस्तुओं या पुनरावर्तनीय वस्तुओं को आसानी से वास्तविक सरणी में परिवर्तित करता है, जिससे सरणी विधियों का उपयोग संभव हो जाता है।

7. आसान ऑब्जेक्ट पुनरावृत्ति के लिए object.entries() का उपयोग करें

const obj = { a: 1, b: 2, c: 3 };
for (const [key, value] of Object.entries(obj)) {
  console.log(`${key}: ${value}`);
}

क्यों: किसी ऑब्जेक्ट की कुंजी और मान दोनों को एक साथ पुनरावृत्त करने का एक साफ़ तरीका प्रदान करता है।

8. नेस्टेड सरणियों को समतल करने के लिए Array.prototype.flat() का उपयोग करें

const nestedArray = [1, [2, 3, [4, 5]]];
console.log(nestedArray.flat(2)); // [1, 2, 3, 4, 5]

क्यों: नेस्टेड सरणियों को एक निर्दिष्ट गहराई तक समतल करके उनके साथ काम करना सरल बनाता है।

9. क्लीनर एसिंक्रोनस कोड के लिए async/प्रतीक्षा का उपयोग करें

async function fetchData() {
  try {
    const response = await fetch('https://api.example.com/data');
    const data = await response.json();
    console.log(data);
  } catch (error) {
    console.error('Error:', error);
  }
}

क्यों: एसिंक्रोनस कोड को सिंक्रोनस कोड की तरह दिखने और व्यवहार करने योग्य बनाता है, जिससे पठनीयता और त्रुटि प्रबंधन में सुधार होता है।

10. किसी सरणी में अद्वितीय मानों के लिए सेट का उपयोग करें

const numbers = [1, 2, 2, 3, 4, 4, 5];
const uniqueNumbers = [...new Set(numbers)];
console.log(uniqueNumbers); // [1, 2, 3, 4, 5]

क्यों: मैन्युअल लूपिंग के बिना किसी सरणी से डुप्लिकेट को हटाने का एक कुशल तरीका प्रदान करता है।

11। अपरिवर्तनीय ऑब्जेक्ट बनाने के लिए object.freeze() का उपयोग करें

const frozenObj = Object.freeze({ prop: 42 });
frozenObj.prop = 100; // Fails silently in non-strict mode
console.log(frozenObj.prop); // 42

क्यों: किसी ऑब्जेक्ट में संशोधन को रोकता है, स्थिरांक बनाने या डेटा अखंडता सुनिश्चित करने के लिए उपयोगी है।

12. शक्तिशाली सरणी परिवर्तनों के लिए Array.prototype.reduce() का उपयोग करें

const numbers = [1, 2, 3, 4, 5];
const sum = numbers.reduce((acc, curr) => acc   curr, 0);
console.log(sum); // 15

क्यों: जटिल सरणी संचालन को एक ही पास में निष्पादित करने की अनुमति देता है, जो अक्सर लूप की तुलना में अधिक कुशलता से होता है।

13. सशर्त निष्पादन के लिए तार्किक AND ऑपरेटर (&&) का उपयोग करें

const isTrue = true;
isTrue && console.log("This will be logged");

क्यों: केवल शर्त सत्य होने पर ही कोड निष्पादित करने का एक संक्षिप्त तरीका प्रदान करता है, बिना किसी स्पष्ट if कथन के।

14. ऑब्जेक्ट को मर्ज करने के लिए object.assign() का उपयोग करें

const obj1 = { a: 1, b: 2 };
const obj2 = { b: 3, c: 4 };
const merged = Object.assign({}, obj1, obj2);
console.log(merged); // { a: 1, b: 3, c: 4 }

क्यों: ऑब्जेक्ट विलय को सरल बनाता है, कॉन्फ़िगरेशन ऑब्जेक्ट को संयोजित करने या ओवरराइड के साथ ऑब्जेक्ट प्रतियां बनाने के लिए उपयोगी है।

15. सरणी
के लिए Array.prototype.some() और Array.prototype.every() का उपयोग करें

checking
const numbers = [1, 2, 3, 4, 5];
console.log(numbers.some(n => n > 3)); // true
console.log(numbers.every(n => n > 0)); // true

क्यों: स्पष्ट लूप से बचते हुए, यह जांचने के लिए संक्षिप्त तरीके प्रदान करता है कि किसी सरणी में कोई या सभी तत्व किसी शर्त को पूरा करते हैं या नहीं।

16. सारणीबद्ध डेटा की बेहतर लॉगिंग के लिए कंसोल.टेबल() का उपयोग करें

const users = [
  { name: "John", age: 30 },
  { name: "Jane", age: 28 },
];
console.table(users);

क्यों: सारणीबद्ध प्रारूप में लॉग किए गए डेटा की पठनीयता में सुधार होता है, विशेष रूप से वस्तुओं की सारणी के लिए उपयोगी।

17. पहला मिलान तत्व प्राप्त करने के लिए Array.prototype.find() का उपयोग करें

const numbers = [1, 2, 3, 4, 5];
const found = numbers.find(n => n > 3);
console.log(found); // 4

क्यों: किसी सरणी में पहला तत्व कुशलतापूर्वक ढूंढता है जो एक शर्त को पूरा करता है, एक बार मिल जाने पर पुनरावृत्ति रोक देता है।

18. ऑब्जेक्ट के लिए ऑब्जेक्ट.कीज़(), ऑब्जेक्ट.वैल्यूज़() और ऑब्जेक्ट.एंट्रीज़() का उपयोग करें

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

क्यों: ऑब्जेक्ट गुणों और मूल्यों को निकालने और उनके साथ काम करने के आसान तरीके प्रदान करता है, जो कई ऑब्जेक्ट संचालन के लिए उपयोगी है।

19. अंतर्राष्ट्रीयकरण के लिए अंतर्राष्ट्रीय एपीआई का उपयोग करें

const number = 123456.789;
console.log(new Intl.NumberFormat('de-DE').format(number)); // 123.456,789

क्यों: मैन्युअल कार्यान्वयन के बिना स्थानीय-विशिष्ट नियमों के अनुसार संख्याओं, तिथियों और स्ट्रिंग्स के स्वरूपण को सरल बनाता है।

20. एक चरण में मैपिंग और फ़्लैटनिंग के लिए Array.prototype.flatMap() का उपयोग करें

const sentences = ["Hello world", "How are you"];
const words = sentences.flatMap(sentence => sentence.split(" "));
console.log(words); // ["Hello", "world", "How", "are", "you"]

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