Javascript freecodecamp挑战-搜索和销毁

我试图解决这个挑战，寻找并摧毁。我想不出是怎么回事。有什么帮助吗

寻根究底 将为您提供一个初始数组（destroyer函数中的第一个参数），后跟一个或多个参数。从初始数组中删除与这些参数值相同的所有元素

以下是初始代码：

功能销毁程序（arr）{
//删除所有值
返回arr；
}
驱逐舰（[1,2,3,1,2,3]，2,3）您可以创建一个包含所有应该删除的值的数组。然后使用
Array.filter
过滤掉这些值

注意：
阵列。拼接
将更改原始阵列


函数销毁程序（）{
var arr=参数[0]；
var参数=[]；
//创建要删除的所有元素的数组
for（var k=1；k日志（驱逐舰（[1,2,3,1,2,3]，2,3））我的答案与前一个类似，但我没有使用
索引of
。相反，我检查了循环中的值，但编译器警告我不要在循环中声明函数

function destroyer(arr) {
// Remove all the values
var temp = [];
for (var i = 1; i < arguments.length; i++) {
    temp.push(arguments[i]);
    arr = arguments[0].filter(function(value) {
        return ( value !== temp[i - 1]) ;
    });
}
return arr;
}
destroyer([1, 2, 3, 1, 2, 3], 2, 3);

功能销毁程序（arr）{
//删除所有值
var-temp=[]；
for（var i=1；i
这对我很有用：


功能销毁程序（arr）{
//删除所有值
var args=Array.from（参数）；
var过滤器=[]；
对于（i=0；i);
//解决FreeCodeCamp上的Seek and Destroy挑战的两种方法
//我试图简化这个代码，请发布你的解决方案，简化代码
//尽可能多

 function destroyer1 (arr){
    //get array from arguments
    var args = Array.prototype.slice.call(arguments);
    args.splice(0,1);
    for (var i = 0; i < arr.length; i++){
     for(var j = 0; j < args.length; j++){
        if(arr[i]===args[j]){
        delete arr[i];
        }
     }
 }
return arr.filter(function(value){
    return Boolean(value);
});
}

功能销毁程序1（arr）{
//从参数获取数组
var args=Array.prototype.slice.call（参数）；
参数拼接（0,1）；
对于（变量i=0；i

//--------------------------------------

 function destroyer(arr) {
  // Remove all the values
  //Get values from arguments of the function to an array, index 0(arr[0] will be "arr", 
  //rest of indexes will be rest of arguments.

  var args = Array.from(arguments);
  for (var i = 0 ; i < args[0].length; i++){
    for (var j = 1; j < args.length; j++){
        if(args[0][i] === args[j]){
            delete args[0][i];
        }
    }
  }
  return args[0].filter(function(value){
    return Boolean(value);
  });
}

console.log(destroyer([1, 2, 3, 1, 2, 3], 2, 3));
console.log(destroyer1([1,6,3,9,8,1,1], 3,1));

功能销毁程序（arr）{
//删除所有值
//从函数的参数获取值到数组，索引0（arr[0]将为“arr”，
//其余的索引将是其余的参数。
var args=Array.from（参数）；
对于（var i=0；i
这是我的代码：


功能销毁程序（arr）{
var argsBeRemove=[…参数]；
argsBeRemove.shift（）；
返回arr.filter（val=>{
返回argsBeRemove.indexOf（val）=-1；
});
}
log（destroyer（[1,2,3,1,2,3]，2,3））；
这是我的Seek and Destroy版本。我假设输入中没有零元素（该假设允许通过质询）。但这样我可以使找到的元素等于零，然后将它们过滤掉。删除for循环中的元素时，这非常简单，没有索引混乱


功能销毁程序（arr）{
//删除所有值
var args=Array.prototype.slice.call（参数）；
var-temp=[]；
temp=参数[0]。切片（）；
对于（j=1；j

功能销毁程序（arr）{
var args=Array.prototype.slice.call（参数，1）；
返回arr.filter（destroyNum）；
函数destroyNum（元素）{
return！args.includes（元素）；
}
}
日志（销毁程序（[1,2,3,1,2,3]，2,3））；
功能销毁程序（arr）{
/*使用扩展运算符将所有参数放入数组中并删除元素
从1开始，使用拼接的切片插入，以免使初始阵列发生突变*/
常量args=[…参数].slice（1）；
/*检查参数是否包含数组中的元素，并返回所有这些元素
不包括（错误）*/
返回arr.filter（el=>！args.includes（el））；
}
console.log（destroyer（[1,2,3,1,2,3]，2,3））；
试一试，它不那么复杂：
功能销毁程序（arr）{
//arr1等于arr内部的数组
var arr1=arr.slice（参数）；
//arr2变成一个参数为2和3的数组
var arr2=Array.prototype.slice.call（参数，1）；
//此函数用于比较两者，并返回元素不等于参数的数组
返回arr1.concat（arr2.filter）（函数（项）{
返回！arr1.包括（项目）| |！arr2.包括（项目）
})
}
驱逐舰（[1,2,3,1,2,3]，2,3）；
将为您提供一个初始数组（destroyer函数中的第一个参数），后跟一个或多个参数。从初始数组中删除与这些参数值相同的所有元素

接受的解决方案返回一个新数组
function destroyer(arr) {
 let removeList=[...arguments].slice(1);
 return arr.filter(e=>removeList.indexOf(e)===-1);
}