Javascript 筛选具有多个属性的两个数组

请看下面的两个数组，首先我们将修复数组发送到后端，然后返回具有有限属性的失败插入，实际上我必须从更大的失败消息中进行子串以形成数组，但基本上是这样的：

var sentRepairs = [
{id: 12345, car: 'Nissan', Model: 'Almera', RepairDate: new Date('2016-04-06'), Modificator: 'User200' },
{id: 12346, car: 'Nissan', Model: 'Almera', RepairDate: new Date('2016-04-07'), Modificator: 'User200' },
{id: 12347, car: 'Toyota', Model: 'Corolla', RepairDate: new Date('2016-04-09'), Modificator: 'User200' },
{id: 12348, car: 'Toyota', Model: 'Corolla', RepairDate: new Date('2016-04-10'), Modificator: 'User200' },
] 

var initislRequestToBackend = [
{ id: 12345, car: 'Nissan', Model: 'Almera', RepairDate: new Date('2016-04-06'), Modificator: 'User200' },
{ id: 12346, car: 'Nissan', Model: 'Almera', RepairDate: new Date('2016-04-07'), Modificator: 'User200' },
{ id: 12347, car: 'Toyota', Model: 'Corolla', RepairDate: new Date('2016-04-09'), Modificator: 'User200' },
{ id: 12348, car: 'Toyota', Model: 'Corolla', RepairDate: new Date('2016-04-09'), Modificator: 'User200' },
{ id: 12348, car: 'Toyota', Model: 'Corolla', RepairDate: new Date('2016-04-10'), Modificator: 'User200' }];

下面是我可以从响应行中解析的所有数据，它们是字符串

var failedRepairs = [
{ car: 'Toyota', Model: 'Corolla', RepairDate: new Date('2016-04-09'),
{ car: 'Nissan', Model: 'Almera', RepairDate: new Date('2016-04-07')
];

在这之后，我需要做一个子数组，其中包括维修失败的汽车。请注意，对于同一型号，可能会进行多次维修。我必须使用的标识符是汽车、型号和日期。后端不提供我的id，这将使我轻而易举

 var resultsArrayShouldLookLikeThis = [
 {id: 12346, car: 'Nissan', Model: 'Almera', RepairDate: new Date('2016-04-07'), Modificator: 'User200' },
 {id: 12347, car: 'Toyota', Model: 'Corolla', RepairDate: new Date('2016-04-09'), Modificator: 'User200' }
 ]  

正如我意识到的，在评论的支持下，这看起来有点像人渣请求，所以这里是我到目前为止的结果，有4个未定义的对象作为结果，正如我所期望的那样。如果在数组中找到匹配的部分，则helper函数返回true，否则返回false

 var result = sentRepairs.map(function (x) { 
  if (
   helperService.searchArrayByProperty(x.car, failedRepairs, "car") && 
   helperService.searchArrayByProperty(x.Model, failedRepairs, "Model")) {
  return x;
 }
 });

Helper函数本身，它不是我写的，我知道它实际上不会在日期之间进行比较，但即使没有日期比较，我仍然得到4个未定义的对象：

var searchArrayByProperty = function(value, array, property) {
        var item = {};
        var found = false;
        for (var i = 0; i < array.length; i++) {
            if (typeof array[i][property] === "string") {
                if (array[i][property].toString() === value) {
                    item = array[i];
                    found = true;
                }
            }
            else if (typeof array[i][property] === "number") {
                if (array[i][property] === value) {
                    item = array[i];
                    found = true;
                }
            }
            else if (typeof array[i][property] === "boolean") {
                if (array[i][property] === value) {
                    item = array[i];
                    found = true;
                }
            }
            else if (typeof array[i][property] === "undefined") {
                return false;
            }
        }

        if (found) {
            return true;
        } else {
            return false;
        }
    }

var searchArrayByProperty=函数（值、数组、属性）{
var item={}；
var=false；
对于（var i=0；i

使用

过滤器和循环：

resultsArrayShouldLookLikeThis  = sentRepairs.filter(function(item){
    for(var i = 0; i < failedRepairs.length; i++){
        if(JSON.stringify(item.RepairDate) == JSON.stringify(failedRepairs[i].RepairDate)){
          return item;
        }
    }
});

resultsArrayShouldLookLikeThis=sentRepairs.filter（函数（项））{
对于（变量i=0；i

我比较了日期，因为它是两个初始数组之间的uniq键

编辑：

我已经添加了附加条件，您可以通过
failedRepairs
进行迭代，并构建一个临时对象，用于过滤器循环中的查找。复杂性O（n+m）


var sentreapers=[{id:12345，汽车：日产，车型：阿尔梅拉，维修日期：新日期（'2016-04-06'），修改人：'User200'}，{id:12346，汽车：日产，车型：阿尔梅拉，维修日期：新日期（'2016-04-07'），修改人：'User200'}，{id:12347，汽车：丰田，车型：卡罗拉，维修日期：新日期（'2016-04-09'），修改人：'User200'}，{id:12348，汽车：'Toyota'，车型：'Corolla'，维修日期：新日期（'2016-04-10'），修改人：'User200'}，]，
failedRepairs=[{汽车：'Toyota'，车型：'Corolla'，维修日期：新日期（'2016-04-09'）}，{汽车：'Nissan'，车型：'Almera'，维修日期：新日期（'2016-04-07'）}]，
过滤=功能（基本，故障）{
功能键（o）{返回[o.car，o.Model，o.RepairDate]。连接（“|”）；}
var对象={}；
失败。forEach（功能（a）{
对象[键（a）]=真；
});
返回基过滤器（函数（a）{
返回对象[键（a）]；
});
}（修理失败、修理失败）；
document.write（“+JSON.stringify（filtered，0，4）+”）；
lodash是为以下任务而开发的实用程序：

var sentRepairs = [
{id: 12345, car: 'Nissan', Model: 'Almera', RepairDate: new Date('2016-04-06'), Modificator: 'User200' },
{id: 12346, car: 'Nissan', Model: 'Almera', RepairDate: new Date('2016-04-07'), Modificator: 'User200' },
{id: 12347, car: 'Toyota', Model: 'Corolla', RepairDate: new Date('2016-04-09'), Modificator: 'User200' },
{id: 12348, car: 'Toyota', Model: 'Corolla', RepairDate: new Date('2016-04-10'), Modificator: 'User200' },
] 

var res = _.intersectionWith(sentRepairs,failedRepairs, function(sentItem, failedItem){
        if(sentItem.car == failedItem.car && sentItem.Model && JSON.stringify(sentItem.RepairDate) == JSON.stringify(failedItem.RepairDate)){
       return sentItem;
    }
});

console.log(res);

var initislRequestToBackend = [
{ id: 12345, car: 'Nissan', Model: 'Almera', RepairDate: new Date('2016-04-06'), Modificator: 'User200' },
{ id: 12346, car: 'Nissan', Model: 'Almera', RepairDate: new Date('2016-04-07'), Modificator: 'User200' },
{ id: 12347, car: 'Toyota', Model: 'Corolla', RepairDate: new Date('2016-04-09'), Modificator: 'User200' },
{ id: 12348, car: 'Toyota', Model: 'Corolla', RepairDate: new Date('2016-04-09'), Modificator: 'User200' },
{ id: 12348, car: 'Toyota', Model: 'Corolla', RepairDate: new Date('2016-04-10'), Modificator: 'User200' }];

这是我的解决方案
我可能对这个问题有不同的解释，但我认为变量名将帮助您理解我的观点

var backendResponse = [{ car: 'Toyota', Model: 'Corolla', RepairDate: new Date('2016-04-09') },
{ car: 'Nissan', Model: 'Almera', RepairDate: new Date('2016-04-07') }];

//

//

你能发布你到目前为止尝试过的代码吗？我们不是一个代码编写服务。我们是一个资源，可以帮助你找出为什么你已经尝试过的代码不能正常工作。要想正常工作，你必须向我们展示你尝试过的代码。等等，我知道。我会在几分钟后更新。这是我的大脑一直在寻找的，但我就是找不到出局。我希望我也能接受其他答案，因为他们也解决了问题，但这是最简单的。谢谢大家。它只按维修日期过滤。谢谢你们，我肯定有解决这个问题的工具。我将研究lodash。嘿，这似乎是一个复杂的解决方案，但我发现只使用过滤功能更有效对于我的情况，我确实从中学会了一种解决问题的新方法，谢谢你花时间来帮助我。是的，我知道，但我的意思只是简单地用for循环使用filter函数来迭代失败。如Durendal的回答所示。