Javascript 按非数组第二个参数筛选第一个参数数组

我是一名javascript初学者，试图解决在线代码夏令营带来的挑战。这个问题类似于在会议上提出的问题。我已经研究过这一点，但仍然没有成功。我试了好几个小时都没有找到解决办法

确切的挑战是：

从数组（第一个参数）中删除所有值（最后一个参数），然后>作为新数组返回

我知道这没什么好谈的。在下面的示例中，所需的输出将是以下数组：

[1,1]

基本前提是通过x个非数组参数过滤第一个参数（数组）。如果数组元素与非数组参数相同，则这些元素将从数组中删除。下面是我尝试过的一条路径的一个无效示例：

<code>
     function result(arr) {
  var list = [];
  var i;
  for(i in Object.keys(arguments)) {
      if(i > 0) {
          list.push(arguments[i]);
      }
  }

  function answer(arr1, arr2) {
    return arr1.filter(function(a) {
        return arr2.indexOf(a) >= 0;
    });
  }

  return answer(arr, list);
}
result([1, 2, 3, 1, 2, 3], 2, 3); 
</code>

---

好吧，现在也许我明白了。如果这是真正的挑战措辞，那么措辞就很糟糕

我的解释是，要求您编写一个函数，该函数接受数组中的第一个参数，然后再接受零个或多个连续参数。任务是从传入的数组中删除所有零个或多个连续参数，并返回一个新数组，其中删除了这些项

function filterArray(sourceArray, arg1, arg2 /* ... more args */) {
    // get arguments after the first argument into their own array
    var args = Array.prototype.slice.call(arguments, 1);
    return sourceArray.filter(function(element, index, array) {
        return args.indexOf(element) === -1;
    });
}

这是通过将连续参数放入它们自己的数组中，然后在

源数组上调用
.filter（）
来实现的。
.filter（）
的回调然后使用
.indexOf（）
检查每个元素是否在参数列表中。如果不是，则返回
true
以将值保留在输出数组中。如果它在参数列表中，则返回
false
，以便将其从输出数组中删除

工作演示：


如果您希望与IE9之前的IE版本兼容，您可以为
.filter（）
和
.indexOf（）
添加一个polyfill，这很容易显示，也可以像下面这样手动执行过滤：

function filterArray(sourceArray, arg1, arg2 /* ... more args */) {
    var result = [], found, item;
    for (var i = 0; i < sourceArray.length; i++) {
        item = sourceArray[i];
        found = false;
        for (var argIndex = 1; argIndex < arguments.length; argIndex++) {
            if (arguments[argIndex] === item) {
                found = true;
                break;
            }
        }
        if (!found) {
            result.push(item);
        }
    }
    return result;
}

函数filterArray（sourceArray，arg1，arg2/*…更多args*/）{
var结果=[]，已找到，项；
对于（var i=0；i

工作演示：
我能想到的最简单的解决方案是：

function result(haystack) {
    // converting the 'non-array' list of additional arguments
    // into an array:
    var needles = Array.prototype.slice.call(arguments, 1),
        // using Array.prototype.filter() to filter the 
        // supplied array ('haystack'):
        filtered = haystack.filter(function (el) {
            // the first argument ('el') is the current array-element

            // if the current array-element is *not* found in the
            // array of 'needles', we retain the element:
            return needles.indexOf(el) === -1;
        });
    return filtered;
}

console.log(result([1, 2, 3, 1, 2, 3], 2, 3)); // [1, 1]

这个解决方案，特别是使用
Array.prototype.filter（）
，在IE8中是有问题的，MDN参考链接（下面）为那些旧浏览器提供了一个垫片


函数结果（haystack）{
var=Array.prototype.slice.call（参数，1），
过滤=干草堆。过滤器（功能（el）{
返回针。索引of（el）=-1；
});
/*仅显示值：*/
document.getElementById（'haystack'）.textContent=haystack.join（'，'）；
document.getElementById（'Piners'）.textContent=Piners.join（'，'）；
document.getElementById（'result'）.textContent=filtered.join（'，'）；
返回过滤；
}
log（结果（[1,2,3,1,2,3]，2,3））
ol，li{
列表样式类型：无；
}
李：以前{
内容：属性（id）“：”；
显示：内联块；
宽度：20%；
文本转换：大写；
}
李：空的{
显示：无；
}




这将检查所有参数是否与输入数组中的值完全匹配。然后返回一个去掉这些值的数组

它不使用
.filter（）
.slice（）
.call（）
或
Object.keys（）
，因此它完全符合古代的web浏览器版本

<script type="text/javascript">

function result(input_array) {
    //  Breakpoint if input is not an array... return the object inside an array for consistency of return type
    if( !(input_array instanceof Array) ) return [].push(input_array);

    //  Gather list of arguments to reject.
    var reject_list = [];
    for(var i in arguments)
        if(i > 0)
            reject_list.push(arguments[i]);

    //  check each element in the input array if it is a value to reject.
    var output_array = []
    for(var i = 0; i < input_array.length; i++){
        var value_is_ok = true
        for(var r = 0; r < reject_list.length; r++){
            if( input_array[i] == reject_list[r] ){
                value_is_ok = false
                break
            }//endif
        }//endfor

        if( value_is_ok )
            output_array.push(input_array[i]);

    }//endfor


    return output_array
}

var my_array = [1, 2, 3, 1, 2, 3]
console.log( result(my_array, 2, 3) )   //  result is [1,1]

</script>


函数结果（输入_数组）{
//断点如果输入不是数组…返回数组中的对象以保持返回类型的一致性
if（！（input_数组instanceof array））返回[]。推送（input_数组）；
//收集要拒绝的参数列表。
var reject_list=[]；
for（参数中的变量i）
如果（i>0）
拒绝_list.push（参数[i]）；
//检查输入数组中的每个元素是否为要拒绝的值。
变量输出_数组=[]
对于（变量i=0；i
如果您确实希望获得编码挑战方面的帮助，请发布该挑战的确切说明，包括解决方案必须遵循的任何规则或限制，以及所需输入和输出的准确示例。抱歉，我是新手。完整而准确的指令说明如下：“从数组（第一个参数）中删除所有值（最后一个参数），并作为新数组返回。”抱歉，我不清楚该说明。如果这是一个特定的挑战，那么请粘贴（到您的问题中）确切的挑战。从数组中删除所有值并作为数组重新调用不会改变任何东西。如果你用期望的输出显示一个或多个输入，这将使你的意图更加清晰。我已经尝试添加挑战提供的所有信息以及期望的结果。原始指令没有扩展性。
for（i in Object.keys（arguments）
-！
.filter（）
回调应该返回
true
或
false
，而不是
el
。如果
el
本身是
false
，那会把你搞砸。@jfriend00：谢谢，一个