किसी नए सरणी को बनाए बिना किसी अन्य सरणी के साथ मौजूदा जावास्क्रिप्ट सरणी का विस्तार कैसे करें

Question

पायथन की extendपद्धति का अनुकरण करने के लिए मौजूदा सरणी को दूसरे सरणी के साथ विस्तारित करने का एक तरीका प्रतीत नहीं होता है ।

मैं निम्नलिखित प्राप्त करना चाहता हूं:

>>> a = [1, 2]
[1, 2]
>>> b = [3, 4, 5]
[3, 4, 5]
>>> SOMETHING HERE
>>> a
[1, 2, 3, 4, 5]

मुझे पता है कि एक a.concat(b)विधि है, लेकिन यह केवल पहले वाले को विस्तारित करने के बजाय एक नई सरणी बनाता है। मुझे एक एल्गोरिथ्म पसंद है जो कुशलता से काम करता है जब aवह b(जो कॉपी नहीं करता है a) से काफी बड़ा है ।

_{नोट: यह किसी सरणी में किसी चीज़ को जोड़ने के लिए कैसे की नकल नहीं है ? - यहां लक्ष्य एक सरणी की पूरी सामग्री को दूसरे में जोड़ना है, और इसे "जगह में" करना है, अर्थात विस्तारित सरणी के सभी तत्वों को कॉपी किए बिना।}

Comments

@ एक जवाब पर टूथब्रश की टिप्पणी से: a.push(...b)। यह शीर्ष उत्तर की अवधारणा में समान है, लेकिन ES6 के लिए अद्यतन किया गया है।

— tscizzle

Answer 1

.pushविधि कई तर्क ले सकते हैं। आप दूसरे सरणी के सभी तत्वों को तर्क के रूप में पारित करने के लिए प्रसार ऑपरेटर का उपयोग कर सकते हैं .push:

>>> a.push(...b)

यदि आपका ब्राउज़र ECMAScript 6 का समर्थन नहीं करता है, तो आप .applyइसके बजाय उपयोग कर सकते हैं :

>>> a.push.apply(a, b)

या शायद, अगर आपको लगता है कि यह स्पष्ट है:

>>> Array.prototype.push.apply(a,b)

कृपया ध्यान दें कि यदि सरणी bबहुत लंबी है (ब्राउज़र के आधार पर परेशानी 100,000 से अधिक तत्वों पर शुरू होती है) तो ये सभी समाधान विफल हो जाएंगे ।
यदि आप इस बात की गारंटी नहीं दे सकते कि bयह पर्याप्त है, तो आपको दूसरे उत्तर में वर्णित मानक लूप-आधारित तकनीक का उपयोग करना चाहिए।

Comments

मुझे लगता है कि यह आपकी सबसे अच्छी शर्त है। कुछ भी शामिल करने के लिए चलना या लागू करने का एक और परिवाद शामिल है ()

— पीटर बेली

यह उत्तर विफल हो जाएगा यदि "b" (मेरे द्वारा विस्तारित करने की सारणी) बड़ी है (मेरे परीक्षणों के अनुसार Chrome में 150000 प्रविष्टियाँ)। आपको लूप के लिए उपयोग करना चाहिए, या "बी" पर इनबिल्ट "फॉरएच" फ़ंक्शन का बेहतर उपयोग करना चाहिए। मेरा उत्तर देखें: stackoverflow.com/questions/1374126/…

— jcdude

@ डाइकिंग: एरे की pushविधि किसी भी संख्या में तर्क ले सकती है, जो तब सरणी के पीछे धकेल दिए जाते हैं। तो a.push('x', 'y', 'z')एक वैध कॉल है जो a3 तत्वों द्वारा विस्तारित होगा । applyकिसी भी फ़ंक्शन का एक तरीका है जो एक सरणी लेता है और इसके तत्वों का उपयोग करता है जैसे कि वे सभी फ़ंक्शन के लिए स्पष्ट रूप से स्थितीय तत्व के रूप में दिए गए थे। इसलिए a.push.apply(a, ['x', 'y', 'z'])सरणी को 3 तत्वों द्वारा विस्तारित किया जाएगा। इसके अतिरिक्त, applyपहले संदर्भ के रूप में एक संदर्भ लेता है (हम aफिर से अपील करने के लिए वहां से गुजरते हैं a)।

— DzinX

नोट: इस परिदृश्य में, पहले वापसी मूल्य [1,2,3,4,5] नहीं है, लेकिन 5 जबकि == [1,2,3,4,5] बाद में।

— जवाओ

अभी तक एक और थोड़ा कम भ्रामक (और अधिक लंबे समय तक) आह्वान नहीं होगा [].push.apply(a, b):।

— niry

Answer 2

_{अद्यतन 2018 : एक बेहतर जवाब मेरा एक नए एक है : a.push(...b)। इसे अब और न बढ़ाएं, क्योंकि यह वास्तव में कभी भी सवाल का जवाब नहीं देता है, लेकिन यह पहली हिट-ऑन-गूगल के आसपास 2015 का हैक था :)}

---

उन लोगों के लिए जो बस "जावास्क्रिप्ट सरणी विस्तार" के लिए खोज करते हैं और यहां मिले हैं, आप बहुत अच्छी तरह से उपयोग कर सकते हैं Array.concat।

var a = [1, 2, 3];
a = a.concat([5, 4, 3]);

कॉनटैट नए एरे को कॉपी करेगा, क्योंकि थ्रेड स्टार्टर नहीं चाहता था। लेकिन आप परवाह नहीं कर सकते हैं (निश्चित रूप से अधिकांश प्रकार के उपयोग के लिए यह ठीक होगा)।

---

प्रसार ऑपरेटर के रूप में इसके लिए कुछ अच्छी ECMAScript 6 चीनी भी है:

const a = [1, 2, 3];
const b = [...a, 5, 4, 3];

(इसकी प्रतियां भी हैं।)

Comments

प्रश्न स्पष्ट रूप से कहा गया था: "एक नई सरणी

— विल्ट

@ रजाई: यह सच है, जवाब में कहा गया है, हालांकि :) यह पहली बार Google पर एक लंबे समय से हिट था। इसके अलावा अन्य समाधान बदसूरत थे, कुछ वैचारिक और अच्छा चाहते थे। हालाँकि आजकल arr.push(...arr2)नया और बेहतर है और इस विशेष प्रश्न का तकनीकी रूप से सही (tm) उत्तर है।

— ओडिन्हो - वेलमॉन्ट

मैं आपको सुनता हूं, लेकिन मैंने "नई श्रेणी बनाए बिना जावास्क्रिप्ट एपेंड अरेंजमेंट" के लिए खोज की , तो यह देखकर दुख होता है कि 60 बार उत्क्रमित उत्तर जो कि उच्च होता है, वह वास्तविक प्रश्न का उत्तर नहीं देता;) मैंने नीचा नहीं देखा; चूंकि आपने अपने उत्तर में इसे स्पष्ट कर दिया है।

— विल्ट

Answer 3

आपको लूप-आधारित तकनीक का उपयोग करना चाहिए। इस पृष्ठ पर अन्य उत्तर जो उपयोग पर आधारित .applyहैं, बड़े सरणियों के लिए विफल हो सकते हैं।

एक काफी लूप आधारित आधारित कार्यान्वयन है:

Array.prototype.extend = function (other_array) {
    /* You should include a test to check whether other_array really is an array */
    other_array.forEach(function(v) {this.push(v)}, this);
}

फिर आप निम्न कार्य कर सकते हैं:

var a = [1,2,3];
var b = [5,4,3];
a.extend(b);

DzinX का उत्तर ( push.apply का उपयोग करके) और अन्य .applyआधारित विधियां विफल हो जाती हैं जब हम जिस सरणी को जोड़ रहे हैं वह बड़ी है (परीक्षण बताते हैं कि मेरे लिए बड़ा है क्रोम में 150,000 प्रविष्टियाँ, और> फ़ायरफ़ॉक्स में 500,000 प्रविष्टियाँ)। आप इस त्रुटि को इस jsperf में देख सकते हैं ।

त्रुटि तब होती है क्योंकि कॉल स्टैक का आकार तब पार हो जाता है जब 'Function.prototype.apply' को दूसरे तर्क के रूप में एक बड़े सरणी के साथ कहा जाता है। (MDN का उपयोग कर कॉल स्टैक आकार को बढ़ाए के खतरों पर एक नोट है Function.prototype.apply - शीर्षक खंड देखें "लागू करते हैं और बिल्ट-इन कार्य"।)

इस पृष्ठ पर अन्य उत्तरों की गति की तुलना के लिए, इस jsperf ( EaterOfCode के लिए धन्यवाद) की जाँच करें। लूप-आधारित कार्यान्वयन उपयोग करने की गति के समान है Array.push.apply, लेकिन इससे थोड़ा धीमा हो जाता है Array.slice.apply।

दिलचस्प बात यह है कि अगर आप forEachजिस ऐरे को जोड़ रहे हैं वह विरल है, तो ऊपर दी गई विधि स्पार्सिटी का फायदा उठा सकती है और .applyबेस्ड तरीकों को बेहतर बना सकती है ; बाहर की जाँच इस jsperf आप खुद के लिए यह परीक्षण करने के लिए चाहते हैं।

वैसे, आगे के क्रियान्वयन को छोटा करने के लिए (जैसा कि मैं था!) ​​को लुभाओ मत:

Array.prototype.extend = function (array) {
    array.forEach(this.push, this);
}

क्योंकि यह कचरा परिणाम पैदा करता है! क्यों? क्योंकि Array.prototype.forEachइस फ़ंक्शन को कॉल करने के लिए तीन तर्क प्रदान करता है - ये हैं: (element_value, element_index, source_array)। forEachयदि आप "forEach (this.push, this)" का उपयोग करते हैं , तो ये सभी आपके पुनरावृत्ति के लिए आपकी पहली सरणी पर धकेल दिए जाएंगे !

Comments

ps का परीक्षण करने के लिए कि क्या अन्य_अरे वास्तव में एक सरणी है, यहां वर्णित विकल्पों में से एक चुनें: stackoverflow.com/questions/767486/…

— 17

अच्छा उत्तर। मुझे इस समस्या की जानकारी नहीं थी। मैंने आपके उत्तर का हवाला दिया है: stackoverflow.com/a/4156156/96100

— टिम डाउन

.push.applyवास्तव .forEachमें v8 की तुलना में बहुत तेज है , सबसे तेज अभी भी एक इनलाइन लूप है।

— बेंजामिन ग्रुएनबाम

@BenjaminGruenbaum - क्या आप कुछ परिणाम दिखाते हुए लिंक पोस्ट कर सकते हैं? जहां तक ​​मैं इस टिप्पणी के अंत में लिंक किए गए jsperf पर एकत्रित परिणामों से देख सकता हूं, क्रोम / क्रोमियम (v25 के बाद से सभी संस्करणों में) की .forEachतुलना .push.applyमें इसका उपयोग तेज है । मैं अलगाव में v8 का परीक्षण करने में सक्षम नहीं हूं, लेकिन अगर आपके पास कृपया अपने परिणाम लिंक करें। Jsperf देखें: jsperf.com/array-extending-push-vs-concat/5

— jcdude

@jcdude आपका jsperf अमान्य है। जैसा कि आपके सरणी में सभी तत्व हैं undefined, इसलिए .forEachउन्हें छोड़ दें, जिससे यह सबसे तेज़ हो जाएगा। .spliceवास्तव में सबसे तेज है ?! jsperf.com/array-extending-push-vs-concat/18

— EaterOfCode

Answer 4

मुझे लगता है कि इन दिनों सबसे सुरुचिपूर्ण है:

arr1.push(...arr2);

प्रसार ऑपरेटर पर MDN लेख ES2015 (ES6) में यह अच्छा मीठा रास्ता उल्लेख है:

एक बेहतर धक्का

उदाहरण: किसी सरणी को किसी मौजूदा सरणी के अंत में धकेलने के लिए अक्सर पुश का उपयोग किया जाता है। ES5 में यह अक्सर किया जाता है:

var arr1 = [0, 1, 2];
var arr2 = [3, 4, 5];
// Append all items from arr2 onto arr1
Array.prototype.push.apply(arr1, arr2);

ES6 में प्रसार के साथ यह हो जाता है:

var arr1 = [0, 1, 2];
var arr2 = [3, 4, 5];
arr1.push(...arr2);

ध्यान दें कि arr2विशाल नहीं हो सकता (इसे लगभग 100 000 आइटम के तहत रखें), क्योंकि कॉल ढेर हो जाती है, जैसे कि jcdude का जवाब।

Comments

बस एक गलती से मैं सिर्फ एक चेतावनी। ES6 संस्करण बहुत करीब है arr1.push(arr2)। यह एक ऐसी समस्या हो सकती है arr1 = []; arr2=['a', 'b', 'd']; arr1.push(arr2), जिसके परिणामस्वरूप arr1 == [['a','b','d']]संयुक्त दो सरणियों के बजाय सरणियों की एक सरणी हो सकती है । यह एक आसान गलती है। मैं इस कारण से नीचे अपना दूसरा उत्तर पसंद करता हूं। stackoverflow.com/a/31521404/4808079

— सेप रीड

उपयोग करते समय एक सुविधा .concatहै कि दूसरा तर्क एक सरणी नहीं होना चाहिए। यह प्रसार संचालक के साथ संयोजन करके प्राप्त किया जा सकता है concat, जैसेarr1.push(...[].concat(arrayOrSingleItem))

— स्टीवन प्रिबिलिनस्की

यह उन मामलों के लिए आधुनिक, सुरुचिपूर्ण जावास्क्रिप्ट है जहां लक्ष्य सरणी खाली नहीं है।

— टिम्बो

क्या यह उपवास पर्याप्त है?

— Roel

@RoelDelosReyes: हाँ।

— ओडिन्हो - वेलमॉन्ट

Answer 5

apply()जावास्क्रिप्ट के बारे में पहले कुछ शब्द यह समझने में मदद करने के लिए कि हम इसका उपयोग क्यों करते हैं:

apply()विधि एक दिए गए के साथ एक फ़ंक्शन को कॉल thisमूल्य, और तर्क एक सरणी के रूप में प्रदान की है।

पुश सरणी में जोड़ने के लिए मदों की एक सूची की अपेक्षा करता है । apply()विधि, तथापि, एक सरणी के रूप में समारोह कॉल के लिए उम्मीद तर्क लेता है। यह हमें pushएक सरणी के तत्वों को आसानी से अंतर्निहित push()विधि के साथ दूसरे सरणी में अनुमति देता है ।

कल्पना कीजिए कि आपके पास ये सरणियाँ हैं:

var a = [1, 2, 3, 4];
var b = [5, 6, 7];

और बस यह करो:

Array.prototype.push.apply(a, b);

परिणाम होगा:

a = [1, 2, 3, 4, 5, 6, 7];

एक ही बात ES6 में प्रसार ऑपरेटर का उपयोग करके किया जा सकता है ("... ") :

a.push(...b); //a = [1, 2, 3, 4, 5, 6, 7]; 

छोटा और बेहतर लेकिन इस समय सभी ब्राउज़रों में पूरी तरह से समर्थित नहीं है।

इसके अलावा, यदि आप इस प्रक्रिया में खाली करने के लिए सरणी से सब कुछ स्थानांतरित करना चाहते हैं , तो आप यह कर सकते हैं:bab

while(b.length) {
  a.push(b.shift());
} 

और परिणाम इस प्रकार होगा:

a = [1, 2, 3, 4, 5, 6, 7];
b = [];

Comments

या while (b.length) { a.push(b.shift()); }, सही है?

— लार्स

Answer 6

यदि आप jQuery का उपयोग करना चाहते हैं, तो $ .merge () है

उदाहरण:

a = [1, 2];
b = [3, 4, 5];
$.merge(a,b);

परिणाम: a = [1, 2, 3, 4, 5]

Comments

मैं (स्रोत कोड में) कार्यान्वयन कैसे पा सकता हूं jQuery.merge()?

— ma11hew28

मुझे 10 मिनट लगे - jQuery खुला स्रोत है और स्रोत जीथब पर प्रकाशित किया गया है। मैंने "मर्ज" के लिए एक खोज की और आगे स्थित है जो कोर। जेएस फ़ाइल में मर्ज फ़ंक्शन की परिभाषा प्रतीत हुई, देखें: github.com/jquery/jquery/blob/master/src/core/js#L331

— amn

Answer 7

मुझे a.push.apply(a, b)ऊपर वर्णित विधि पसंद है , और यदि आप चाहते हैं कि आप हमेशा इस तरह से एक पुस्तकालय समारोह बना सकें:

Array.prototype.append = function(array)
{
    this.push.apply(this, array)
}

और इसे इस तरह से उपयोग करें

a = [1,2]
b = [3,4]

a.append(b)

Comments

Push.apply विधि का उपयोग नहीं किया जाना चाहिए क्योंकि यह एक स्टैक ओवरफ्लो का कारण बन सकता है (और इसलिए विफल) अगर आपका "सरणी" तर्क एक बड़ा सरणी है (जैसे कि Chrome में ~ 150000 प्रविष्टियाँ)। आपको "array.forEach" का उपयोग करना चाहिए - मेरा उत्तर देखें: stackoverflow.com/a/17368101/1280629

— jcdude

Answer 8

इसका उपयोग करना संभव है splice():

b.unshift(b.length)
b.unshift(a.length)
Array.prototype.splice.apply(a,b) 
b.shift() // Restore b
b.shift() // 

लेकिन बदसूरत होने के बावजूद यह push.applyकम से कम फ़ायरफ़ॉक्स 3.0 में नहीं है।

Comments

मैं एक ही बात पाया है, जोड़ लगभग 10,000 तत्व सरणियों जब तक प्रत्येक आइटम धकेलने के लिए प्रदर्शन संवर्द्धन प्रदान नहीं करता है jsperf.com/splice-vs-push

— ड्रयू

+1 इसे जोड़ने और प्रदर्शन तुलना के लिए धन्यवाद, मुझे इस पद्धति के परीक्षण के प्रयास से बचाया।

— jjrv

यदि कोई ख बड़ी है तो स्टैक ओवरफ्लो के कारण स्प्लिस.प्पली या पुश.प्पली या तो फेल हो सकते हैं। वे "for" या "forEach" लूप का उपयोग करने से भी धीमी हैं - इस jsPerf देखें: jsperf.com/array-extending-push-vs-concat/5 और मेरा उत्तर stackoverflow.com.com/estions/1374126/…

— jcdude

Answer 9

यह समाधान मेरे लिए काम करता है (ECMAScript 6 के प्रसार ऑपरेटर का उपयोग करके):

let array = ['my', 'solution', 'works'];
let newArray = [];
let newArray2 = [];
newArray.push(...array); // Adding to same array
newArray2.push([...array]); // Adding as child/leaf/sub-array
console.log(newArray);
console.log(newArray2);

Answer 10

आप विस्तार के लिए पॉलीफ़िल बना सकते हैं जैसा कि मैंने नीचे दिया है। यह सरणी में जोड़ देगा; इन-प्लेस और स्वयं वापसी, ताकि आप अन्य तरीकों को चेन कर सकें।

if (Array.prototype.extend === undefined) {
  Array.prototype.extend = function(other) {
    this.push.apply(this, arguments.length > 1 ? arguments : other);
    return this;
  };
}

function print() {
  document.body.innerHTML += [].map.call(arguments, function(item) {
    return typeof item === 'object' ? JSON.stringify(item) : item;
  }).join(' ') + '\n';
}
document.body.innerHTML = '';

var a = [1, 2, 3];
var b = [4, 5, 6];

print('Concat');
print('(1)', a.concat(b));
print('(2)', a.concat(b));
print('(3)', a.concat(4, 5, 6));

print('\nExtend');
print('(1)', a.extend(b));
print('(2)', a.extend(b));
print('(3)', a.extend(4, 5, 6));

body {
  font-family: monospace;
  white-space: pre;
}

Answer 11

जवाब मिला रहा है ...

Array.prototype.extend = function(array) {
    if (array.length < 150000) {
        this.push.apply(this, array)
    } else {
        for (var i = 0, len = array.length; i < len; ++i) {
            this.push(array[i]);
        };
    }  
}

Comments

नहीं, ऐसा करने की कोई आवश्यकता नहीं है। ForEach का उपयोग करने वाले लूप के लिए push.apply का उपयोग करने की तुलना में तेज़ है, और इससे कोई फर्क नहीं पड़ता कि ऐरे की लंबाई कितनी है। मेरे संशोधित उत्तर पर एक नज़र डालें: stackoverflow.com/a/17368101/1280629 किसी भी मामले में, आप कैसे जानते हैं कि 150000 सभी ब्राउज़रों के लिए उपयोग करने के लिए सही संख्या है? यह एक ठगना है।

— jcdude

जबरदस्त हंसी। मेरा उत्तर पहचानने योग्य नहीं है, लेकिन उस समय पाए गए अन्य लोगों के कुछ कॉम्बो प्रतीत होते हैं - अर्थात सारांश। कोई चिंता नहीं है

— zCoder 12

Answer 12

एक और समाधान दो से अधिक सरणियों को मर्ज करने के लिए

var a = [1, 2],
    b = [3, 4, 5],
    c = [6, 7];

// Merge the contents of multiple arrays together into the first array
var mergeArrays = function() {
 var i, len = arguments.length;
 if (len > 1) {
  for (i = 1; i < len; i++) {
    arguments[0].push.apply(arguments[0], arguments[i]);
  }
 }
};

फिर कॉल करें और प्रिंट करें:

mergeArrays(a, b, c);
console.log(a)

आउटपुट होगा: Array [1, 2, 3, 4, 5, 6, 7]

Answer 13

जवाब सुपर सरल है।

>>> a = [1, 2]
[1, 2]
>>> b = [3, 4, 5]
[3, 4, 5]
>>> SOMETHING HERE
(The following code will combine the two arrays.)

a = a.concat(b);

>>> a
[1, 2, 3, 4, 5]

कॉनकैट, जावास्क्रिप्ट स्ट्रिंग संघनन के समान ही कार्य करता है। यह आपके द्वारा फ़ंक्शन को कॉल करने वाले सरणी के अंत में कॉनकैट फ़ंक्शन में डाले गए पैरामीटर के संयोजन को वापस कर देगा। क्रूक्स यह है कि आपको किसी वैरिएबल को लौटाया गया मान असाइन करना होगा या यह खो जाता है। इसलिए उदाहरण के लिए

a.concat(b);  <--- This does absolutely nothing since it is just returning the combined arrays, but it doesn't do anything with it.

Comments

के रूप में स्पष्ट रूप से में कहा गया है के लिए डॉक्स Array.prototype.concat()MDN में यह एक वापस आ जाएगी नई सरणी , यह ओ पी के रूप में मौजूदा सरणी के लिए संलग्न नहीं स्पष्ट रूप से पूछ रहा था होगा।

— विल्ट

Answer 14

Array.extendइसके बजाय Array.push> 150,000 रिकॉर्ड्स के लिए उपयोग करें ।

if (!Array.prototype.extend) {
  Array.prototype.extend = function(arr) {
    if (!Array.isArray(arr)) {
      return this;
    }

    for (let record of arr) {
      this.push(record);
    }

    return this;
  };
}

Answer 15

सुपर सरल, प्रसार ऑपरेटरों पर भरोसा नहीं करता है या लागू होता है, अगर यह एक मुद्दा है।

b.map(x => a.push(x));

इस पर कुछ प्रदर्शन परीक्षण चलाने के बाद, यह बहुत धीमा है, लेकिन एक नई सरणी नहीं बनाने के संबंध में सवाल का जवाब देता है। कॉनकैट काफी तेज है, यहां तक ​​कि jQuery का $.merge()व्हूप्स भी ।

https://jsperf.com/merge-arrays19b/1

Comments

यदि आप रिटर्न वैल्यू का उपयोग नहीं कर रहे हैं तो आपको .forEachइसके बजाय उपयोग करना चाहिए .map। यह आपके कोड के इरादे को बेहतर बनाता है।

— डेविड

@david - प्रत्येक को अपना। मैं सिनैक्स पसंद करता हूं .mapलेकिन आप भी कर सकते हैं b.forEach(function(x) { a.push(x)} )। वास्तव में मैंने इसे जेस्पेर टेस्ट में जोड़ा और यह नक्शे की तुलना में तेजी से एक बाल है। फिर भी सुपर स्लो।

— इलास्टैस्टर

यह वरीयता का मामला नहीं है। इन 'कार्यात्मक' विधियों में प्रत्येक का उनसे जुड़ा एक विशिष्ट अर्थ है। .mapयहां कॉल करना बहुत अजीब लगता है। यह कॉलिंग की तरह होगा b.filter(x => a.push(x))। यह काम करता है, लेकिन यह पाठक को भ्रमित करता है कि कुछ ऐसा हो रहा है जब वह नहीं है।

— डेविड

@elPastor यह आपके समय के लायक होना चाहिए, क्योंकि मेरे जैसा कोई दूसरा आदमी बैठेगा और अपनी गर्दन की नस को खरोंच देगा और सोच रहा होगा कि आपके कोड में और क्या हो रहा है जो वह नहीं देख सकता है। अधिकांश सामान्य मामलों में, यह इरादे की स्पष्टता है जो मायने रखती है, प्रदर्शन नहीं। कृपया उन लोगों के समय का सम्मान करें जो आपके कोड को पढ़ते हैं, क्योंकि जब आप सिर्फ एक होते हैं तो वे कई हो सकते हैं। धन्यवाद।

— दिमित्रो वाई।

@elPastor मुझे पता है कि वास्तव में क्या .map()होता है और यह मुद्दा है। यह ज्ञान मुझे लगता है कि आपको परिणामी सरणी की आवश्यकता होगी, अन्यथा यह .forEach()कॉलबैक फ़ंक्शन के दुष्प्रभावों के बारे में पाठक को सतर्क करने के लिए उपयोग करने के लिए एक अच्छी बात होगी । सख्ती से आपका समाधान बोलने से प्राकृतिक संख्याओं (परिणामों push) का एक अतिरिक्त सरणी बन जाता है , जबकि प्रश्न कहता है: "एक नया सरणी बनाए बिना"।

— दिमित्रो वाई।