Cara memfilter array dari semua elemen array lain

140


Saya ingin memahami cara terbaik untuk memfilter array dari semua elemen yang lain . Saya mencoba dengan fungsi filter, tetapi tidak sampai pada saya bagaimana memberikannya nilai yang ingin saya hapus.
Sesuatu seperti:

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

jika fungsi filter tidak berguna, bagaimana Anda menerapkan ini?
Sunting: saya memeriksa kemungkinan pertanyaan rangkap, dan itu bisa bermanfaat bagi mereka yang mengerti javascript dengan mudah. Jawabannya diperiksa dengan baik membuat semuanya menjadi mudah.

javascript arrays filter Koop4
sumber
8
Lewati array lain untuk memfilter panggilan balik dan gunakan return arrTwo.indexOf(e) === -1; Kode: var filteredArr = firstArr.filter(el => secondArr.indexOf(el) === -1);
Tushar
1
Kemungkinan duplikat array .filter () menggunakan elemen array lain
Dawid Rutkowski
apakah kedua array tersebut dipesan?
Nina Scholz
array tidak dipesan, juga, array kedua memiliki jumlah elemen acak.
Koop4

Jawaban:

145

Anda dapat menggunakan thisparameter filter()fungsi untuk menghindari menyimpan array filter Anda dalam variabel global.

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

Simon Hai
sumber
Itu bekerja seperti pesona. Apakah mungkin untuk memindahkan fungsi ke luar dan menyebutnya dengan cara yang lebih dimengerti? Seperti: var difilter = [1,2,3,4] .filter (myfunct (), [2,4]);
Koop4
1
Tentu: var myFunct = function (e) {return this.indexOf (e) <0;}; var difilter = [1,2,3,4] .filter (myFunct, [2,4]);
Simon Hai
1
Bisakah ini dicapai dengan ekspresi lambda di ES2016 atau TypesScript?
Prabu
1
Versi sudut: stackblitz.com/edit/angular-wbynpf?embed=1&file=src/app/…
Sunil Raj
Ketika saya menggunakan pendekatan ini, param kedua filter tidak menjadikannya sebagai fungsi saya this. thissepertinya selalu tidak terdefinisi ?! Aneh
SomethingOn
149

Saya akan lakukan sebagai berikut;

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

Redu
sumber
6
Rockstar. Terima kasih, ini sangat membantu untuk menyelesaikan masalah yang sedikit berbeda. Memfilter array objek berdasarkan array nilai dalam komponen reaksi: di const filteredResults = this.state.cards.filter( result => !this.state.filterOut.includes(result.category) ) mana this.state.cards dalam array objek dan this.state.filterOut adalah array nilai yang sesuai dengan kunci 'kategori' pada objek yang Saya ingin menghapus.
Josh Pittman
Saya tahu, ini adalah respons yang lebih lama, tetapi saya hanya ingin memberi tahu Anda bahwa saya lebih menyukai respons ini dan itu membantu saya dengan salah satu masalah yang saya miliki. Ini sangat mudah dibaca dan karenanya lebih mudah bagi saya untuk memahami masalah dengan lebih baik.
ak.leimrey
1
termasuk hanya akan bekerja dari ES7. Jika Anda menggunakan ES6 gunakan solusi yang diterima.
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;
}

Dalam panggilan balik, Anda memeriksa apakah setiap nilai arraydalamanotherOne

https://jsfiddle.net/0tsyc1sx/

Jika Anda menggunakan lodash.js, gunakan_.difference 

filteredArray = _.difference(array, anotherOne);

Demo

Jika Anda memiliki array objek:

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 array benda

Demo berbagai objek dengan lodash

AshBringer
sumber
Hai, bisakah Anda memperpanjang yang ini dalam array objek? saya akan sangat menghargainya
Roel
Apakah Anda menggunakan lodash?
AshBringer
Tidak, sir saya lebih suka mengikuti metode panggilan balik
Roel
Yah pak itu benar-benar berhasil tetapi selain dari id bagaimana saya bisa menyaring jalan lain dengan nama?
Roel
Hummm ... Anda hanya perlu perubahan iddalam anotherOne_el.id == array_el.iddengan apa pun kunci yang Anda miliki di objek Anda sendiri. Anda harus mendapatkan pengetahuan tentang array dan objek dalam javascript, ini akan membantu Anda memahami lebih baik jawabannya
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);
Luaskan cuplikan

David Alan Condit
sumber
Apa yang saya butuhkan. Terima kasih
vikrantnegi
12

Kode di bawah ini adalah cara paling sederhana untuk memfilter array sehubungan dengan array lain. Kedua array dapat memiliki objek di dalamnya, bukan nilai.

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

Keluaran: [3, 6]

Awais Jameel
sumber
8

Ada banyak jawaban untuk pertanyaan Anda, tetapi saya tidak melihat siapa pun yang menggunakan ekspresi lambda:

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

Semua solusi di atas "berfungsi", tetapi kurang optimal untuk kinerja dan semuanya mendekati masalah dengan cara yang sama yang secara linear mencari semua entri pada setiap titik menggunakan Array.prototype.indexOf atau Array.prototype.includes . Solusi yang jauh lebih cepat (jauh lebih cepat daripada pencarian biner untuk kebanyakan kasus) adalah dengan mengurutkan array dan melompat ke depan saat Anda melanjutkan seperti yang terlihat di bawah ini. Namun, satu kelemahannya adalah ini mengharuskan semua entri dalam array menjadi angka atau string. Namun, pencarian biner dalam beberapa kasus yang jarang terjadi mungkin lebih cepat daripada pencarian linear progresif. Kasus-kasus ini muncul dari fakta bahwa pencarian linear progresif saya memiliki kompleksitas O (2n 1 + n 2 ) (hanya O (n 1+ n 2 ) dalam versi C / C ++ yang lebih cepat) (di mana n 1 adalah array yang dicari dan n 2 adalah array filter), sedangkan pencarian biner memiliki kompleksitas O (n 1 ceil (log 2 n 2 )) ( ceil = round up - to ceil ing), dan, terakhir, pencarian indexOf memiliki kompleksitas yang sangat bervariasi antara O (n 1 ) dan O (n 1 n 2 ) , rata-rata keluar ke O (n 1 ceil (n 2 ÷ 2)) . Dengan demikian, indexOf hanya akan menjadi yang tercepat, rata-rata, dalam kasus(n 1 , n 2 ) sama dengan {1,2} , {1,3} , atau {x, 1 | x∈N} . Namun, ini masih bukan representasi sempurna dari perangkat keras modern. IndexOf secara asli dioptimalkan sejauh yang bisa dibayangkan di sebagian besar browser modern, membuatnya sangat tunduk pada hukum prediksi cabang . Dengan demikian, jika kita membuat asumsi yang sama pada indexOf seperti yang kita lakukan dengan pencarian linear dan biner progresif - bahwa array tersebut didahului - kemudian, menurut statistik yang tercantum dalam tautan, kita dapat mengharapkan sekitar 6x kecepatan untuk IndexOf, menggeser kompleksitasnya ke antara O (n 1 ÷ 6) dan O (n 1 n 2 ), rata-rata ke O (n 1 ceil (n 2 7 ÷ 12)) . Akhirnya, perhatikan bahwa solusi di bawah ini tidak akan pernah berfungsi dengan objek karena objek dalam JavaScript tidak dapat dibandingkan dengan pointer dalam JavaScript.

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

Silakan lihat posting saya yang lain di sini untuk rincian lebih lanjut tentang algoritma pencarian biner yang digunakan

Jika Anda tidak yakin tentang ukuran file (yang saya hormati), maka Anda dapat mengorbankan sedikit kinerja untuk mengurangi ukuran file dan meningkatkan pemeliharaan.

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

Untuk membuktikan perbedaan kecepatan, mari kita periksa beberapa JSPerfs. Untuk memfilter array 16 elemen , pencarian biner kira-kira 17% lebih cepat dari indexOf sementara filterArrayByAnotherArray kira-kira 93% lebih cepat dari indexOf. Untuk memfilter array 256 elemen , pencarian biner kira-kira 291% lebih cepat daripada indexOf sementara filterArrayByAnotherArray kira-kira 353% lebih cepat dari indexOf. Untuk memfilter array 4096 elemen , pencarian biner kira-kira 2655% lebih cepat daripada indexOf sementara filterArrayByAnotherArray kira-kira 4627% lebih cepat daripada indexOf.

Filter balik (seperti gerbang AND)

Bagian sebelumnya menyediakan kode untuk mengambil larik A dan larik B, dan menghapus semua elemen dari A yang ada di B:

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

Bagian selanjutnya ini akan menyediakan kode untuk pemfilteran terbalik, tempat kami menghapus semua elemen dari A yang TIDAK ada di B. Proses ini secara fungsional setara dengan hanya mempertahankan elemen yang sama untuk A dan B, seperti gerbang AND:

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

Berikut adalah kode untuk pemfilteran terbalik:

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

Untuk versi yang lebih kecil dari kode penyaringan balik, lihat di bawah.

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
sumber
4
Terima kasih atas jawaban Anda, saya yakin akan membantu seseorang cepat atau lambat, bahkan jika itu harus digunakan dalam kasus tepi (yaitu hanya ketika masalah kinerja muncul). Dalam semua kasus lain saya menyarankan untuk menggunakan versi yang dapat dikelola / dibaca.
Koop4
1
@JackGiffin Saya pikir dengan mudah dibaca maksudnya mantainable dan cepat dibaca dan dipahami oleh pengembang web rata-rata, karena ketika perubahan atau pemahaman sederhana diperlukan. Solusi hebat, hanya saja tidak untuk sebagian besar kasus.
zardilior
1
@JackGiffin optimisasi awal adalah salah satu hal terburuk untuk proyek, kinerja harus diterapkan secara umum dalam cara-cara, menulis kode efisien, jika cukup sederhana, artinya jangan menulis langsung melalui kode buruk, dan ketika optimasi diperlukan karena kinerja tidak memenuhi persyaratan . Jadi orang seperti Anda harus bekerja mengoptimalkan proyek-proyek lain yang membutuhkan keterampilan obsesi itu. Semoga ini membantu :)
zardilior
1
@ zardilior Ini benar-benar membantu. Terima kasih banyak atas saran Anda zardilior. Saya akan membawanya ke hati dan bertindak atasnya.
Jack Giffin
1
@JackGiffin senang bisa melayani
zardilior
3

OA juga dapat diimplementasikan dalam ES6 sebagai berikut

ES6:

 const filtered = [1, 2, 3, 4].filter(e => {
    return this.indexOf(e) < 0;
  },[2, 4]);
Hemadri Dasari
sumber
Di luar sintaks panah, keunggulan ES6 apa yang dimiliki solusi ini sejauh pemfilteran?
Carl Edwards
1

Anda dapat mengatur fungsi filter untuk beralih ke "array filter".

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
sumber
1

Anda dapat menggunakan filter dan kemudian untuk fungsi filter gunakan pengurangan array filter yang memeriksa dan mengembalikan true ketika menemukan kecocokan kemudian balikkan pada pengembalian (!). Fungsi filter disebut sekali per elemen dalam array. Anda tidak melakukan perbandingan elemen apa pun dalam fungsi di pos Anda.

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);
Luaskan cuplikan

Goblinlord
sumber
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>
Luaskan cuplikan

hypemichael
sumber
Terima kasih, ini berhasil, tetapi saya lebih memilih untuk mempertahankan lingkup lokal. Arr2 juga memiliki sejumlah elemen acak.
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>
Luaskan cuplikan

hypemichael
sumber
1

Array pemfilteran yang lebih fleksibel dari array lain yang berisi properti objek

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)
Luaskan cuplikan

syarul
sumber
1

Anda dapat menulis fungsi generik filterByIndex () dan memanfaatkan tipe inferensi di TS untuk menyimpan kerumitan dengan fungsi callback:

katakanlah Anda memiliki array [1,2,3,4] yang ingin Anda filter () dengan indeks yang ditentukan dalam array [2,4].

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

fungsi byIndex mengharapkan fungsi elemen dan array dan terlihat seperti ini:

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

hasilnya kemudian 

filtered = [1,3]
lama
sumber
1

Contoh berikut digunakan new Set()untuk membuat array yang difilter yang hanya memiliki elemen unik:

Array dengan tipe data primitif: string, angka, boolean, null, undefined, simbol:

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

Array dengan objek sebagai item:

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
sumber
1

Di bawah ini adalah contohnya

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]
Luaskan cuplikan

Sagar M
sumber
0

Solusi Jack Giffin sangat bagus tetapi tidak bekerja untuk array dengan angka lebih besar dari 2 ^ 32. Di bawah ini adalah versi refactored, cepat untuk memfilter array berdasarkan solusi Jack tetapi berfungsi untuk array 64-bit.

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
sumber