सरणी आइटम को किसी अन्य सरणी में कॉपी करें

Question

मेरे पास एक जावास्क्रिप्ट सरणी है dataArrayजिसे मैं एक नए सरणी में धकेलना चाहता हूं newArray। सिवाय मैं newArray[0]होना नहीं चाहता dataArray। मैं सभी वस्तुओं को नए सरणी में धकेलना चाहता हूं:

var newArray = [];

newArray.pushValues(dataArray1);
newArray.pushValues(dataArray2);
// ...

या इससे भी बेहतर:

var newArray = new Array (
   dataArray1.values(),
   dataArray2.values(),
   // ... where values() (or something equivalent) would push the individual values into the array, rather than the array itself
);

तो अब नए सरणी में व्यक्तिगत डेटा सरणियों के सभी मूल्य शामिल हैं। क्या कुछ आशुलिपि pushValuesउपलब्ध हैं जैसे कि मुझे प्रत्येक व्यक्ति पर एक- dataArrayएक करके आइटम्स जोड़ना नहीं है?

Comments

इस url stackoverflow.com/questions/351409/appending-to-array

— जाकिर हुसैन

यह उत्तर होना चाहिए davidwalsh.name/combining-js-arrays

— starikovs

क्या इससे आपके सवाल का जवाब मिलता है? जावास्क्रिप्ट और डी-डुप्लिकेट आइटम में दो सरणियों का विलय कैसे करें

— हैकरमैन

Answer 1

कॉनकट फ़ंक्शन का उपयोग करें , जैसे:

var arrayA = [1, 2];
var arrayB = [3, 4];
var newArray = arrayA.concat(arrayB);

का मान newArrayहोगा [1, 2, 3, 4]( arrayAऔर arrayBअपरिवर्तित रहेगा; concatपरिणाम के लिए एक नया सरणी बनाता है और लौटाता है)।

Comments

एक बेहतर संदर्भ होगा: developer.mozilla.org/en/JavaScript/Reference/Global_Objects/… [1]: developer.mozilla.org/en/JavaScript/Reference/Global_Object//

— Jamund Ferguson

मैं मानता हूं कि निष्पादन निष्पादन बहुत अच्छा है। लेकिन के लिए concat बिल्कुल नहीं है कि करने के लिए उद्देश्य concat सरणियों के लिए? तो यह मानक होना चाहिए । या क्या अन्य बेहतर चीजें कॉनैट के साथ हैं? और यह केवल ब्राउज़र के जेएस इंजन के खराब कार्यान्वयन के कारण या जहां भी आप इसे उपयोग कर रहे हैं, धीमा हो सकता है? यह एक दिन तय हो सकता है। मैं हैकी स्पीड ऑप्टिमाइज़ेशन पर कोड मेंटेनेंस चुनूंगा। हम्म ....

— बिटरब्लू

इसके अलावा, मैंने सिर्फ स्थिति को चिह्नित किया: संक्षिप्त बनाम पुश.लीली। Google Chrome: fast (concat = विजेता) Opera,: fast (concat = विजेता) IE,: slower (concat = विजेता) Firefox,: slow (push.apply = विजेता), Chrome के concat से 10 गुना धीमा,) ... JS इंजन खराब होने की बात करें ।

— Bitterblue

कैसे की जाती है श्रृंखलाबद्ध दो सरणियों कैसे करने के लिए स्वीकार किए जाते हैं जवाब धक्का दूसरे में एक ?! वे दो अलग-अलग ऑपरेशन हैं।

— kaqqao

@kaqao क्योंकि pushमूल्यों की एक सरणी समतल नहीं होगा। concatप्रश्न क्या आवश्यकता है प्राप्त करता है।

— वाइजग्येह

Answer 2

बशर्ते आपके सरणियाँ विशाल नहीं हों (नीचे कैविएट देखें), आप push()उस ऐरे की विधि का उपयोग कर सकते हैं जिसमें आप मूल्यों को जोड़ना चाहते हैं। फ़ंक्शन मापदंडों की सूची के रूप में धकेल दिए जाने वाले मानों को पास करने के लिए push()आप इसकी apply()विधि का उपयोग करने के लिए कई पैरामीटर ले सकते हैं । concat()नए एरे बनाने के बजाय एलीमेंट में एलीमेंट्स को जोड़ने के उपयोग से यह फायदा होता है ।

हालांकि, ऐसा लगता है कि बड़े सरणियों (100,000 सदस्यों या अधिक के आदेश के लिए) के लिए, यह चाल विफल हो सकती है । ऐसे सरणियों के लिए, लूप का उपयोग करना बेहतर दृष्टिकोण है। देखें https://stackoverflow.com/a/17368101/96100 जानकारी के लिए।

var newArray = [];
newArray.push.apply(newArray, dataArray1);
newArray.push.apply(newArray, dataArray2);

आप इसे एक समारोह में सामान्यीकृत करना चाहते हैं:

function pushArray(arr, arr2) {
    arr.push.apply(arr, arr2);
}

... या इसे Arrayप्रोटोटाइप में जोड़ें :

Array.prototype.pushArray = function(arr) {
    this.push.apply(this, arr);
};

var newArray = [];
newArray.pushArray(dataArray1);
newArray.pushArray(dataArray2);

... या push()इस तथ्य का उपयोग करके कई मापदंडों की अनुमति देकर मूल विधि का अनुकरण करें concat(), जैसे push(), कई मापदंडों की अनुमति देता है:

Array.prototype.pushArray = function() {
    this.push.apply(this, this.concat.apply([], arguments));
};

var newArray = [];
newArray.pushArray(dataArray1, dataArray2);

यहां अंतिम उदाहरण का एक लूप-आधारित संस्करण है, जो बड़े सरणियों और IE <= 8 सहित सभी प्रमुख ब्राउज़रों के लिए उपयुक्त है:

Array.prototype.pushArray = function() {
    var toPush = this.concat.apply([], arguments);
    for (var i = 0, len = toPush.length; i < len; ++i) {
        this.push(toPush[i]);
    }
};

Comments

नोट: के newArray.push.apply(newArray, dataArray1);रूप में ही देता हैArray.prototype.push.applay(newArray,dataArra1);

क्या यह पुराने ब्राउज़रों के साथ संगत है?

— डेमियन la Ceallaigh

developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/…

— डेमियन

@ Damien @Ceallaigh: हाँ। यह सभी IE 6 और पहले भी वापस आने वाले ब्राउज़रों के साथ संगत है।

— टिम डाउन

यह खराब प्रोग्रामिंग प्रथाओं का प्रतीक है। Array.prototype.concatयह बुरा नहीं है, बल्कि यह केवल गलत समझा जाता है और कभी-कभी इसका दुरुपयोग किया जाता है। इन परिस्थितियों में, यह केवल गलत समझा जाता है, लेकिन इसका दुरुपयोग नहीं किया जाता है।

— जैक गिफिन

Answer 3

मैं एक और "भविष्य प्रूफ" उत्तर जोड़ूंगा

ECMAScript 6 में, आप स्प्रेड सिंटैक्स का उपयोग कर सकते हैं :

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

console.log(arr1)

स्प्रेड सिंटैक्स अभी तक सभी प्रमुख ब्राउज़रों में शामिल नहीं है। वर्तमान संगतता के लिए, इसे (लगातार अद्यतन) संगतता तालिका देखें ।

हालाँकि, आप Babel.js के साथ फैल सिंटैक्स का उपयोग कर सकते हैं ।

संपादित करें:

प्रदर्शन के बारे में अधिक टिप्पणियों के लिए जैक गिफिन का जवाब नीचे देखें। ऐसा लगता है कि कॉनकैट प्रसार ऑपरेटर की तुलना में अभी भी बेहतर और तेज है।

Comments

यदि आप टाइपस्क्रिप्ट का उपयोग कर रहे हैं, तो आप स्प्रेड ऑपरेटर का भी उपयोग कर सकते हैं। यदि आप ES5 को लक्षित करते हैं, तो यह संकलन करेगा newArray.apply(newArray, dataArray1)।

— एजे रिचर्डसन

ध्यान दें: यदि आपको तीसरे सरणी में परिणाम की आवश्यकता है (इस प्रकार arr1 को संशोधित नहीं किया जा सकता है, जैसा कि प्रारंभिक प्रश्न की आवश्यकता थी), तो आप newArray = [... arr1, ... arr2] कर सकते हैं

— dim

ओह, मुझे नहीं पता था। धन्यवाद। मैंने एक टिप्पणी संपादित की है।

— कारेल बिलेक

इसी तरह से कैसे कॉनकैट तब काम करेगा, जब बोनस कायम रहना (मूल सरणी को बदलना)।

— रोब

@robertmylne प्रसार ऑपरेटर स्पष्ट रूप से मूल सरणी को संशोधित नहीं करता है, इसके बजाय सभी सरणियों सामग्री की एक नई प्रतिलिपि बनाता है।

— जैक गिफिन

Answer 4

एमडीएन से एक सुंदर तरीका मिला

var vegetables = ['parsnip', 'potato'];
var moreVegs = ['celery', 'beetroot'];

// Merge the second array into the first one
// Equivalent to vegetables.push('celery', 'beetroot');
Array.prototype.push.apply(vegetables, moreVegs);

console.log(vegetables); // ['parsnip', 'potato', 'celery', 'beetroot']

या आप spread operatorES6 की सुविधा का उपयोग कर सकते हैं :

let fruits = [ 'apple', 'banana'];
const moreFruits = [ 'orange', 'plum' ];

fruits.push(...moreFruits); // ["apple", "banana", "orange", "plum"]

Comments

यह वह नहीं है जो सवाल पूछ रहा था। सवाल हर बार एक नई सरणी बनाने का तरीका पूछ रहा है, एक पुरानी सरणी को संशोधित करने का नहीं।

— जैक गिफिन

Answer 5

var a=new Array('a','b','c');
var b=new Array('d','e','f');
var d=new Array('x','y','z');
var c=a.concat(b,d)

क्या इससे आपकी समस्या हल होती है?

Answer 6

निम्नलिखित मुझे सबसे सरल लगता है:

var newArray = dataArray1.slice();
newArray.push.apply(newArray, dataArray2);

जैसा कि "पुश" तर्कों की एक चर संख्या लेता है, आप किसी अन्य सरणी के सभी तत्वों को पुश करने applyके लिए pushफ़ंक्शन की विधि का उपयोग कर सकते हैं । यह अपने पहले तर्क ("newArray" को यहां "इस" और बाकी तर्कों के रूप में सरणी के तत्वों का उपयोग करके पुश करने के लिए कॉल का निर्माण करता है।

sliceपहले बयान में पहली सरणी की एक प्रति हो जाता है, तो आप इसे बदलाव न करें।

अद्यतन यदि आप उपलब्ध स्लाइस के साथ जावास्क्रिप्ट के एक संस्करण का उपयोग कर रहे हैं, तो आप pushअभिव्यक्ति को सरल बना सकते हैं :

newArray.push(...dataArray2)

Comments

एमडीएन में "विलय दो सरणियों" के लिए एक उदाहरण के रूप में यहां भी उल्लेख किया गया है

— विल्ट

Answer 7

नीचे दिए गए फ़ंक्शन में सरणियों की लंबाई के साथ कोई समस्या नहीं है और सभी सुझाए गए समाधानों से बेहतर प्रदर्शन करता है:

function pushArray(list, other) {
    var len = other.length;
    var start = list.length;
    list.length = start + len;
    for (var i = 0; i < len; i++ , start++) {
        list[start] = other[i];
    }
}

दुर्भाग्य से, jspref ने मेरी प्रस्तुतियाँ स्वीकार करने से इंकार कर दिया, इसलिए यहाँ वे बेंचमार्क.जेएस का उपयोग कर परिणाम हैं

        Name            |   ops/sec   |  ± %  | runs sampled
for loop and push       |      177506 |  0.92 | 63
Push Apply              |      234280 |  0.77 | 66
spread operator         |      259725 |  0.40 | 67
set length and for loop |      284223 |  0.41 | 66

कहाँ पे

पाश और धक्का के लिए है:

    for (var i = 0, l = source.length; i < l; i++) {
        target.push(source[i]);
    }

पुश लागू करें:

target.push.apply(target, source);

प्रसार ऑपरेटर:

    target.push(...source);

और अंत में 'सेट की लंबाई और लूप के लिए' उपरोक्त फ़ंक्शन है

Comments

यह प्रश्न हर बार एक नई सरणी बनाने का तरीका खोज रहा है, किसी मौजूदा सरणी को संशोधित करने का नहीं।

— जैक गिफिन

Answer 8

𝗥𝗲𝘀𝘂𝗹𝘁𝘀 𝗥𝗲𝘀𝘂𝗹𝘁𝘀 𝗥𝗲𝘀𝘂𝗹𝘁𝘀

तथ्यों के लिए, jsperf में एक प्रदर्शन परीक्षण और कंसोल में कुछ चीजों की जांच की जाती है। शोध के लिए, irt.org वेबसाइट का उपयोग किया जाता है। नीचे इन सभी स्रोतों का एक संग्रह है, साथ ही नीचे एक उदाहरण समारोह भी रखा गया है।

╔═══════════════╦══════╦═════════════════╦════════ ═══════╦═════════╦══════════╗
║ विधि ║Concat║slice और push.apply app push.apply x2 ║ ForLoop ║Spread ║
╠═══════════════╬══════╬═════════════════╬════════ ═══════╬═════════╬══════════╣
║ mOps / Sec 9179 ║104 ║ 76 ║ 81 O28 /
╠═══════════════╬══════╬═════════════════╬════════ ═══════╬═════════╬══════════╣
║ विरल सरणियों ESYES! ║ केवल कटा हुआ ║ नहीं ║ शायद 2   ║ कोई slic
║ विरल रखा गया ║ ║array (प्रथम arg) se se sp se
╠═══════════════╬══════╬═════════════════╬════════ ═══════╬═════════╬══════════╣
║ समर्थन ║MSIE 4║MSIE 5.5 5.5 MSIE 5.5 4 MSIE 4 dEdge 12 ║
║ ( स्रोत ) NNNav 4║NNav 4.06 av NNav 4.06 N NNav 3 av MSIE  NNav ║
╠═══════════════╬══════╬═════════════════╬════════ ═══════╬═════════╬══════════╣
Lyअरे की तरह हरकतें ║ केवल ║ हां धकेल दिया! ║ हाँ! ║यदि ║ है
║like एक सरणी ║ rayarray (दूसरा arg) ║ ║ atoriterator 1   ║
╚═══════════════╩══════╩═════════════════╩════════ ═══════╩═════════╩══════════╝
1 यदि सरणी जैसी ऑब्जेक्ट में Symbol.iterator गुण नहीं है , तो कोशिश कर रहा है
  फैलाने के लिए यह एक अपवाद फेंक देगा।
2 कोड पर निर्भर करता है। निम्न उदाहरण कोड "YES" विरलता को संरक्षित करता है।

function mergeCopyTogether(inputOne, inputTwo){
   var oneLen = inputOne.length, twoLen = inputTwo.length;
   var newArr = [], newLen = newArr.length = oneLen + twoLen;
   for (var i=0, tmp=inputOne[0]; i !== oneLen; ++i) {
        tmp = inputOne[i];
        if (tmp !== undefined || inputOne.hasOwnProperty(i)) newArr[i] = tmp;
    }
    for (var two=0; i !== newLen; ++i, ++two) {
        tmp = inputTwo[two];
        if (tmp !== undefined || inputTwo.hasOwnProperty(two)) newArr[i] = tmp;
    }
    return newArr;
}

जैसा कि ऊपर देखा गया है, मैं तर्क दूंगा कि कॉनैट लगभग हमेशा प्रदर्शन के लिए जाने का तरीका है और अतिरिक्त सरणियों की दुर्लभता को बनाए रखने की क्षमता है। फिर, सरणी-पसंद (जैसे DOMNodeLists जैसे document.body.children) के लिए, मैं लूप के लिए उपयोग करने की सलाह दूंगा क्योंकि यह 2 सबसे अधिक प्रदर्शन करने वाला और एकमात्र अन्य तरीका है जो विरल सरणियों को बनाए रखता है। नीचे, हम जल्दी से खत्म हो जाएगा और विरल सरणियों और भ्रम को स्पष्ट करने के लिए सरणी-पसंद से क्या मतलब है।

𝗧𝗵𝗲 𝗧𝗵𝗲

सबसे पहले, कुछ लोग सोच सकते हैं कि यह एक अस्थायी है और ब्राउज़र विक्रेताओं को अंततः Array.prototyp.push का अनुकूलन करने के लिए चारों ओर ले जाएगा और Array.prototyp.concat को हरा देने के लिए पर्याप्त तेज़ होगा। गलत! Array.prototype.concat हमेशा तेज़ होगा (सिद्धांत में कम से कम) क्योंकि यह डेटा पर एक साधारण कॉपी-एन-पेस्ट है। नीचे एक सरलीकृत प्रेरक-दृश्य आरेख है, जिसमें 32-बिट सरणी कार्यान्वयन कैसा दिख सकता है (कृपया ध्यान दें कि वास्तविक कार्यान्वयन एक बहुत अधिक जटिल हैं)

बाइट te यहां डेटा
═════╬═══════════
0x00 x int nonNumericPropertiesLength = 0x00000000
0x01 ║ ibid
0x02 ║ ibid
0x03 ║ ibid
0x00 x इंट लंबाई = 0x00000001
0x01 ║ ibid
0x02 ║ ibid
0x03 ║ ibid
0x00 x int valueIndex = 0x00000000
0x01 ║ ibid
0x02 ║ ibid
0x03 ║ ibid
0x00 x int valueType = JS_PRIMITIVE_NUMBER
0x01 ║ ibid
0x02 ║ ibid
0x03 ║ ibid
0x00 x uintptr_t valuePointer = 0x38d9eb60 (या जहाँ भी यह मेमोरी में है)
0x01 ║ ibid
0x02 ║ ibid
0x03 ║ ibid

जैसा कि ऊपर देखा गया है, आपको कुछ ऐसा करने की ज़रूरत है जो बाइट के लिए बाइट को कॉपी करते हुए लगभग उतना ही सरल हो। Array.prototype.push.apply के साथ, यह डेटा पर एक साधारण कॉपी-एन-पेस्ट की तुलना में बहुत अधिक है। ".Apply" को सरणी में प्रत्येक सूचकांक की जांच करनी होगी और इसे Array.prototype.push पर जाने से पहले तर्क के सेट में परिवर्तित करना होगा। फिर, Array.prototype.push को अतिरिक्त रूप से प्रत्येक बार अधिक मेमोरी आवंटित करनी होती है, और (कुछ ब्राउज़र कार्यान्वयनों के लिए) शायद स्पार्सनेस के लिए कुछ पोजीशन-लुकअप डेटा की पुन: गणना भी करें।

इसके बारे में सोचने का एक वैकल्पिक तरीका यह है। स्रोत सरणी एक एक साथ स्टेपल किए गए कागजों का एक बड़ा ढेर है। स्रोत सरणी दो भी कागजात का एक और बड़ा ढेर है। क्या यह आपके लिए तेज़ होगा

1. स्टोर पर जाएं, प्रत्येक स्रोत सरणी की प्रतिलिपि के लिए आवश्यक पर्याप्त कागज खरीदें। फिर कॉपी-मशीन के माध्यम से कागज के प्रत्येक स्रोत सरणी स्टैक रखें और परिणामस्वरूप दो प्रतियों को एक साथ स्टेपल करें।
2. स्टोर पर जाएं, पहले स्रोत सरणी की एक प्रति के लिए पर्याप्त कागज खरीदें। फिर, स्रोत सरणी को नए पेपर में हाथ से कॉपी करें, किसी भी रिक्त विरल स्पॉट को भरना सुनिश्चित करें। फिर, स्टोर पर वापस जाएं, दूसरे स्रोत सरणी के लिए पर्याप्त पेपर खरीदें। फिर, दूसरे स्रोत सरणी से गुजरें और प्रतिलिपि में कोई रिक्त अंतराल सुनिश्चित करते हुए इसे कॉपी करें। फिर, सभी कॉपी किए गए पेपर्स को एक साथ स्टेपल करें।

उपरोक्त सादृश्य में, विकल्प # 1 Array.prototype.concat का प्रतिनिधित्व करता है, जबकि # 2 Array.prototype.push.apply का प्रतिनिधित्व करता है। आइए हम इसे एक समान JSperf के साथ अलग-अलग परीक्षण करते हैं कि यह एक विरल सरणियों के तरीकों का परीक्षण करता है, न कि ठोस सरणियों का। कोई इसे यहीं पा सकता है ।

इसलिए, मैं अपने मामले को आराम देता हूं कि इस विशेष उपयोग के मामले में प्रदर्शन का भविष्य Array.prototyp.push में नहीं है, बल्कि Array.prototyp.concat में निहित है।

𝗖𝗹𝗮𝗿𝗶𝗳𝗶𝗰𝗮𝘁𝗶𝗼𝗻𝘀

𝗦𝗽𝗮𝗿𝗲 𝗦𝗽𝗮𝗿𝗲

जब सरणी के कुछ सदस्य बस गायब हैं। उदाहरण के लिए:

// This is just as an example. In actual code, 
// do not mix different types like this.
var mySparseArray = [];
mySparseArray[0] = "foo";
mySparseArray[10] = undefined;
mySparseArray[11] = {};
mySparseArray[12] =  10;
mySparseArray[17] = "bar";
console.log("Length:   ", mySparseArray.length);
console.log("0 in it:  ", 0 in mySparseArray);
console.log("arr[0]:   ", mySparseArray[0]);
console.log("10 in it: ", 10 in mySparseArray);
console.log("arr[10]   ", mySparseArray[10]);
console.log("20 in it: ", 20 in mySparseArray);
console.log("arr[20]:  ", mySparseArray[20]);

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

var mySparseArray = ["foo",,,,,,,,,,undefined,{},10,,,,,"bar"];

𝗔𝗿𝗿𝗮𝘆-𝗟𝗶𝗸𝗲𝘀

एक सरणी की तरह एक वस्तु कम से कम एक है कि lengthसंपत्ति है, लेकिन साथ आरंभ नहीं किया गया था new Arrayया []; उदाहरण के लिए, नीचे की वस्तुओं को सरणी की तरह वर्गीकृत किया गया है।

{0: "फू", 1: "बार", लंबाई: 2}

document.body.children

नई Uint8Array (3)

• यह सरणी-जैसा है क्योंकि यह एक (n) (टाइप) सरणी है, लेकिन इसे किसी सरणी में ले जाने से कंस्ट्रक्टर बदल जाता है।

(फ़ंक्शन () {वापसी तर्क}) ()

निरीक्षण करें कि एक विधि का उपयोग करने से क्या होता है जो एरोस-लाइक को स्लाइस की तरह ले जाती है।

var slice = Array.prototype.slice;
// For arrays:
console.log(slice.call(["not an array-like, rather a real array"]));
// For array-likes:
console.log(slice.call({0: "foo", 1: "bar", length:2}));
console.log(slice.call(document.body.children));
console.log(slice.call(new Uint8Array(3)));
console.log(slice.call( function(){return arguments}() ));

• ध्यान दें: प्रदर्शन के कारण फ़ंक्शन तर्कों पर स्लाइस कॉल करना बुरा अभ्यास है।

निरीक्षण करें कि एक विधि का उपयोग करने से क्या होता है जो एरे-कॉर्ट में सरणी-पसंद को कॉनराट की तरह नहीं करता है ।

var empty = [];
// For arrays:
console.log(empty.concat(["not an array-like, rather a real array"]));
// For array-likes:
console.log(empty.concat({0: "foo", 1: "bar", length:2}));
console.log(empty.concat(document.body.children));
console.log(empty.concat(new Uint8Array(3)));
console.log(empty.concat( function(){return arguments}() ));

Answer 9

जावास्क्रिप्ट ईएस 6 के साथ, आप ... ऑपरेटर को एक प्रसार ऑपरेटर के रूप में उपयोग कर सकते हैं जो अनिवार्य रूप से सरणी को मूल्यों में बदल देगा। फिर, आप कुछ इस तरह से कर सकते हैं:

const myArray = [1,2,3,4,5];
const moreData = [6,7,8,9,10];

const newArray = [
  ...myArray,
  ...moreData,
];

जबकि वाक्यविन्यास संक्षिप्त है, मुझे नहीं पता कि यह आंतरिक रूप से कैसे काम करता है और बड़े सरणियों पर प्रदर्शन के निहितार्थ क्या हैं।

Comments

यदि आप एक नज़र डालते हैं कि बैबल इसे कैसे परिवर्तित करता है , तो आप देखेंगे कि यह Array.push.applyतकनीक का उपयोग करने की तुलना में कोई धीमा नहीं होना चाहिए ।

— emil.c

@JackGiffin मैं केवल उस बात का जिक्र कर रहा था जिसका उल्लेख रयान ने किया था कि वह नहीं जानता कि यह आंतरिक रूप से कैसे काम करता है और प्रदर्शन के निहितार्थ क्या हैं, मैं वास्तव में इस दृष्टिकोण का सुझाव नहीं दे रहा था। किसी भी मामले में, आपने अपने उत्तर, अच्छे शोध पर बहुत अच्छा काम किया है, ऐसे विवरणों को जानना हमेशा अच्छा होता है।

— emil.c

Answer 10

यहाँ ES6 रास्ता है

var newArray = [];
let dataArray1 = [1,2,3,4]
let dataArray2 = [5,6,7,8]
newArray = [...dataArray1, ...dataArray2]
console.log(newArray)

उपरोक्त विधि अधिकांश मामलों और उन मामलों के लिए जाने के लिए अच्छा है, जिन पर कृपया विचार नहीं किया जाता है concat, जैसे आपके पास सरणियों में सौ हजारों आइटम हैं।

    let dataArray1 = [1,2,3,4]
    let dataArray2 = [5,6,7,8]
    let newArray = dataArray1.concat(dataArray2);
    console.log(newArray)

Answer 11

Array.prototype.push.apply के बारे में बात करने वाले कई उत्तर हैं । यहाँ एक स्पष्ट उदाहरण है:

var dataArray1 = [1, 2];
var dataArray2 = [3, 4, 5];
var newArray = [ ];
Array.prototype.push.apply(newArray, dataArray1); // newArray = [1, 2]
Array.prototype.push.apply(newArray, dataArray2); // newArray = [1, 2, 3, 4, 5]
console.log(JSON.stringify(newArray)); // Outputs: [1, 2, 3, 4, 5]

यदि आपके पास ES6 सिंटैक्स है:

var dataArray1 = [1, 2];
var dataArray2 = [3, 4, 5];
var newArray = [ ];
newArray.push(...dataArray1); // newArray = [1, 2]
newArray.push(...dataArray2); // newArray = [1, 2, 3, 4, 5]
console.log(JSON.stringify(newArray)); // Outputs: [1, 2, 3, 4, 5]

Answer 12

यदि आप मूल सरणी को संशोधित करना चाहते हैं, तो आप फैला सकते हैं और धक्का दे सकते हैं:

var source = [1, 2, 3];
var range = [5, 6, 7];
var length = source.push(...range);

console.log(source); // [ 1, 2, 3, 5, 6, 7 ]
console.log(length); // 6

यदि आप यह सुनिश्चित करना चाहते हैं कि एक ही प्रकार की वस्तुएं sourceसरणी में जाएं (उदाहरण के लिए संख्याओं और तारों को नहीं मिलाएं), तो टाइपस्क्रिप्ट का उपयोग करें।

/**
 * Adds the items of the specified range array to the end of the source array.
 * Use this function to make sure only items of the same type go in the source array.
 */
function addRange<T>(source: T[], range: T[]) {
    source.push(...range);
}

Answer 13

हमारे पास दो ए और बी हैं। कोड यहाँ क्या किया है सरणी एक मान सरणी बी में धकेल दिया है।

let a = [2, 4, 6, 8, 9, 15]

function transform(a) {
    let b = ['4', '16', '64']
    a.forEach(function(e) {
        b.push(e.toString());
    });
    return b;
}

transform(a)

[ '4', '16', '64', '2', '4', '6', '8', '9', '15' ]

Comments

कृपया उत्तर के रूप में कोड को पोस्ट न करें। बताएं कि कोड क्या करता है और यह समस्या को कैसे हल करता है।

— पैट्रिक हुंड

Answer 14

इसे इस्तेमाल करे:

var arrayA = [1, 2];
var arrayB = [3, 4];
var newArray = arrayB.reduce((pre, cur) => [...pre, ...cur], arrayA);
console.log(newArray)

Answer 15

IE के लिए पुश () फ़ंक्शन का उपयोग कॉनकैट फ़ंक्शन के बजाय। उदाहरण,

var a=a.concat(a,new Array('amin'));

Comments

दोनों बहुत ही IE संगत हैं

— जैक गिफिन

Answer 16

Тhis एक कामकाजी कोड है और यह ठीक काम करता है:

var els = document.getElementsByTagName('input'), i;
var invnum = new Array();
var k = els.length;
for(i = 0; i < k; i++){invnum.push(new Array(els[i].id,els[i].value))}