JavaScript 实现删除数组指定元素的方法

JavaScript 删除数组元素实现原理

实现该功能的核心函数定义如下：

 
foreach = function (obj, insp){
if(obj== null && obj.constructor != Array){
return [];
} 
//obj 代表待处理的数组。若 obj 为 null 表示对象不存在，或 obj.constructor 不等于 Array 表示其构造函数非数组类型；
//constructor 属性始终指向创建当前对象的构造函数。当上述两个条件同时满足时，函数返回空数组 []；
//此处对 constructor 属性进行进一步说明。
var obj= [1, 2, 3, 4]; // 此写法等价于 var obj= new Array(1, 2, 3, 4);
console.log(obj.constructor === Array); // 输出 true，表明 obj 的构造函数确认为 Array；
var foo= function() { }; // 此写法等价于 var foo = new Function();
console.log(foo.constructor === Function); // 输出 true，表明 foo 的构造函数为 Function；
var obj = new Foo(); // 通过构造函数实例化生成 obj 对象
console.log(obj.constructor === Foo); // 输出 true，表明 obj 的构造函数为 Foo；

var i=0, len = obj.length, r = [];

while(i<len){

var x = insp(obj[i], i);

if (x !== null) {

r[r.length] = x;

i++;

return r;

//遍历数组对象 obj，参数 insp 为用于处理每个元素的方法或函数。向 insp 传递两个参数：obj[i] 代表当前数组元素值，并将 insp 的执行结果赋值给 x，最终将 x 存入数组 r。

例如遍历数组元素并调用 foreach 函数：

var testArray = [1,2,3,4,5,1,2,'w'];

foreach(testArray, function(i){

alert(i)

ArrayWithout 函数核心逻辑

//使用另一个函数来删除数组中的指定元素；

 
ArrayWithout = function(){
if (arguments.length < 2) {
// Arguments 是代表函数参数的特殊对象。
return arguments.length == 1 ? arguments[0] : null;
　　} 
var results = [];
var aa = arguments[0];
//将第一个参数赋值给变量 aa；
if (aa === null || aa.constructor != Array) {
return null;
//若 aa 不存在或不是数组类型，则返回 null；
　　} 
if(arguments[1].constructor == Array){
//若第二个参数是数组，则删除该数组中对应的所有元素；
var args = [];
args[0] = aa;
//aa = arguments[0] 将aa赋给数组args，作为其第一个元素值；
foreach(arguments[1], function(v, i){
//调用 foreach 函数处理 arguments[1] 数组中的每个元素，
args[i+1] = v;
//v 代表 arguments[1] 中的元素值，依次赋值给 args[1], args[2]...，而 args[0] 保持为 arguments[0]；
　　　}); 
　　 } 
else{
args = arguments;
//若第二个参数不是数组，则直接将 arguments 赋值给 args；
　　} 
for(var i = 0;i < aa.length; i ++){
var isWithout = true;
for(var j = 1; j < args.length ; j ++){
if(aa[i] == args[j]){
isWithout = false;
break;
//注意 j 从 1 开始，因为 args[0] 是原数组 aa，即我们要处理的对象。
将待删除元素与原数组 aa 中的元素逐一比较，若相同则 break 跳出循环；此时 isWithout 为 false，不再执行后续的 results.push(aa[i]);
　　　 } 
　　 } 
if (isWithout) {
results.push(aa[i]);
//删除原理：将原数组元素与待删除元素比较，保留不相同的元素并赋予新数组 results；
　　　　} 
　　} 
return results;
//返回已删除指定元素的新数组；
}; 
//ArrayWithout 函数的引用示例
var testArray = [1,2,3,4,5,1,2,'w'];
var result = ArrayWithout(testArray, 1, 3);
//var result = ArrayWithout(testArray, [1, 4]);
alert(result) //输出 [2,4,5,2]

完整代码示例

完整源代码如下：

 
foreach = function (obj, insp){
if(obj == null && obj.constructor != Array){
return [];
} 
var i=0, len = obj.length, r = [];
while(i<len){
var x = insp(obj[i], i);
if (x !== null) {
r[r.length] = x;
} 
i++;
} 
return r;
}; 
ArrayWithout = function(){
if (arguments.length < 2) {
return arguments.length == 1 ? arguments[0] : null;
} 
var results = [];
var aa = arguments[0];
if (aa === null || aa.constructor != Array) {
return null;
} 
if(arguments[1].constructor == Array){
var args = [];
args[0] = aa;
foreach(arguments[1], function(v, i){
args[i+1] = v;
}); 
} 
else{
args = arguments;
} 
for(var i = 0;i < aa.length; i ++){
var isWithout = true;
for(var j = 1; j < args.length ; j ++){
if(aa[i] == args[j]){
isWithout = false;
break;
} 
} 
if (isWithout) {
results.push(aa[i]);
} 
} 
return results;
}; 
var testArray = [1,2,3,4,5,1,2];
foreach(testArray, function(i){
alert(i)
}) 
var result = ArrayWithout(testArray, 1, 3);
//var result = ArrayWithout(testArray, [1, 3]);
alert(result) //输出 [2,4,5,2]