JavaScript में 1…N ऐरे: स्पीड और परफॉरमेंस के रहस्य

JavaScript में 1…N ऐरे: सरल से लेकर हाई-परफॉरमेंस तक

नमस्ते, डेवलपर साथी! अगर आपने कभी "1 से N तक numbers का array बनाने" का काम किया है, तो आप अकेले नहीं हैं। Stack Overflow पर यह इतना लोकप्रिय सवाल है कि इसके हज़ारों व्यूज़ और दर्जनों जवाब हैं। सोचो, इसमें इतना मुश्किल क्या है? लेकिन असली चुनौती है: परफॉरमेंस, रीडेबिलिटी और कोड की versatility।

आज हम JavaScript में [1, 2, 3, ..., N] ऐरे बनाने के सभी मुख्य तरीकों को समझेंगे, उनकी स्पीड, elegance और उपयोग के आधार पर तुलना करेंगे। आप जानेंगे कि सामान्य प्रोजेक्ट के लिए कौन सा method चुनें, और कब हर मिलीसेकंड मायने रखता है। चलिए शुरू करते हैं!

यह क्यों ज़रूरी है? समस्या का संदर्भ

कल्पना करें: आप sorting algorithm लिख रहे हैं, test data generate कर रहे हैं, गेम के लिए grid बना रहे हैं, या बस numbers का sequence चाहिए। इन सभी मामलों में 1 से N तक array चाहिए। लगता है — for loop लगाओ और काम खत्म। लेकिन modern JavaScript में इतना syntactic sugar है कि भ्रमित होना आसान है।

हम 5 मुख्य approaches देखेंगे, classic से लेकर modern one-liners तक, और real-world conditions में उनकी परफॉरमेंस जाँचेंगे। अपना browser console और पसंदीदा editor तैयार रखें — मज़ा आने वाला है!

तरीका 1: क्लासिक for लूप

बुनियादी लेकिन भरोसेमंद तरीका, जो हर beginner जानता है:

function createArrayLoop(n) {\n  const arr = [];\n  for (let i = 1; i <= n; i++) {\n    arr.push(i);\n  }\n  return arr;\n}\n\nconsole.log(createArrayLoop(5)); // [1, 2, 3, 4, 5]

फायदे:

\n
• सबसे ज़्यादा readable — JS सीखने वालों के लिए भी आसान।
\n
• कोई hidden calls या magic नहीं।
\n
• पुराने browsers सहित सभी environments में काम करता है।
\n

नुकसान:

\n
• कुछ alternatives से धीमा (लेकिन छोटे N के लिए कोई बड़ी बात नहीं)।
\n
• साधारण काम के लिए ज़्यादा कोड।
\n

तरीका 2: Array.from() map फंक्शन के साथ

ES6 में आया elegant modern तरीका:

const createArrayFrom = n => Array.from({ length: n }, (_, i) => i + 1);\n\nconsole.log(createArrayFrom(5)); // [1, 2, 3, 4, 5]

यहाँ हम एक निश्चित length का array बनाते हैं और तुरंत map function से भरते हैं। Array.from का दूसरा argument एक mapper function है, जो current index i लेता है और i + 1 return करता है।

फायदे:

\n
• बहुत concise और expressive।
\n
• पहले से empty array बनाने की ज़रूरत नहीं।
\n
• अच्छी परफॉरमेंस।
\n

नुकसान:

\n
• शुरुआती लोगों के लिए कम obvious।
\n
• एक intermediate object { length: n } बनाता है।
\n

तरीका 3: Spread ऑपरेटर + keys()

Stack Overflow पर सबसे लोकप्रिय one-liners में से एक:

const createArraySpread = n => [...Array(n).keys()].map(i => i + 1);\n\nconsole.log(createArraySpread(5)); // [1, 2, 3, 4, 5]

यह कैसे काम करता है? Array(n) n empty elements का sparse array बनाता है। .keys() indices (0, 1, 2...) का iterator return करता है। Spread operator इसे normal array में बदलता है, फिर map values को +1 shift करता है।

फायदे:

\n
• बहुत concise (एक ही call)।
\n
• "Magical" लगता है — code review में colleagues को impress करता है।
\n

नुकसान:

\n
• बड़े N के लिए सबसे धीमा (double pass और intermediate arrays के कारण)।
\n
• शुरुआती लोगों के लिए समझना मुश्किल।
\n
• ज़्यादा memory consume करता है।
\n

तरीका 4: Array.fill() + map()

एक और लोकप्रिय विकल्प:

const createArrayFill = n => Array(n).fill().ma