Bir diziyi başka bir dizinin tüm öğelerinden filtreleme

140


Bir diziyi başka bir öğenin tüm öğelerinden filtrelemenin en iyi yolunu anlamak istiyorum . Filtre işlevini denedim, ancak kaldırmak istediğim değerleri nasıl vereceğim bana gelmiyor.
Gibi bir şey:

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

filtre işlevinin yararlı olmaması durumunda, bunu nasıl uygularsınız?
Düzenleme: Ben olası yinelenen soru kontrol ve javascript kolayca anlayanlar için yararlı olabilir. İyi olarak işaretlenen cevap işleri kolaylaştırır.

javascript  arrays  filter 
— Koop4
kaynak
8
Geri aramayı filtrelemek için diğer diziyi geçin ve return arrTwo.indexOf(e) === -1; Kod kullanın :var filteredArr = firstArr.filter(el => secondArr.indexOf(el) === -1);
— Tushar
1
— Dawid Rutkowski
Her iki dizi de sıralanıyor mu?
— Nina Scholz
dizi sıralı değildir, ayrıca, ikinci dizi rastgele sayıda öğeye sahiptir.
— Koop4

Yanıtlar:

145

Filtre dizinizi genel bir değişkende saklamaktan kaçınmak için işlevin thisparametresini kullanabilirsiniz filter().

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

— Simon Merhaba
kaynak
Mucizevi şekilde çalışır. Fonksiyonu dışarıya taşımak ve daha anlaşılır bir şekilde aramak mümkün müdür? Gibi: var filtrelenmiş = [1,2,3,4] .filter (myfunct (), [2,4]);
— Koop4
1
Elbette: var myFunct = function (e) {dönüş bu.indexOf (e) <0;}; filtrelenen var = [1,2,3,4] .filtre (myFunct, [2,4]);
— Simon Hi
1
Bu, ES2016 veya TypesScript'te lambda ifadesi ile başarılabilir mi?
— Prabu
1
— Sunil Raj
Bu yaklaşımı kullandığımda, ikinci filtre parametresi benim işlevime girmiyor this. thisher zaman tanımsız gibi görünüyor mu ?! Tuhaf
— Bir
149

Ben şöyle yaparım;

var arr = [1,2,3,4],
    brr = [2,4],
    res = arr.filter(f => !brr.includes(f));
console.log(res);
Snippet'i genişlet

— Redu
kaynak
6
Rock yıldızı. Teşekkür ederim, bu biraz farklı bir sorunu çözmek için inanılmaz yardımcı oldu. Bir tepki bileşenindeki bir değer dizisine dayalı olarak bir nesne dizisini filtreleme: const filteredResults = this.state.cards.filter( result => !this.state.filterOut.includes(result.category) ) burada bir nesne dizisindeki this.state.cards ve this.state.filterOut, nesnelerin içindeki 'kategori' anahtarına karşılık gelen bir değerler dizisidir. Kaldırmak istedim.
— Josh Pittman
Biliyorum, bu daha eski bir yanıt, ama ben sadece bu yanıtı daha çok sevdiğimi bildirmek istedim ve yaşadığım sorunlarımdan birinde bana yardımcı oldu. Çok okunabilir ve bu nedenle konuyu daha iyi anlamam daha kolay oldu.
— ak.leimrey
1
içerir, yalnızca ES7'den çalışır. ES6 kullanıyorsanız, kabul edilen çözümü kullanın.
— rudrasiva86
39 
var array = [1,2,3,4];
var anotherOne = [2,4];
var filteredArray = array.filter(myCallBack);

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

Her değeri ise callback'inde, denetlemek arrayolduğunuanotherOne

https://jsfiddle.net/0tsyc1sx/

Kullanıyorsanız lodash.js,_.difference 

filteredArray = _.difference(array, anotherOne);

gösteri

Bir dizi nesneniz varsa:

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

Demo nesne dizisi

Demo ile dizi nesneleri lodash ile demo

— ashbringer
kaynak
Merhaba, bunu bir nesne dizisinde genişletebilir misiniz? Çok takdir edeceğim
— Roel
Lodash mı kullanıyorsunuz?
— AshBringer
Hayır efendim ben geri arama yöntemini takip tercih
— Roel
Peki efendim gerçekten işe yaradı ama kimliğini dışında nasıl adıyla diğer şekilde filtre?
— Roel
Hummm ... Sadece değişikliğine sahip idiçinde anotherOne_el.id == array_el.idne yapmanız gereken anahtar kendi nesnesinde ile. Javascript diziler ve nesneler hakkında bilgi almak gerekir, bu cevabı daha iyi anlamanıza yardımcı olacaktır
— AshBringer
26 

        /* 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);
Snippet'i genişlet

— David Alan Condit
kaynak
Tam olarak ihtiyacım olan şey. Teşekkürler
— vikrantnegi
12

Aşağıdaki kod, bir diziyi başka bir diziye göre filtrelemenin en basit yoludur. Her iki dizide de değerler yerine nesneler olabilir.

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

Çıktı: [3, 6]

— Awais Jameel
kaynak
8

Sorunuzun birçok yanıtı var, ancak lambda ifadesini kullanan kimseyi görmüyorum:

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

Yukarıdaki tüm çözümler "çalışır", ancak performans için optimumdan daha azdır ve hepsi, Array.prototype.indexOf veya Array.prototype.includes kullanarak her noktada tüm girdileri doğrusal olarak araştıran aynı şekilde yaklaşırlar . Çok daha hızlı bir çözüm (çoğu durumda ikili bir aramadan bile daha hızlı), dizileri sıralamak ve aşağıda görüldüğü gibi ilerlerken atlamak olacaktır. Ancak, bir dezavantajı bunun dizideki tüm girişlerin sayı veya dize olmasını gerektirmesidir. Bununla birlikte, ikili arama bazı nadir durumlarda aşamalı doğrusal aramadan daha hızlı olabilir. Bu vakalar, ilerici doğrusal aramamın O (2n 1 + n 2 ) karmaşıklığına sahip olmasından kaynaklanmaktadır (sadece O (n 1)+ n 2 ) daha hızlı C / C ++ sürümünde) (burada n 1 aranan dizi ve n 2 filtre dizisidir), ikili aramanın karmaşıklığı O (n 1 tavan (günlük 2 n 2 )) ( ceil = yuvarla - tavana ) ve son olarak, indexOf aramasının O (n 1 ) ve O (n 1 n 2 ) arasında oldukça değişken bir karmaşıklığa sahip olması, O (n 1 tavan (n 2 ) ortalamasıdır. ÷ 2)) . Bu nedenle, indexOf yalnızca ortalama olarak en hızlı(n 1 , n 2 ) eşittir {1,2} , {1,3} veya {x, 1 | x∈N} . Ancak, bu hala modern donanımın mükemmel bir temsili değildir. IndexOf, çoğu modern tarayıcıda hayal edilebilecek en geniş ölçüde yerel olarak optimize edilmiştir ve bu da şube tahmini yasalarına çok tabidir . Böylece, indexOf üzerinde ilerleyen doğrusal ve ikili arama ile yaptığımız varsayımı yaparsak - dizinin sunulduğu - bağlantıda listelenen istatistiklere göre, IndexOf için kabaca 6 kat bir hız bekleyebiliriz, karmaşıklığını O (n 1 ÷ 6) ve O (n 1 n 2 ) arasında değiştirmek, O (n 1 tavan (n 2 7 ÷ 12)) ortalaması alınmıştır . Son olarak, JavaScript'teki nesneler JavaScript'teki işaretçilerle karşılaştırılamadığından aşağıdaki çözümün hiçbir zaman nesnelerle çalışmayacağını unutmayın.

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

Benim diğer yazı bakınız burada kullanılan ikili arama algoritması hakkında daha fazla ayrıntı için

Dosya boyutu konusunda titizseniz (saygı duyduğum), dosya boyutunu büyük ölçüde azaltmak ve sürdürülebilirliği artırmak için biraz performanstan ödün verebilirsiniz.

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

Hız farkını kanıtlamak için, bazı JSPerfs'leri inceleyelim. İçin 16 elemanlarından oluşan bir dizi filtre filterArrayByAnotherArray yaklaşık% 93 daha hızlı indexOf daha iken, ikili arama yaklaşık% 17 daha hızlı indexOf fazladır. İçin 256 elemanlarından oluşan bir dizi filtre filterArrayByAnotherArray yaklaşık 353% daha indexOf daha iken, ikili arama yaklaşık 291% daha indexOf fazladır. İçin 4096 elemanlarının, bir dizi filtre filterArrayByAnotherArray yaklaşık 4627% daha indexOf daha iken, ikili arama yaklaşık 2655% daha indexOf fazladır.

Ters filtreleme (AND geçidi gibi)

Önceki bölüm, A dizisini ve B dizisini almak ve B'de bulunan tüm öğeleri A'dan kaldırmak için kod sağlamıştır:

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

Bu sonraki bölüm, ters filtreleme için kod sağlayacaktır; burada A'da B'de OLMAYAN tüm öğeleri kaldırırız. Bu işlem işlevsel olarak yalnızca hem A hem de B için ortak olan bir AND geçidi gibi öğeleri tutmaya eşdeğerdir:

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

İşte ters filtreleme kodu:

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

Ters filtreleme kodunun daha yavaş daha küçük versiyonu için aşağıya bakın.

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;
    });
}
— Jack Giffin
kaynak
4
Cevabınız için teşekkürler, eminim er ya da geç biri için yararlı olacaktır, kenar durumlarda kullanılması gerekir (IE sadece bir performans sorunları yükseldiğinde). Diğer tüm durumlarda bakımı yapılabilen / okunabilir sürümü kullanmanızı öneririm.
— Koop4
1
@JackGiffin Okunabilir olarak, ortalama bir web geliştiricisi tarafından okunabilir ve hızlı bir şekilde okunması ve anlaşılması anlamına gelir, çünkü bir değişiklik veya basit bir anlama gerektiğinde. Harika bir çözüm, çoğu durum için değil.
— zardilior
1
@JackGiffin erken optimizasyonu projeler için en kötü şeylerden biridir, performans genellikle yollara uygulanmalıdır, verimli kod yazmak, yeterince basitse, yani doğrudan kötü kodla yazmayın ve optimizasyon gerektiğinde, performans gereksinimleri karşılamadığı için . Bu yüzden sizin gibi bir kişi, bu saplantıdan kaynaklanan beceriye ihtiyaç duyan diğer projeleri optimize etmeye çalışmalıdır. Umarım yardımcı olur :)
— zardilior
1
@zardilior Gerçekten yardımcı oluyor. Tavsiyeniz için çok teşekkür ederim zardilior. Onu kalbe götürüp harekete geçeceğim.
— Jack Giffin
1
@JackGiffin hizmete sevindim
— zardilior
3

OA ayrıca ES6'da aşağıdaki gibi uygulanabilir

ES6:

 const filtered = [1, 2, 3, 4].filter(e => {
    return this.indexOf(e) < 0;
  },[2, 4]);
— Hemadri Dasari
kaynak
Ok sözdiziminin dışında, bu çözümün filtreleme kadar ES6 avantajı nedir?
— Carl Edwards
1

"Filtre dizisi" üzerinden yineleme yapmak için filtre işlevini ayarlayabilirsiniz.

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;
  }
);
— Metapod
kaynak
1

Filtreyi kullanabilirsiniz ve daha sonra filtre işlevi için, bir eşleşme bulduğunda true değerini kontrol eden ve döndüren ve ardından dönüşte (!) Ters çeviren filtreleme dizisinin bir indirgenmesini kullanın. Filtre işlevi, dizideki öğe başına bir kez çağrılır. Yayınınızdaki işlevdeki hiçbir öğeyi karşılaştırmıyorsunuz.

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);
Snippet'i genişlet

— Goblinlord
kaynak
1 

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>
Snippet'i genişlet

— hypemichael
kaynak
Teşekkürler, işe yarıyor, ama yerel kapsamı korumayı tercih ederim. Ayrıca arr2'nin rastgele sayıda elemanı vardır.
— Koop4
1 

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>
Snippet'i genişlet

— hypemichael
kaynak
1

Nesne özellikleri içeren başka bir diziden daha esnek bir filtreleme dizisi

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)
Snippet'i genişlet

— syarul
kaynak
1

Genel bir filterByIndex () işlevi yazabilir ve güçlükleri geri arama işleviyle kaydetmek için TH'de tür çıkarımı kullanabilirsiniz:

diyelim ki [2,4] dizisinde belirtilen dizinlerle filtrelemek () istediğiniz [1,2,3,4] diziniz var.

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

byIndex işlevi element işlevini ve bir diziyi bekler ve şöyle görünür:

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

sonuç o zaman 

filtered = [1,3]
— lama
kaynak
1

Aşağıdaki örnekler new Set(), yalnızca benzersiz öğelere sahip filtrelenmiş bir dizi oluşturmak için kullanılır :

İlkel veri türlerine sahip dizi: dize, sayı, boole, null, tanımsız, sembol:

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

Nesne olarak öğe olarak dizi:

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);
— didinko
kaynak
1

Aşağıda bir örnek var

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]
Snippet'i genişlet

— Sagar M
kaynak
0

Jack Giffin'in çözümü harikadır, ancak 2 ^ 32'den büyük sayılara sahip diziler için çalışmaz. Aşağıda, Jack'in çözümüne göre bir diziyi filtrelemek için yeniden düzenlenmiş, hızlı bir sürüm var, ancak 64 bit diziler için çalışıyor.

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;
}
— Edgard
kaynak
Sitemizi kullandığınızda şunları okuyup anladığınızı kabul etmiş olursunuz: Çerez Politikası ve Gizlilik Politikası.
Licensed under cc by-sa 3.0 with attribution required.