किसी विशिष्ट इंडेक्स (जावास्क्रिप्ट) पर एक सरणी में एक आइटम कैसे डालें?

Question

मैं एक जावास्क्रिप्ट सरणी डालने की विधि के लिए देख रहा हूँ, की शैली में:

arr.insert(index, item)

अधिमानतः jQuery में, लेकिन कोई भी जावास्क्रिप्ट कार्यान्वयन इस बिंदु पर करेगा।

Comments

ध्यान दें कि JQuery एक DOM और ईवेंट मैनिपुलेशन लाइब्रेरी है, अपनी खुद की भाषा नहीं। यह सरणी हेरफेर के साथ कुछ नहीं करना है।

— डोमिनोज़

api.jquery.com/jQuery.inArray का DOM या घटनाओं से कोई लेना-देना नहीं है। jQuery ब्राउज़र जेएस विकास के लिए एक मिश्रित टूलकिट में विकसित हुआ है, जिससे लोगों को यह उम्मीद है कि यह सब कुछ के लिए एक विधि है।

— टिम

@ टिम, लेकिन यह अभी भी अपनी खुद की एक भाषा नहीं है (अभी भी कुछ सवाल हैं जैसे "कैसे दो नंबर को jQuery में" यहाँ SO पर)

— विक्टर

@ विक्टर नहीं, और कभी नहीं होगा। jQuery उपयोगी और प्रासंगिक था, लेकिन इसका दिन था।

— टिम

इसके अलावा, यह एक मुड़ आश्चर्य के लिए देखें (:

— noobie

Answer 1

आप जो चाहते हैं वह spliceमूल सरणी ऑब्जेक्ट पर फ़ंक्शन है।

arr.splice(index, 0, item);डाल देगा itemमें arrनिर्दिष्ट सूचकांक में (को हटाने 0पहले आइटम, यह है कि, यह सिर्फ एक डालने है)।

इस उदाहरण में हम एक सरणी बनाएंगे और इसमें एक तत्व जोड़ेंगे सूचकांक 2:

var arr = [];
arr[0] = "Jani";
arr[1] = "Hege";
arr[2] = "Stale";
arr[3] = "Kai Jim";
arr[4] = "Borge";

console.log(arr.join());
arr.splice(2, 0, "Lene");
console.log(arr.join());

Comments

धन्यवाद, मैंने सोचा कि मैं पूछने के लिए बेवकूफ महसूस करूंगा लेकिन अब जब मुझे पता है कि मैं जवाब नहीं देता हूं! क्यों पृथ्वी पर उन्होंने इसे विभाजित करने का फैसला किया जब एक ही खोज के लिए एक अधिक खोज योग्य शब्द सामान्य उपयोग में था?!

— 14

@ tags2k: क्योंकि फ़ंक्शन आइटम डालने से अधिक है और यह नाम पहले से ही पर्ल में स्थापित है?

— क्रिस्टोफ

doc: developer.mozilla.org/en/JavaScript/Guide/…

— डिंगो

ब्याह सम्मिलित कर सकते हैं , लेकिन बस के रूप में अक्सर नहीं है । उदाहरण के लिए: arr.splice(2,3)अनुक्रमणिका 2 से शुरू होने वाले 3 तत्वों को हटा देगा। 3 के बिना। .... एनटी पैरामीटर कुछ भी नहीं डाला गया है। इसलिए यह नाम insert()न्याय नहीं करता है।

— EBarr

मुझे लगता है कि "ब्याह" शब्द समझ में आता है। ब्याह का अर्थ है जुड़ना या जुड़ना, बदलना भी। आपके पास एक स्थापित सरणी है जिसे आप अब "बदलते" हैं जिसमें तत्वों को जोड़ना या निकालना शामिल है। आप निर्दिष्ट करें कि कहां से शुरू करना है, फिर कितनी पुरानी वस्तुओं को निकालना है (यदि कोई हो) और अंत में, वैकल्पिक रूप से जोड़ने के लिए नए तत्वों की एक सूची। स्प्लिस भी एक महान विज्ञान-फाई शब्द है।

— जैकब केलर

Answer 2

आप Array.insertऐसा करके विधि लागू कर सकते हैं :

Array.prototype.insert = function ( index, item ) {
    this.splice( index, 0, item );
};

तब आप इसका उपयोग कर सकते हैं जैसे:

var arr = [ 'A', 'B', 'D', 'E' ];
arr.insert(2, 'C');

// => arr == [ 'A', 'B', 'C', 'D', 'E' ]

Comments

कई वस्तुओं को सम्मिलित करने के लिए आप उपयोग कर सकते हैंArray.prototype.insert = function (index, items) { this.splice.apply(this, [index, 0].concat(items)); }

— रयान स्मिथ

सरणी में सामान जोड़ने के साथ समस्या यह है कि फ़ंक्शन एक तत्व के रूप में दिखाई देगा जब आप (मैं

— गिरफ्तारी में

लेकिन ध्यान रखें कि देशी प्रकारों को विस्तारित करने की अनुशंसा नहीं की जाती है क्योंकि यह अन्य कोड या भविष्य की कार्यक्षमता में हस्तक्षेप कर सकता है।

— मंगल

ऐसी वस्तुओं को संशोधित न करें जिन्हें आप स्वयं नहीं करते हैं

— लुइस कैबरे बेनिटो

प्रोटोटाइप को संशोधित न करें

— satya164

Answer 3

ब्याह के अलावा, आप इस दृष्टिकोण का उपयोग कर सकते हैं जो मूल सरणी को म्यूट नहीं करेगा, लेकिन जोड़े गए आइटम के साथ एक नया सरणी बनाएगा। जब भी संभव हो आप आमतौर पर उत्परिवर्तन से बचना चाहिए। मैं यहाँ ES6 स्प्रेड ऑपरेटर का उपयोग कर रहा हूँ।

const items = [1, 2, 3, 4, 5]

const insert = (arr, index, newItem) => [
  // part of the array before the specified index
  ...arr.slice(0, index),
  // inserted item
  newItem,
  // part of the array after the specified index
  ...arr.slice(index)
]

const result = insert(items, 1, 10)

console.log(result)
// [1, 10, 2, 3, 4, 5]

यह नए आइटम के लिए बाकी ऑपरेटर का उपयोग करने के लिए फ़ंक्शन को थोड़ा मोड़कर एक से अधिक आइटम जोड़ने के लिए इस्तेमाल किया जा सकता है, और यह कि परिणाम के रूप में अच्छी तरह से फैल गया

const items = [1, 2, 3, 4, 5]

const insert = (arr, index, ...newItems) => [
  // part of the array before the specified index
  ...arr.slice(0, index),
  // inserted items
  ...newItems,
  // part of the array after the specified index
  ...arr.slice(index)
]

const result = insert(items, 1, 10, 20)

console.log(result)
// [1, 10, 20, 2, 3, 4, 5]

Comments

क्या ऐसा करने का यह एक अच्छा, सुरक्षित तरीका है? मैं पूछता हूं क्योंकि यह बहुत ही सुरुचिपूर्ण और संक्षिप्त लगता है लेकिन कोई अन्य उत्तर इस पर स्पर्श नहीं करता है। उनमें से अधिकांश प्रोटोटाइप ऑब्जेक्ट को संशोधित करते हैं!

— हर्ष कांचीना

@ हर्षकंचिना शायद ऐसा इसलिए है क्योंकि अधिकांश उत्तर पूर्व ईएस 6 हैं, लेकिन यह दृष्टिकोण मेरे अनुभव से बहुत आम है

— gafi

Answer 4

कस्टम सरणी insertविधियाँ

1. कई तर्कों और जंजीरों के सहारे

/* Syntax:
   array.insert(index, value1, value2, ..., valueN) */

Array.prototype.insert = function(index) {
    this.splice.apply(this, [index, 0].concat(
        Array.prototype.slice.call(arguments, 1)));
    return this;
};

यह कई तत्वों को सम्मिलित कर सकता है (जैसा कि देशी spliceकरता है) और चेनिंग का समर्थन करता है:

["a", "b", "c", "d"].insert(2, "X", "Y", "Z").slice(1, 6);
// ["b", "X", "Y", "Z", "c"]

---

2. सरणी-प्रकार के तर्कों के साथ मर्जिंग और चेनिंग समर्थन

/* Syntax:
   array.insert(index, value1, value2, ..., valueN) */

Array.prototype.insert = function(index) {
    index = Math.min(index, this.length);
    arguments.length > 1
        && this.splice.apply(this, [index, 0].concat([].pop.call(arguments)))
        && this.insert.apply(this, arguments);
    return this;
};

यह दिए गए एरे से तर्कों से एरेज़ को मर्ज कर सकता है और चैनिंग का भी समर्थन कर सकता है:

["a", "b", "c", "d"].insert(2, "V", ["W", "X", "Y"], "Z").join("-");
// "a-b-V-W-X-Y-Z-c-d"

डेमो: http://jsfiddle.net/UPphH/

Comments

जब इस तर्क में एक मिल जाए तो क्या इस संस्करण का एक संक्षिप्त तरीका भी एक सरणी को मर्ज कर सकता है?

— नोलो

मैं पहला परिणाम नहीं समझता ["b", "X", "Y", "Z", "c"]। क्यों "d"शामिल नहीं है ? यह मुझे लगता है कि यदि आप 6 को दूसरे पैरामीटर के रूप में रखते हैं slice()और निर्दिष्ट सूचकांक से शुरू होने वाले सरणी में 6 तत्व हैं, तो आपको रिटर्न वैल्यू में सभी 6 तत्व मिलना चाहिए। (डॉक्टर howManyउस पैरामीटर के लिए कहते हैं ।) developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/…

— एलेक्सिस विलके

वास्तव में, अगर मैं 3 या अधिक के सूचकांक का उपयोग करता हूं, तो मुझे आउटपुट में कुछ भी नहीं मिलता है (केस 1, फायरफॉक्स) ["a", "b", "c", "d"].insert(2, "X", "Y", "Z").slice(3, 3);=>[ ]

— एलेक्सिस विल्के

@AlexisWilke पहले उदाहरण में मैंने sliceपद्धति का उपयोग किया है और नहीं splice, जिसका आप टिप्पणी में उल्लेख कर रहे हैं। slice(नामित end) का दूसरा पैरामीटर शून्य-आधारित सूचकांक है जिस पर निष्कर्षण समाप्त होता है। sliceसहित अर्क, लेकिन शामिल नहीं हैend । इसलिए बाद insertआपके पास ["a", "b", "X", "Y", "Z", "c", "d"]जहाँ से, sliceसे सूचकांक के साथ अर्क तत्वों 1अप करने के लिए 6से, यानी "b"करने के लिए "d"लेकिन सहित नहीं "d"। क्या इस का कोई मतलब निकलता है?

— VisioN

Answer 5

यदि आप एक बार में कई तत्वों को एक सरणी में सम्मिलित करना चाहते हैं, तो इस ढेर अतिप्रवाह उत्तर की जांच करें: किसी सरणी में जावास्क्रिप्ट में एक सरणी को विभाजित करने का एक बेहतर तरीका

दोनों उदाहरणों को स्पष्ट करने के लिए यहां कुछ कार्य दिए गए हैं:

function insertAt(array, index) {
    var arrayToInsert = Array.prototype.splice.apply(arguments, [2]);
    return insertArrayAt(array, index, arrayToInsert);
}

function insertArrayAt(array, index, arrayToInsert) {
    Array.prototype.splice.apply(array, [index, 0].concat(arrayToInsert));
    return array;
}

अंत में यहाँ एक jsFiddle है ताकि आप इसे स्वयं देख सकें: http://jsfiddle.net/luisperezphd/Wc8aS/

और यह है कि आप कार्यों का उपयोग कैसे करते हैं:

// if you want to insert specific values whether constants or variables:
insertAt(arr, 1, "x", "y", "z");

// OR if you have an array:
var arrToInsert = ["x", "y", "z"];
insertArrayAt(arr, 1, arrToInsert);

Comments

एक बार एक तत्व-तत्व arrayToInsert बना लेने के बाद, सम्मिलित करना बेहतर नहीं होगा? यह समान कोड की पुनरावृत्ति से बचा जाता है।

— मैट सच्चा

'लागू ’का उपयोग करने का यह एक बड़ा उदाहरण है

— CRice

मैंने उस इंडेक्स पर आइटम को हटाने के लिए ब्याह की क्षमता का लाभ उठाने के लिए इस विधि में एक रिमूवल पैरामीटर जोड़ा: Array.prototype.splice.apply (सरणी, [सूचकांक, removeCount || 0] .concat (arrayToInsert));

— क्राइसिस

Answer 6

उचित कार्यात्मक प्रोग्रामिंग और चेनिंग उद्देश्यों के लिए एक आविष्कार Array.prototype.insert()आवश्यक है। वास्तव में ब्याह एकदम सही हो सकता था अगर यह पूरी तरह से अर्थहीन खाली सरणी के बजाय उत्परिवर्तित सरणी लौटाता था। तो यहाँ यह जाता है

Array.prototype.insert = function(i,...rest){
  this.splice(i,0,...rest)
  return this
}

var a = [3,4,8,9];
document.write("<pre>" + JSON.stringify(a.insert(2,5,6,7)) + "</pre>");

अच्छी तरह से ऊपर Array.prototype.splice()एक मूल सरणी को बदल देता है और कुछ शिकायत कर सकते हैं जैसे "आप संशोधित नहीं करना चाहिए जो आपके पास नहीं है" और यह सही भी हो सकता है। इसलिए लोक कल्याण के लिए मैं एक और देना चाहूंगा Array.prototype.insert()जो मूल सरणी को परिवर्तित नहीं करता है। ये रहा;

Array.prototype.insert = function(i,...rest){
  return this.slice(0,i).concat(rest,this.slice(i));
}

var a = [3,4,8,9],
    b = a.insert(2,5,6,7);
console.log(JSON.stringify(a));
console.log(JSON.stringify(b));

Comments

"एक पूरी तरह से अर्थहीन खाली सरणी" - यह केवल एक खाली सरणी देता है जब दूसरा पैरामीटर 0. होता है। यदि यह 0 से अधिक है, तो यह सरणी से हटाए गए आइटम लौटाता है। यह देखते हुए कि आप एक प्रोटोटाइप में जोड़ रहे हैं, और spliceमूल सरणी को उत्परिवर्तित करते हैं, मुझे नहीं लगता कि "उचित कार्यात्मक प्रोग्रामिंग" इसके आसपास के क्षेत्र में कहीं भी है splice।

— क्रिसबजोरिन

हम यहां डालने के बारे में बात कर रहे हैं और Array.prototype.splice () के दूसरे पैरामीटर को शून्य होना चाहिए। और जो रिटर्न देता है उसका कोई मतलब नहीं है "मैं कुछ भी नहीं मिटाया है" और चूंकि हम इसका उपयोग करते हैं एक आइटम डालने के लिए हमारे पास पहले से ही वह जानकारी है। यदि आप मूल सरणी को बदलना नहीं चाहते हैं, तो आप दो Array.prototype.slice () और एक Array.prototype.concat () संचालन के साथ भी ऐसा कर सकते हैं। यह आप पर निर्भर करता है।

— रेडू

आपका दूसरा कार्यान्वयन इस पूरे पृष्ठ से सबसे साफ है और आपके पास शून्य वोट हैं। कृपया मेरा काम करें और अच्छे काम को जारी रखें। (आपको केवल प्रोटोटाइप को

— म्यूट करने

मुझे लगता है कि यह ध्यान देने योग्य है कि बाकी पैरामीटर नया ECMA 6th ( developer.mozilla.org/en/docs/Web/JavaScript/Reference/… ) है

— Geza Turi

Answer 7

मैं इस मामले में शुद्ध जावास्क्रिप्ट का उपयोग करने की सलाह देता हूं , यह भी कि जावास्क्रिप्ट में कोई सम्मिलित विधि नहीं है, लेकिन हमारे पास एक विधि है जो एक अंतर्निर्मित एरे विधि है जो आपके लिए काम करती है, इसे ब्याह कहा जाता है ...

आइए देखें कि ब्याह () क्या है ...

ब्याह () विधि मौजूदा तत्वों को हटाने और / या नए तत्वों को जोड़कर एक सरणी की सामग्री को बदल देती है।

ठीक है, कल्पना कीजिए कि हमारे पास यह सरणी है:

const arr = [1, 2, 3, 4, 5];

हम 3इस तरह निकाल सकते हैं :

arr.splice(arr.indexOf(3), 1);

यह 3 वापस आ जाएगा, लेकिन अगर हम अब गिरफ्तारी की जाँच करते हैं, तो हमारे पास है:

[1, 2, 4, 5]

अब तक, बहुत अच्छा है, लेकिन हम ब्याह का उपयोग करके सरणी में एक नया तत्व कैसे जोड़ सकते हैं? आइए गिरफ्तारी में 3 वापस ...

arr.splice(2, 0, 3);

आइए देखें कि हमने क्या किया है ...

हम फिर से ब्याह का उपयोग करते हैं, लेकिन इस बार दूसरे तर्क के लिए, हम 0 पास करते हैं करते हैं, इसका मतलब है कि हम कोई आइटम नहीं हटाना चाहते हैं, लेकिन साथ ही, हम तीसरा तर्क जोड़ते हैं जो 3 है जो दूसरे सूचकांक में जोड़ा जाएगा ...

आपको पता होना चाहिए, कि हम एक ही समय में हटा सकते हैं और जोड़ सकते हैं, उदाहरण के लिए अब हम कर सकते हैं:

arr.splice(2, 2, 3);

जो 2 आइटम को 2 सूचकांक में हटा देगा , फिर 3 को सूचकांक 2 में जोड़ देगा और परिणाम होगा:

[1, 2, 3, 5];

यह दिखा रहा है कि ब्याह के काम में प्रत्येक वस्तु कैसे है:

array.splice (प्रारंभ, हटाएं, आइटम 1, आइटम 2, आइटम 3 ...)

Answer 8

एक विशिष्ट सूचकांक पर एकल तत्व जोड़ें

//Append at specific position(here at index 1)
arrName.splice(1, 0,'newName1');
//1: index number, 0: number of element to remove, newName1: new element


//Append at specific position (here at index 3)
arrName[3] = 'newName1';

एक विशिष्ट सूचकांक में कई तत्व जोड़ें

//Append from index number 1
arrName.splice(1, 0,'newElemenet1', 'newElemenet2', 'newElemenet3');
//1: index number from where append start, 
//0: number of element to remove, 
//newElemenet1,2,3: new elements

Comments

वर्थ नोटिंग कि गिरफ्तारी [3] नहीं है, यह ओवरराइड करता है।

— सफ़ेटिनी

यह तत्व को मौजूदा सरणी में सवारी से अधिक नहीं जोड़ता है, Ex: let arrName = ['xxx', 'yyy', 'zzz']; arrName.splice (1, 0, 'आ' ',' बीब ',' सीसीसी '); गिरफ्तार करने के बाद नाम

— श्रीकृष्णा

यदि arrName में 3 से अधिक तत्व हैं, तो आप 3rd को ओवरराइड कर रहे हैं, एपेंडिंग नहीं। या मैं इसे गलत तरीके से देख रहा हूं?

— १।

यदि हम बीच में एक तत्व सम्मिलित करते हैं, तो यह अगले तत्व को स्थानांतरित नहीं करता है। कृपया अपनी समस्या निर्दिष्ट करें, आपको क्या चाहिए। एक सरणी (उदाहरण) लें और आपको आउटपुट पर क्या चाहिए। plz टिप्पणी मुझे

— श्रीकृष्ण

arrName[3] = 'newName1';अगर सरणी में केवल 3 तत्व हैं तो @Srikrushna अपील करेगा। यदि सूचकांक 3 में एक तत्व है, तो इसे बदल दिया जाएगा। आप अंत में संलग्न करना चाहते हैं, तो यह बेहतर करने के लिए इस्तेमाल होता हैarrName.push('newName1');

— भय

Answer 9

एक और संभावित समाधान, जिसके उपयोग के साथ Array#reduce।

var arr = ["apple", "orange", "raspberry"],
    arr2 = [1, 2, 4];

function insert(arr, item, index) {
    arr = arr.reduce(function(s, a, i) {
      i == index ? s.push(item, a) : s.push(a);
      return s;
    }, []);   
    console.log(arr);
}

insert(arr, "banana", 1);
insert(arr2, 3, 2);

Answer 10

यहाँ दो तरीके हैं:

const array = [ 'My', 'name', 'Hamza' ];

array.splice(2, 0, 'is');

console.log("Method 1 : ", array.join(" "));

या

Array.prototype.insert = function ( index, item ) {
    this.splice( index, 0, item );
};

const array = [ 'My', 'name', 'Hamza' ];
array.insert(2, 'is');

console.log("Method 2 : ", array.join(" "));

Answer 11

हालांकि इसका उत्तर पहले ही दिया जा चुका है, मैं इस नोट को वैकल्पिक दृष्टिकोण के लिए जोड़ रहा हूं।

मैं एक ज्ञात संख्या रखना चाहता था आइटम को एक सरणी में, विशिष्ट स्थितियों में , क्योंकि वे एक "साहचर्य सरणी" (यानी एक वस्तु) से निकलते हैं जो परिभाषा के अनुसार क्रमबद्ध क्रम में होने की गारंटी नहीं है। मैं चाहता था कि परिणामी सरणी वस्तुओं की एक सरणी हो, लेकिन सरणी में एक विशिष्ट क्रम में होने वाली वस्तुएं चूंकि एक सरणी उनके आदेश की गारंटी देती है। इसलिए मैंने ऐसा किया।

पहले स्रोत वस्तु, एक JSONB स्ट्रिंग PostgreSQL से पुनर्प्राप्त की गई। मैं चाहता था कि यह प्रत्येक बच्चे के ऑब्जेक्ट में "ऑर्डर" संपत्ति द्वारा क्रमबद्ध हो।

var jsonb_str = '{"one": {"abbr": "", "order": 3}, "two": {"abbr": "", "order": 4}, "three": {"abbr": "", "order": 5}, "initialize": {"abbr": "init", "order": 1}, "start": {"abbr": "", "order": 2}}';

var jsonb_obj = JSON.parse(jsonb_str);

चूंकि ऑब्जेक्ट में नोड्स की संख्या ज्ञात है, मैं पहली बार निर्दिष्ट लंबाई के साथ एक सरणी बनाता हूं:

var obj_length = Object.keys(jsonb_obj).length;
var sorted_array = new Array(obj_length);

और फिर ऑब्जेक्ट को पुनरावृत्त करें, नए बनाए गए अस्थायी ऑब्जेक्ट को सरणी में वांछित स्थानों में रखकर बिना किसी "सॉर्टिंग" के जगह ले रहा है।

for (var key of Object.keys(jsonb_obj)) {
  var tobj = {};
  tobj[key] = jsonb_obj[key].abbr;

  var position = jsonb_obj[key].order - 1;
  sorted_array[position] = tobj;
}

console.dir(sorted_array);

Answer 12

जो भी अभी भी इस एक के साथ समस्या है और ऊपर सभी विकल्पों की कोशिश की है और कभी नहीं मिला। मैं अपना समाधान साझा कर रहा हूं, यह ध्यान रखना है कि आप अपने ऑब्जेक्ट के गुणों को स्पष्ट रूप से वर्णन नहीं करना चाहते हैं।

function isIdentical(left, right){
    return JSON.stringify(left) === JSON.stringify(right);
}

function contains(array, obj){
    let count = 0;
    array.map((cur) => {
          if(this.isIdentical(cur, obj)) count++;
    });
    return count > 0;
}

यह संदर्भ सरणी को पुनरावृत्त करने और इसे उस वस्तु से तुलना करने का एक संयोजन है जिसे आप जांचना चाहते हैं, दोनों को एक स्ट्रिंग में परिवर्तित करें, अगर यह मिलान हुआ तो पुनरावृत्त। तब तुम सिर्फ गिन सकते हो। इसमें सुधार किया जा सकता है लेकिन यह वह जगह है जहां मैं बस गया। उम्मीद है की यह मदद करेगा।

Answer 13

निम्नलिखित के रूप में कम करने की विधि का लाभ लेना:

function insert(arr, val, index) {
    return index >= arr.length 
        ? arr.concat(val)
        : arr.reduce((prev, x, i) => prev.concat(i === index ? [val, x] : x), []);
}

इसलिए इस तरह हम एक नया ऐरे वापस कर सकते हैं (इंडेक्स में डाले गए एलीमेंट के साथ एक नया फंक्शनल तरीका होगा - यूज़ पुश या स्प्लिस से ज्यादा बेहतर) अतं मै।

Answer 14

Array#splice()जाने का रास्ता है, जब तक आप वास्तव में सरणी को बदलने से बचना चाहते हैं। 2 सरणियों को देखते हुए arr1और arr2, आपके द्वारा की सामग्री सम्मिलित करेंगे arr2में arr1पहला तत्व के बाद:

const arr1 = ['a', 'd', 'e'];
const arr2 = ['b', 'c'];

arr1.splice(1, 0, ...arr2); // arr1 now contains ['a', 'b', 'c', 'd', 'e']

console.log(arr1)

यदि आप सरणी को बदलने के बारे में चिंतित हैं (उदाहरण के लिए, अगर Immutable.js का उपयोग करते हुए), तो आप इसके बजाय उपयोग कर सकते हैं slice(), splice()ए के साथ भ्रमित होने की नहीं 'p'।

const arr3 = [...arr1.slice(0, 1), ...arr2, ...arr1.slice(1)];

Answer 15

मैंने यह कोशिश की और यह ठीक काम कर रहा है!

var initialArr = ["India","China","Japan","USA"];
initialArr.splice(index, 0, item);

सूचकांक वह स्थिति है जहाँ आप तत्व को सम्मिलित या हटाना चाहते हैं। 0 यानी दूसरा पैरामीटर इंडेक्स से निकाले जाने वाले आइटम की संख्या को परिभाषित करता है आइटम नई प्रविष्टियां हैं जिन्हें आप सरणी में बनाना चाहते हैं। यह एक या एक से अधिक हो सकते हैं।

initialArr.splice(2, 0, "Nigeria");
initialArr.splice(2, 0, "Australia","UK");

Comments

बस ऊपर दिए गए उत्तर को कॉपी पेस्ट करें। यह प्रश्न के लिए कोई मूल्य नहीं जोड़ रहा है। या तो आप एक नया उत्तर जोड़ें या मौजूदा पर टिप्पणी करें। कृपया कुछ नया योगदान करने का प्रयास करें। हम इस समुदाय को खराब नहीं करना चाहते

— हन्नाद

Answer 16

यहां एक कार्यशील फ़ंक्शन है जिसका उपयोग मैं अपने आवेदन में करता हूं।

यह जाँचता है कि आइटम से बाहर निकलें

let ifExist = (item, strings = [ '' ], position = 0) => {
     // output into an array with empty string. Important just in case their is no item. 
    let output = [ '' ];
    // check to see if the item that will be positioned exist.
    if (item) {
        // output should equal to array of strings. 
        output = strings;
       // use splice in order to break the array. 
       // use positition param to state where to put the item
       // and 0 is to not replace an index. Item is the actual item we are placing at the prescribed position. 
        output.splice(position, 0, item);
    }
    //empty string is so we do not concatenate with comma or anything else. 
    return output.join("");
};

और फिर मैं इसे नीचे कहता हूं।

ifExist("friends", [ ' ( ', ' )' ], 1)}  // output: ( friends )
ifExist("friends", [ ' - '], 1)}  // output:  - friends 
ifExist("friends", [ ':'], 0)}  // output:   friends: 

Answer 17

थोड़ा पुराना धागा, लेकिन मुझे ऊपर रेडू के साथ सहमत होना होगा क्योंकि ब्याह निश्चित रूप से एक भ्रामक इंटरफ़ेस का एक सा है। और सीडीबजोरिन द्वारा दी गई प्रतिक्रिया कि "यह केवल एक खाली सरणी देता है जब दूसरा पैरामीटर 0. होता है। यदि यह 0 से अधिक है, तो यह सरणी से हटाए गए आइटमों को लौटाता है", जबकि सटीक, बिंदु साबित होता है। फ़ंक्शन का इरादा जेकब केलर द्वारा विभाजित या पहले कहा गया है, "जुड़ने या कनेक्ट करने के लिए, बदलने के लिए भी। आपके पास एक स्थापित सरणी है जिसे आप अब बदल रहे हैं जिसमें तत्वों को जोड़ना या निकालना शामिल है ...." यह देखते हुए। तत्वों का रिटर्न वैल्यू, यदि कोई हो, जिसे हटा दिया गया था, तो यह सबसे अच्छा है। और मैं 100% सहमत हूं कि यह विधि जंजीर के लिए बेहतर अनुकूल हो सकती है यदि यह स्वाभाविक रूप से वापस आ गई है, जो कि स्पिलिटेड तत्वों के साथ एक नया सरणी जोड़ा गया है। तब आप ["19", "17"] जैसी चीजें कर सकते थे। ब्याह (1,0, "18")। ज्वाइन करें ("...") या जो भी आपको दी गई सरणी के साथ पसंद हो। तथ्य यह है कि यह जो हटा दिया गया था वह थोड़े बकवास IMHO है। यदि विधि का इरादा "तत्वों का एक सेट काट देना" था और यह केवल इरादा था, तो शायद। ऐसा लगता है जैसे मुझे नहीं पता कि मैं क्या पहले से ही काट रहा हूं, मेरे पास शायद उन तत्वों को काटने का कोई कारण नहीं है, है न? यह बेहतर होगा यदि यह समतल, नक्शा, कम, टुकड़ा आदि की तरह व्यवहार करता है, जहां मौजूदा सरणी को बदलने के बजाय मौजूदा सरणी से एक नया सरणी बनाया जाता है। वे सभी श्रृंखलाबद्ध हैं, और यह एक महत्वपूर्ण मुद्दा है। यह श्रृंखला सरणी हेरफेर के लिए सामान्य है। ऐसा लगता है कि भाषा को एक या दूसरी दिशा में जाने की जरूरत है और जितना संभव हो उतना इसे छड़ी करने की कोशिश करें। जावास्क्रिप्ट कार्यात्मक और कम घोषणात्मक होने के नाते, यह सिर्फ आदर्श से एक विचलन की तरह लगता है।

Answer 18

प्रदर्शन

आज (2020.04.24) मैं बड़े और छोटे सरणियों के लिए चुने गए समाधानों के लिए परीक्षण करता हूं। मैंने उन्हें क्रोम 81.0, सफारी 13.1, फ़ायरफ़ॉक्स 75.0 पर मैको हाई सिएरा 10.13.6 पर परीक्षण किया।

निष्कर्ष

सभी ब्राउज़रों के लिए

• आश्चर्यजनक रूप से छोटे सरणियों के लिए गैर-इन-प्लेस समाधानों के आधार पर sliceऔरreduce (डी, ई, एफ) आमतौर पर इन-प्लेस समाधान की तुलना में 10x-100x तेज होते हैं
• के आधार पर जगह में समाधान के बड़े सरणियों के लिए splice(एआई, बीआई, सीआई) के सबसे तेज़ था (कभी-कभी ~ 100x - लेकिन यह सरणी आकार पर निर्भर करता है)
• छोटे सरणियों के लिए बीआई समाधान सबसे धीमा था
• बड़े सरणियों के लिए ई समाधान सबसे धीमा था

विवरण

परीक्षणों को दो समूहों में विभाजित किया गया था: इन-प्लेस समाधान (एआई, बीआई, सीआई) और गैर-इन-प्लेस समाधान (डी, ई, एफ) और दो मामलों के लिए प्रदर्शन किया गया था

• 10 तत्वों के साथ सरणी के लिए परीक्षण - आप इसे यहाँ चला सकते हैं
• 1.000.000 तत्वों के साथ सरणी के लिए परीक्षण - आप इसे यहाँ चला सकते हैं

परीक्षण कोड स्निपेट के नीचे प्रस्तुत किया गया है

function AI(arr, i, el) {
  arr.splice(i, 0, el);
  return arr;
}

function BI(arr, i, el) {
  Array.prototype.splice.apply(arr, [i, 0, el]);
  return arr;
}

function CI(arr, i, el) {
  Array.prototype.splice.call(arr, i, 0, el);
  return arr;
}

function D(arr, i, el) {
  return arr.slice(0, i).concat(el, arr.slice(i));
}

function E(arr, i, el) {
  return [...arr.slice(0, i), el, ...arr.slice(i)]
}

function F(arr, i, el) {
  return arr.reduce((s, a, j)=> (j-i ? s.push(a) : s.push(el, a), s), []);
}



// -------------
// TEST
// -------------

let arr = ["a", "b", "c", "d", "e", "f"];

let log = (n, f) => {
  let a = f([...arr], 3, "NEW");
  console.log(`${n}: [${a}]`);
};

log('AI', AI);
log('BI', BI);
log('CI', CI);
log('D', D);
log('E', E);
log('F', F);

This snippet only presents tested code (it not perform tests)

क्रोम पर छोटे सरणी के लिए उदाहरण परिणाम नीचे हैं