javascript - atscript - जावास्क्रिप्ट इन भाषाओं से प्रेरित




जावास्क्रिप्ट में सरणी तत्वों को हटाना-बनाम छेद हटाएं (15)

Array.remove () विधि

JQuery 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);

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

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

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

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

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

यदि मैं ऑब्जेक्ट्स के साथ सरणी तत्वों को हटा सकता हूं तो स्प्लिस विधि क्यों है?


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

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]


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

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

> 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

कृपया ध्यान दें कि यह एक सरणी में डुप्लिकेट के साथ काम नहीं करेगा, क्योंकि इंडेक्सऑफ ("सी") को केवल पहला मौका मिलेगा, और केवल इसे विभाजित करने वाले पहले "सी" को हटा दें और हटा दें।


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

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

जैसा कि ऊपर दिया गया है, कई बार 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).

item1, item2, ...

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

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

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

[...]


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

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

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

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

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

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)
},

यदि वांछित तत्व को हटाने के लिए मध्य में है (कहें कि हम 'सी' को हटाना चाहते हैं, जिसका सूचकांक 1 है):

var arr = ['a','b','c'];

आप इसका उपयोग कर सकते हैं: var indexToDelete = 1; var newArray = arr.slice(0, indexToDelete).combine(arr.slice(indexToDelete+1, arr.length)) var indexToDelete = 1; var newArray = arr.slice(0, indexToDelete).combine(arr.slice(indexToDelete+1, arr.length))


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

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

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

इस प्रश्न के वर्तमान उत्तरों में से कुछ गलत तरीके से बताते हैं कि " 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

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


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

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

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

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

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


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

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

जबकि delete जा सकता है अन्य प्रकार के सूचकांक के खिलाफ ..

उदाहरण:

delete myArray['text1'];

बनाम splice हटा दें

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

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

जब आप splice

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

हटाए जाने के मामले में तत्व हटा दिया गया है लेकिन सूचकांक खाली रहता है

जबकि विभाजन तत्व के मामले में हटा दिया जाता है और शेष तत्वों की अनुक्रमणिका तदनुसार कम हो जाती है


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






delete-operator