javascript - रपत - मैं जावास्क्रिप्ट में किसी सरणी से किसी विशेष तत्व को कैसे हटा सकता हूं?




जावास्क्रिप्ट में एक वेब पेज बनाने के लिए और उपयोगकर्ता से एक इनपुट के रूप पृष्ठभूमि रंग ले (20)

मेरे पास पूर्णांक की एक सरणी है, और मैं इसमें तत्व जोड़ने के लिए .push() विधि का उपयोग कर रहा हूं।

क्या किसी सरणी से विशिष्ट तत्व को निकालने का कोई आसान तरीका है? array.remove(int); जैसे कुछ के बराबर array.remove(int);

मुझे कोर जावास्क्रिप्ट का उपयोग करना है - कोई ढांचे की अनुमति नहीं है।

https://code.i-harness.com


2016 अक्टूबर को संपादित किया गया

  • यह सरल, सहज और स्पष्ट ( https://en.wikipedia.org/wiki/Occam%27s_razor ) करें
  • इसे अपरिवर्तनीय करें (मूल सरणी अपरिवर्तित रहें)
  • मानक जेएस फ़ंक्शंस के साथ ऐसा करें, यदि आपका ब्राउज़र उनका समर्थन नहीं करता है - पॉलीफिल का उपयोग करें

इस कोड उदाहरण में मैं सरणी से अवांछित वस्तुओं को निकालने के लिए "array.filter (...)" फ़ंक्शन का उपयोग करता हूं, यह फ़ंक्शन मूल सरणी को नहीं बदलता है और एक नया बनाता है। यदि आपका ब्राउज़र इस फ़ंक्शन का समर्थन नहीं करता है (उदाहरण के लिए संस्करण 9 से पहले IE, या संस्करण 1.5 से पहले फ़ायरफ़ॉक्स), मोज़िला से फ़िल्टर पॉलीफ़िल का उपयोग करने पर विचार करें।

आइटम को हटा रहा है (ईसीएमए -262 संस्करण 5 कोड उर्फ ​​पुरानी जेएस)

var value = 3

var arr = [1, 2, 3, 4, 5, 3]

arr = arr.filter(function(item) { 
    return item !== value
})

console.log(arr)
// [ 1, 2, 4, 5 ]

आइटम को हटा रहा है (ES2015 कोड)

let value = 3

let arr = [1, 2, 3, 4, 5, 3]

arr = arr.filter(item => item !== value)

console.log(arr)
// [ 1, 2, 4, 5 ]

महत्वपूर्ण ES2015 "() => {}" तीर फ़ंक्शन सिंटैक्स IE में बिल्कुल समर्थित नहीं है, 45 संस्करण से पहले क्रोम, 22 संस्करण से पहले फ़ायरफ़ॉक्स, 10 संस्करण से पहले सफारी। पुराने ब्राउज़र में ES2015 वाक्यविन्यास का उपयोग करने के लिए आप BabelJS का उपयोग कर सकते हैं

कई वस्तुओं को हटा रहा है (ES2016 कोड)

इस विधि का एक अतिरिक्त लाभ यह है कि आप कई वस्तुओं को हटा सकते हैं

let forDeletion = [2, 3, 5]

let arr = [1, 2, 3, 4, 5, 3]

arr = arr.filter(item => !forDeletion.includes(item))
// !!! Read below about array.includes(...) support !!!

console.log(arr)
// [ 1, 4 ]

महत्वपूर्ण "array.includes (...)" फ़ंक्शन को IE में समर्थित नहीं है, 47 संस्करण से पहले क्रोम, 43 संस्करण से पहले फ़ायरफ़ॉक्स, 9 संस्करण से पहले सफारी और 14 संस्करण से पहले एज, तो मोज़िला से पॉलीफिल यहां है

कई वस्तुओं को हटा रहा है (कटिंग-एज प्रयोगात्मक जावास्क्रिप्ट ES2018?)

// array-lib.js

export function remove(...forDeletion) {
    return this.filter(item => !forDeletion.includes(item))
}

// main.js

import { remove } from './array-lib.js'

let arr = [1, 2, 3, 4, 5, 3]

// :: This-Binding Syntax Proposal
// using "remove" function as "virtual method"
// without extending Array.prototype
arr = arr::remove(2, 3, 5)

console.log(arr)
// [ 1, 4 ]

BabelJS में इसे स्वयं आज़माएं :)

संदर्भ


ईएस 6 और उत्परिवर्तन के बिना: (अक्टूबर 2016)

const removeByIndex = (list, index) =>
  [
    ...list.slice(0, index),
    ...list.slice(index + 1)
  ];

फिर :

removeByIndex([33,22,11,44],1) //=> [33,11,44]

आप lodash _.pull (mutate array) का उपयोग कर सकते हैं, _.pullAt (mutate array) या _.without (सरणी को म्यूटेट नहीं करता है)

var array1 = ['a', 'b', 'c', 'd']
_.pull(array1, 'c')
console.log(array1) // ['a', 'b', 'd']

var array2 = ['e', 'f', 'g', 'h']
_.pullAt(array2, 0)
console.log(array2) // ['f', 'g', 'h']

var array3 = ['i', 'j', 'k', 'l']
var newArray = _.without(array3, 'i') // ['j', 'k', 'l']
console.log(array3) // ['i', 'j', 'k', 'l']

आप इसे filter विधि के साथ आसानी से कर सकते हैं:

function remove(arrOriginal, elementToRemove){
    return arrOriginal.filter(function(el){return el !== elementToRemove});
}
console.log( remove([1, 2, 1, 0, 3, 1, 4], 1) );

यह सरणी से सभी तत्वों को हटा देता है और स्लाइस और इंडेक्स के संयोजन के बाद तेज़ी से काम करता है


इस कोड को देखें। यह हर प्रमुख ब्राउज़र में काम करता है

remove_item = function (arr, value) {
    var b = '';
    for (b in arr) {
        if (arr[b] === value) {
            arr.splice(b, 1);
            break;
        }
    }
    return arr;
}

इस समारोह को बुलाओ

remove_item(array,value);

इस पर निर्भर करता है कि आप खाली जगह रखना चाहते हैं या नहीं।

यदि आप एक खाली स्लॉट चाहते हैं, तो हटाएं ठीक है:

delete array[ index ];

यदि आप नहीं करते हैं, तो आपको splice विधि का उपयोग करना चाहिए:

array.splice( index, 1 );

और यदि आपको उस आइटम के मान की आवश्यकता है, तो आप केवल लौटे सरणी के तत्व को स्टोर कर सकते हैं:

var value = array.splice( index, 1 )[0];

यदि आप इसे किसी क्रम में करना चाहते हैं, तो आप पहले के लिए array.pop() उपयोग कर सकते हैं या array.shift() पहले के लिए (और दोनों आइटम के मान को भी वापस कर सकते हैं)।

और यदि आप आइटम की अनुक्रमणिका नहीं जानते हैं, तो आप इसे प्राप्त करने के लिए array.indexOf( item ) का उपयोग कर सकते हैं array.indexOf( item ) एक if() में एक आइटम प्राप्त करने के लिए या while() )। array.indexOf( item ) या तो नहीं मिला तो सूचकांक या -1 देता है।


एक दोस्त को Internet Explorer 8 में समस्याएं थीं, और मुझे दिखाया कि उसने क्या किया। मैंने उससे कहा कि यह गलत था, और उसने मुझे बताया कि उसे यहां जवाब मिला है। वर्तमान शीर्ष उत्तर सभी ब्राउज़रों (उदाहरण के लिए इंटरनेट एक्सप्लोरर 8) में काम नहीं करेगा, और यह केवल आइटम की पहली घटना को हटा देगा।

एक सरणी से सभी उदाहरण निकालें

function remove(arr, item) {
    for (var i = arr.length; i--;) {
        if (arr[i] === item) {
            arr.splice(i, 1);
        }
    }
}

यह पीछे की ओर सरणी के माध्यम से loops (चूंकि वस्तुओं को हटा दिया जाता है के रूप में सूचकांक और लंबाई बदल जाएगा) और अगर यह पाया जाता है तो आइटम को हटा देता है। यह सभी ब्राउज़रों में काम करता है।


जवाब देने के लिए बहुत पुराना है, लेकिन यह किसी मूल्य की बजाय भविष्यवाणी प्रदान करके किसी की सहायता कर सकता है।

नोट: यह दिए गए सरणी को अपडेट करेगा, और प्रभावित पंक्तियों को वापस करेगा

प्रयोग

var removed = helper.removeOne(arr, row => row.id === 5 );

var removed = helper.remove(arr, row => row.name.startsWith('BMW'));

परिभाषा

var helper = {

    // Remove and return the first occurrence     

    removeOne: function(array, predicate) {
        for (var i = 0; i < array.length; i++) {
            if (predicate(array[i])) {
                return array.splice(i, 1);
            }
        }
    },

    // Remove and return all occurrences  

    remove: function(array, predicate) {
        var removed = [];

        for (var i = 0; i < array.length;) {

            if (predicate(array[i])) {
                removed.push(array.splice(i, 1));
                continue;
            }

            i++;                
        }

        return removed;
    }
};

दो प्रमुख दृष्टिकोण हैं:

  1. splice () : anArray.splice(index, 1);

  2. हटाएं : delete anArray[index];

जब आप किसी सरणी के लिए डिलीट का उपयोग करते हैं तो सावधान रहें। ऑब्जेक्ट्स के गुणों को हटाने के लिए यह अच्छा है लेकिन सरणी के लिए इतना अच्छा नहीं है। सरणी के लिए splice का उपयोग करना बेहतर है।

ध्यान रखें कि जब आप किसी सरणी के लिए delete उपयोग करते हैं तो आपको anArray.length लिए गलत परिणाम मिल सकते हैं। दूसरे शब्दों में, delete तत्व को हटा देंगे लेकिन लंबाई संपत्ति के मूल्य को अपडेट नहीं करेंगे।

आप डिलीट का उपयोग करने के बाद इंडेक्स नंबरों में छेद भी प्राप्त कर सकते हैं, उदाहरण के लिए आप इंडेक्स 1,3,4,8,9,11 और लंबाई के साथ समाप्त कर सकते हैं क्योंकि यह डिलीट का उपयोग करने से पहले था। उस स्थिति में, लूप के for अनुक्रमित सभी क्रैश हो जाएंगे, क्योंकि इंडेक्स अब अनुक्रमिक नहीं हैं।

यदि आपको किसी कारण से delete का उपयोग करने के लिए मजबूर किया जाता है, तो आपको for each लूप के for each उपयोग करना चाहिए जब आपको सरणी के माध्यम से लूप की आवश्यकता होती है। वास्तव में, यदि संभव हो तो हमेशा लूप के लिए अनुक्रमित का उपयोग करने से बचें। इस तरह कोड अधिक मजबूत और इंडेक्स के साथ समस्याओं के लिए कम प्रवण होगा।


मुझे नहीं पता कि आप array.remove(int) से व्यवहार करने की अपेक्षा कैसे कर रहे हैं। ऐसी तीन संभावनाएं हैं जिनके बारे में मैं सोच सकता हूं कि आप चाहें।

इंडेक्स पर सरणी के तत्व को निकालने के लिए i :

array.splice(i, 1);

यदि आप सरणी से मूल्य number प्रत्येक तत्व को हटाना चाहते हैं:

for(var i = array.length - 1; i >= 0; i--) {
    if(array[i] === number) {
       array.splice(i, 1);
    }
}

यदि आप इंडेक्स में तत्व बनाना चाहते हैं तो i अब अस्तित्व में नहीं हूं, लेकिन आप नहीं चाहते कि अन्य तत्वों की अनुक्रमणिका बदल जाए:

delete array[i];

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

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]


यदि आपके पास सरणी में जटिल वस्तुएं हैं तो आप फ़िल्टर का उपयोग कर सकते हैं? ऐसी परिस्थितियों में जहां $ .inArray या array.splice उपयोग करने में आसान नहीं है। विशेष रूप से अगर वस्तुओं सरणी में उथले हैं।

उदाहरण के लिए यदि आपके पास एक आईडी फ़ील्ड वाला कोई ऑब्जेक्ट है और आप ऑब्जेक्ट को सरणी से हटा देना चाहते हैं:

this.array = this.array.filter(function(element, i) {
    return element.id !== idToRemove;
});

indexOf या splice का उपयोग करने की कोई आवश्यकता नहीं है। हालांकि, यह बेहतर प्रदर्शन करता है यदि आप केवल तत्व की एक घटना को हटाना चाहते हैं।

ढूंढें और स्थानांतरित करें (स्थानांतरित करें):

function move(arr, val) {
  var j = 0;
  for (var i = 0, l = arr.length; i < l; i++) {
    if (arr[i] !== val) {
      arr[j++] = arr[i];
    }
  }
  arr.length = j;
}

IndexOf और splice (indexof) का उपयोग करें:

function indexof(arr, val) {
  var i;
  while ((i = arr.indexOf(val)) != -1) {
    arr.splice(i, 1);
  }
}

केवल splice (splice) का प्रयोग करें:

function splice(arr, val) {
  for (var i = arr.length; i--;) {
    if (arr[i] === val) {
      arr.splice(i, 1);
    }
  }
}

1000 तत्वों (10000 से अधिक रनों के औसत) के साथ सरणी के लिए नोडजेज़ पर रन-टाइम:

सूचकांक चाल से लगभग 10x धीमी है। यहां तक ​​कि अगर indexOf में कॉल को हटाकर सुधार किया जाता है तो indexOf में यह चाल से कहीं ज्यादा खराब होता है।

Remove all occurrences:
    move 0.0048 ms
    indexof 0.0463 ms
    splice 0.0359 ms

Remove first occurrence:
    move_one 0.0041 ms
    indexof_one 0.0021 ms

अद्यतन: इस विधि की केवल तभी अनुशंसा की जाती है जब आप ECMAScript 2015 (जिसे पहले ES6 के नाम से जाना जाता है) का उपयोग नहीं कर सकते। यदि आप इसका उपयोग कर सकते हैं, तो अन्य उत्तर यहां बहुत साफ कार्यान्वयन प्रदान करते हैं।

यह सारांश यहां आपकी समस्या का समाधान करेगा, और केवल 1 (या निर्दिष्ट मान) की बजाय तर्क की सभी घटनाओं को हटा देगा।

Array.prototype.destroy = function(obj){
    // Return null if no objects were found and removed
    var destroyed = null;

    for(var i = 0; i < this.length; i++){

        // Use while-loop to find adjacent equal objects
        while(this[i] === obj){

            // Remove this[i] and store it within destroyed
            destroyed = this.splice(i, 1)[0];
        }
    }

    return destroyed;
}

उपयोग:

var x = [1, 2, 3, 3, true, false, undefined, false];

x.destroy(3);         // => 3
x.destroy(false);     // => false
x;                    // => [1, 2, true, undefined]

x.destroy(true);      // => true
x.destroy(undefined); // => undefined
x;                    // => [1, 2]

x.destroy(3);         // => null
x;                    // => [1, 2]

ठीक है, उदाहरण के लिए आप नीचे सरणी रखते हैं:

var num = [1, 2, 3, 4, 5];

और हम नंबर 4 को हटाना चाहते हैं, आप बस नीचे दिए गए कोड को कर सकते हैं:

num.splice(num.indexOf(4), 1); //num will be [1, 2, 3, 5];

यदि आप इस फ़ंक्शन का पुन: उपयोग करते हैं, तो आप एक पुन: प्रयोज्य फ़ंक्शन लिखते हैं जो मूल सरणी फ़ंक्शन से नीचे दिखेगा:

Array.prototype.remove = Array.prototype.remove || function(x) {
  const i = this.indexOf(x);
  if(i===-1) return;
  this.splice(i, 1); //num.remove(5) === [1, 2, 3];
}

लेकिन अगर आपके नीचे ऐरे में कुछ [5] एस के साथ नीचे सरणी है तो कैसे?

var num = [5, 6, 5, 4, 5, 1, 5];

हमें उन सभी को जांचने के लिए एक लूप की आवश्यकता है, लेकिन अंतर्निहित जावास्क्रिप्ट फ़ंक्शंस का उपयोग करना आसान और अधिक कुशल तरीका है, इसलिए हम एक फ़ंक्शन लिखते हैं जो नीचे दिए गए फ़िल्टर का उपयोग करते हैं:

const _removeValue = (arr, x) => arr.filter(n => n!==x);
//_removeValue([1, 2, 3, 4, 5, 5, 6, 5], 5) //return [1, 2, 3, 4, 6]

इसके अलावा तीसरे पक्ष के पुस्तकालय भी हैं जो आपको ऐसा करने में मदद करते हैं, जैसे लोडाश या अंडरस्कोर, अधिक जानकारी के लिए lodash _.pull, _.pullAt या _.without देखें।


आपके पास 1 से 9 सरणी है और आप कोड के नीचे 5 उपयोग को हटाना चाहते हैं।

var numberArray = [1, 2, 3, 4, 5, 6, 7, 8, 9];

var newNumberArray = numberArray.filter(m => {
  return m !== 5;
});

console.log("new Array, 5 removed", newNumberArray);

यदि आप कई मान पूर्व चाहते हैं: - 1,7,8

var numberArray = [1, 2, 3, 4, 5, 6, 7, 8, 9];

var newNumberArray = numberArray.filter(m => {
  return (m !== 1) && (m !== 7) && (m !== 8);
});

console.log("new Array, 5 removed", newNumberArray);

यदि आप सरणी में सरणी मान को निकालना चाहते हैं: - [3,4,5]

var numberArray = [1, 2, 3, 4, 5, 6, 7, 8, 9];
var removebleArray = [3,4,5];

var newNumberArray = numberArray.filter(m => {
    return !removebleArray.includes(m);
});

console.log("new Array, [3,4,5] removed", newNumberArray);

समर्थित ब्राउज़र शामिल है link


मेरे पास सरणी से हटाने के लिए एक और अच्छा समाधान है:

var words = ['spray', 'limit', 'elite', 'exuberant', 'destruction', 'present'];

const result = words.filter(word => word.length > 6);

console.log(result);
// expected output: Array ["exuberant", "destruction", "present"]

filter


यदि तत्व के कई उदाहरण हैं, तो आप इंडेक्स को पेंच नहीं करना सुनिश्चित करने के लिए पिछड़ा लूप कर सकते हैं।

var myElement = "chocolate";
var myArray = ['chocolate', 'poptart', 'poptart', 'poptart', 'chocolate', 'poptart', 'poptart', 'chocolate'];

/* Important code */
for (var i = myArray.length - 1; i >= 0; i--) {
    if (myArray[i] == myElement) myArray.splice(i, 1);
}

लाइव डेमो


मुझे पता है कि पहले से ही बहुत सारे जवाब हैं, लेकिन उनमें से कई समस्या को जटिल बनाते हैं। यहां एक कुंजी के सभी उदाहरणों को हटाने का एक सरल, पुनरावर्ती तरीका है - इंडेक्स नहीं मिलने तक स्वयं को कॉल करें। हां, यह केवल ब्राउज़र में काम करता है indexOf, लेकिन यह आसान है और आसानी से पॉलीफिल किया जा सकता है।

स्टैंड-अलोन फ़ंक्शन

function removeAll(array, key){
    var index = array.indexOf(key);

    if(index === -1) return;

    array.splice(index, 1);
    removeAll(array,key);
}

प्रोटोटाइप विधि

Array.prototype.removeAll = function(key){
    var index = this.indexOf(key);

    if(index === -1) return;

    this.splice(index, 1);
    this.removeAll(key);
}

  Array.prototype.removeItem = function(a) {
            for (i = 0; i < this.length; i++) {
                if (this[i] == a) {
                    for (i2 = i; i2 < this.length - 1; i2++) {
                        this[i2] = this[i2 + 1];
                    }
                    this.length = this.length - 1
                    return;
                }
            }
        }

    var recentMovies = ['Iron Man', 'Batman', 'Superman', 'Spiderman'];
    recentMovies.removeItem('Superman');







arrays