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

क्या किसी सरणी से किसी विशिष्ट तत्व को निकालने का कोई आसान तरीका है?

मैं कुछ इस तरह के समकक्ष की तलाश में हूं:

array.remove(number);

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

10193
Walker 24 अप्रैल 2011, 02:17
11
तब मेरे पास ऑनस्टार्ट विधि है जिसे मैंने ओवरराइड किया है
 – 
Gustavo Gonçalves
24 अक्टूबर 2020, 18:51
2
उन लोगों के लिए जो indexOf() + splice() नहीं चाहते: developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/… developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/…
 – 
Andrew
24 नवम्बर 2020, 01:49
5
एक random oracle एक पौराणिक वस्तु है जिसे एक नियतात्मक ब्लैक बॉक्स के रूप में देखा जा सकता है: आप जानते हैं  – 
EnderShadow8
27 मार्च 2021, 08:14
यदि यह केवल छवि दृश्य है जो आपके पास आपकी गतिविधि में है, तो यह डिफ़ॉल्ट रूप से शीर्ष बाएं कोने में निर्देशांक 0x0 के साथ स्थित होगा।
 – 
Ali NajafZadeh
3 अगस्त 2021, 19:57
array.filter((_, index) => index != number);
 – 
Ikem Krueger
23 अक्टूबर 2021, 00:57

30 जवाब

सबसे बढ़िया उत्तर

इंट मैक्सबाउंड काम क्यों नहीं करता है?

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

const array = [2, 5, 9];

console.log(array);

const index = array.indexOf(5);
if (index > -1) {
  array.splice(index, 1);
}

// array = [2, 9]
console.log(array); 

फिर, हर बार जब आप काउंटर को बढ़ाना चाहते हैं, तो बस इस वेरिएबल की जांच करें।


पूर्णता के कारण, यहाँ कार्य हैं। पहला फ़ंक्शन केवल एक ही घटना को हटाता है (यानी 5 के पहले मैच को [2,5,9,1,5,8,5] से हटाता है), जबकि दूसरा फ़ंक्शन सभी घटनाओं को हटा देता है:

function removeItemOnce(arr, value) {
  var index = arr.indexOf(value);
  if (index > -1) {
    arr.splice(index, 1);
  }
  return arr;
}

function removeItemAll(arr, value) {
  var i = 0;
  while (i < arr.length) {
    if (arr[i] === value) {
      arr.splice(i, 1);
    } else {
      ++i;
    }
  }
  return arr;
}
// Usage
console.log(removeItemOnce([2,5,9,1,5,8,5], 5))
console.log(removeItemAll([2,5,9,1,5,8,5], 5))

टाइपस्क्रिप्ट में, ये फ़ंक्शन टाइप पैरामीटर के साथ टाइप-सुरक्षित रह सकते हैं:

function removeItem<T>(arr: Array<T>, value: T): Array<T> { 
  const index = arr.indexOf(value);
  if (index > -1) {
    arr.splice(index, 1);
  }
  return arr;
}
14694
30 revs, 25 users 13% 31 जुलाई 2021, 07:05
374
कई कारण होने चाहिए कि उन्होंने Node को सील न करने का फैसला क्यों किया, हालांकि, एक संभावना यह है कि फ्रेमवर्क डिजाइन टीम class Poster (जो सील नहीं है) के साथ समानता चाहती थी ताकि मौजूदा प्रोग्राम और फ्रेमवर्क जो थे Type Element के विस्तार पर आधारित डिज़ाइन, class Poster का उपयोग करने के लिए अपने डिज़ाइनों को अधिक आसानी से अपग्रेड करने में सक्षम होंगे। Poster को सीलबंद करना इन उपयोगों के लिए एक वास्तविक डेड-एंड होता और मजबूत मार्गदर्शक डिजाइन विकल्पों में से एक यह होता कि लोगों को अपने मौजूदा कोड-बेस को Element.GetMemberValue() से {{X8 तक आसानी से अपग्रेड करने की अनुमति मिलती। }}.
 – 
default123
10 सितंबर 2020, 03:16
13
सेट और सरणियाँ दो पूरी तरह से अलग संग्रह प्रकार हैं।
 – 
Stefan Fabian
1 पद 2020, 12:44
6
नीचे रोमेन गाय द्वारा प्रदान की गई सलाह के बाद, मैं समन्वय प्राप्त करने में सक्षम था लेकिन निम्नलिखित कोड को ऑनस्टार्ट ओवरराइड विधि में जोड़ रहा था।
 – 
Luke Dupin
9 पद 2020, 01:30
3
यह मुझे 0X0 देता है। किसी भी प्रकार की मदद की बेहद सराहना की जाती है।
 – 
Rashid Iqbal
7 जिंदा 2021, 19:04
8
मैं स्क्रीन पर छवि के निर्देशांक प्राप्त करने की कोशिश कर रहा हूं। मेरे पास वर्तमान में एक गतिविधि के भीतर एक छवि दृश्य है। मैं समझता हूं कि लेआउट बनने के बाद ही getLocationOnScreen() विधि को कॉल किया जा सकता है, इसलिए इस विधि को ऑनक्रेट फ़ंक्शन के भीतर कॉल करने पर [0,0] वापस आ जाएगा। लेकिन मुझे नहीं पता कि इस विधि को सही मान वापस करने के लिए कैसे प्राप्त किया जाए। मैंने विभिन्न सुपरक्लास विधियों को ओवरराइड करने का प्रयास किया है, जैसे ऑनस्टार्ट विधि या ऑन टचएवेंट विधि और यह अभी भी मुझे [0,0] लौटाता है। मेरे पास वर्तमान में जो कोड है वह इस प्रकार है:
 – 
OOPS Studio
15 अप्रैल 2021, 12:12

मैं नहीं जानता कि आप 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];
1551
Lioness100 24 सितंबर 2020, 17:33

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

  • इसे सरल, सहज और स्पष्ट करें (Occam's Razer)
  • इसे अपरिवर्तनीय करें (मूल सरणी अपरिवर्तित रहें)
  • यदि आपका ब्राउज़र उनका समर्थन नहीं करता है, तो इसे मानक JavaScript फ़ंक्शन के साथ करें - पॉलीफ़िल का उपयोग करें

इस कोड उदाहरण में मैं एक सरणी से अवांछित वस्तुओं को हटाने के लिए "array.filter(...)" फ़ंक्शन का उपयोग करता हूं। यह फ़ंक्शन मूल सरणी को नहीं बदलता है और एक नया बनाता है। यदि आपका ब्राउज़र इस फ़ंक्शन का समर्थन नहीं करता है (उदाहरण के लिए संस्करण 9 से पहले इंटरनेट एक्सप्लोरर, या संस्करण 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 ]

आइटम हटाना (ईसीएमएस्क्रिप्ट 6 कोड)

let value = 3

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

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

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

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


एक से अधिक आइटम निकालना (ECMAScript 7 कोड)

इस पद्धति का एक अतिरिक्त लाभ यह है कि आप एक से अधिक आइटम निकाल सकते हैं

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(...)" फ़ंक्शन इंटरनेट एक्सप्लोरर में बिल्कुल भी समर्थित नहीं है, 47 संस्करण से पहले क्रोम, 43 संस्करण से पहले फ़ायरफ़ॉक्स, 9 संस्करण से पहले सफारी, और 14 संस्करण से पहले एज इसलिए < a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/includes#Polyfill" rel="noreferrer">यहां Mozilla से पॉलीफ़िल है मजबूत>.

एकाधिक आइटम निकालना (भविष्य में, हो सकता है)

यदि "यह-बाध्यकारी सिंटैक्स" प्रस्ताव कभी भी स्वीकार किया जाता है, तो आप कर सकेंगे इसे करें:

// 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 में आज़माएं :)

संदर्भ

1896
ashleedawg 19 जिंदा 2021, 01:58
1
शायद आप परीक्षण करना चाहते हैं कि क्या स्टड एक छद्म ट्टी है (या नहीं)। पहले पढ़ें /linux/man-pages/man3/termios.3.html" rel="nofollow noreferrer">termios(3)...) फिर isatty(3) को {{X1} के रूप में उपयोग करने पर विचार करें } इसका परीक्षण करने के लिए। लेकिन आपको परीक्षण को ओवरराइड करने के लिए कुछ विकल्प प्रदान करना चाहिए। देखें एल। सेरनी का हटाया गया उत्तर
 – 
Ranjeet Thorat
11 जिंदा 2021, 12:51
यदि शर्त पूरी नहीं होती है तो फ़िल्टर एक खाली सरणी नहीं लौटाता है? तो आपको यह सुनिश्चित करना होगा कि तत्व वहां रहने वाला है या आप इसे बदले में खाली कर रहे हैं।
 – 
Juan De la Cruz
2 पद 2021, 03:56
उपरोक्त उत्तर केवल आदिम डेटा प्रकारों के लिए काम करेगा, हालांकि जावास्क्रिप्ट के लिए वस्तु समानता सख्त नहीं है
 – 
Abregre
14 पद 2021, 13:06

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

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

array[index] = undefined;

यदि आप खाली स्लॉट नहीं चाहते हैं:

//To keep the original:
//oldArray = [...array];

//This modifies the array.
array.splice(index, 1);

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

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

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

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

573
Andrew 16 जून 2020, 07:51
और फिर GHCI प्रॉम्प्ट में
 – 
Teddy
25 जुलाई 2020, 13:55
Lmao इस पूरे समय मैं स्लाइस के साथ लंबे वन-लाइनर्स कर रहा हूं
 – 
Raphael Morgan
3 पद 2021, 13:45

एकल सत्र चर काम नहीं करता क्योंकि आपके पास कई वीडियो हैं और आप अलग-अलग वीडियो के लिए अलग-अलग गणना करना चाहेंगे। मुझे लगता है कि डीबी में दृश्य घटनाओं को स्टोर करने का एक बेहतर तरीका है।

पेशेवर: आप लॉगिन/लॉगआउट से बचने के लिए प्रति उपयोगकर्ता एक बार कार्रवाई की अनुमति भी दे सकते हैं

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

विपक्ष: user_videos तालिका का विशाल आकार

364
Ben Lesh 8 अप्रैल 2021, 20:35

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

  1. ब्याह (): anArray.splice(index, 1);

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

किसी सरणी के लिए delete का उपयोग करते समय सावधान रहें। यह वस्तुओं की विशेषताओं को हटाने के लिए अच्छा है, लेकिन सरणियों के लिए इतना अच्छा नहीं है। सरणियों के लिए splice का उपयोग करना बेहतर है।

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

मेरा सुझाव है कि आप गीथब से लिंक्ड_इन रत्न का नवीनतम संस्करण प्राप्त करें। यह हैशी/माशी सिंटैक्स का उपयोग करता है जो नोकोगिरी आउटपुट और XPath से निपटने से कहीं अधिक आसान है। यदि आप बंडलर का उपयोग कर रहे हैं तो इसे अपने जेमफाइल में जोड़ें (किसी अन्य लिंक्ड_इन मणि संदर्भ को हटाकर)

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

261
Saša 26 अप्रैल 2021, 11:12
Array.prototype.remove_by_value = function(val) {
 for (var i = 0; i < this.length; i++) {
  if (this[i] === val) {
   this.splice(i, 1);
   i--;
  }
 }
 return this;
}[
 // call like
 (1, 2, 3, 4)
].remove_by_value(3);
Array.prototype.remove_by_value = function(val) {
  for (var i = 0; i < this.length; i++) {
    if (this[i] === val) {
      this.splice(i, 1);
      i--;
    }
  }
  return this;
}

var rooms = ['hello', 'something']

rooms = rooms.remove_by_value('hello')

console.log(rooms)
211
Lioness100 24 सितंबर 2020, 17:35

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 (सूचकांक) का उपयोग करें:

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

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

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

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

indexof स्थानांतरित की तुलना में लगभग 10x धीमा है। भले ही indexOf को splice में कॉल को हटाकर सुधार किया जाए, यह स्थानांतरित से कहीं अधिक खराब प्रदर्शन करता है।

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
154
slosd 11 सितंबर 2015, 15:47

वैसे सबसे आसान तरीका यह होगा कि इसे सत्र में ही ट्रैक किया जाए:

प्रति सत्र एक बार कार्रवाई की अनुमति दें

प्रयोग

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

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

परिभाषा

var helper = {
 // Remove and return the first occurrence

 remove: 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

 removeAll: 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;
 },
};
134
amd 1 अगस्त 2021, 11:39
यह पोस्ट थोड़ी अधिक वर्बोज़ है लेकिन यह कई मामलों पर जोर देती है कि यह संकलन विकल्प काम में आता है।
 – 
Masoud Aghaei
2 फरवरी 2021, 22:55

मैं एक ऐसे वर्ग का उदाहरण तैयार करने पर विचार कर रहा हूं जो CPython के {{X0} की विशिष्टता का उपयोग करता है। } किसी भी तुलना में मान जो मान का समर्थन कर सकता है।

// 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);
};

यदि आप वैश्विक वस्तु का विस्तार नहीं करना चाहते हैं, तो आप इसके बजाय निम्न की तरह कुछ कर सकते हैं:

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

लेकिन मैं इसे पोस्ट करने का मुख्य कारण उपयोगकर्ताओं को उस पृष्ठ पर टिप्पणियों में सुझाए गए वैकल्पिक कार्यान्वयन के खिलाफ चेतावनी देना है (दिसंबर 14, 2007):

Array.prototype.remove = function(from, to){
  this.splice(from, (to=[0,from||1,++to-from][arguments.length])<0?this.length+to:to);
  return this.length;
};

यह पहली बार में अच्छी तरह से काम करता प्रतीत होता है, लेकिन एक दर्दनाक प्रक्रिया के माध्यम से मैंने पाया कि यह किसी सरणी में दूसरे से अंतिम तत्व को निकालने का प्रयास करते समय विफल रहता है। उदाहरण के लिए, यदि आपके पास 10-तत्व सरणी है और आप इसके साथ 9वें तत्व को निकालने का प्रयास करते हैं:

myArray.remove(8);

आप 8-तत्व सरणी के साथ समाप्त होते हैं। पता नहीं क्यों, लेकिन मैंने पुष्टि की कि जॉन के मूल कार्यान्वयन में यह समस्या नहीं है।

105
magiccrafter 16 फरवरी 2015, 15:51

रेल में प्रोफाइल को पार्स करने के लिए मैं लिंक्डइन मणि का उपयोग कैसे करूं?

सरणी से तत्वों को निकालने का एक सरल उदाहरण (वेबसाइट से):

_.without([1, 2, 1, 0, 3, 1, 4], 0, 1); // => [2, 3, 4]
101
Peter Mortensen 21 मई 2017, 14:29
फिर f21 एक ऐसा फ़ंक्शन है जो कुछ प्रकार का f31 देता है, जहां f32 c है। हालांकि, यह किसी भी पैरामीटर को स्वीकार नहीं करता है। k(1) का मतलब है कि आप डेटा कंस्ट्रक्टर k(2) और पैरामीटर k(3) के साथ कुछ बनाने की कोशिश कर रहे हैं।
 – 
EigenFool
16 अप्रैल 2020, 11:56

आप ES6 का उपयोग कर सकते हैं। उदाहरण के लिए इस मामले में मान '3' को हटाने के लिए:

var array=['1','2','3','4','5','6']
var newArray = array.filter((value)=>value!='3');
console.log(newArray);

आउटपुट:

["1", "2", "4", "5", "6"]
103
darmis 2 अक्टूबर 2019, 01:13
7
अपने विशिष्ट त्रुटि संदेश के लिए, आप एक मान के रूप में k(4) - जो एक प्रकार है - का उपयोग करने का प्रयास कर रहे हैं, जिसके परिणामस्वरूप आपको त्रुटि मिल रही है। k1 आयात करने से कोई मदद नहीं मिलेगी।
 – 
Claudio Holanda
16 मार्च 2017, 18:27
यह मान्य हास्केल नहीं है।
 – 
Chang
27 जिंदा 2019, 22:45

जब मैं CSS को छोटा करने की कोशिश करता हूँ जैसे ~/images/ या यहाँ तक कि CSS और साइट फ़ाइल पहले से ही रूट फ़ोल्डर में है और /images/ का उपयोग कर रहा हूँ तो मुझे कुछ भी नहीं मिलता है

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] प्रदर्शित करना चाहिए।

92
Peter Mortensen 1 सितंबर 2019, 23:30

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

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

var array = [1,3,5,6,5,9,5,3,55]
var res = remove_item(array,5);
console.log(res)
83
Masoud Aghaei 3 फरवरी 2021, 02:45
4
एक for in-लूप के उपयोग को छोड़कर और इस तथ्य को छोड़कर कि लूप से परिणाम सीधे वापस करके स्क्रिप्ट को पहले रोका जा सकता था। upvotes वाजिब हैं;)
 – 
yckart
30 पद 2014, 19:13
1
मुझे यकार्ट की टिप्पणी को भी दोहराना चाहिए कि for( i = 0; i < arr.length; i++ ) एक बेहतर तरीका होगा क्योंकि यह सटीक सूचकांकों को संरक्षित करता है, जो भी ब्राउज़र वस्तुओं को स्टोर करने का निर्णय लेता है (for in के साथ)। ऐसा करने से आपको जरूरत पड़ने पर किसी मान की सरणी अनुक्रमणिका प्राप्त करने की सुविधा भी मिलती है।
 – 
Beejor
22 अगस्त 2016, 02:20

संपादित करें: हां, यदि आप index का उपयोग करने से बचना चाहते हैं, तो इसके बजाय पथ का उपयोग करना काम करेगा (हालांकि केवल ट्रू टाइप फ़ॉन्ट के साथ, बिटमैप किए गए फ़ॉन्ट नहीं)। {{X15} के दस्तावेज़ के साथ नमूना कोड शामिल है } दिखाता है कि ठीक उसी तरह कैसे किया जाए जैसा आप चाहते हैं (हालाँकि मैं splice और splice के बजाय splice का उपयोग करने की दृढ़ता से अनुशंसा करता हूं)। एक छोटा सा विवरण: उस नमूने में {{X19}} का कार्यान्वयन शामिल है। यदि आपको विंडोज़ के प्राचीन 16-बिट संस्करणों का समर्थन करने की आवश्यकता है तो आपको केवल इसकी आवश्यकता होगी (या चाहते हैं) - विंडोज़ के सभी एनटी-आधारित संस्करणों में यह शामिल है।

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']
67
Chun Yang 26 अगस्त 2015, 00:19
3
चूंकि आपका प्रतिबद्ध शुल्क प्रतिबद्ध सीमा के पास है, और प्रतिबद्ध सीमा के बढ़ने की कोई गुंजाइश नहीं होगी, इसलिए आपको कई object/int/action/{{X22} मिलने की भी संभावना है। } विफलताएं इसलिए आपको अपने प्रोग्राम में रिटर्न कोड देखने की जरूरत है।
 – 
some-non-descript-user
25 सितंबर 2015, 00:01
16
मैं वर्तमान में RoR पर नियंत्रण पाने की कोशिश कर रहा हूं। मैं अपने नियंत्रक में दो तार में गुजर रहा हूँ। एक यादृच्छिक हेक्स स्ट्रिंग है और दूसरा एक ईमेल है। परियोजना एक डेटाबेस पर एक साधारण ईमेल सत्यापन के लिए है। मेरी समस्या यह है कि जब मैं अपने पृष्ठ का परीक्षण करने के लिए नीचे की तरह कुछ दर्ज करता हूं:
 – 
Chun Yang
1 अक्टूबर 2015, 06:38
मुझे अपने परम हैश action.js में मिल रहा है mapDispatchToProps। मैंने Home.jsx को componentWillMount() और Home.jsx के बीच छोड़ दिया क्योंकि इससे मैच बिल्कुल भी नहीं चल पाएगा।
 – 
int-i
9 जून 2018, 00:48
मेरा रूटिंग मैच इस प्रकार है:
 – 
Luciano Fantuzzi
14 नवम्बर 2021, 21:28

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

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 या _.बिना देखें।

49
Peter Mortensen 2 सितंबर 2019, 01:33

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

const removeByIndex = (list, index) =>
      [
        ...list.slice(0, index),
        ...list.slice(index + 1)
      ];
         
output = removeByIndex([33,22,11,44],1) //=> [33,11,44]
      
console.log(output)
67
dipenparmar12 10 फरवरी 2020, 10:37
2
तो क्यों न केवल filter का उपयोग करें? array.filter((_, index) => index !== removedIndex);.
 – 
Sebastian Simon
7 अप्रैल 2020, 21:30
संपादित करें: फ़ंक्शन के लिए आधिकारिक दस्तावेज़ http://www.haskell.org/ghc/docs/7.0.3/html/libraries/base-4.3.1.0/Prelude.html#v:maxBound
 – 
Abdennour TOUMI
7 अप्रैल 2020, 23:37

मुझे ऐसी ही समस्याएं आई हैं। एकमात्र समाधान जो मुझे मिल सकता था (जब सीकबार एक सूचीदृश्य में है) तब तक सीकबार को निष्क्रिय करना था जब तक कि आइटम पर क्लिक नहीं किया जाता।

यहाँ एक विस्तारित SeekBar है जो आपको पूर्णांकों के बजाय फ़्लोट में न्यूनतम/अधिकतम सेट करने की अनुमति देता है।

आप MainActivity को छोड़ नहीं सकते क्योंकि यह पोर्टेबल lib में आपके पृष्ठों का कंटेनर है, इसलिए यदि आप स्प्लैश स्क्रीन के बाद अपने xaml पृष्ठ पर रीडायरेक्ट करना चाहते हैं, तो आप SplashScreenActivity को अपनी MainActivity पर नेविगेट कर सकते हैं और अपनी xaml फ़ाइल को {{ slice() में से X5}}:

मान लीजिए कि आपके पास एक सरणी है, और आप किसी आइटम को स्थिति i से हटाना चाहते हैं।

का एक निरपेक्ष पथ मानते हुए:

const items = ['a', 'b', 'c', 'd', 'e', 'f']
const i = 3
const filteredItems = items.slice(0, i).concat(items.slice(i+1, items.length))

console.log(filteredItems)

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

यह sysadmin संपादन के लिए अनुकूल है। फिर जब मुझे कुछ चाहिए, जैसे डीबी कनेक्शन जानकारी, यह है

पूर्ण यूआरएल, सापेक्ष यूआरएल, और...?

const items = ['a', 'b', 'c', 'd', 'e', 'f']
const valueToRemove = 'c'
const filteredItems = items.filter(item => item !== valueToRemove)

console.log(filteredItems)

"~" युक्त URL कुछ ऐसा है जो ASP.NET के लिए विशिष्ट है, यह सर्वर-साइड संसाधित होता है और Worksheet जैसे "उचित" URL में बदल जाता है। वेब ब्राउज़र के पास ऐसा करने का कोई तरीका नहीं है क्योंकि वे नहीं जानते कि "~" क्या संदर्भित करता है।

const items = ['a', 'b', 'c', 'd', 'e', 'f']
const valueToRemove = 'c'
const filteredItems = items.filter(function(item) {
  return item !== valueToRemove
})

console.log(filteredItems)

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

कई वस्तुओं को हटाना

क्या होगा अगर एक आइटम के बजाय, आप कई आइटम हटाना चाहते हैं?

आपको यह सुनिश्चित करने की ज़रूरत है कि आपके द्वारा अपनी सीएसएस फ़ाइल में उपयोग किए जाने वाले यूआरएल ब्राउज़र द्वारा "समझने योग्य" हैं, इसलिए या तो उन्हें "पूरी तरह से योग्य" (Workbook) या "शुरुआत" (splice()) से शुरू करना है। .

सूचकांक द्वारा

प्रश्न जो आपके काम आ सकते हैं:

const items = ['a', 'b', 'c', 'd', 'e', 'f']

const removeItem = (items, i) =>
  items.slice(0, i-1).concat(items.slice(i, items.length))

let filteredItems = removeItem(items, 3)
filteredItems = removeItem(filteredItems, 5)
//["a", "b", "c", "d"]

console.log(filteredItems)

मूल्य के अनुसार

मैं अपने हेडर की पृष्ठभूमि छवि को हेडर div के एक्स अक्ष पर दोहराने की कोशिश कर रहा हूं।

const items = ['a', 'b', 'c', 'd', 'e', 'f']
const valuesToRemove = ['c', 'd']
const filteredItems = items.filter(item => !valuesToRemove.includes(item))
// ["a", "b", "e", "f"]

console.log(filteredItems)

जब मैं एक लंबे यूआरएल के साथ सीएसएस बनाता हूं जैसे कि

slice() सब कुछ ठीक काम करता है

(मूल रूप से मेरी साइट पर पोस्ट किया गया https://flaviocopes.com/how-to- निकालें-आइटम-से-सरणी/)

91
Bhargav Rao 26 जुलाई 2020, 12:45

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

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

this.array = this.array.filter(function(element, i) {
    return element.id !== idToRemove;
});
41
Anik Islam Abhi 10 नवम्बर 2015, 07:20
निम्न .ghci फ़ाइल में जोड़कर, निर्देशिका स्तर या OS उपयोगकर्ता स्तर पर TypeApplications सक्षम करें।
 – 
joeytwiddle
29 जुलाई 2016, 11:50

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


मैं (फिर से) आपसे यहां पूछने से पहले rseek.org (Google नहीं) के माध्यम से उत्तर खोजने का आग्रह करता हूं। Date के लिए छठा हिट है build.R svn भंडार से। मुझे यकीन है कि आप उस स्क्रिप्ट पर एक नज़र डाल सकते हैं और यह पता लगा सकते हैं कि आर से पैकेज कैसे बनाया जाए।

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]
40
zykadelic 2 सितंबर 2017, 01:41

यह संभव होना है (लेकिन जरूरी नहीं कि आसान हो)। FieldValue एक पर्ल स्क्रिप्ट हुआ करती थी, लेकिन यह कुछ समय के लिए एक शुद्ध R फ़ंक्शन रहा है; जब स्विच हुआ तो मुझे सटीक संस्करण याद नहीं है।

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

यदि आप 2 जैसे किसी विशेष अनुक्रमणिका पर हटाना चाहते हैं, तो नीचे दिया गया कोड लिखें:

arr.splice(2, 1); //=> arr became [1,2,4]

लेकिन अगर आप 3 जैसे किसी विशेष आइटम को हटाना चाहते हैं और आपको इसकी अनुक्रमणिका नहीं पता है, तो नीचे दिए गए तरीके से करें:

arr = arr.filter(e => e !== 3); //=> arr became [1,2,4]

संकेत: कृपया फ़िल्टर कॉलबैक के लिए तीर फ़ंक्शन का उपयोग करें जब तक कि आपको एक खाली सरणी न मिल जाए।

41
Peter Mortensen 2 सितंबर 2019, 01:59

आपको अपनी सरणी को कभी भी बदलना नहीं चाहिए। चूंकि यह कार्यात्मक प्रोग्रामिंग पैटर्न के खिलाफ है। आप ईसीएमएस्क्रिप्ट 6 पद्धति filter का उपयोग करके उस सरणी को संदर्भित किए बिना एक नई सरणी बना सकते हैं जिसका डेटा आप बदलना चाहते हैं;

var myArray = [1, 2, 3, 4, 5, 6];

मान लीजिए कि आप सरणी से 5 हटाना चाहते हैं, तो आप इसे इस तरह से कर सकते हैं:

myArray = myArray.filter(value => value !== 5);

यह आपको उस मूल्य के बिना एक नई सरणी देगा जिसे आप हटाना चाहते हैं। तो परिणाम होगा:

 [1, 2, 3, 4, 6]; // 5 has been removed from this array

आगे की समझ के लिए आप Array पर एमडीएन दस्तावेज पढ़ सकते हैं। .फ़िल्टर.

35
Peter Mortensen 2 सितंबर 2019, 01:41

grid.common.js पर कॉल करके यह वास्तव में संभव है। आप तर्क भी जोड़ सकते हैं, जैसे: grid.formedit.js। लेकिन ध्यान रखें कि पूरा होने के बाद यह आपका आर सत्र छोड़ देगा, इसलिए मुझे नहीं पता कि यह कितना उपयोगी है।

const items = [1, 2, 3, 4];
const index = 2;

फिर:

items.filter((x, i) => i !== index);

उपज:

[1, 2, 4]

आर सीएमडी बिल्ड - आर के भीतर से संभव है?

32
Peter Mortensen 25 जून 2016, 16:01
4
ध्यान दें कि .filter एक नई सरणी देता है, जो बिल्कुल उसी सरणी से तत्व को हटाने के समान नहीं है। इस दृष्टिकोण का लाभ यह है कि आप सरणी विधियों को एक साथ श्रृंखलाबद्ध कर सकते हैं। उदाहरण: [1,2,3].filter(n => n%2).map(n => n*n) === [ 1, 9 ]
 – 
CodeOcelot
6 मई 2016, 21:58
किसी विशेष प्रकार के लिए बाध्य होने के लिए, आपको इसे किसी विशेष प्रकार के विशेषज्ञ बनाने की आवश्यकता है। एनोटेशन टाइप करें< /a> अभिव्यक्तियों पर s सिंटैक्स द्वारा दिए गए हैं, जैसे:
 – 
dev1223
30 मई 2016, 18:11
उसके लिए, आप शायद splice या slice का उपयोग करना चाहेंगे।
 – 
bjfletcher
1 जून 2016, 01:04
मैं मानता हूं कि इसके लिए एक संकलन विकल्प/प्रज्ञा की आवश्यकता है, लेकिन यह उन कई में से एक है जिसे मैंने वैश्विक स्तर पर ~/.ghci फ़ाइल में सक्रिय किया है। और इसे लागू करना आसान है!
 – 
dev1223
1 जून 2016, 02:06
मैं bjfletcher का उत्तर पसंद करूंगा, जो items= items.filter(x=>x!=3) जितना छोटा हो सकता है। इसके अलावा, ओपी ने बड़े डेटा सेट के लिए कोई आवश्यकता नहीं बताई।
 – 
runsun
27 अगस्त 2016, 04:55

मुझे पता है कि पहले से ही बहुत सारे उत्तर हैं, लेकिन उनमें से कई समस्या को अधिक जटिल कर देते हैं। यहां कुंजी के सभी उदाहरणों को हटाने का एक सरल, पुनरावर्ती तरीका है - स्वयं को तब तक कॉल करें जब तक कि अनुक्रमणिका न मिल जाए। हां, यह केवल 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);
}
18
wharding28 20 फरवरी 2014, 02:20
प्राइम मिलने के ठीक बाद।
 – 
wharding28
8 सितंबर 2015, 08:57
अपने प्रतिनिधि के भीतर आप अपने स्वामी CommandTimeout की Where-Object संपत्ति पर एक नज़र डाल सकते हैं। इस जानकारी के साथ {{X11 पर कॉल करें }} और अपने स्लेव ग्रिड में इस अनुक्रमणिका का उपयोग करें this
 – 
Peter Mortensen
2 सितंबर 2019, 01:14

सभी उत्तरों के आधार पर जो मुख्य रूप से सही थे और सुझाई गई सर्वोत्तम प्रथाओं को ध्यान में रखते हुए (विशेषकर सीधे Array.prototype का उपयोग नहीं कर रहे थे), मैं नीचे दिए गए कोड के साथ आया:

function arrayWithout(arr, values) {
  var isArray = function(canBeArray) {
    if (Array.isArray) {
      return Array.isArray(canBeArray);
    }
    return Object.prototype.toString.call(canBeArray) === '[object Array]';
  };

  var excludedValues = (isArray(values)) ? values : [].slice.call(arguments, 1);
  var arrCopy = arr.slice(0);

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

  return arrCopy;
}

उपरोक्त फ़ंक्शन की समीक्षा करते हुए, इस तथ्य के बावजूद कि यह ठीक काम करता है, मैंने महसूस किया कि कुछ प्रदर्शन सुधार हो सकते हैं। इसके अलावा ES5 के बजाय ES6 का उपयोग करना एक बेहतर तरीका है। इसके लिए, यह बेहतर कोड है:

const arrayWithoutFastest = (() => {
  const isArray = canBeArray => ('isArray' in Array) 
    ? Array.isArray(canBeArray) 
    : Object.prototype.toString.call(canBeArray) === '[object Array]';

  let mapIncludes = (map, key) => map.has(key);
  let objectIncludes = (obj, key) => key in obj;
  let includes;

  function arrayWithoutFastest(arr, ...thisArgs) {
    let withoutValues = isArray(thisArgs[0]) ? thisArgs[0] : thisArgs;

    if (typeof Map !== 'undefined') {
      withoutValues = withoutValues.reduce((map, value) => map.set(value, value), new Map());
      includes = mapIncludes;
    } else {
      withoutValues = withoutValues.reduce((map, value) => { map[value] = value; return map; } , {}); 
      includes = objectIncludes;
    }

    const arrCopy = [];
    const length = arr.length;

    for (let i = 0; i < length; i++) {
      // If value is not in exclude list
      if (!includes(withoutValues, arr[i])) {
        arrCopy.push(arr[i]);
      }
    }

    return arrCopy;
  }

  return arrayWithoutFastest;  
})();

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

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

arrayWithoutFastest(arr, 1); // will return array [2,3,4,5,"name", false]
arrayWithoutFastest(arr, 'name'); // will return [2,3,4,5, false]
arrayWithoutFastest(arr, false); // will return [2,3,4,5]
arrayWithoutFastest(arr,[1,2]); // will return [3,4,5,"name", false];
arrayWithoutFastest(arr, {bar: "foo"}); // will return the same array (new copy)

मैं वर्तमान में एक ब्लॉग पोस्ट लिख रहा हूं जिसमें मैंने बिना किसी समस्या के ऐरे के लिए कई समाधानों को बेंचमार्क किया है और इसे चलाने में लगने वाले समय की तुलना की है। एक बार जब मैं उस पोस्ट को समाप्त कर दूंगा तो मैं इस उत्तर को लिंक के साथ अपडेट कर दूंगा। बस आपको यह बताने के लिए, मैंने उपरोक्त की तुलना लॉश के बिना से की है और यदि ब्राउज़र Map का समर्थन करता है, तो यह लॉश को मात देता है! ध्यान दें कि मैं Array.prototype.indexOf या Array.prototype.includes का उपयोग Map या Object में exlcudeValues ​​​​को लपेटने के रूप में नहीं कर रहा हूं, इससे पूछताछ तेज हो जाती है!

18
Ardi 20 नवम्बर 2018, 02:02

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

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);
}
console.log(myArray);

लाइव डेमो

33
Edric 10 जुलाई 2020, 15:53

मेरे पास एक साइट है जो वीडियो दृश्यों को ट्रैक करती है... हर बार जब नियंत्रक को कॉल किया जाता है। कुछ भारी F5ing के साथ कोई भी अपने स्वयं के वीडियो दृश्यों को भर सकता है।

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

यह सरणी से सभी तत्वों को हटा देता है और slice और indexOf के संयोजन से भी तेजी से काम करता है।

114
Masoud Aghaei 31 जिंदा 2021, 14:47

ES10

यह पोस्ट ECMAScript 2019< के रूप में एक सरणी से तत्व हटाने के सामान्य तरीकों को सारांशित करता है। /ए> (ईएस10)।

1. सामान्य मामले

1.1. .splice() का उपयोग करके मान के आधार पर ऐरे तत्व को हटाना

| स्थान पर: हां |
| डुप्लिकेट हटाता है: हां (लूप), नहीं (इंडेक्सऑफ) |
| मान / अनुक्रमणिका द्वारा: अनुक्रमणिका द्वारा |

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

// With a 'for' loop
const arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0];
for( let i = 0; i < arr.length; i++){
  if ( arr[i] === 5) {
    arr.splice(i, 1);
  }
} // => [1, 2, 3, 4, 6, 7, 8, 9, 0]

// With the .indexOf() method
const arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0];
const i = arr.indexOf(5);
arr.splice(i, 1); // => [1, 2, 3, 4, 6, 7, 8, 9, 0]

1.2. .filter() विधि का उपयोग करके ऐरे तत्व को हटाना

| स्थान पर: नहीं |
| डुप्लिकेट निकालता है: हां |
| मान / अनुक्रमणिका द्वारा: मान के अनुसार |

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

const value = 3
let arr = [1, 2, 3, 4, 5, 3]
arr = arr.filter(item => item !== value)
console.log(arr)
// [ 1, 2, 4, 5 ]

1.3. Array.prototype को बढ़ाकर ऐरे एलिमेंट को हटा रहा है

| स्थान पर: हां/नहीं (कार्यान्वयन पर निर्भर करता है) |
| डुप्लीकेट हटाता है: हां/नहीं (कार्यान्वयन पर निर्भर करता है) |
| मान / अनुक्रमणिका द्वारा: अनुक्रमणिका द्वारा / मान द्वारा (कार्यान्वयन पर निर्भर करता है) |

ऐरे के प्रोटोटाइप को अतिरिक्त तरीकों से बढ़ाया जा सकता है। इस तरह के तरीके तब बनाए गए सरणियों पर उपयोग करने के लिए उपलब्ध होंगे।

नोट: जावास्क्रिप्ट के मानक पुस्तकालय (जैसे ऐरे) से वस्तुओं के प्रोटोटाइप का विस्तार करना कुछ लोगों द्वारा एक एंटीपैटर्न के रूप में माना जाता है।

// In-place, removes all, by value implementation
Array.prototype.remove = function(item) {
    for (let i = 0; i < this.length; i++) {
        if (this[i] === item) {
            this.splice(i, 1);
        }
    }
}
const arr1 = [1,2,3,1];
arr1.remove(1) // arr1 equals [2,3]

// Non-stationary, removes first, by value implementation
Array.prototype.remove = function(item) {
    const arr = this.slice();
    for (let i = 0; i < this.length; i++) {
        if (arr[i] === item) {
            arr.splice(i, 1);
            return arr;
        }
    }
    return arr;
}
let arr2 = [1,2,3,1];
arr2 = arr2.remove(1) // arr2 equals [2,3,1]

1.4. delete ऑपरेटर का उपयोग करके ऐरे तत्व को हटाना

| स्थान पर: हां |
| डुप्लिकेट निकालता है: नहीं |
| मान / अनुक्रमणिका द्वारा: अनुक्रमणिका द्वारा |

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

const arr = [1, 2, 3, 4, 5, 6];
delete arr[4]; // Delete element with index 4
console.log( arr ); // [1, 2, 3, 4, undefined, 6]

डिलीट ऑपरेटर को जावास्क्रिप्ट ऑब्जेक्ट्स से गुणों को हटाने के लिए डिज़ाइन किया गया है, जो एरेज़ ऑब्जेक्ट हैं।

1.5. Object उपयोगिताओं (>= ES10) का उपयोग करके ऐरे तत्व को हटाना

| स्थान पर: नहीं |
| डुप्लिकेट निकालता है: हां |
| मान / अनुक्रमणिका द्वारा: मान के अनुसार |

ES10 ने Object.fromEntries पेश किया, जिसका उपयोग किसी भी सरणी जैसी वस्तु से वांछित सरणी बनाने और प्रक्रिया के दौरान अवांछित तत्वों को फ़िल्टर करने के लिए किया जा सकता है।

const object = [1,2,3,4];
const valueToRemove = 3;
const arr = Object.values(Object.fromEntries(
  Object.entries(object)
  .filter(([ key, val ]) => val !== valueToRemove)
));
console.log(arr); // [1,2,4]

2. विशेष मामले

2.1 तत्व को हटाना यदि वह ऐरे के अंत में है

2.1.1. ऐरे बदलना length

| स्थान पर: हां |
| डुप्लिकेट निकालता है: नहीं |
| मान / अनुक्रमणिका के अनुसार: लागू नहीं |

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

const arr = [1, 2, 3, 4, 5, 6];
arr.length = 5; // Set length to remove element
console.log( arr ); // [1, 2, 3, 4, 5]

<मजबूत> 2.1.2। .pop() पद्धति Using का उपयोग करना

| स्थान पर: हां |
| डुप्लिकेट निकालता है: नहीं |
| मान / अनुक्रमणिका के अनुसार: लागू नहीं |

पॉप विधि सरणी के अंतिम तत्व को हटा देती है, उस तत्व को वापस कर देती है, और लंबाई संपत्ति को अपडेट करती है। पॉप विधि उस सरणी को संशोधित करती है जिस पर इसे लागू किया जाता है, इसका मतलब है कि हटाए गए अंतिम तत्व को पूरी तरह से हटा दिया जाता है और सरणी की लंबाई कम हो जाती है।

const arr = [1, 2, 3, 4, 5, 6];
arr.pop(); // returns 6
console.log( arr ); // [1, 2, 3, 4, 5]

2.2. तत्व को हटा रहा है अगर यह ऐरे की शुरुआत में है

| स्थान पर: हां |
| डुप्लिकेट निकालता है: नहीं |
| मान / अनुक्रमणिका के अनुसार: लागू नहीं |

.shift() विधि बहुत हद तक पॉप विधि की तरह काम करती है, सिवाय इसके कि यह जावास्क्रिप्ट सरणी के पहले तत्व को अंतिम के बजाय हटा देती है। जब तत्व हटा दिया जाता है तो शेष तत्वों को नीचे स्थानांतरित कर दिया जाता है।

const arr = [1, 2, 3, 4];
arr.shift(); // returns 1
console.log( arr ); // [2, 3, 4]

2.3. तत्व को हटा रहा है अगर यह ऐरे में एकमात्र तत्व है

| स्थान पर: हां |
| डुप्लिकेट निकालता है: लागू नहीं |
| मान / अनुक्रमणिका के अनुसार: लागू नहीं |

सबसे तेज़ तकनीक एक सरणी चर को एक खाली सरणी में सेट करना है।

let arr = [1];
arr = []; //empty array

वैकल्पिक रूप से 2.1.1 से तकनीक का उपयोग लंबाई को 0 पर सेट करके किया जा सकता है।

46
Peter Mortensen 2 जिंदा 2022, 19:33
विरल सरणी को समझाने के लिए धन्यवाद - delete में कुछ भी गलत नहीं है जैसा कि अन्य सुझाव देते हैं
 – 
Sławomir Lenart
8 पद 2021, 22:07

सरणी से किसी विशेष तत्व/स्ट्रिंग को हटाना एक-लाइनर में किया जा सकता है:

theArray.splice(theArray.indexOf("stringToRemoveFromArray"), 1);

कहां:

theArray: वह सरणी जिससे आप कुछ विशेष हटाना चाहते हैं

stringToRemoveFromArray: वह स्ट्रिंग जिसे आप हटाना चाहते हैं और 1 उन तत्वों की संख्या है जिन्हें आप हटाना चाहते हैं।

नोट: यदि "stringToRemoveFromArray" सरणी में स्थित नहीं है, तो यह सरणी के अंतिम तत्व को हटा देगा।

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

if (theArray.indexOf("stringToRemoveFromArray") >= 0){
   theArray.splice(theArray.indexOf("stringToRemoveFromArray"), 1);
}

इस पर निर्भर करते हुए कि आपके क्लाइंट के कंप्यूटर पर Ecmascript का नया या पुराना संस्करण चल रहा है:

var array=['1','2','3','4','5','6']
var newArray = array.filter((value)=>value!='3');

या

var array = ['1','2','3','4','5','6'];
var newArray = array.filter(function(item){ return item !== '3' });

जहां '3' वह मान है जिसे आप सरणी से हटाना चाहते हैं। तब सरणी बन जाएगी: ['1','2','4','5','6']

66
Max Alexander Hanna 30 जिंदा 2021, 00:55
1
साथ ही .siblings() विधि को यहां सेट करना बेहतर होगा, मुझे लगता है
 – 
jdavid05
3 अप्रैल 2019, 14:52
6
सावधान रहें, यदि "stringToRemoveFromArray" आपके सरणी में स्थित नहीं है, तो यह सरणी के अंतिम तत्व को हटा देगा।
 – 
Fusion
7 अप्रैल 2019, 02:35