数组过滤，一定要考虑性能，一定要考虑性能，一定要考虑性能，数据量10w

Question

const data = Array.from({ length: 100 }).map((item, index) => index + 1);

const filter = [
  {
    start: 2,
    end: 25,
  },
  {
    start: 27,
    end: 55,
  },
  {
    start: 58,
    end: 99,
  },
];

期望结果，

[1,26,56,57,100]

const data = Array.from({ length: 100 }).map((item, index) => index + 1);

const filter = [
  {
    start: 2,
    end: 25,
  },
  {
    start: 37,
    end: 55,
  },
  {
    start: 58,
    end: 99,
  },
];

const result = [];

let fi = 0;
let flag = false;

for (let index = 0; index < data.length ; index++) {
  const item = filter[fi];

  if (isOk(data[index], item)) {
    flag = true;
  } else if (filter[fi + 1] && isOk(data[index], filter[fi + 1])) {
    fi++;
  } else {
    flag = false;
    result.push(data[index]);
  }
}

function isOk(data, item) {
  if (!item) {
    return true;
  }
  const { start, end } = item;
  return data >= start && data <= end;
}

console.log("result", result);

Answer 1

说句不相干的
真要考虑性能也不该前端来做了

Answer 2

function arrayFilter(data, filter) {
  return data.filter((item) => filter.reduce((c, i) => c && (item < i.start || item > i.end), true));
}

// 10W数据量不会有性能问题吧 

Answer 3

let lastIndex = 0;
filter.flatMap((item, index) => {
  const {start, end} = item;
  const arr = data.slice(lastIndex, start - 1);
  index == filter.length - 1 && arr.push(...data.slice(end));
  lastIndex = end;
  return arr;
})

时间复杂度为：filter.length
当然，这里有2个前提：data的数字是连续的、filter是有序的

Answer 4

每个都需要遍历，没法从算法角度优化性能。
10w数据遍历起来也很快的，要确实慢，建议用worker

Answer 5

function reject(arr, filter) {
    var ret = arr.slice();
    for (var i = filter.length; i--;) {
        var item = filter[i];
        ret.splice(item.start - 1, item.end - item.start + 1);
    }
    return ret;
}
console.dir(reject(data, filter));