Я хотел бы понять, как лучше всего отфильтровать массив от всех элементов другого. Я пробовал использовать функцию фильтра, но мне не пришло в голову, как присвоить ей значения, которые я хочу удалить.
что-то вроде:

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

в случае, если функция фильтра бесполезна, как бы вы это реализовали?
Edit: я проверил возможный повторяющийся вопрос, и он может быть полезен для тех, кто легко разбирается в javascript. Ответ, отмеченный как хороший, упрощает задачу.

Koop4

Ответов: 21

Ответы (21)

Вы можете использовать параметр this функции filter (), чтобы избежать сохранения массива фильтров в глобальной переменной.

var filter = [1, 2, 3, 4] .filter (
    function (e) {
      вернуть this.indexOf (e) <0;
    },
    [2, 4]
);
console.log (отфильтровано);

Все вышеперечисленные решения «работают», но менее чем оптимальны с точки зрения производительности, и все они решают проблему одинаково, при линейном поиске всех записей в каждой точке с использованием Array.prototype.indexOf илиArray.prototype.includes. Гораздо более быстрым решением (намного быстрее, чем бинарный поиск в большинстве случаев) было бы отсортировать массивы и пропустить вперед по мере продвижения, как показано ниже. Однако есть один недостаток: для этого требуется, чтобы все записи в массиве были числами или строками. Также, однако, двоичный поиск в некоторых редких случаях может быть быстрее, чем прогрессивный линейный поиск. Эти случаи возникают из-за того, что мой прогрессивный линейный поиск имеет сложность O (2n1+ n2) (только O (n1+ n2) в более быстрой версии C / C ++) (где n1 - искомый массив, а n2 - массив фильтров), тогда как двоичный поиск имеет сложность O (n1ceil (log2n2)) (ceil = round up - до ceiling), и, наконец, поиск indexOf имеет сильно различающуюся сложность между O (n1) и O (n1n2), с усреднением до O (n1ceil (n2÷ 2)). Таким образом, indexOf будет в среднем самым быстрым только в случаях (n1, n2) равняется {1,2}, {1,3}или {x, 1 | x∈N}. Однако это все еще не идеальное представление о современном оборудовании. IndexOf изначально оптимизирован в максимально возможной степени в большинстве современных браузеров, что делает его очень зависимым от законов предсказания ветвлений. Таким образом, если мы сделаем то же предположение для indexOf, что и для прогрессивного линейного и двоичного поиска - что массив предварительно отсортирован - тогда, согласно статистике, указанной в ссылке, мы можем ожидать примерно 6-кратного ускорения для IndexOf, изменение его сложности между O (n1÷ 6) и O (n1n2)с усреднением до O (n1ceil (n27 ÷ 12)). Наконец, обратите внимание, что приведенное ниже решение никогда не будет работать с объектами, потому что объекты в JavaScript нельзя сравнивать с помощью указателей в JavaScript.

функция sortAnyArray (a, b) {return a> b? 1: (а === b? 0: -1); }
функция sortIntArray (a, b) {return (a | 0) - (b | 0) | 0; }
function fastFilter (массив, дескриптор) {
    var out = [], значение = 0;
    для (var i = 0, len = array.length | 0; i >> 0) / LN2 | 0; // "| 0" действует как math.floor
  };
}) (Math.log, Math.LN2);

/* ИСПОЛЬЗОВАНИЕ:
  filterArrayByAnotherArray (
      [1,3,5],
      [2,3,4]
  ) дает [1, 5], и он также может работать со строками
* /
function filterArrayByAnotherArray (searchArray, filterArray) {
    если (
        // ПРИМЕЧАНИЕ: это не проверяет весь массив. Но, если ты знаешь
        // что есть только строки или числа (не смесь
        // оба) в массиве, то это безопасное предположение.
        // Всегда используйте `==` с `typeof`, потому что браузеры могут оптимизировать
        // `==` в `===` (ТОЛЬКО В ЭТОМ ОБСТОЯТЕЛЬСТВЕ)
        typeof searchArray [0] == "число" &&
        typeof filterArray [0] == "число" &&
        (searchArray [0] | 0) === searchArray [0] &&
        (filterArray [0] | 0) === filterArray [0]
    ) {filterArray
        // если все записи в обоих массивах целые
        searchArray.sort (sortIntArray);
        filterArray.sort (sortIntArray);
    } еще {
        searchArray.sort (sortAnyArray);
        filterArray.sort (sortAnyArray);
    }
    var searchArrayLen = searchArray.length, filterArrayLen = filterArray.length;
    vargressiveLinearComplexity = ((searchArrayLen << 1) + filterArrayLen) >>> 0
    var binarySearchComplexity = (searchArrayLen * (32-Math_clz32 (filterArrayLen-1))) >>> 0;
    // После вычисления сложности мы можем предсказать, какой алгоритм будет самым быстрым
    var i = 0;
    if (gressiveLinearComplexity >> 0);
        }
      Дело 1:
        if (len & 0x40000000) {
          константа nCB = len & 0xc0000000;
          len ^ = (len ^ (nCB-1)) & ((array [nCB] <= sValue | 0) - 1 >>> 0);
        }
      случай 2:
        if (len & 0x20000000) {
          константа nCB = len & 0xe0000000;
          len ^ = (len ^ (nCB-1)) & ((array [nCB] <= sValue | 0) - 1 >>> 0);
        }
      случай 3:
        if (len & 0x10000000) {
          константа nCB = len & 0xf0000000;
          len ^ = (len ^ (nCB-1)) & ((array [nCB] <= sValue | 0) - 1 >>> 0);
        }
      случай 4:
        if (len & 0x8000000) {
          константа nCB = len & 0xf8000000;
          len ^ = (len ^ (nCB-1)) & ((array [nCB] <= sValue | 0) - 1 >>> 0);
        }
      случай 5:
        if (len & 0x4000000) {
          константа nCB = len & 0xfc000000;
          len ^ = (len ^ (nCB-1)) & ((array [nCB] <= sValue | 0) - 1 >>> 0);
        }
      case 6:
        if (len & 0x2000000) {
          константа nCB = len & 0xfe000000;
          len ^ = (len ^ (nCB-1)) & ((array [nCB] <= sValue | 0) - 1 >>> 0);
        }
      case 7:
        if (len & 0x1000000) {
          константа nCB = len & 0xff000000;
          len ^ = (len ^ (nCB-1)) & ((array [nCB] <= sValue | 0) - 1 >>> 0);
        }
      case 8:
        if (len & 0x800000) {
          константа nCB = len & 0xff800000;
          len ^ = (len ^ (nCB-1)) & ((array [nCB] <= sValue | 0) - 1 >>> 0);
        }
      case 9:
        if (len & 0x400000) {
          константа nCB = len & 0xffc00000;
          len ^ = (len ^ (nCB-1)) & ((array [nCB] <= sValue | 0) - 1 >>> 0);
        }
      case 10:
        if (len & 0x200000) {
          константа nCB = len & 0xffe00000;len ^ = (len ^ (nCB-1)) & ((array [nCB] <= sValue | 0) - 1 >>> 0);
        }
      case 11:
        if (len & 0x100000) {
          константа nCB = len & 0xfff00000;
          len ^ = (len ^ (nCB-1)) & ((array [nCB] <= sValue | 0) - 1 >>> 0);
        }
      case 12:
        if (len & 0x80000) {
          константа nCB = len & 0xfff80000;
          len ^ = (len ^ (nCB-1)) & ((array [nCB] <= sValue | 0) - 1 >>> 0);
        }
      case 13:
        if (len & 0x40000) {
          константа nCB = len & 0xfffc0000;
          len ^ = (len ^ (nCB-1)) & ((array [nCB] <= sValue | 0) - 1 >>> 0);
        }
      case 14:
        if (len & 0x20000) {
          константа nCB = len & 0xfffe0000;
          len ^ = (len ^ (nCB-1)) & ((array [nCB] <= sValue | 0) - 1 >>> 0);
        }
      case 15:
        if (len & 0x10000) {
          константа nCB = len & 0xffff0000;
          len ^ = (len ^ (nCB-1)) & ((array [nCB] <= sValue | 0) - 1 >>> 0);
        }
      case 16:
        if (len & 0x8000) {
          константа nCB = len & 0xffff8000;
          len ^ = (len ^ (nCB-1)) & ((array [nCB] <= sValue | 0) - 1 >>> 0);
        }
      case 17:
        if (len & 0x4000) {
          константа nCB = len & 0xffffc000;
          len ^ = (len ^ (nCB-1)) & ((array [nCB] <= sValue | 0) - 1 >>> 0);
        }
      case 18:
        if (len & 0x2000) {
          константа nCB = len & 0xffffe000;
          len ^ = (len ^ (nCB-1)) & ((array [nCB] <= sValue | 0) - 1 >>> 0);
        }
      case 19:
        if (len & 0x1000) {
          константа nCB = len & 0xfffff000;
          len ^ = (len ^ (nCB-1)) & ((array [nCB] <= sValue | 0) - 1 >>> 0);
        }
      case 20:
        if (len & 0x800) {
          константа nCB = len & 0xfffff800;
          len ^ = (len ^ (nCB-1)) & ((array [nCB] <= sValue | 0) - 1 >>> 0);
        }
      case 21:
        if (len & 0x400) {
          константа nCB = len & 0xfffffc00;
          len ^ = (len ^ (nCB-1)) & ((array [nCB] <= sValue | 0) - 1 >>> 0);
        }
      case 22:
        if (len & 0x200) {
          константа nCB = len & 0xfffffe00;
          len ^ = (len ^ (nCB-1)) & ((array [nCB] <= sValue | 0) - 1 >>> 0);
        }
      case 23:
        if (len & 0x100) {
          константа nCB = len & 0xffffff00;
          len ^ = (len ^ (nCB-1)) & ((array [nCB] <= sValue | 0) - 1 >>> 0);
        }
      case 24:
        if (len & 0x80) {
          константа nCB = len & 0xffffff80;
          len ^ = (len ^ (nCB-1)) & ((array [nCB] <= sValue | 0) - 1 >>> 0);
        }
      case 25:
        if (len & 0x40) {
          константа nCB = len & 0xffffffc0;
          len ^ = (len ^ (nCB-1)) & ((array [nCB] <= sValue | 0) - 1 >>> 0);
        }
      case 26:
        if (len & 0x20) {
          константа nCB = len & 0xffffffe0;
          len ^ = (len ^ (nCB-1)) & ((array [nCB] <= sValue | 0) - 1 >>> 0);
        }
      case 27:
        if (len & 0x10) {
          константа nCB = len & 0xfffffff0;
          len ^ = (len ^ (nCB-1)) & ((array [nCB] <= sValue | 0) - 1 >>> 0);
        }
      case 28:
        if (len & 0x8) {
          константа nCB = len & 0xfffffff8;
          len ^ = (len ^ (nCB-1)) & ((array [nCB] <= sValue | 0) - 1 >>> 0);
        }
      case 29:
        if (len & 0x4) {
          константа 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);
        }
    }
    // МОДИФИКАЦИЯ: вместо возврата индекса этот двоичный поиск
    // вместо этого возвращает, было ли что-то найдено или нет.
    if (array [len | 0]! == sValue) {
       вернуть истину; // сохраняем значение по этому индексу
    } еще {
       вернуть ложь; // удаляем значение по этому индексу
    }
  };
}

Пожалуйста, посмотрите мой другой пост здесь для получения более подробной информации об используемом алгоритме двоичного поиска

Если вы брезгливо относитесь к размеру файла (что я уважаю), то вы можете немного пожертвовать производительностью, чтобы значительно уменьшить размер файла и повысить удобство обслуживания.

функция sortAnyArray (a, b) {return a> b? 1: (а === b? 0: -1); }
функция sortIntArray (a, b) {return (a | 0) - (b | 0) | 0; }
function fastFilter (массив, дескриптор) {
    var out = [], значение = 0;
    для (var i = 0, len = array.length | 0; i 

Чтобы доказать разницу в скорости, давайте рассмотрим некоторые JSPerfs. Для фильтрации массива из 16 элементовдвоичный поиск примерно на 17% быстрее, чем indexOf, а filterArrayByAnotherArray примерно на 93% быстрее, чем indexOf. Для фильтрации массива из 256 элементовдвоичный поиск примерно на 291% быстрее, чем indexOf, а filterArrayByAnotherArray примерно на 353% быстрее, чем indexOf. Для фильтрации массива из 4096 элементовдвоичный поиск примерно на 2655% быстрее, чем indexOf, а filterArrayByAnotherArray примерно на 4627% быстрее, чем indexOf.

Обратная фильтрация (как логический элемент И)

В предыдущем разделе предоставлен код для получения массива A и массива B и удаления всех элементов из A, которые существуют в B:

filterArrayByAnotherArray (
    [1,3,5],
    [2,3,4]
);
// дает [1, 5]

В следующем разделе будет представлен код для обратной фильтрации, в котором мы удаляем все элементы из A, которые НЕ существуют в B. Этот процесс функционально эквивалентен сохранению только элементов, общих как для A, так и для B, например логического элемента AND:

reverseFilterArrayByAnotherArray (
    [1,3,5],
    [2,3,4]
);
// дает [3]

Вот код для обратной фильтрации:

функция sortAnyArray (a, b) {return a> b? 1: (а === b? 0: -1); }
функция sortIntArray (a, b) {return (a | 0) - (b | 0) | 0; }
function fastFilter (массив, дескриптор) {
    var out = [], значение = 0;
    для (var i = 0, len = array.length | 0; i >> 0) / LN2 | 0; // "| 0" действует как math.floor
  };
}) (Math.log, Math.LN2);

/* ИСПОЛЬЗОВАНИЕ:
  reverseFilterArrayByAnotherArray (
      [1,3,5],
      [2,3,4]
  ) дает [3], и он также может работать со строками
* /
function reverseFilterArrayByAnotherArray (searchArray, filterArray) {
    если (
        // ПРИМЕЧАНИЕ: это не проверяет весь массив. Но, если ты знаешь
        // что есть только строки или числа (не смесь
        // оба) в массиве, то это безопасное предположение.
        // Всегда используйте `==` с `typeof`, потому что браузеры могут оптимизировать
        // `==` в `===` (ТОЛЬКО В ЭТОМ ОБСТОЯТЕЛЬСТВЕ)
        typeof searchArray [0] == "число" &&
        typeof filterArray [0] == "число" &&
        (searchArray [0] | 0) === searchArray [0] &&
        (filterArray [0] | 0) === filterArray [0]
    ) {
        // если все записи в обоих массивах целые
        searchArray.sort (sortIntArray);
        filterArray.sort (sortIntArray);
    } еще {
        searchArray.sort (sortAnyArray);
        filterArray.sort (sortAnyArray);
    }
    var searchArrayLen = searchArray.length, filterArrayLen = filterArray.length;
    vargressiveLinearComplexity = ((searchArrayLen << 1) + filterArrayLen) >>> 0
    var binarySearchComplexity = (searchArrayLen * (32-Math_clz32 (filterArrayLen-1))) >>> 0;
    // После вычисления сложности мы можем предсказать, какой алгоритм будет самым быстрым
    var i = 0;
    if (gressiveLinearComplexity >> 0);
        }
      Дело 1:
        if (len & 0x40000000) {
          константа nCB = len & 0xc0000000;
          len ^ = (len ^ (nCB-1)) & ((array [nCB] <= sValue | 0) - 1 >>> 0);
        }
      случай 2:
        if (len & 0x20000000) {
          константа nCB = len & 0xe0000000;
          len ^ = (len ^ (nCB-1)) & ((array [nCB] <= sValue | 0) - 1 >>> 0);
        }
      случай 3:
        if (len & 0x10000000) {
          константа nCB = len & 0xf0000000;
          len ^ = (len ^ (nCB-1)) & ((array [nCB] <= sValue | 0) - 1 >>> 0);
        }
      случай 4:
        if (len & 0x8000000) {
          константа nCB = len & 0xf8000000;
          len ^ = (len ^ (nCB-1)) & ((array [nCB] <= sValue | 0) - 1 >>> 0);
        }
      случай 5:
        if (len & 0x4000000) {
          константа nCB = len & 0xfc000000;
          len ^ = (len ^ (nCB-1)) & ((array [nCB] <= sValue | 0) - 1 >>> 0);
        }
      case 6:
        if (len & 0x2000000) {
          константа nCB = len & 0xfe000000;
          len ^ = (len ^ (nCB-1)) & ((array [nCB] <= sValue | 0) - 1 >>> 0);
        }
      case 7:
        if (len & 0x1000000) {
          константа nCB = len & 0xff000000;
          len ^ = (len ^ (nCB-1)) & ((array [nCB] <= sValue | 0) - 1 >>> 0);
        }
      case 8:
        if (len & 0x800000) {
          константа nCB = len & 0xff800000;
          len ^ = (len ^ (nCB-1)) & ((array [nCB] <= sValue | 0) - 1 >>> 0);
        }
      case 9:
        if (len & 0x400000) {
          константа nCB = len & 0xffc00000;
          len ^ = (len ^ (nCB-1)) & ((array [nCB] <= sValue | 0) - 1 >>> 0);
        }
      case 10:
        if (len & 0x200000) {константа nCB = len & 0xffe00000;
          len ^ = (len ^ (nCB-1)) & ((array [nCB] <= sValue | 0) - 1 >>> 0);
        }
      case 11:
        if (len & 0x100000) {
          константа nCB = len & 0xfff00000;
          len ^ = (len ^ (nCB-1)) & ((array [nCB] <= sValue | 0) - 1 >>> 0);
        }
      case 12:
        if (len & 0x80000) {
          константа nCB = len & 0xfff80000;
          len ^ = (len ^ (nCB-1)) & ((array [nCB] <= sValue | 0) - 1 >>> 0);
        }
      case 13:
        if (len & 0x40000) {
          константа nCB = len & 0xfffc0000;
          len ^ = (len ^ (nCB-1)) & ((array [nCB] <= sValue | 0) - 1 >>> 0);
        }
      case 14:
        if (len & 0x20000) {
          константа nCB = len & 0xfffe0000;
          len ^ = (len ^ (nCB-1)) & ((array [nCB] <= sValue | 0) - 1 >>> 0);
        }
      case 15:
        if (len & 0x10000) {
          константа nCB = len & 0xffff0000;
          len ^ = (len ^ (nCB-1)) & ((array [nCB] <= sValue | 0) - 1 >>> 0);
        }
      case 16:
        if (len & 0x8000) {
          константа nCB = len & 0xffff8000;
          len ^ = (len ^ (nCB-1)) & ((array [nCB] <= sValue | 0) - 1 >>> 0);
        }
      case 17:
        if (len & 0x4000) {
          константа nCB = len & 0xffffc000;
          len ^ = (len ^ (nCB-1)) & ((array [nCB] <= sValue | 0) - 1 >>> 0);
        }
      case 18:
        if (len & 0x2000) {
          константа nCB = len & 0xffffe000;
          len ^ = (len ^ (nCB-1)) & ((array [nCB] <= sValue | 0) - 1 >>> 0);
        }
      case 19:
        if (len & 0x1000) {
          константа nCB = len & 0xfffff000;
          len ^ = (len ^ (nCB-1)) & ((array [nCB] <= sValue | 0) - 1 >>> 0);
        }
      case 20:
        if (len & 0x800) {
          константа nCB = len & 0xfffff800;
          len ^ = (len ^ (nCB-1)) & ((array [nCB] <= sValue | 0) - 1 >>> 0);
        }
      case 21:
        if (len & 0x400) {
          константа nCB = len & 0xfffffc00;
          len ^ = (len ^ (nCB-1)) & ((array [nCB] <= sValue | 0) - 1 >>> 0);
        }
      case 22:
        if (len & 0x200) {
          константа nCB = len & 0xfffffe00;
          len ^ = (len ^ (nCB-1)) & ((array [nCB] <= sValue | 0) - 1 >>> 0);
        }
      case 23:
        if (len & 0x100) {
          константа nCB = len & 0xffffff00;
          len ^ = (len ^ (nCB-1)) & ((array [nCB] <= sValue | 0) - 1 >>> 0);
        }
      case 24:
        if (len & 0x80) {
          константа nCB = len & 0xffffff80;
          len ^ = (len ^ (nCB-1)) & ((array [nCB] <= sValue | 0) - 1 >>> 0);
        }
      case 25:
        if (len & 0x40) {
          константа nCB = len & 0xffffffc0;
          len ^ = (len ^ (nCB-1)) & ((array [nCB] <= sValue | 0) - 1 >>> 0);
        }
      case 26:
        if (len & 0x20) {
          константа nCB = len & 0xffffffe0;
          len ^ = (len ^ (nCB-1)) & ((array [nCB] <= sValue | 0) - 1 >>> 0);
        }
      case 27:
        if (len & 0x10) {
          константа nCB = len & 0xfffffff0;
          len ^ = (len ^ (nCB-1)) & ((array [nCB] <= sValue | 0) - 1 >>> 0);
        }
      case 28:
        if (len & 0x8) {
          константа nCB = len & 0xfffffff8;
          len ^ = (len ^ (nCB-1)) & ((array [nCB] <= sValue | 0) - 1 >>> 0);
        }
      case 29:
        if (len & 0x4) {
          константа 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);
        }
    }
    // МОДИФИКАЦИЯ: вместо возврата индекса этот двоичный поиск
    // вместо этого возвращает, было ли что-то найдено или нет.
    // Для обратной фильтрации я заменил истину на ложь и наоборот
    if (array [len | 0]! == sValue) {
       вернуть ложь; // сохраняем значение по этому индексу
    } еще {
       вернуть истину; // удаляем значение по этому индексу
    }
  };
}

Более медленную и меньшую версию кода обратной фильтрации см. Ниже.

функция sortAnyArray (a, b) {return a> b? 1: (а === b? 0: -1); }
функция sortIntArray (a, b) {return (a | 0) - (b | 0) | 0; }
function fastFilter (массив, дескриптор) {
    var out = [], значение = 0;
    для (var i = 0, len = array.length | 0; i 

OA также может быть реализован в ES6 следующим образом

ES6:

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

с результатом фильтрации объектов

[{id:1},{id:2},{id:3},{id:4}].filter(v=>!([{id:2},{id:4}].some(e=>e.id === v.id)))

enter image description here

Вот как это можно сделать, когда элементы в массивах являются объектами.

Идея состоит в том, чтобы найти массив только ключей во внутреннем массиве с помощью функции карты

Затем проверьте, содержит ли массив этих ключей определенный ключ элемента во внешнем массиве.

const existsInBothArrays = array1.filter((element1) =>
    array2.map((element2) => element2._searchKey).includes(element1._searchKey),
  );

Ниже приведен пример

пусть firstArray = [1,2,3,4,5];
пусть secondArray = [2,3];
пусть filterArray = firstArray.filter ((a) => secondArray.indexOf (a) <0);
console.log (filterArray); // строка выше дает [1,4,5]

Если вам нужно сравнить массив объектов, это работает во всех случаях:

let arr = [{ id: 1, title: "title1" },{ id: 2, title: "title2" }]
let brr = [{ id: 2, title: "title2" },{ id: 3, title: "title3" }]

const res = arr.filter(f => brr.some(item => item.id === f.id));
console.log(res);

Решение Джека Гиффина отличное, но не работает для массивов с числами больше 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;
}

Вы можете настроить функцию фильтрации для перебора "массива фильтров".

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

На ваш вопрос есть много ответов, но я не вижу никого, кто использовал бы лямбда-выражение:

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

В следующих примерах используется new Set () для создания отфильтрованного массива, содержащего только уникальные элементы:

Массив с примитивными типами данных: строка, число, логическое значение, null, undefined, символ:

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

функция arr (arr1, arr2) {
  
  function filter (value) {
    return arr2.indexOf (значение) === -1;
    }
  
  вернуть arr1.filter (filter)
  }

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

 / * Вот пример, который использует (некоторую) семантику ES6 Javascript для фильтрации массива объектов по другому массиву объектов. * /

        // x = полный набор данных
        // y = фильтровать набор данных
        пусть 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"}
            ];

        // Используем карту, чтобы получить простой массив значений "val". Пример: [1,4]
        пусть yFilter = y.map (itemY => {return itemY.val;});

        // Используйте фильтр и "не" включает, чтобы отфильтровать полный набор данных по значению набора данных фильтра.
        let filterX = x.filter (itemX =>! yFilter.includes (itemX.val));

        // Распечатываем результат.
        console.log (отфильтрованныйX);

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

функция fil (значение) {
возвращаемое значение! = arr2 [0] && value! = arr2 [1]
}

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





Лучшее описание для фильтра функция: 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);

И вы не можете получить доступ к значению переменной, пока оно не было присвоено

Вы можете написать общую функцию filterByIndex () и использовать вывод типа в TS, чтобы избавиться от хлопот с функцией обратного вызова:

предположим, что у вас есть массив [1,2,3,4], который вы хотите использовать filter () с индексами, указанными в массиве [2,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]

Я бы сделал следующее:

var arr1 = [1,2,3,4],
    arr2 = [2,4],
    res = arr1.filter (элемент =>! arr2.includes (элемент));
console.log (res);

Вы можете использовать фильтр, а затем для функции фильтра использовать сокращение массива фильтрации, которое проверяет и возвращает истину, когда находит совпадение, а затем инвертирует при возврате (!). Функция фильтра вызывается один раз для каждого элемента в массиве. Вы не сравниваете ни один из элементов функции в своем сообщении.

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

var filter = a1.filter (function (x) {
  return! a2.reduce (function (y, z) {
    вернуть x == y || х == г || у == истина;
  })
});

document.write (отфильтровано);

Приведенный ниже код представляет собой простейший способ отфильтровать массив по отношению к другому массиву. Оба массива могут иметь внутри объекты вместо значений.

пусть array1 = [1, 3, 47, 1, 6, 7];
пусть array2 = [3, 6];
пусть filterArray1 = array1.filter (el => array2.includes (el));
console.log (filterArray1);

Вывод: [3, 6]

Более гибкий массив фильтрации из другого массива, который содержит свойства объекта

function filterFn (array, diffArray, prop, propDiff) {
    diffArray =! propDiff? diffArray: diffArray.map (d => d [propDiff])
    this.fn = f => diffArray.indexOf (f) === -1
    if (prop) {
         вернуть array.map (r => r [prop]). filter (this.fn)
    } еще {
         вернуть array.filter (this.fn)
    }
}

// Вы можете использовать это так;

вар arr = [];

for (var i = 0; i <10; i ++) {
    var obj = {}
    obj.index = я
    obj.value = Math.pow (2, i)
    arr.push (объект)
}

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

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

var log = console.log.bind (консоль)

var filter = filterFn (arr, sec, 'значение', 't')

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

журнал (отфильтровано, отфильтровано2)

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, используйте _. Разница

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

Демонстрационный массив объектов

Демо-массив различий объектов с lodash

2022 WebDevInsider