एक सरणी को दूसरे सरणी के सभी तत्वों से कैसे फ़िल्टर करें

Question

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

var array = [1,2,3,4];
var anotherOne = [2,4];
var filteredArray = array.filter(myCallback);
// filteredArray should now be [1,3]


function myCallBack(){
    return element ! filteredArray; 
    //which clearly can't work since we don't have the reference <,< 
}

यदि फ़िल्टर फ़ंक्शन उपयोगी नहीं है, तो आप इसे कैसे लागू करेंगे?
संपादित करें: मैंने संभव डुप्लिकेट प्रश्न की जाँच की, और यह उन लोगों के लिए उपयोगी हो सकता है जो जावास्क्रिप्ट को आसानी से समझते हैं। उत्तर के रूप में जाँच की गई चीजें आसान बनाती हैं।

Comments

कॉलबैक को फ़िल्टर करने और return arrTwo.indexOf(e) === -1; कोड का उपयोग करने के लिए अन्य सरणी पास करें :var filteredArr = firstArr.filter(el => secondArr.indexOf(el) === -1);

— तुषार

.Filter

— Dawid Rutkowski

क्या दोनों सरणियों का आदेश दिया गया है?

— नीना स्कोल्ज़

सरणी का आदेश नहीं दिया जाता है, साथ ही, दूसरे सरणी में तत्वों की एक यादृच्छिक संख्या होती है।

— Koop4

Answer 1

आप एक वैश्विक चर में अपने फिल्टर सरणी को स्टोर करने से बचने के लिए फ़ंक्शन के thisपैरामीटर का उपयोग कर सकते हैं filter()।

var filtered = [1, 2, 3, 4].filter(
    function(e) {
      return this.indexOf(e) < 0;
    },
    [2, 4]
);
console.log(filtered);

Comments

यह एक सम्मोहन की तरह काम करता है। क्या फ़ंक्शन को बाहर स्थानांतरित करना और इसे अधिक समझ में आना संभव है? जैसे: var फ़िल्टर्ड = [1,2,3,4] .filter (myfunct (), [2,4]);

— 16

ज़रूर: var myFunct = function (e) {इसे वापस करें ।indexOf (e) <0;}; var फ़िल्टर्ड = [1,2,3,4] .filter (myFunct, [2,4]);

— सिमोन हाय

क्या यह ES2016 या टाइपस्क्रिप्ट में लंबोदर अभिव्यक्ति के साथ प्राप्त किया जा सकता है?

— प्रभा

कोणीय संस्करण: stackblitz.com/edit/angular-wbynpf?embed=1&file=src/app/…

— सुनील राज

जब मैं इस दृष्टिकोण का उपयोग करता हूं, तो फ़िल्टर का दूसरा पैराम इसे अपने कार्य में नहीं बना रहा है this। thisहमेशा अपरिभाषित लगता है ?! अजीब

— कुछ

Answer 2

मैं निम्नानुसार करूँगा;

var arr = [1,2,3,4],
    brr = [2,4],
    res = arr.filter(f => !brr.includes(f));
console.log(res);

Comments

रॉकस्टार। धन्यवाद, यह थोड़ा अलग समस्या को हल करने के लिए अविश्वसनीय रूप से उपयोगी था। एक प्रतिक्रिया घटक में मूल्यों की एक सरणी के आधार पर वस्तुओं की एक सरणी को const filteredResults = this.state.cards.filter( result => !this.state.filterOut.includes(result.category) ) छानना : जहाँ यह .state.cards में वस्तुओं की एक सरणी और this.state.filterOut मूल्यों का एक सरणी है जो वस्तुओं में 'श्रेणी' कुंजी के अनुरूप है मैं हटाना चाहता था।

— जोश पिटमैन

मुझे पता है, यह एक पुरानी प्रतिक्रिया है, लेकिन मैं आपको यह बताना चाहता हूं कि मुझे यह प्रतिक्रिया बहुत अधिक पसंद आई और इसने मुझे मेरी एक समस्या के साथ मदद की। यह बहुत पठनीय है और इस प्रकार मेरे लिए इस मुद्दे को बेहतर ढंग से समझना आसान था।

— ak.leimrey

शामिल हैं केवल ES7 से काम करेंगे। यदि आप ES6 का उपयोग करते हैं तो स्वीकृत समाधान का उपयोग करें।

— रुद्रशिव 86६

Answer 3

var array = [1,2,3,4];
var anotherOne = [2,4];
var filteredArray = array.filter(myCallBack);

function myCallBack(el){
  return anotherOne.indexOf(el) < 0;
}

कॉलबैक में, आप चेक करते हैं कि प्रत्येक मान arrayअंदर है या नहींanotherOne

https://jsfiddle.net/0tsyc1sx/

यदि आप उपयोग कर रहे हैं lodash.js, तो उपयोग करें_.difference

filteredArray = _.difference(array, anotherOne);

डेमो

यदि आपके पास वस्तुओं की एक सरणी है:

var array = [{id :1, name :"test1"},{id :2, name :"test2"},{id :3, name :"test3"},{id :4, name :"test4"}];

var anotherOne = [{id :2, name :"test2"}, {id :4, name :"test4"}];

var filteredArray  = array.filter(function(array_el){
   return anotherOne.filter(function(anotherOne_el){
      return anotherOne_el.id == array_el.id;
   }).length == 0
});

वस्तुओं की डेमो सरणी

डेमो लॉश के साथ वस्तुओं की सरणी अलग है

Comments

नमस्ते आप वस्तुओं की एक सरणी में इस एक का विस्तार कर सकते हैं? मैं इसकी अत्यधिक सराहना करूंगा

— Roel

क्या आप लिटाश का उपयोग कर रहे हैं?

— एशब्रिंगर

नहीं साहब मैं कॉलबैक विधि का पालन करना पसंद करता हूं

— रोएल

अच्छा सर, यह वास्तव में काम करता था लेकिन आईडी से हटकर मैं नाम के साथ दूसरे मार्ग को कैसे फ़िल्टर कर सकता हूं?

— Roel

Hummm ... तुम बस परिवर्तन करने के लिए है idमें anotherOne_el.id == array_el.idजो कुछ भी कुंजी अपनी खुद की वस्तु में आप के साथ। आपको जावास्क्रिप्ट में सरणियों और वस्तुओं के बारे में ज्ञान प्राप्त करना चाहिए, इससे आपको बेहतर उत्तर समझने में मदद मिलेगी

— AshBringer

Answer 4

        /* Here's an example that uses (some) ES6 Javascript semantics to filter an object array by another object array. */

        // x = full dataset
        // y = filter dataset
        let x = [
            {"val": 1, "text": "a"},
            {"val": 2, "text": "b"},
            {"val": 3, "text": "c"},
            {"val": 4, "text": "d"},
            {"val": 5, "text": "e"}
            ],
            y = [
            {"val": 1, "text": "a"},
            {"val": 4, "text": "d"}               
            ];

        // Use map to get a simple array of "val" values. Ex: [1,4]
        let yFilter = y.map(itemY => { return itemY.val; });

        // Use filter and "not" includes to filter the full dataset by the filter dataset's val.
        let filteredX = x.filter(itemX => !yFilter.includes(itemX.val));

        // Print the result.
        console.log(filteredX);

Comments

बिल्कुल वही जो मुझे चाहिए था। धन्यवाद

— vikrantnegi

Answer 5

नीचे दिया गया कोड एक सरणी को दूसरे सरणी के संबंध में फ़िल्टर करने का सबसे सरल तरीका है। दोनों सरणियों में मानों के बजाय उनके अंदर ऑब्जेक्ट हो सकते हैं।

let array1 = [1, 3, 47, 1, 6, 7];
let array2 = [3, 6];
let filteredArray1 = array1.filter(el => array2.includes(el));
console.log(filteredArray1); 

आउटपुट: [3, 6]

Answer 6

आपके प्रश्न के लिए कई उत्तर हैं, लेकिन मैं लैंबडा एक्सप्रेशन का उपयोग करते हुए किसी को नहीं देखता:

var array = [1,2,3,4];
var anotherOne = [2,4];
var filteredArray = array.filter(x => anotherOne.indexOf(x) < 0);

Answer 7

उपरोक्त सभी समाधान "काम", लेकिन प्रदर्शन के लिए इष्टतम से कम हैं और सभी एक ही तरीके से समस्या का सामना कर रहे हैं जो कि Array.prototype.indexOf या Array.prototyp.inceses का उपयोग करके प्रत्येक बिंदु पर सभी प्रविष्टियों को रैखिक रूप से खोज रहा है । एक अधिक तेज़ समाधान (अधिकांश मामलों के लिए एक द्विआधारी खोज की तुलना में बहुत तेज़ी से) सरणियों को सॉर्ट करना और आगे बढ़ना छोड़ना होगा जैसा कि आप नीचे देखे गए हैं। हालांकि, एक नकारात्मक पक्ष यह है कि इसके लिए सरणी में सभी प्रविष्टियों को संख्या या तार की आवश्यकता होती है। हालांकि, कुछ दुर्लभ मामलों में बाइनरी खोज प्रगतिशील रैखिक खोज की तुलना में तेज़ हो सकती है। ये मामले इस तथ्य से उत्पन्न होते हैं कि मेरी प्रगतिशील रैखिक खोज में O (2n ₁ + n ₂ ) की जटिलता है (केवल O (n ₁₎+ N ₂ ) तेज C / C ++ संस्करण में) (जहां n ₁ खोजा गया सरणी है और n ₂ फ़िल्टर सरणी है), जबकि बाइनरी खोज में O (n ₁ छत (लॉग ₂ n ₂ ) की जटिलता है ) ( Ceil = Round up - to theilil ing), और, आख़िरकार, indexOf सर्च में O (n ₁ ) और O (n ₁ n ₂ ) के बीच अत्यधिक परिवर्तनशील जटिलता होती है, O के लिए औसत (n ₁ Ceil) (n ₂₎ ) 2)) । इस प्रकार, IndexOf केवल मामलों में, सबसे तेज़, औसतन होगा(n ₁ , n ₂ ) बराबरी{1,2} , {1,3} O (n ₁ and 6) और O (n ₁ n ₂ ) के, या {x, 1 | x∈N} । हालाँकि, यह अभी भी आधुनिक हार्डवेयर का एक सही प्रतिनिधित्व नहीं है। IndexOf मूल रूप से अधिकांश आधुनिक ब्राउज़रों में पूरी तरह से कल्पना करने के लिए अनुकूलित है, जो शाखा भविष्यवाणी के कानूनों के अधीन है । इस प्रकार, यदि हम इंडेक्सऑफ पर समान धारणा बनाते हैं जैसा कि हम प्रगतिशील रैखिक और द्विआधारी खोज के साथ करते हैं - जो कि सरणी को प्रस्तुत किया जाता है - फिर, लिंक में सूचीबद्ध आंकड़ों के अनुसार, हम इंडेक्सऑफ के लिए लगभग 6x की गति की उम्मीद कर सकते हैं, के बीच अपनी जटिलता को स्थानांतरित करना, O के लिए औसत (n ₁ छत (n ₂ 7) 12))। अंत में, ध्यान दें कि नीचे दिए गए समाधान वस्तुओं के साथ कभी काम नहीं करेंगे क्योंकि जावास्क्रिप्ट में ऑब्जेक्ट्स की तुलना जावास्क्रिप्ट में पॉइंटर्स द्वारा नहीं की जा सकती है।

function sortAnyArray(a,b) { return a>b ? 1 : (a===b ? 0 : -1); }
function sortIntArray(a,b) { return (a|0) - (b|0) |0; }
function fastFilter(array, handle) {
    var out=[], value=0;
    for (var i=0,  len=array.length|0; i < len; i=i+1|0)
        if (handle(value = array[i])) 
            out.push( value );
    return out;
}

const Math_clz32 = Math.clz32 || (function(log, LN2){
  return function(x) {
    return 31 - log(x >>> 0) / LN2 | 0; // the "| 0" acts like math.floor
  };
})(Math.log, Math.LN2);

/* USAGE:
  filterArrayByAnotherArray(
      [1,3,5],
      [2,3,4]
  ) yields [1, 5], and it can work with strings too
*/
function filterArrayByAnotherArray(searchArray, filterArray) {
    if (
        // NOTE: This does not check the whole array. But, if you know
        //        that there are only strings or numbers (not a mix of
        //        both) in the array, then this is a safe assumption.
        // Always use `==` with `typeof` because browsers can optimize
        //  the `==` into `===` (ONLY IN THIS CIRCUMSTANCE)
        typeof searchArray[0] == "number" &&
        typeof filterArray[0] == "number" &&
        (searchArray[0]|0) === searchArray[0] &&
        (filterArray[0]|0) === filterArray[0]
    ) {filterArray
        // if all entries in both arrays are integers
        searchArray.sort(sortIntArray);
        filterArray.sort(sortIntArray);
    } else {
        searchArray.sort(sortAnyArray);
        filterArray.sort(sortAnyArray);
    }
    var searchArrayLen = searchArray.length, filterArrayLen = filterArray.length;
    var progressiveLinearComplexity = ((searchArrayLen<<1) + filterArrayLen)>>>0
    var binarySearchComplexity= (searchArrayLen * (32-Math_clz32(filterArrayLen-1)))>>>0;
    // After computing the complexity, we can predict which algorithm will be the fastest
    var i = 0;
    if (progressiveLinearComplexity < binarySearchComplexity) {
        // Progressive Linear Search
        return fastFilter(searchArray, function(currentValue){
            while (filterArray[i] < currentValue) i=i+1|0;
            // +undefined = NaN, which is always false for <, avoiding an infinite loop
            return filterArray[i] !== currentValue;
        });
    } else {
        // Binary Search
        return fastFilter(
            searchArray,
            fastestBinarySearch(filterArray)
        );
    }
}

// see https://stackoverflow.com/a/44981570/5601591 for implementation
//  details about this binary search algorithm

function fastestBinarySearch(array){
  var initLen = (array.length|0) - 1 |0;
  
  const compGoto = Math_clz32(initLen) & 31;
  return function(sValue) {
    var len = initLen |0;
    switch (compGoto) {
      case 0:
        if (len & 0x80000000) {
          const nCB = len & 0x80000000;
          len ^= (len ^ (nCB-1)) & ((array[nCB] <= sValue |0) - 1 >>>0);
        }
      case 1:
        if (len & 0x40000000) {
          const nCB = len & 0xc0000000;
          len ^= (len ^ (nCB-1)) & ((array[nCB] <= sValue |0) - 1 >>>0);
        }
      case 2:
        if (len & 0x20000000) {
          const nCB = len & 0xe0000000;
          len ^= (len ^ (nCB-1)) & ((array[nCB] <= sValue |0) - 1 >>>0);
        }
      case 3:
        if (len & 0x10000000) {
          const nCB = len & 0xf0000000;
          len ^= (len ^ (nCB-1)) & ((array[nCB] <= sValue |0) - 1 >>>0);
        }
      case 4:
        if (len & 0x8000000) {
          const nCB = len & 0xf8000000;
          len ^= (len ^ (nCB-1)) & ((array[nCB] <= sValue |0) - 1 >>>0);
        }
      case 5:
        if (len & 0x4000000) {
          const nCB = len & 0xfc000000;
          len ^= (len ^ (nCB-1)) & ((array[nCB] <= sValue |0) - 1 >>>0);
        }
      case 6:
        if (len & 0x2000000) {
          const nCB = len & 0xfe000000;
          len ^= (len ^ (nCB-1)) & ((array[nCB] <= sValue |0) - 1 >>>0);
        }
      case 7:
        if (len & 0x1000000) {
          const nCB = len & 0xff000000;
          len ^= (len ^ (nCB-1)) & ((array[nCB] <= sValue |0) - 1 >>>0);
        }
      case 8:
        if (len & 0x800000) {
          const nCB = len & 0xff800000;
          len ^= (len ^ (nCB-1)) & ((array[nCB] <= sValue |0) - 1 >>>0);
        }
      case 9:
        if (len & 0x400000) {
          const nCB = len & 0xffc00000;
          len ^= (len ^ (nCB-1)) & ((array[nCB] <= sValue |0) - 1 >>>0);
        }
      case 10:
        if (len & 0x200000) {
          const nCB = len & 0xffe00000;
          len ^= (len ^ (nCB-1)) & ((array[nCB] <= sValue |0) - 1 >>>0);
        }
      case 11:
        if (len & 0x100000) {
          const nCB = len & 0xfff00000;
          len ^= (len ^ (nCB-1)) & ((array[nCB] <= sValue |0) - 1 >>>0);
        }
      case 12:
        if (len & 0x80000) {
          const nCB = len & 0xfff80000;
          len ^= (len ^ (nCB-1)) & ((array[nCB] <= sValue |0) - 1 >>>0);
        }
      case 13:
        if (len & 0x40000) {
          const nCB = len & 0xfffc0000;
          len ^= (len ^ (nCB-1)) & ((array[nCB] <= sValue |0) - 1 >>>0);
        }
      case 14:
        if (len & 0x20000) {
          const nCB = len & 0xfffe0000;
          len ^= (len ^ (nCB-1)) & ((array[nCB] <= sValue |0) - 1 >>>0);
        }
      case 15:
        if (len & 0x10000) {
          const nCB = len & 0xffff0000;
          len ^= (len ^ (nCB-1)) & ((array[nCB] <= sValue |0) - 1 >>>0);
        }
      case 16:
        if (len & 0x8000) {
          const nCB = len & 0xffff8000;
          len ^= (len ^ (nCB-1)) & ((array[nCB] <= sValue |0) - 1 >>>0);
        }
      case 17:
        if (len & 0x4000) {
          const nCB = len & 0xffffc000;
          len ^= (len ^ (nCB-1)) & ((array[nCB] <= sValue |0) - 1 >>>0);
        }
      case 18:
        if (len & 0x2000) {
          const nCB = len & 0xffffe000;
          len ^= (len ^ (nCB-1)) & ((array[nCB] <= sValue |0) - 1 >>>0);
        }
      case 19:
        if (len & 0x1000) {
          const nCB = len & 0xfffff000;
          len ^= (len ^ (nCB-1)) & ((array[nCB] <= sValue |0) - 1 >>>0);
        }
      case 20:
        if (len & 0x800) {
          const nCB = len & 0xfffff800;
          len ^= (len ^ (nCB-1)) & ((array[nCB] <= sValue |0) - 1 >>>0);
        }
      case 21:
        if (len & 0x400) {
          const nCB = len & 0xfffffc00;
          len ^= (len ^ (nCB-1)) & ((array[nCB] <= sValue |0) - 1 >>>0);
        }
      case 22:
        if (len & 0x200) {
          const nCB = len & 0xfffffe00;
          len ^= (len ^ (nCB-1)) & ((array[nCB] <= sValue |0) - 1 >>>0);
        }
      case 23:
        if (len & 0x100) {
          const nCB = len & 0xffffff00;
          len ^= (len ^ (nCB-1)) & ((array[nCB] <= sValue |0) - 1 >>>0);
        }
      case 24:
        if (len & 0x80) {
          const nCB = len & 0xffffff80;
          len ^= (len ^ (nCB-1)) & ((array[nCB] <= sValue |0) - 1 >>>0);
        }
      case 25:
        if (len & 0x40) {
          const nCB = len & 0xffffffc0;
          len ^= (len ^ (nCB-1)) & ((array[nCB] <= sValue |0) - 1 >>>0);
        }
      case 26:
        if (len & 0x20) {
          const nCB = len & 0xffffffe0;
          len ^= (len ^ (nCB-1)) & ((array[nCB] <= sValue |0) - 1 >>>0);
        }
      case 27:
        if (len & 0x10) {
          const nCB = len & 0xfffffff0;
          len ^= (len ^ (nCB-1)) & ((array[nCB] <= sValue |0) - 1 >>>0);
        }
      case 28:
        if (len & 0x8) {
          const nCB = len & 0xfffffff8;
          len ^= (len ^ (nCB-1)) & ((array[nCB] <= sValue |0) - 1 >>>0);
        }
      case 29:
        if (len & 0x4) {
          const nCB = len & 0xfffffffc;
          len ^= (len ^ (nCB-1)) & ((array[nCB] <= sValue |0) - 1 >>>0);
        }
      case 30:
        if (len & 0x2) {
          const nCB = len & 0xfffffffe;
          len ^= (len ^ (nCB-1)) & ((array[nCB] <= sValue |0) - 1 >>>0);
        }
      case 31:
        if (len & 0x1) {
          const nCB = len & 0xffffffff;
          len ^= (len ^ (nCB-1)) & ((array[nCB] <= sValue |0) - 1 >>>0);
        }
    }
    // MODIFICATION: Instead of returning the index, this binary search
    //                instead returns whether something was found or not.
    if (array[len|0] !== sValue) {
       return true; // preserve the value at this index
    } else {
       return false; // eliminate the value at this index
    }
  };
}

^{उपयोग किए गए बाइनरी सर्च एल्गोरिथ्म के बारे में अधिक जानकारी के लिए कृपया मेरी अन्य पोस्ट यहाँ देखें}

यदि आप फ़ाइल आकार (जो मैं सम्मान करता हूं) के बारे में व्यंग्य कर रहा हूं, तो आप फ़ाइल के आकार को कम करने और स्थिरता बनाए रखने के लिए थोड़ा सा प्रदर्शन कर सकते हैं।

function sortAnyArray(a,b) { return a>b ? 1 : (a===b ? 0 : -1); }
function sortIntArray(a,b) { return (a|0) - (b|0) |0; }
function fastFilter(array, handle) {
    var out=[], value=0;
    for (var i=0,  len=array.length|0; i < len; i=i+1|0)
        if (handle(value = array[i])) 
            out.push( value );
    return out;
}

/* USAGE:
  filterArrayByAnotherArray(
      [1,3,5],
      [2,3,4]
  ) yields [1, 5], and it can work with strings too
*/
function filterArrayByAnotherArray(searchArray, filterArray) {
    if (
        // NOTE: This does not check the whole array. But, if you know
        //        that there are only strings or numbers (not a mix of
        //        both) in the array, then this is a safe assumption.
        typeof searchArray[0] == "number" &&
        typeof filterArray[0] == "number" &&
        (searchArray[0]|0) === searchArray[0] &&
        (filterArray[0]|0) === filterArray[0]
    ) {
        // if all entries in both arrays are integers
        searchArray.sort(sortIntArray);
        filterArray.sort(sortIntArray);
    } else {
        searchArray.sort(sortAnyArray);
        filterArray.sort(sortAnyArray);
    }
    // Progressive Linear Search
    var i = 0;
    return fastFilter(searchArray, function(currentValue){
        while (filterArray[i] < currentValue) i=i+1|0;
        // +undefined = NaN, which is always false for <, avoiding an infinite loop
        return filterArray[i] !== currentValue;
    });
}

गति में अंतर साबित करने के लिए, आइए हम कुछ JSPerfs की जाँच करें। 16 तत्वों की एक सरणी को छानने के लिए , बाइनरी सर्च इंडेक्सऑफ की तुलना में लगभग 17% तेज है जबकि फ़िल्टरएयरबेयरऑनथेरेअर्रे इंडेक्सऑफ की तुलना में लगभग 93% तेज है। के लिये256 तत्वों की एक सरणी को फ़िल्टर करने के , बाइनरी सर्च इंडेक्सऑफ की तुलना में लगभग 291% तेज है, जबकि फ़िल्टरएयर्रेबायॉइंटएयर्रे इंडेक्सऑफ की तुलना में लगभग 353% तेज है। 4096 तत्वों की एक सरणी को छानने के लिए , बाइनरी सर्च इंडेक्सऑफ की तुलना में लगभग 2655% तेज है, जबकि फ़िल्टरएयर्रे बायऑनथेरेअर्रे इंडेक्सऑफ की तुलना में लगभग 4627% तेज है।

रिवर्स-फ़िल्टरिंग (एक और गेट की तरह)

पिछला अनुभाग सरणी A और सरणी B लेने के लिए कोड प्रदान करता है, और A में मौजूद सभी तत्वों को B से हटाता है:

filterArrayByAnotherArray(
    [1,3,5],
    [2,3,4]
);
// yields [1, 5]

यह अगला खंड रिवर्स-फ़िल्टरिंग के लिए कोड प्रदान करेगा, जहां हम ए से सभी तत्वों को हटाते हैं जो बी में मौजूद नहीं है। यह प्रक्रिया कार्यात्मक रूप से केवल ए और बी दोनों के लिए आम तत्वों को बनाए रखने के बराबर है, जैसे कि एंड गेट:

reverseFilterArrayByAnotherArray(
    [1,3,5],
    [2,3,4]
);
// yields [3]

यहाँ रिवर्स फ़िल्टरिंग के लिए कोड है:

function sortAnyArray(a,b) { return a>b ? 1 : (a===b ? 0 : -1); }
function sortIntArray(a,b) { return (a|0) - (b|0) |0; }
function fastFilter(array, handle) {
    var out=[], value=0;
    for (var i=0,  len=array.length|0; i < len; i=i+1|0)
        if (handle(value = array[i])) 
            out.push( value );
    return out;
}

const Math_clz32 = Math.clz32 || (function(log, LN2){
  return function(x) {
    return 31 - log(x >>> 0) / LN2 | 0; // the "| 0" acts like math.floor
  };
})(Math.log, Math.LN2);

/* USAGE:
  reverseFilterArrayByAnotherArray(
      [1,3,5],
      [2,3,4]
  ) yields [3], and it can work with strings too
*/
function reverseFilterArrayByAnotherArray(searchArray, filterArray) {
    if (
        // NOTE: This does not check the whole array. But, if you know
        //        that there are only strings or numbers (not a mix of
        //        both) in the array, then this is a safe assumption.
        // Always use `==` with `typeof` because browsers can optimize
        //  the `==` into `===` (ONLY IN THIS CIRCUMSTANCE)
        typeof searchArray[0] == "number" &&
        typeof filterArray[0] == "number" &&
        (searchArray[0]|0) === searchArray[0] &&
        (filterArray[0]|0) === filterArray[0]
    ) {filterArray
        // if all entries in both arrays are integers
        searchArray.sort(sortIntArray);
        filterArray.sort(sortIntArray);
    } else {
        searchArray.sort(sortAnyArray);
        filterArray.sort(sortAnyArray);
    }
    var searchArrayLen = searchArray.length, filterArrayLen = filterArray.length;
    var progressiveLinearComplexity = ((searchArrayLen<<1) + filterArrayLen)>>>0
    var binarySearchComplexity= (searchArrayLen * (32-Math_clz32(filterArrayLen-1)))>>>0;
    // After computing the complexity, we can predict which algorithm will be the fastest
    var i = 0;
    if (progressiveLinearComplexity < binarySearchComplexity) {
        // Progressive Linear Search
        return fastFilter(searchArray, function(currentValue){
            while (filterArray[i] < currentValue) i=i+1|0;
            // +undefined = NaN, which is always false for <, avoiding an infinite loop
            // For reverse filterning, I changed !== to ===
            return filterArray[i] === currentValue;
        });
    } else {
        // Binary Search
        return fastFilter(
            searchArray,
            inverseFastestBinarySearch(filterArray)
        );
    }
}

// see https://stackoverflow.com/a/44981570/5601591 for implementation
//  details about this binary search algorithim

function inverseFastestBinarySearch(array){
  var initLen = (array.length|0) - 1 |0;
  
  const compGoto = Math_clz32(initLen) & 31;
  return function(sValue) {
    var len = initLen |0;
    switch (compGoto) {
      case 0:
        if (len & 0x80000000) {
          const nCB = len & 0x80000000;
          len ^= (len ^ (nCB-1)) & ((array[nCB] <= sValue |0) - 1 >>>0);
        }
      case 1:
        if (len & 0x40000000) {
          const nCB = len & 0xc0000000;
          len ^= (len ^ (nCB-1)) & ((array[nCB] <= sValue |0) - 1 >>>0);
        }
      case 2:
        if (len & 0x20000000) {
          const nCB = len & 0xe0000000;
          len ^= (len ^ (nCB-1)) & ((array[nCB] <= sValue |0) - 1 >>>0);
        }
      case 3:
        if (len & 0x10000000) {
          const nCB = len & 0xf0000000;
          len ^= (len ^ (nCB-1)) & ((array[nCB] <= sValue |0) - 1 >>>0);
        }
      case 4:
        if (len & 0x8000000) {
          const nCB = len & 0xf8000000;
          len ^= (len ^ (nCB-1)) & ((array[nCB] <= sValue |0) - 1 >>>0);
        }
      case 5:
        if (len & 0x4000000) {
          const nCB = len & 0xfc000000;
          len ^= (len ^ (nCB-1)) & ((array[nCB] <= sValue |0) - 1 >>>0);
        }
      case 6:
        if (len & 0x2000000) {
          const nCB = len & 0xfe000000;
          len ^= (len ^ (nCB-1)) & ((array[nCB] <= sValue |0) - 1 >>>0);
        }
      case 7:
        if (len & 0x1000000) {
          const nCB = len & 0xff000000;
          len ^= (len ^ (nCB-1)) & ((array[nCB] <= sValue |0) - 1 >>>0);
        }
      case 8:
        if (len & 0x800000) {
          const nCB = len & 0xff800000;
          len ^= (len ^ (nCB-1)) & ((array[nCB] <= sValue |0) - 1 >>>0);
        }
      case 9:
        if (len & 0x400000) {
          const nCB = len & 0xffc00000;
          len ^= (len ^ (nCB-1)) & ((array[nCB] <= sValue |0) - 1 >>>0);
        }
      case 10:
        if (len & 0x200000) {
          const nCB = len & 0xffe00000;
          len ^= (len ^ (nCB-1)) & ((array[nCB] <= sValue |0) - 1 >>>0);
        }
      case 11:
        if (len & 0x100000) {
          const nCB = len & 0xfff00000;
          len ^= (len ^ (nCB-1)) & ((array[nCB] <= sValue |0) - 1 >>>0);
        }
      case 12:
        if (len & 0x80000) {
          const nCB = len & 0xfff80000;
          len ^= (len ^ (nCB-1)) & ((array[nCB] <= sValue |0) - 1 >>>0);
        }
      case 13:
        if (len & 0x40000) {
          const nCB = len & 0xfffc0000;
          len ^= (len ^ (nCB-1)) & ((array[nCB] <= sValue |0) - 1 >>>0);
        }
      case 14:
        if (len & 0x20000) {
          const nCB = len & 0xfffe0000;
          len ^= (len ^ (nCB-1)) & ((array[nCB] <= sValue |0) - 1 >>>0);
        }
      case 15:
        if (len & 0x10000) {
          const nCB = len & 0xffff0000;
          len ^= (len ^ (nCB-1)) & ((array[nCB] <= sValue |0) - 1 >>>0);
        }
      case 16:
        if (len & 0x8000) {
          const nCB = len & 0xffff8000;
          len ^= (len ^ (nCB-1)) & ((array[nCB] <= sValue |0) - 1 >>>0);
        }
      case 17:
        if (len & 0x4000) {
          const nCB = len & 0xffffc000;
          len ^= (len ^ (nCB-1)) & ((array[nCB] <= sValue |0) - 1 >>>0);
        }
      case 18:
        if (len & 0x2000) {
          const nCB = len & 0xffffe000;
          len ^= (len ^ (nCB-1)) & ((array[nCB] <= sValue |0) - 1 >>>0);
        }
      case 19:
        if (len & 0x1000) {
          const nCB = len & 0xfffff000;
          len ^= (len ^ (nCB-1)) & ((array[nCB] <= sValue |0) - 1 >>>0);
        }
      case 20:
        if (len & 0x800) {
          const nCB = len & 0xfffff800;
          len ^= (len ^ (nCB-1)) & ((array[nCB] <= sValue |0) - 1 >>>0);
        }
      case 21:
        if (len & 0x400) {
          const nCB = len & 0xfffffc00;
          len ^= (len ^ (nCB-1)) & ((array[nCB] <= sValue |0) - 1 >>>0);
        }
      case 22:
        if (len & 0x200) {
          const nCB = len & 0xfffffe00;
          len ^= (len ^ (nCB-1)) & ((array[nCB] <= sValue |0) - 1 >>>0);
        }
      case 23:
        if (len & 0x100) {
          const nCB = len & 0xffffff00;
          len ^= (len ^ (nCB-1)) & ((array[nCB] <= sValue |0) - 1 >>>0);
        }
      case 24:
        if (len & 0x80) {
          const nCB = len & 0xffffff80;
          len ^= (len ^ (nCB-1)) & ((array[nCB] <= sValue |0) - 1 >>>0);
        }
      case 25:
        if (len & 0x40) {
          const nCB = len & 0xffffffc0;
          len ^= (len ^ (nCB-1)) & ((array[nCB] <= sValue |0) - 1 >>>0);
        }
      case 26:
        if (len & 0x20) {
          const nCB = len & 0xffffffe0;
          len ^= (len ^ (nCB-1)) & ((array[nCB] <= sValue |0) - 1 >>>0);
        }
      case 27:
        if (len & 0x10) {
          const nCB = len & 0xfffffff0;
          len ^= (len ^ (nCB-1)) & ((array[nCB] <= sValue |0) - 1 >>>0);
        }
      case 28:
        if (len & 0x8) {
          const nCB = len & 0xfffffff8;
          len ^= (len ^ (nCB-1)) & ((array[nCB] <= sValue |0) - 1 >>>0);
        }
      case 29:
        if (len & 0x4) {
          const nCB = len & 0xfffffffc;
          len ^= (len ^ (nCB-1)) & ((array[nCB] <= sValue |0) - 1 >>>0);
        }
      case 30:
        if (len & 0x2) {
          const nCB = len & 0xfffffffe;
          len ^= (len ^ (nCB-1)) & ((array[nCB] <= sValue |0) - 1 >>>0);
        }
      case 31:
        if (len & 0x1) {
          const nCB = len & 0xffffffff;
          len ^= (len ^ (nCB-1)) & ((array[nCB] <= sValue |0) - 1 >>>0);
        }
    }
    // MODIFICATION: Instead of returning the index, this binary search
    //                instead returns whether something was found or not.
    // For reverse filterning, I swapped true with false and vice-versa
    if (array[len|0] !== sValue) {
       return false; // preserve the value at this index
    } else {
       return true; // eliminate the value at this index
    }
  };
}

रिवर्स फ़िल्टरिंग कोड के धीमे छोटे संस्करण के लिए, नीचे देखें।

function sortAnyArray(a,b) { return a>b ? 1 : (a===b ? 0 : -1); }
function sortIntArray(a,b) { return (a|0) - (b|0) |0; }
function fastFilter(array, handle) {
    var out=[], value=0;
    for (var i=0,  len=array.length|0; i < len; i=i+1|0)
        if (handle(value = array[i])) 
            out.push( value );
    return out;
}

/* USAGE:
  reverseFilterArrayByAnotherArray(
      [1,3,5],
      [2,3,4]
  ) yields [3], and it can work with strings too
*/
function reverseFilterArrayByAnotherArray(searchArray, filterArray) {
    if (
        // NOTE: This does not check the whole array. But, if you know
        //        that there are only strings or numbers (not a mix of
        //        both) in the array, then this is a safe assumption.
        typeof searchArray[0] == "number" &&
        typeof filterArray[0] == "number" &&
        (searchArray[0]|0) === searchArray[0] &&
        (filterArray[0]|0) === filterArray[0]
    ) {
        // if all entries in both arrays are integers
        searchArray.sort(sortIntArray);
        filterArray.sort(sortIntArray);
    } else {
        searchArray.sort(sortAnyArray);
        filterArray.sort(sortAnyArray);
    }
    // Progressive Linear Search
    var i = 0;
    return fastFilter(searchArray, function(currentValue){
        while (filterArray[i] < currentValue) i=i+1|0;
        // +undefined = NaN, which is always false for <, avoiding an infinite loop
        // For reverse filter, I changed !== to ===
        return filterArray[i] === currentValue;
    });
}

Comments

आपके उत्तर के लिए धन्यवाद, मुझे यकीन है कि किसी के लिए जल्द या बाद में मददगार होगा, भले ही इसका उपयोग किनारे के मामलों में किया जाए (आईई केवल जब एक प्रदर्शन समस्याएं उठती हैं)। अन्य सभी मामलों में मैं सुझाव देने योग्य / पठनीय संस्करण का उपयोग करने का सुझाव दूंगा।

— कोप 4

@JackGiffin मुझे लगता है कि पठनीय से उनका मतलब है कि औसत वेब डेवलपर द्वारा पढ़ने और समझने के लिए जब परिवर्तन या सरल अंडरस्टैंडिंग की आवश्यकता होती है, तो वह पढ़ने योग्य और तेज़ होता है। महान समाधान, ज्यादातर मामलों के लिए नहीं।

— जार्डिलियोर

@JackGiffin जल्दी अनुकूलन परियोजनाओं के लिए सबसे खराब चीजों में से एक है, प्रदर्शन को आम तौर पर तरीकों से लागू किया जाना चाहिए, कुशल कोड लिखना, यदि पर्याप्त सरल, अर्थ न तो खराब कोड के माध्यम से सीधे लिखें, और जब अनुकूलन की आवश्यकता होती है क्योंकि प्रदर्शन आवश्यकताओं को पूरा नहीं करता है । तो आप जैसे व्यक्ति को अन्य परियोजनाओं के अनुकूलन के लिए काम करना चाहिए जो उस जुनून से व्युत्पन्न कौशल की आवश्यकता होती है। आशा है कि यह मदद करता है :)

— zardilior

@zardilior यह वास्तव में मदद करता है। आपकी सलाह zardilior के लिए बहुत बहुत धन्यवाद। मैं इसे दिल से लगाऊंगा और इस पर कार्रवाई करूंगा।

— जैक गिफिन

@JackGiffin को सेवा के लिए खुशी है

— zardilior

Answer 8

OA को ES6 में भी निम्न प्रकार से लागू किया जा सकता है

ES6:

 const filtered = [1, 2, 3, 4].filter(e => {
    return this.indexOf(e) < 0;
  },[2, 4]);

Comments

तीर सिंटैक्स के बाहर, इस समाधान का क्या लाभ है जहां तक ​​फ़िल्टर करना है?

— कार्ल एडवर्ड्स

Answer 9

filterकार्य करने का सबसे अच्छा विवरण है https://developer.mozilla.org/pl/docs/Web/JavaScript/Referencje/Obiekty/Array/filter है

आप बस हालत समारोह चाहिए:

function conditionFun(element, index, array) {
   return element >= 10;
}
filtered = [12, 5, 8, 130, 44].filter(conditionFun);

और इसे असाइन किए जाने से पहले आप वैरिएबल मान तक नहीं पहुँच सकते

Answer 10

आप फ़िल्टर फ़ंक्शन को "फ़िल्टर सरणी" पर पुनरावृत्त करने के लिए सेटअप कर सकते हैं।

var arr = [1, 2, 3 ,4 ,5, 6, 7];
var filter = [4, 5, 6];

var filtered = arr.filter(
  function(val) {
    for (var i = 0; i < filter.length; i++) {
      if (val == filter[i]) {
        return false;
      }
    }
    return true;
  }
); 

Answer 11

आप फ़िल्टर का उपयोग कर सकते हैं और फिर फ़िल्टर फ़ंक्शन के लिए फ़िल्टरिंग एरे की कमी का उपयोग करते हैं जो जांचता है और जब वह मैच पाता है तो वापस लौटता है (रिटर्न!)। फ़िल्टर फ़ंक्शन को सरणी में एक बार प्रति तत्व कहा जाता है। आप अपनी पोस्ट में फ़ंक्शन के किसी भी तत्व की तुलना नहीं कर रहे हैं।

var a1 = [1, 2, 3, 4],
  a2 = [2, 3];

var filtered = a1.filter(function(x) {
  return !a2.reduce(function(y, z) {
    return x == y || x == z || y == true;
  })
});

document.write(filtered);

Answer 12

var arr1= [1,2,3,4];
var arr2=[2,4]

function fil(value){
return value !=arr2[0] &&  value != arr2[1]
}

document.getElementById("p").innerHTML= arr1.filter(fil)

<!DOCTYPE html> 
<html> 
<head> 
</head>
<body>
<p id="p"></p>

Comments

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

— कोप 4

Answer 13

function arr(arr1,arr2){
  
  function filt(value){
    return arr2.indexOf(value) === -1;
    }
  
  return arr1.filter(filt)
  }

document.getElementById("p").innerHTML = arr([1,2,3,4],[2,4])

<p id="p"></p>

Answer 14

किसी अन्य सरणी से अधिक लचीला फ़िल्टरिंग सरणी जिसमें ऑब्जेक्ट गुण होते हैं

function filterFn(array, diffArray, prop, propDiff) {
    diffArray = !propDiff ? diffArray : diffArray.map(d => d[propDiff])
    this.fn = f => diffArray.indexOf(f) === -1
    if (prop) {
         return array.map(r => r[prop]).filter(this.fn)
    } else {
         return array.filter(this.fn)
    }
}

//You can use it like this;

var arr = [];

for (var i = 0; i < 10; i++) {
    var obj = {}
    obj.index = i
    obj.value = Math.pow(2, i)
    arr.push(obj)
}

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

var sec = [{t:2}, {t:99}, {t:256}, {t:4096}]

var log = console.log.bind(console)

var filtered = filterFn(arr, sec, 'value', 't')

var filtered2 = filterFn(arr2, sec, null, 't')

log(filtered, filtered2)

Answer 15

आप कॉलबैक फ़ंक्शन के साथ परेशानी को बचाने के लिए एक सामान्य फ़िल्टरबाइंडेक्स () फ़ंक्शन लिख सकते हैं और TS में टाइप इंफ़ेक्शन का उपयोग कर सकते हैं:

मान लें कि आपके पास [2,2] सरणी में निर्दिष्ट सूचकांकों के साथ आपका सरणी [1,2,3,4] है जिसे आप फ़िल्टर करना चाहते हैं ()।

var filtered = [1,2,3,4,].filter(byIndex(element => element, [2,4]))

byIndex फ़ंक्शन तत्व फ़ंक्शन और एक सरणी की अपेक्षा करता है और इस तरह दिखता है:

byIndex = (getter: (e:number) => number, arr: number[]) => (x: number) => {
    var i = getter(x);
    return arr.indexOf(i); 
}

परिणाम तो है

filtered = [1,3]

Answer 16

निम्नलिखित उदाहरण new Set()एक फ़िल्टर्ड सरणी बनाने के लिए उपयोग करते हैं जिसमें केवल अनन्य तत्व होते हैं:

आदिम डेटा प्रकारों के साथ सरणी: स्ट्रिंग, संख्या, बूलियन, अशक्त, अपरिभाषित, प्रतीक:

const a = [1, 2, 3, 4];
const b = [3, 4, 5];
const c = Array.from(new Set(a.concat(b)));

वस्तुओं के रूप में वस्तुओं के साथ सरणी:

const a = [{id:1}, {id: 2}, {id: 3}, {id: 4}];
const b = [{id: 3}, {id: 4}, {id: 5}];
const stringifyObject = o => JSON.stringify(o);
const parseString = s => JSON.parse(s);
const c = Array.from(new Set(a.concat(b).map(stringifyObject)), parseString);

Answer 17

नीचे एक उदाहरण है

let firstArray=[1,2,3,4,5];
let secondArray=[2,3];  
let filteredArray = firstArray.filter((a) => secondArray.indexOf(a)<0);
console.log(filteredArray); //above line gives [1,4,5]

Answer 18

जैक गिफिन का समाधान बहुत अच्छा है लेकिन 2 ^ 32 से बड़ी संख्या वाले सरणियों के लिए काम नहीं करता है। नीचे जैक के समाधान के आधार पर एक सरणी को फ़िल्टर करने के लिए एक परिष्कृत, तेज संस्करण है, लेकिन यह 64-बिट सरणियों के लिए काम करता है।

const Math_clz32 = Math.clz32 || ((log, LN2) => x => 31 - log(x >>> 0) / LN2 | 0)(Math.log, Math.LN2);

const filterArrayByAnotherArray = (searchArray, filterArray) => {

    searchArray.sort((a,b) => a > b);
    filterArray.sort((a,b) => a > b);

    let searchArrayLen = searchArray.length, filterArrayLen = filterArray.length;
    let progressiveLinearComplexity = ((searchArrayLen<<1) + filterArrayLen)>>>0
    let binarySearchComplexity = (searchArrayLen * (32-Math_clz32(filterArrayLen-1)))>>>0;

    let i = 0;

    if (progressiveLinearComplexity < binarySearchComplexity) {
      return searchArray.filter(currentValue => {
        while (filterArray[i] < currentValue) i=i+1|0;
        return filterArray[i] !== currentValue;
      });
    }
    else return searchArray.filter(e => binarySearch(filterArray, e) === null);
}

const binarySearch = (sortedArray, elToFind) => {
  let lowIndex = 0;
  let highIndex = sortedArray.length - 1;
  while (lowIndex <= highIndex) {
    let midIndex = Math.floor((lowIndex + highIndex) / 2);
    if (sortedArray[midIndex] == elToFind) return midIndex; 
    else if (sortedArray[midIndex] < elToFind) lowIndex = midIndex + 1;
    else highIndex = midIndex - 1;
  } return null;
}