इंडेक्स के अनुसार ऐरे में एलिमेंट डालना: JS में अंदरूनी काम कैसे होता है

परिचय: ऐरे में एलिमेंट डालने का सवाल इतना लोकप्रिय क्यों है?

कल्पना करें: आप कोड लिख रहे हैं, और आपको कार्यों की सूची के बीच में एक नया कार्य जोड़ना है, या वर्णमाला क्रम में एक सॉर्ट किए गए ऐरे में एक उपयोगकर्ता डालना है। लगता है, इसमें क्या मुश्किल है? लेकिन अगर आप JavaScript में नए हैं, तो पहला विचार push() या unshift() का उपयोग करने का आता है। हालांकि, ये केवल अंत या शुरुआत में एलिमेंट जोड़ते हैं। लेकिन अगर किसी विशिष्ट इंडेक्स की आवश्यकता हो तो क्या करें?

यही सवाल Stack Overflow पर हज़ारों बार देखा गया है। इस लेख में हम केवल तैयार उत्तर नहीं देंगे, बल्कि JavaScript इंजन के अंदरूनी काम को देखेंगे और समझेंगे कि ऐरे में एलिमेंट डालना वास्तव में कैसे काम करता है। आप न केवल splice() विधि का जादू जानेंगे, बल्कि यह भी समझेंगे कि मेमोरी में क्या प्रक्रियाएँ होती हैं। चलिए शुरू करते हैं!

सीधा उत्तर: इंडेक्स के अनुसार एलिमेंट कैसे डालें

सबसे सरल और सही तरीका splice() विधि का उपयोग करना है। यह विधि ऐरे की सामग्री को बदलती है, एलिमेंट्स को हटाकर, बदलकर या जोड़कर। क्लासिक डालने का तरीका इस प्रकार है:

let fruits = ['apple', 'banana', 'cherry'];\nlet index = 1; // 'apple' के बाद डालें\nlet itemToInsert = 'orange';\n\nfruits.splice(index, 0, itemToInsert);\nconsole.log(fruits); // ['apple', 'orange', 'banana', 'cherry']

सिंटैक्स को समझते हैं:

\n
• पहला आर्गुमेंट (index) — वह इंडेक्स जहाँ से ऐरे को बदलना शुरू करना है।
\n
• दूसरा आर्गुमेंट (0) — हटाए जाने वाले एलिमेंट्स की संख्या। शून्य का मतलब है कि हम कुछ नहीं हटा रहे, केवल डाल रहे हैं।
\n
• तीसरा और बाद के आर्गुमेंट्स — वे एलिमेंट्स जिन्हें जोड़ना है। आप कई मान भेज सकते हैं।
\n

यह विधि ऐरे के साथ काम करने के लिए एक बहुमुखी स्विस चाकू है। लेकिन यह अंदर से कैसे काम करता है? आइए समझते हैं।

अंदरूनी काम: splice() एलिमेंट्स को कैसे हिलाता है

जब आप splice() को कॉल करते हैं, तो JavaScript इंजन (जैसे Chrome में V8 या Firefox में SpiderMonkey) कई चरण करता है:

1. सीमाओं और प्रकार की जाँच

इंजन जाँचता है कि इंडेक्स एक संख्या है और ऐरे की लंबाई की सीमा के भीतर है या नहीं। यदि इंडेक्स नकारात्मक है, तो इसे length + index में बदल दिया जाता है। यदि आप कोई संख्या नहीं भेजते हैं — तो इसे संख्या में बदल दिया जाता है (अक्सर 0 या NaN में)।

2. ऐरे में "छेद" बनाना

मान लीजिए, हमारे पास ऐरे [A, B, C] है, और हम पोज़ीशन 1 पर X डालते हैं। इंजन को जगह खाली करनी होगी। यह केवल B के ऊपर X को "लिखता" नहीं है। इसके बजाय, यह इंडेक्स 1 से शुरू होने वाले सभी एलिमेंट्स को एक पोज़ीशन दाईं ओर खिसका देता है। यानी B, C की जगह लेता है, C एक नई पोज़ीशन (इंडेक्स 3) पर चला जाता है। इसे शिफ्टिंग कहा जाता है।

3. ऑप्टिमाइज़ेशन: निरंतर ऐरे बनाम sparse array

JavaScript ऐरे, C की तरह मेमोरी सेल्स का सिर्फ एक क्रम नहीं हैं। ये विशेष व्यवहार वाली ऑब्जेक्ट हैं। इंजन डेटा को निरंतर बफर (जैसे टाइप किए गए ऐरे में) में स्टोर करने की कोशिश करता है। यदि बीच में एलिमेंट डाला जाता है, तो इंजन को मेमोरी को पुनः आवंटित करना पड़ता है: बड़े आकार का एक नया ब्लॉक आवंटित करना और उसमें सभी एलिमेंट्स को कॉपी करना। यह एक O(n) (रैखिक जटिलता) ऑपरेशन है। ऐरे जितना बड़ा होगा, डालने में उतना ही अधिक समय लगेगा।

यदि ऐरे sparse (विरल) है, यानी इसमें "छेद" हैं (जैसे [1, , 3]), तो इंजन हैश-टेबल के रूप में स्टोरेज पर स्विच करता है। ऐसे ऐरे में डालना तेज़ हो सकता है, लेकिन अधिक मेमोरी खपत करता है।

4. लंबाई अपडेट करना

शिफ्टिंग और डालने के बाद, इंजन ऐरे की length प्रॉपर्टी को अपडेट करता है। यदि आपने एक एलिमेंट डाला है, तो लंबाई 1 बढ़ जाएगी।

यहाँ प्रक्रिया का एक सरलीकृत दृश्य है:

// मेमोरी में मूल ऐरे: [A, B, C]\n// इंडेक्स 1 पर X डालें\n// चरण 1: शिफ्ट: [A, B, C, undefined] (जगह बनाएँ)\n// चरण 2: कॉपी करना: [A, B, B, C] (B और C को शिफ्ट करें)\n// चरण 3: डालना: [A, X, B, C]\n// चरण 4: अप