जावास्क्रिप्ट में सरणी तत्वों को हटाना - बनाम विभाजन को हटाएं

Question

का उपयोग करते हुए बीच क्या अंतर है ऑपरेटर के रूप में प्रयोग करने का विरोध किया सरणी तत्व पर विधि ?deleteArray.splice

उदाहरण के लिए:

myArray = ['a', 'b', 'c', 'd'];

delete myArray[1];
//  or
myArray.splice (1, 1);

यहां तक ​​कि अगर मेरे पास ऑब्जेक्ट्स की तरह सरणी तत्वों को हटा सकते हैं तो भी ब्याह विधि क्यों है?

Comments

के लिए .splice: लूप में, इस सवाल पर एक नजर है जावास्क्रिप्ट में सरणी से हटाएं ।

— रोब डब्ल्यू

@andynormancx हां, लेकिन यह उत्तर उसके ठीक एक दिन बाद पोस्ट किया गया, और इतने अधिक वोट मिले - मैं कहूंगा कि यह बेहतर लिखा गया है, यह होना चाहिए।

— कैमिलो मार्टिन

@andynormancx - यह एक सटीक डुप्लिकेट प्रतीत नहीं होता है। आपके द्वारा जुड़ा प्रश्न मूल रूप से यह पूछ रहा है कि किसी तत्व को किसी सरणी से हटाना (इस प्रकार इसे विरल बनाना) इसकी लंबाई को कम नहीं करेगा। यह सवाल deleteऔर के बीच के अंतर के लिए पूछ रहा है Array.prototype.splice।

— छरवे

@chharvey ने सहमति व्यक्त की, अधिक महत्वपूर्ण बात यह है कि यह प्रश्न 9 साल पहले कैसे पोस्ट किया जा सकता है! मुझे इस पर टिप्पणी करते हुए यहाँ वापस आना पुराना लगता है

— andynormancx

Answer 1

deleteऑब्जेक्ट प्रॉपर्टी को हटा देगा, लेकिन ऐरे को रीइन्डेक्स नहीं करेगा या इसकी लंबाई अपडेट नहीं करेगा। यह ऐसा प्रतीत होता है जैसे कि यह अपरिभाषित है:

> myArray = ['a', 'b', 'c', 'd']
  ["a", "b", "c", "d"]
> delete myArray[0]
  true
> myArray[0]
  undefined

ध्यान दें कि यह वास्तव में मूल्य पर सेट नहीं है undefined , बल्कि संपत्ति को सरणी से हटा दिया जाता है, जिससे यह अपरिभाषित दिखाई देता है । emptyसरणी को लॉग करते समय Chrome देव उपकरण मुद्रण द्वारा इस अंतर को स्पष्ट करते हैं।

> myArray[0]
  undefined
> myArray
  [empty, "b", "c", "d"]

myArray.splice(start, deleteCount) वास्तव में तत्व को हटाता है, सरणी को फिर से जोड़ता है, और इसकी लंबाई बदलता है।

> myArray = ['a', 'b', 'c', 'd']
  ["a", "b", "c", "d"]
> myArray.splice(0, 2)
  ["a", "b"]
> myArray
  ["c", "d"]

Comments

वास्तव में, तत्व delete को हटाता है, लेकिन सरणी को फिर से विभाजित नहीं करता है या इसकी लंबाई को अपडेट नहीं करता है (जो पहले से ही पहले से निहित है क्योंकि लंबाई हमेशा उच्चतम सूचकांक + 1 है)।

— फेलिक्स क्लिंग

JSlint को delete myArray[0]सिंटैक्स कहना पसंद नहीं है " एक ऑपरेटर की अपेक्षा की और इसके बजाय 'हटाएं' देखा। " का उपयोग करने spliceकी सिफारिश की गई है।

— आँख

@Eye: वास्तव में, JSLint केवल पिछली पंक्ति पर अर्धविराम की कमी के बारे में शिकायत कर रहा है। और आप वास्तव में एक दूसरे पर सलाह नहीं दे सकते, क्योंकि वे पूरी तरह से अलग चीजें करते हैं ...

— Ry-

"इस मामले में हटाएं केवल तत्व को अपरिभाषित के रूप में सेट किया जाएगा:" नहीं, यह बिल्कुल गलत है। के बीच एक मूलभूत अंतर है delete myArray[0]और myArray[0] = undefined। पूर्व के मामले में, संपत्ति को सरणी ऑब्जेक्ट से पूरी तरह से हटा दिया जाता है। दूसरे मामले में, संपत्ति मूल्य के साथ बनी हुई है undefined।

— टीजे क्राउडर

FYI करें, क्रोम देव उपकरण वास्तव में हटाए गए (या असिंचित) सरणी तत्व के बीच अंतर को बेहतर बनाने के emptyबजाय कीवर्ड को दिखाता undefinedहै जिसका वास्तविक मूल्य है undefined। ध्यान दें कि जैसा कि मैं कहता हूं इसका मतलब है कि यह केवल के रूप में प्रदर्शित करता है empty, और एक वास्तविक मूल्य का उल्लेख नहीं करता है empty(जिसका अस्तित्व नहीं है)।

— छरवे

Answer 2

Array.remove () विधि

जॉन रेजिग , jQuery के निर्माता ने एक बहुत ही आसान Array.removeतरीका बनाया है जिसका उपयोग मैं हमेशा अपनी परियोजनाओं में करता हूं।

// Array Remove - By John Resig (MIT Licensed)
Array.prototype.remove = function(from, to) {
  var rest = this.slice((to || from) + 1 || this.length);
  this.length = from < 0 ? this.length + from : from;
  return this.push.apply(this, rest);
};

और यहाँ इसका उपयोग कैसे किया जा सकता है इसके कुछ उदाहरण हैं:

// Remove the second item from the array
array.remove(1);
// Remove the second-to-last item from the array
array.remove(-2);
// Remove the second and third items from the array
array.remove(1,2);
// Remove the last and second-to-last items from the array
array.remove(-2,-1);

जॉन की वेबसाइट

Comments

Array.remove () के लिए +1। हालाँकि, यह कड़े तर्कों को पारित करने में खुश नहीं है (अधिकांश ऐरे तरीकों के विपरीत, उदा [1,2,3].slice('1'); // =[2,3]), इसलिए इसे बदलने के लिए सुरक्षित हैvar rest = this.slice(parseInt(to || from) + 1 || this.length);

— रिचर्ड इंग्लिस

@tomwrong, जावास्क्रिप्ट में कोई थ्रेड नहीं हैं, और फ़ंक्शन निष्पादित होता है this.push.apply(this, rest), फिर वह मान लौटाता है

— बिली

इस सवाल का जवाब बिल्कुल नहीं है।

— Ry-

सिर्फ ब्याह () का उपयोग क्यों न करें? इस फ़ंक्शन का नाम, पैरामीटर के नाम और परिणाम स्पष्ट नहीं हैं। मेरे सिफारिश सिर्फ उपयोग जोड़ (सूचकांक, लंबाई) के लिए है - (एंडी ह्यूम के जवाब देखें)

— auco

ऊपर दिया गया कार्य, जैसा कि समझाया गया है, कार्य करता है, फिर भी for(var i in array)चक्र के साथ सरणी के माध्यम से पुनरावृत्ति करने पर यह अवांछित दुष्प्रभाव पैदा करता है। मैंने इसे हटा दिया है और इसके बजाय ब्याह का उपयोग किया है।

— एलेक्सकोट

Answer 3

क्योंकि हटाना केवल ऑब्जेक्ट को एरे में तत्व से हटाता है, एरे की लंबाई नहीं बदलेगी। ब्याह वस्तु को हटाता है और सरणी को छोटा करता है।

निम्नलिखित कोड "a", "b", "अपरिभाषित", "d" प्रदर्शित करेगा

myArray = ['a', 'b', 'c', 'd']; delete myArray[2];

for (var count = 0; count < myArray.length; count++) {
    alert(myArray[count]);
}

जबकि यह "ए", "बी", "डी" प्रदर्शित करेगा

myArray = ['a', 'b', 'c', 'd']; myArray.splice(2,1);

for (var count = 0; count < myArray.length; count++) {
    alert(myArray[count]);
}

Comments

1,1 का उपयोग करके दूसरे उदाहरण में अस्पष्टता को छोड़कर महान उदाहरण - पहला 1 ब्याह शुरू करने के लिए सरणी में सूचकांक को संदर्भित करता है, दूसरे 1 को हटाने के लिए तत्वों की संख्या है। तो मूल सरणी से 'सी' को हटाने के लिए, उपयोग करेंmyArray.splice(2,1)

— iancoleman

Answer 4

मैं इस सवाल पर अड़ गया कि यह समझने की कोशिश कर रहा हूं कि किसी ऐरे से किसी तत्व की घटना को कैसे हटाया जाए। यहाँ तुलना दी गई है की spliceऔर deleteहर दूर करने के लिए 'c'से itemsसरणी।

var items = ['a', 'b', 'c', 'd', 'a', 'b', 'c', 'd'];

while (items.indexOf('c') !== -1) {
  items.splice(items.indexOf('c'), 1);
}

console.log(items); // ["a", "b", "d", "a", "b", "d"]

items = ['a', 'b', 'c', 'd', 'a', 'b', 'c', 'd'];

while (items.indexOf('c') !== -1) {
  delete items[items.indexOf('c')];
}

console.log(items); // ["a", "b", undefined, "d", "a", "b", undefined, "d"]
​

Answer 5

से कोर जावास्क्रिप्ट 1.5 संदर्भ> ऑपरेटर्स> विशेष ऑपरेटरों> हटाएं ऑपरेटर :

जब आप किसी सरणी तत्व को हटाते हैं, तो सरणी लंबाई प्रभावित नहीं होती है। उदाहरण के लिए, यदि आप एक [3] को हटाते हैं, तो एक [4] अभी भी [4] है और एक [3] अपरिभाषित है। यह तब भी होता है जब आप सरणी के अंतिम तत्व को हटाते हैं ([a.length-1] हटाएं)।

Answer 6

splice संख्यात्मक सूचकांक के साथ काम करेंगे।

जहाँ तक delete अन्य तरह के सूचकांकों के खिलाफ इस्तेमाल किया जा सकता है।

उदाहरण:

delete myArray['text1'];

Comments

जब आप 'किसी अन्य प्रकार के सूचकांकों' को कहते हैं, तो आप किसी भी अधिक सरणियों के बारे में बात नहीं कर रहे हैं, बल्कि वस्तुओं, जो ओपी के बारे में पूछ रहे हैं।

— यी जियांग

@ यिजियांग: एरे ऑब्जेक्ट हैं। संकेत गुण हैं। इसमें कोई फर्क नही है।

— बरगी

Answer 7

यह भी ध्यान देने योग्य है कि ब्याह केवल सरणियों पर काम करता है। (एक सुसंगत आदेश का पालन करने के लिए ऑब्जेक्ट गुण पर भरोसा नहीं किया जा सकता है।)

किसी ऑब्जेक्ट से की-वैल्यू पेयर को हटाने के लिए, वास्तव में डिलीट वह है जो आप चाहते हैं:

delete myObj.propName;     // , or:
delete myObj["propName"];  // Equivalent.

Comments

हटाएं सरणी कुंजियों को फिर से नहीं बनाता है, इसलिए: var arr = [1,2,3,4,5]; गिरफ्तारी को हटा दें [3]; for (var i = 0; i <= arr.length; i ++) कंसोल.लॉग (गिरफ्तार [i]); अप्रत्याशित परिणाम प्रदर्शित करेगा।

— क्रिस्टियन विलियम्स

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

— jtrick

लेकिन क्यों हटाएंगे अप्रत्याशित परिणाम फेंक देंगे ??

— एलेक्स

Answer 8

Vs विभाजन को हटाएं

जब आप किसी ऐरे से आइटम हटाते हैं

var arr = [1,2,3,4]; delete arr[2]; //result [1, 2, 3:, 4]
console.log(arr)

जब आप अलग हो जाते हैं

var arr = [1,2,3,4]; arr.splice(1,1); //result [1, 3, 4]
console.log(arr);

डिलीट के मामले में एलिमेंट डिलीट हो जाता है लेकिन इंडेक्स खाली रहता है

जबकि ब्याह तत्व के मामले में हटा दिया जाता है और बाकी तत्वों का सूचकांक तदनुसार कम हो जाता है

Answer 9

जैसा कि ऊपर कई बार कहा गया है, का उपयोग करना splice()एक सही फिट की तरह लगता है। मोज़िला में प्रलेखन:

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

var myFish = ['angel', 'clown', 'mandarin', 'sturgeon'];

myFish.splice(2, 0, 'drum'); 
// myFish is ["angel", "clown", "drum", "mandarin", "sturgeon"]

myFish.splice(2, 1); 
// myFish is ["angel", "clown", "mandarin", "sturgeon"]

वाक्य - विन्यास

array.splice(start)
array.splice(start, deleteCount)
array.splice(start, deleteCount, item1, item2, ...)

पैरामीटर

शुरू

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

deleteCount

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

यदि DeleteCount छोड़ा गया है, तो DeleteCount बराबर होगा (arr.length - start).

आइटम 1, आइटम 2, ...

एरे को जोड़ने वाले तत्व, शुरुआत सूचकांक पर शुरुआत करते हैं। यदि आप कोई तत्व निर्दिष्ट नहीं करते हैं, splice()तो केवल सरणी से तत्व निकाल देंगे।

प्रतिलाभ की मात्रा

हटाए गए तत्वों से युक्त एक सरणी। यदि केवल एक तत्व हटा दिया जाता है, तो एक तत्व का एक सरणी वापस आ जाता है। यदि कोई तत्व नहीं निकाले जाते हैं, तो एक खाली सरणी वापस आ जाती है।

[...]

Comments

@downvoter: डाउनवोट क्यों? समझाने के लिए परवाह है, या नहीं?

— सर्व-इन

Answer 10

हटाना एक गैर वास्तविक दुनिया स्थिति की तरह काम करती है, यह सिर्फ निकाल देता है आइटम, लेकिन सरणी लंबाई रहता है एक ही:

नोड टर्मिनल से उदाहरण:

> var arr = ["a","b","c","d"];
> delete arr[2]
true
> arr
[ 'a', 'b', , 'd', 'e' ]

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

function(arr,arrIndex){
    return arr.slice(0,arrIndex).concat(arr.slice(arrIndex + 1));
}

ऊपर क्या कार्य करता है, सभी सदस्यों को सूचकांक तक ले जाता है, और सभी सदस्यों को सूचकांक के बाद, और उन्हें एक साथ मिलाता है, और परिणाम देता है।

एक नोड मॉड्यूल के रूप में उपरोक्त फ़ंक्शन का उपयोग करके यहां एक उदाहरण दिया गया है, टर्मिनल को देखना उपयोगी होगा:

> var arr = ["a","b","c","d"]
> arr
[ 'a', 'b', 'c', 'd' ]
> arr.length
4 
> var arrayRemoveIndex = require("./lib/array_remove_index");
> var newArray = arrayRemoveIndex(arr,arr.indexOf('c'))
> newArray
[ 'a', 'b', 'd' ] // c ya later
> newArray.length
3

कृपया ध्यान दें कि यह इसमें किसी एक सरणी के साथ काम नहीं करेगा, क्योंकि indexOf ("c") को केवल पहला रोशन मिलेगा, और केवल अलग हो जाएगा और पहले "c" को हटा देगा।

Answer 11

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

आप इसे एक नई सरणी बनाकर कर सकते हैं। जैसे

function reindexArray( array )
{
       var result = [];
        for( var key in array )
                result.push( array[key] );
        return result;
};

लेकिन मुझे नहीं लगता कि आप मूल सरणी में प्रमुख मूल्यों को संशोधित कर सकते हैं, जो अधिक कुशल होगा - ऐसा लगता है कि आपको एक नया सरणी बनाना पड़ सकता है।

ध्यान दें कि आपको "अपरिभाषित" प्रविष्टियों की जांच करने की आवश्यकता नहीं है क्योंकि वे वास्तव में मौजूद नहीं हैं और लूप के लिए उन्हें वापस नहीं करते हैं। यह सरणी मुद्रण की एक कलाकृति है जो उन्हें अपरिभाषित प्रदर्शित करती है। वे स्मृति में मौजूद नहीं हैं।

यह अच्छा होगा यदि आप स्लाइस () जैसे कुछ का उपयोग कर सकते हैं जो जल्दी हो जाएगा, लेकिन यह फिर से अनुक्रमणिका नहीं करता है। किसी को भी बेहतर तरीके से पता है?

---

वास्तव में, आप संभवतः इसे निम्न प्रकार से कर सकते हैं जो संभवतः अधिक कुशल, प्रदर्शन-वार है:

reindexArray : function( array )
{
    var index = 0;                          // The index where the element should be
    for( var key in array )                 // Iterate the array
    {
        if( parseInt( key ) !== index )     // If the element is out of sequence
        {
            array[index] = array[key];      // Move it to the correct, earlier position in the array
            ++index;                        // Update the index
        }
    }

    array.splice( index );  // Remove any remaining elements (These will be duplicates of earlier items)
},

Comments

मुझे विश्वास है कि ++ सूचकांक; 'अगर' के बाहर होने की जरूरत है। संपादन करना

— mishal153

Answer 12

आप कुछ इस तरह का उपयोग कर सकते हैं

var my_array = [1,2,3,4,5,6];
delete my_array[4];
console.log(my_array.filter(function(a){return typeof a !== 'undefined';})); // [1,2,3,4,6]

Comments

sliceयदि आप एक कार्यात्मक पृष्ठभूमि से आते हैं तो यह अधिक सहज है (शायद कम कुशल, यद्यपि)।

— जेथ्रो

Answer 13

सिर्फ फिल्टर क्यों नहीं? मुझे लगता है कि यह जेएस में सरणियों पर विचार करने का सबसे स्पष्ट तरीका है।

myArray = myArray.filter(function(item){
    return item.anProperty != whoShouldBeDeleted
});

Comments

सैकड़ों (यदि हजारों नहीं) अभिलेखों के साथ एक सरणी के बारे में क्या उनमें से केवल 3 को हटाने की आवश्यकता है?

— जोएल हर्नांडेज़

अच्छी बात। मैं विरल सरणियों के लिए इस पद्धति का उपयोग करता हूं जिनकी लंबाई 200 या 300 से अधिक नहीं है और बहुत अच्छा प्रदर्शन करती है। हालाँकि, मुझे लगता है कि यदि आपको इस तरह के बड़े सरणियों का प्रबंधन करना है तो अंडरलाइन जैसे पुस्तकालयों को प्राथमिकता दी जानी चाहिए।

— आकांक्षा

हालाँकि, यह मुझसे deleteया उससे भी ज्यादा अच्छा लगता sliceहै।

— जुनेगॉन्ग ओह

Answer 14

deleteऑपरेटर और splice()विधि लागू होने के बाद प्रत्येक सरणी की लंबाई को लॉग करके अंतर को देखा जा सकता है। उदाहरण के लिए:

ऑपरेटर हटाएं

var trees = ['redwood', 'bay', 'cedar', 'oak', 'maple'];
delete trees[3];

console.log(trees); // ["redwood", "bay", "cedar", empty, "maple"]
console.log(trees.length); // 5

deleteऑपरेटर सरणी से तत्व निकालता है, लेकिन तत्व की "प्लेसहोल्डर" अभी भी मौजूद है।oakहटा दिया गया है, लेकिन यह अभी भी सरणी में जगह लेता है। इस वजह से, सरणी की लंबाई 5 बनी हुई है।

ब्याह () विधि

var trees = ['redwood', 'bay', 'cedar', 'oak', 'maple'];
trees.splice(3,1);

console.log(trees); // ["redwood", "bay", "cedar", "maple"]
console.log(trees.length); // 4

splice()विधि पूरी तरह से लक्ष्य मूल्य को हटा और साथ ही "प्लेसहोल्डर"। oakयह उस स्थान के साथ ही हटा दिया गया है जिसका उपयोग यह सरणी में रखने के लिए करता था। सरणी की लंबाई अब 4 है।

Answer 15

function remove_array_value(array, value) {
    var index = array.indexOf(value);
    if (index >= 0) {
        array.splice(index, 1);
        reindex_array(array);
    }
}
function reindex_array(array) {
   var result = [];
    for (var key in array) {
        result.push(array[key]);
    }
    return result;
}

उदाहरण:

var example_arr = ['apple', 'banana', 'lemon'];   // length = 3
remove_array_value(example_arr, 'banana');

केला हटा दिया जाता है और सरणी लंबाई = 2

Answer 16

वे अलग-अलग चीजें हैं जिनके अलग-अलग उद्देश्य हैं।

spliceसरणी-विशिष्ट है और, जब हटाने के लिए उपयोग किया जाता है, तो सरणी से प्रविष्टियों को निकालता है और अंतराल को भरने के लिए सभी पिछली प्रविष्टियों को ऊपर ले जाता है। (इसका उपयोग प्रविष्टियों को सम्मिलित करने के लिए या एक ही समय में दोनों के लिए भी किया जा सकता है।) ऐरे spliceको बदल देगा length(यह मानते हुए कि यह नो-ऑप कॉल नहीं है:) theArray.splice(x, 0)।

deleteसरणी-विशिष्ट नहीं है; यह वस्तुओं पर उपयोग के लिए डिज़ाइन किया गया है: यह आपके द्वारा उपयोग की जाने वाली वस्तु से एक संपत्ति (कुंजी / मूल्य जोड़ी) निकालता है। यह केवल सरणियों पर लागू होता है क्योंकि जावास्क्रिप्ट में मानक (जैसे, गैर-टाइप किए गए) सरणियाँ वास्तव में बिल्कुल नहीं हैं *, वे कुछ गुणों के लिए विशेष हैंडलिंग वाली वस्तुएं हैं, जैसे कि जिनके नाम "सरणी अनुक्रमित" हैं (जो हैं स्ट्रिंग नामों के रूप में परिभाषित किया गया है "... जिसका संख्यात्मक मान iसीमा में है +0 ≤ i < 2^32-1") और length। जब आप deleteकिसी सरणी प्रविष्टि को निकालने के लिए उपयोग करते हैं, तो यह सब प्रविष्टि को हटा देता है; यह अंतर को भरने के लिए अन्य प्रविष्टियों को स्थानांतरित नहीं करता है, और इसलिए सरणी "विरल" हो जाती है (कुछ प्रविष्टियां पूरी तरह से गायब हैं)। इसका कोई असर नहीं हुआ length।

इस प्रश्न के वर्तमान उत्तर की एक जोड़ी गलत तरीके से बताती है कि delete"प्रविष्टि को सेट करता है" का उपयोग करना undefined। यह सही नहीं है। यह प्रविष्टि (संपत्ति) को पूरी तरह से हटा देता है , एक अंतर को छोड़कर।

अंतर बताने के लिए कुछ कोड का उपयोग करते हैं:

console.log("Using `splice`:");
var a = ["a", "b", "c", "d", "e"];
console.log(a.length);            // 5
a.splice(0, 1);
console.log(a.length);            // 4
console.log(a[0]);                // "b"

console.log("Using `delete`");
var a = ["a", "b", "c", "d", "e"];
console.log(a.length);            // 5
delete a[0];
console.log(a.length);            // still 5
console.log(a[0]);                // undefined
console.log("0" in a);            // false
console.log(a.hasOwnProperty(0)); // false

console.log("Setting to `undefined`");
var a = ["a", "b", "c", "d", "e"];
console.log(a.length);            // 5
a[0] = undefined;
console.log(a.length);            // still 5
console.log(a[0]);                // undefined
console.log("0" in a);            // true
console.log(a.hasOwnProperty(0)); // true

---

* (यह मेरे एनीमिक थोड़ा ब्लॉग पर एक पोस्ट है)

Answer 17

वर्तमान में ऐसा करने के दो तरीके हैं

1. ब्याह का उपयोग कर ()

   arrayObject.splice(index, 1);

2. हटाने का उपयोग करना

   delete arrayObject[index];

लेकिन मैं हमेशा ऐरे ऑब्जेक्ट्स के लिए स्प्लिस का उपयोग करने और ऑब्जेक्ट विशेषताओं को हटाने का सुझाव देता हूं क्योंकि हटाए जाने से सरणी की लंबाई अपडेट नहीं होती है।

Answer 18

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

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

चलो पहले हटाते हैं:

delete arr[1];

और यह परिणाम है:

[1, empty, 3, 4, 5];

खाली! और चलो इसे प्राप्त करें:

arr[1]; //undefined

तो इसका मतलब है कि अभी हटाया गया मूल्य और यह अपरिभाषित है, इसलिए लंबाई समान है, यह भी सच हो जाएगा ...

आइए अपना ऐरे रीसेट करें और इस बार इसे ब्याह के साथ करें:

arr.splice(1, 1);

और इस बार यह परिणाम है:

[1, 3, 4, 5];

जैसा कि आप देख सरणी लंबाई बदल गया है और arr[1]है 3 अब ...

इसके अलावा यह एक एरे में नष्ट की गई वस्तु को लौटाएगा जो [3]इस मामले में है ...

Answer 19

दूसरों के deleteसाथ पहले से ही ठीक से तुलना की हैsplice ।

एक और दिलचस्प तुलना deleteबनाम है undefined: एक हटाए गए सरणी आइटम एक से कम मेमोरी का उपयोग करता है जो अभी सेट है undefined;

उदाहरण के लिए, यह कोड समाप्त नहीं होगा:

let y = 1;
let ary = [];
console.log("Fatal Error Coming Soon");
while (y < 4294967295)
{
    ary.push(y);
    ary[y] = undefined;
    y += 1;
}
console(ary.length);

यह इस त्रुटि का उत्पादन करता है:

FATAL ERROR: CALL_AND_RETRY_LAST Allocation failed - JavaScript heap out of memory.

तो, जैसा कि आप देख सकते हैं कि undefinedवास्तव में ढेर स्मृति लेता है।

हालाँकि, यदि आप भी deleteआर्य-आइटम (केवल इसे सेट करने के बजाय undefined), कोड धीरे-धीरे समाप्त हो जाएगा:

let x = 1;
let ary = [];
console.log("This will take a while, but it will eventually finish successfully.");
while (x < 4294967295)
{
    ary.push(x);
    ary[x] = undefined;
    delete ary[x];
    x += 1;
}
console.log(`Success, array-length: ${ary.length}.`);

ये चरम उदाहरण हैं, लेकिन वे इस बारे में एक बिंदु बनाते हैं deleteकि मैंने किसी का कहीं भी उल्लेख नहीं किया है।

Answer 20

यदि आपके पास छोटा सरणी है, तो आप इसका उपयोग कर सकते हैं filter:

myArray = ['a', 'b', 'c', 'd'];
myArray = myArray.filter(x => x !== 'b');

Answer 21

सबसे आसान तरीका शायद है

var myArray = ['a', 'b', 'c', 'd'];
delete myArray[1]; // ['a', undefined, 'c', 'd']. Then use lodash compact method to remove false, null, 0, "", undefined and NaN
myArray = _.compact(myArray); ['a', 'c', 'd'];

उम्मीद है की यह मदद करेगा। संदर्भ: https://lodash.com/docs#compact

Comments

क्या किसी को इस बारे में सोचकर ठोकर compactखानी चाहिए ... लेश की कोई आवश्यकता नहीं है। प्रयास करेंmyArray.filter(function(n){return n;})

— Dat

Answer 22

उन लोगों के लिए जो लॉडश का उपयोग करना चाहते हैं: myArray = _.without(myArray, itemToRemove)

या जैसा कि मैं Angular2 में उपयोग करता हूं

import { without } from 'lodash';
...
myArray = without(myArray, itemToRemove);
...

Answer 23

डिलीट : डिलीट, ऑब्जेक्ट प्रॉपर्टी को डिलीट कर देगा, लेकिन एरे को रिजेक्ट नहीं करेगा या उसकी लंबाई को अपडेट नहीं करेगा। यह ऐसा प्रतीत होता है जैसे कि यह अपरिभाषित है:

ब्याह : वास्तव में तत्व को हटाता है, सरणी को फिर से जोड़ता है, और इसकी लंबाई बदलता है।

तत्व को अंतिम से हटाएं

arrName.pop();

पहले से तत्व हटाएं

arrName.shift();

बीच से हटाओ

arrName.splice(starting index,number of element you wnt to delete);

Ex: arrName.splice(1,1);

एक तत्व को पिछले से हटा दें

arrName.splice(-1);

ऐरे इंडेक्स नंबर का उपयोग करके हटाएं

 delete arrName[1];

Answer 24

यदि हटाने का वांछित तत्व बीच में है (कहते हैं कि हम 'ग' को हटाना चाहते हैं, जिसका सूचकांक 1 है), आप इसका उपयोग कर सकते हैं:

var arr = ['a','b','c'];
var indexToDelete = 1;
var newArray = arr.slice(0,indexToDelete).combine(arr.slice(indexToDelete+1, arr.length))

Answer 25

IndexOfएक संदर्भ प्रकार भी स्वीकार करता है। मान लीजिए कि निम्नलिखित परिदृश्य:

var arr = [{item: 1}, {item: 2}, {item: 3}];
var found = find(2, 3); //pseudo code: will return [{item: 2}, {item:3}]
var l = found.length;

while(l--) {
   var index = arr.indexOf(found[l])
      arr.splice(index, 1);
   }
   
console.log(arr.length); //1

अलग ढंग से:

var item2 = findUnique(2); //will return {item: 2}
var l = arr.length;
var found = false;
  while(!found && l--) {
  found = arr[l] === item2;
}

console.log(l, arr[l]);// l is index, arr[l] is the item you look for

Answer 26

function deleteFromArray(array, indexToDelete){
  var remain = new Array();
  for(var i in array){
    if(array[i] == indexToDelete){
      continue;
    }
    remain.push(array[i]);
  }
  return remain;
}

myArray = ['a', 'b', 'c', 'd'];
deleteFromArray(myArray , 0);

// परिणाम: myArray = ['b', 'c', 'd'];

Comments

@ क्रिसडेन क्यों? (कोई व्यंग्य या द्वेष का इरादा नहीं है, यह एक ईमानदार सवाल है)

— क्रिस बिएर

इस तथ्य के अलावा कि यह जवाब ओपी के सवाल को संबोधित नहीं करता है

— क्रिस बिएर