使用场景

  在数组[ 0, 1, 2, 3, 9, 0, 9, 9 ]中，对照数组[ 0, 2, 3, 8, 9, 10 ]，删除其中所有相同的元素。
  常用的方式是嵌套循环，逐个对比判断为true时，使用splice函数逐个删除。这样删除N个元素，就需调用N次splice函数，效率低。
  通过简单分析可看出，原数组中的2, 3和9, 9是一段连续的元素，所以调用splice时，可获取此区间的“起始”、“结束”索引值，分批删除，减少调用次数。

代码实现

简单实现一个数组分段批量删除：

/**
 * 区间算法，分段批量删除
 * @param a {@link Array}：被执行数组；
 * @param b {@link Array}：对比参照数组；
 */
function rangeDel(a, b) {
    
	if (!a || !a.length || !b || !b.length)
		return a;

	for (var i = 0, idx = i; i < a.length; i++) {
    
		let item = a[i];
		if (b.indexOf(item) == -1) {
    
			if (idx < i) {
    
				let m = i - idx;
				let s = a.splice(i = idx, m);
				console.log('批量删除：', s);
			}
			idx++;      //idx与i同步
		}
	}
	if (idx < a.length) {
       //删除末尾元素
		let s = a.splice(idx, a.length - idx);
		console.log('批量删除（末尾）：', s);
	}
	return a;
}

  测试示例：

let a = [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 9, 9 ];
let b = [ 0, 2, 3, 4, 8, 9, 10 ];
console.log('结果：', rangeDel(a, b)); //结果： [ 1, 5, 6, 7 ]

---

升级：#1

  既然是对数组本身进行操作，且改变了原数组，那么可将此方法直接放到Array原型上，以方便实例直接调用。
  另外，某些情况下，不单单是两个不同数组中的元素进行对照删除，还可能是其它判断条件，比如删除所有“奇数”元素。因此可将判断条件设置为自定义函数，获取其返回值即可。

/**
 * 分段区间算法，删除元素
 * @param arr {@link Array}：对比参照数组；
 * @param pms {@link Object}：非必参，自定义功能；
 *  pms.judge {@link Function}：两个数组以某种条件进行判断，返回{@link Boolean}值；
 *  pms.fn {@link Function}：当pms.judge判断为true时，调用的函数；
 * @return {@link Array}：this改变后的结果。
 * @version V1.0.1
 */
Array.prototype.rangeDel = function (arr, {
    
	judge = v => arr.indexOf(v) == -1,
	fn = (start, end, dif = end - start + 1) => {
     start, end, dif }
} = (pms = {
    })) {
    
	if (!arr || !arr.length || !this.length)
		return this;

	let splice = (start, end) => {
    
		fn(start, end);
		let items = this.splice(start, end - start + 1);
		return items;
	};
	for (var i = 0, idx = i; i < this.length; i++) {
    
		let item = this[i];
		if (judge(item)) {
    
			if (idx < i) {
    
				splice(idx, i - 1);
				i = idx;
			}
			idx++;  //judge返回true时，idx与i同步
		}
	}
	if (idx < this.length)  //删除末尾元素
		splice(idx, this.length - 1);
	return this;
};

知识点：rangeDel函数中，形参"pms"为Object类型，使用了“解构”。且解构的每个属性都赋予了默认值。
因其使用了解构，传入实参时，不能为空（否则会抛异常），故又给"pms"赋予了默认值。

  测试示例：

let arr1 = [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 11 ];
let arr2 = [ 0, 2, 3, 4, 7, 8, 10, 11, 12, 12 ];

var rs = [ ...arr1 ].rangeDel(arr2);
console.log(rs);    //[ 1, 5, 6, 9, 13 ]

var rs = [ ...arr1 ].rangeDel(arr2, {
    
	judge: v => arr2.indexOf(v) != -1   //自定义判断函数
});
console.log(rs);    //[ 0, 2, 3, 4, 7, 8, 10, 11, 11 ]

  对比两个测试示例，发现rangeDel函数中形参arr并非关键参数，可有可无。起关键作用的是形参pms中的judge属性，因此可将形参arr删除。

---

改造为工具类

  区间算法不只用于进行删除操作，多数为获取数组中符合条件的区间范围，因此可改造为工具类使用。

/**
 * 分段区间算法：获取区间。
 * @param judge {@link Function}：以某种条件进行判断，返回{@link Boolean}值。接收3个参数function(currentValue, index, arr)，用法同Array的"forEach"、"map"函数；
 * @param fn {@link Function}：每获得一个区间，调用此函数；
 * @return {@link Array}：分段区间计算结果（[ { start, end }... ]）。
 * @version V1.0.1
 */
Array.prototype.range4 = function (judge, fn = () => {
    }) {
    
	let rs = [];
	if (!judge || !this.length)
		return rs;

	let push = (start, end) => {
    
		let dif = end - start + 1;
		let r = {
     start, end, dif };
		rs.push(r);
		fn(start, end, dif, this);	//获得区间后的回调
		return r;
	};
	for (var i = 0, idx = i; i < this.length; i++) {
    
		let item = this[i];
		if (!judge(item, i, this)) {
    
			if (idx < i) {
    
				push(idx, i - 1);
				idx = i;
			}
			idx++;  //!judge返回true时，idx与i同步
		}
	}
	if (idx < this.length)   //末尾区间
		push(idx, this.length - 1);
	return rs;
};

  测试示例：

let arr = [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, '', false, null, 10 ];
let rs = arr.range4(v => !v);	//获取数组中“无效元素”的所有区间
console.log(rs);	//[ { start: 0, end: 0, dif: 1 }, { start: 10, end: 12, dif: 3 } ]

---

使用过程中，如出现bug，或有其它优化建议，欢迎在此文章“评论区”留言讨论，并留下您的邮箱，以便改正后及时通知您。