在javascript中使用多个条件过滤arrray_Javascript_Ecmascript 6

在javascript中使用多个条件过滤arrray

javascript ecmascript-6

在javascript中使用多个条件过滤arrray,javascript,ecmascript-6,Javascript,Ecmascript 6,我有一个名为FieldValue的对象数组。我想删除类型不以A、C、G开头，以utt、alt和mor结尾的对象 [ { "language": "language1", "type": "A-def" }, { "language": "language1", "type": "B-def" }, { "language": "language3", "

我有一个名为FieldValue的对象数组。我想删除类型不以A、C、G开头，以utt、alt和mor结尾的对象

 [   
    {
        "language": "language1",
        "type": "A-def"
    },
    {
        "language": "language1",
        "type": "B-def"
    },
    {
        "language": "language3",
        "type": "C-def"
    },
    {
        "language": "language4",
        "type": "D-def"
    },
    {
        "language": "language5",
        "type": "E-def"
    },
    {
        "language": "language6",
        "type": "F-def"
    },
    {
        "language": "language7",
        "type": "G-def"
    },
    {
        "language": "language1",
        "type": "A-utt"
    },
    {
        "language": "language1",
        "type": "B-utt"
    },
    {
        "language": "language3",
        "type": "C-utt"
    },
    {
        "language": "language4",
        "type": "D-utt"
    },
    {
        "language": "language5",
        "type": "E-utt"
    },
    {
        "language": "language6",
        "type": "F-utt"
    },
    {
        "language": "language7",
        "type": "G-utt"
    },
    {
        "language": "language1",
        "type": "A-kat"
    },
    {
        "language": "language1",
        "type": "B-kat"
    },
    {
        "language": "language3",
        "type": "C-kat"
    },
    {
        "language": "language4",
        "type": "D-kat"
    },
    {
        "language": "language5",
        "type": "E-kat"
    },
    {
        "language": "language6",
        "type": "F-kat"
    },
    {
        "language": "language7",
        "type": "G-kat"
    },
    {
        "language": "language1",
        "type": "A-alt"
    },
    {
        "language": "language1",
        "type": "B-alt"
    },
    {
        "language": "language3",
        "type": "C-alt"
    },
    {
        "language": "language4",
        "type": "D-alt"
    },
    {
        "language": "language5",
        "type": "E-alt"
    },
    {
        "language": "language6",
        "type": "F-alt"
    },
    {
        "language": "language7",
        "type": "G-alt"
    },
    {
        "language": "language1",
        "type": "A-mor"
    },
    {
        "language": "language1",
        "type": "B-mor"
    },
    {
        "language": "language3",
        "type": "C-mor"
    },
    {
        "language": "language4",
        "type": "D-mor"
    },
    {
        "language": "language5",
        "type": "E-mor"
    },
    {
        "language": "language6",
        "type": "F-mor"
    },
    {
        "language": "language7",
        "type": "G-mor"
    }
]

我试图通过用“-”拆分类型来过滤数组，并找到不应该包含的对象，然后从数组中拼接。但是我没有得到预期的结果

过滤后的预期结果：-

[   
    {
        "language": "language1",
        "type": "A-def"
    },
    {
        "language": "language1",
        "type": "B-def"
    },
    {
        "language": "language3",
        "type": "C-def"
    },
    {
        "language": "language4",
        "type": "D-def"
    },
    {
        "language": "language5",
        "type": "E-def"
    },
    {
        "language": "language6",
        "type": "F-def"
    },
    {
        "language": "language7",
        "type": "G-def"
    },
    {
        "language": "language1",
        "type": "A-utt"
    },
    {
        "language": "language3",
        "type": "C-utt"
    },
    {
        "language": "language5",
        "type": "E-utt"
    },
    {
        "language": "language7",
        "type": "G-utt"
    },
    {
        "language": "language1",
        "type": "A-kat"
    },
    {
        "language": "language1",
        "type": "B-kat"
    },
    {
        "language": "language3",
        "type": "C-kat"
    },
    {
        "language": "language4",
        "type": "D-kat"
    },
    {
        "language": "language5",
        "type": "E-kat"
    },
    {
        "language": "language6",
        "type": "F-kat"
    },
    {
        "language": "language7",
        "type": "G-kat"
    },
    {
        "language": "language1",
        "type": "A-alt"
    },
    {
        "language": "language3",
        "type": "C-alt"
    },
    {
        "language": "language7",
        "type": "G-alt"
    },
    {
        "language": "language1",
        "type": "A-mor"
    },
    {
        "language": "language3",
        "type": "C-mor"
    },
    {
        "language": "language7",
        "type": "G-mor"
    }
]

使用

fieldValues.filter（v=>！（！“ACG”.includes（v.type[0]）&&&['mor'、'utt'、'alt']）。includes（v.type.slice（2））
使用
fieldValues.filter（v=>！（！“ACG”.includes（v.type[0]）&&&['mor'、'utt'、'alt']）。includes（v.type.slice（2））
听起来这些条件可以看作是两个输入
如问题所述，每种类型的值在“-”处分开
let values = object.type.split('-'); // ex. ['A', 'def']

这是处理两个输入的方式：
let A = inputs[0].includes(values[0]) ? 1 : 0;
let B = inputs[1].includes(values[1]) ? 1 : 0;

.filter（）
返回true
值，因此我们需要一个非门来返回所有不匹配的B（[“utt”、“alt”、“mor”]
）值：
// NOT Gate will return all objects with `type:` `"*-def"` or `"*-kat"`
!B ? 1 : 0

返回的后半部分由AND门过滤，AND门要求a（[“a”、“C”、“G”]
）和B的值匹配：
/* 
AND Gate will only return combinations that include both 
A (`["A", "C", "G"]`) and B (`["utt", "alt", "mor"]`) 
*/
A && B ? 1 : 0

最后，返回的对象将由充当NOT和and门的两个链式三元组确定：
return !B ? 1 : A && B ? 1: 0



演示

let数据=[
{语言：“语言1”，类型：“A-def”}，{语言：“语言1”，类型：“B-def”}，{语言：“语言3”，类型：“C-def”}，{语言：“语言4”，类型：“D-def”}，{语言：“语言5”，类型：“E-def”}，{语言：“语言6”，类型：“F-def”}，{语言：“语言7”，类型：“G-def”}，{语言：“语言1”，类型：“A-utt”}，{语言：“语言1”，类型：“B-utt”}，{语言：“语言3”，类型：“C-utt”}，{语言：“语言4”，类型：“D-utt”}，{语言：“语言5”，类型：“E-utt”}，{语言：“语言6”，类型：“F-utt”}，{语言：“语言7”，类型：“G-utt”}，{语言：“语言1”，类型：“A-kat”}，{语言：“语言1”，类型：“B-kat”}，{语言：“语言3”，类型：“C-kat”}，{语言：“语言4”，类型：“D-kat”}，{“语言6”，类型：“F-kat”}，{语言：“语言7”，类型：“G-kat”}，{语言：“语言1”，类型：“A-alt”}，{语言：“语言1”，类型：“B-alt”}，{语言：“语言3”，类型：“C-alt”}，{语言：“语言4”，类型：“D-alt”}，{语言：“语言5”，类型：“E-alt”}，{语言：“语言6”，类型：“F-alt”}，{语言：“语言7”，类型：“G-alt”}，{语言：“A-alt 1”，类型：{，{语言：“语言1”，类型：“B-mor”}，{语言：“语言3”，类型：“C-mor”}，{语言：“语言4”，类型：“D-mor”}，{语言：“语言5”，类型：“E-mor”}，{语言：“语言6”，类型：“F-mor”}，{语言：“语言7”，类型：“G-mor”}
];
常量前缀=[“A”、“C”、“G”]；
常量后缀=[“utt”、“alt”、“mor”]；
常量NOTxAND=（数组、键、termsA、termsB）=>{
常量输入=[termsA，termsB]；
返回数组.filter（obj=>{
让value=obj[key].split（'-'）；
设第一个=输入[0]。包括（值[0]）？1:0；
let last=输入[1]。包括（值[1]）？1:0；
return！last？1:first和last？1:0；
});
}
log（JSON.stringify（NOTxAND（数据，'type'，前缀，后缀））；
听起来这些条件可以看作是两个输入
如问题所述，每种类型的值在“-”处分开
let values = object.type.split('-'); // ex. ['A', 'def']

这是处理两个输入的方式：
let A = inputs[0].includes(values[0]) ? 1 : 0;
let B = inputs[1].includes(values[1]) ? 1 : 0;

.filter（）
返回true
值，因此我们需要一个非门来返回所有不匹配的B（[“utt”、“alt”、“mor”]
）值：
// NOT Gate will return all objects with `type:` `"*-def"` or `"*-kat"`
!B ? 1 : 0

返回的后半部分由AND门过滤，AND门要求a（[“a”、“C”、“G”]
）和B的值匹配：
/* 
AND Gate will only return combinations that include both 
A (`["A", "C", "G"]`) and B (`["utt", "alt", "mor"]`) 
*/
A && B ? 1 : 0

最后，返回的对象将由充当NOT和and门的两个链式三元组确定：
return !B ? 1 : A && B ? 1: 0



演示

let数据=[
{语言：“语言1”，类型：“A-def”}，{语言：“语言1”，类型：“B-def”}，{语言：“语言3”，类型：“C-def”}，{语言：“语言4”，类型：“D-def”}，{语言：“语言5”，类型：“E-def”}，{语言：“语言6”，类型：“F-def”}，{语言：“语言7”，类型：“G-def”}，{语言：“语言1”，类型：“A-utt”}，{语言：“语言1”，类型：“B-utt”}，{语言3:{“，类型：“C-utt”}，{语言：“语言4”，类型：“D-utt”}，{语言：“语言5”，类型：“E-utt”}，{语言：“语言6”，类型：“F-utt”}，{语言：“语言7”，类型：“G-utt”}，{语言：“语言1”，类型：“A-kat”}，{语言：“语言1”，类型：“B-kat”}，{语言：“语言3”，类型：“C-kat”}，{语言：“语言4”，类型：“D-kat”}，{，{语言：“语言6”，类型：“F-kat”}，{语言：“语言7”，类型：“G-kat”}，{语言：“语言1”，类型：“A-alt”}，{语言：“语言1”，类型：“B-alt”}，{语言：“语言3”，类型：“C-alt”}，{语言：“语言4”，类型：“D-alt”}，{语言：“语言5”，类型：“E-alt”}，{语言：“语言6”，类型：“F-alt”}，{语言：“语言7”，类型：“G-alt”}，{语言：“语言1”，类型：“A-mor”}，{语言：“语言1”，类型：“B-mor”}，{语言：“语言3”，类型：“C-mor”}，{语言：“语言4”，类型：“D-mor”}，{语言：“语言5”，类型：“E-mor”}，{语言：“语言6”，类型：“F-mor”}，{语言：“语言7”，类型：“G-mor”}
];
常量前缀=[“A”、“C”、“G”]；
常量后缀=[“utt”、“alt”、“mor”]；
常量NOTxAND=（数组、键、termsA、termsB）=>{
常量输入=[termsA，termsB]；
返回数组.filter（obj=>{
让value=obj[key].split（'-'）；
设第一个=输入[0]。包括（值[0]）？1:0；
let last=输入[1]。包括（值[1]）？1:0；
return！last？1:first和last？1:0；
});
}
console.log（JSON.stringify（NOTxAND（data，'type'，prefix，suffix））；
我已经尝试过这个方法，现在效果很好。这里filteredArray包含了上面提到的数组。但是我认为可以用更好的方法来完成
filterEntries(filteredArray){
            var filterValues=[];
            var filterInvalidEntries=[];
            var languageCode=['A','C','G']
            var entries=['utt','alt','mor'];
            entries.forEach((entry)=>{
                filterValues=filteredArray.filter(x=>x.type.split('-')[1]==entry);
                filterInvalidEntries.push(...filterValues.filter((val) => languageCode.indexOf(val.type.split('-')[0])== -1));
            });
            filteredArray = filteredArray.filter( ( el ) => !filterInvalidEntries.includes( el ) );
        },

我已经试过了，现在效果很好。这里filteredArray包含了上面提到的数组。但是我认为可以用更好的方法来完成
filterEntries(filteredArray){
            var filterValues=[];
            var filterInvalidEntries=[];
            var languageCode=['A','C','G']
            var entries=['utt','alt','mor'];
            entries.forEach((entry)=>{
                filterValues=filteredArray.filter(x=>x.type.split('-')[1]==entry);
                filterInvalidEntries.push(...filterValues.filter((val) => languageCode.indexOf(val.type.split('-')[0])== -1));
            });
            filteredArray = filteredArray.filter( ( el ) => !filterInvalidEntries.includes( el ) );
        },

将JavaScript添加到post中，请参阅如何生成。在筛选函数中使用正则表达式。如果不起作用，请在此处发布您的尝试。@Chetna您的预期结果似乎与yo不匹配