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

问题描述 投票：0回答：2

我有一个名为fieldValues的对象数组，我想删除那些类型不是以A,C,G开头，以utt,alt和mor结尾的对象。我想删除那些类型不是以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"
    }
]
javascript ecmascript-6 es6-promise
2个回答
0
投票

听起来这些条件可以被认为是两个输入到 一个NOT和一个AND门.

const inputs = [["A", "C", "G"], ["utt", "alt", "mor"]];

正如问题中提到的，每个类型的值都在'-'处被拆分

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() Returns true 值，所以我们需要一个NOT门来返回B的所有值(["utt", "alt", "mor"])，即 不符合:

// NOT Gate will return all objects with `type:` `"*-def"` or `"*-kat"`
!B ? 1 : 0

返回的后半部分由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

NOT = !B ? 1 : ... AND = A && B ? 1 : ...(0)

演示

let data = [
{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"}
];

const prefix = ["A", "C", "G"];
const suffix = ["utt", "alt", "mor"];

const NOTxAND = (array, key, termsA, termsB) => {
  const inputs = [termsA, termsB];
  return array.filter(obj => {
    let values = obj[key].split('-');
    let first = inputs[0].includes(values[0]) ? 1 : 0;
    let last = inputs[1].includes(values[1]) ? 1 : 0;
    return !last ? 1 : first && last ? 1 : 0;
  });
}

console.log(JSON.stringify(NOTxAND(data, 'type', prefix, suffix)));
0
投票
langs = [   
    {
        "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"
    }
];

langs.filter( (l) => {
    return !l.type.match(/^[^ACG]-(utt|alt|mor)$/);
});
0
投票

使用

fieldValues.filter(v=>!(!"ACG".includes(v.type[0])&&['mor','utt','alt'].includes(v.type.slice(2))));

0
投票

我试了一下，现在工作正常。这里传递的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 ) );
        },
最新问题
© www.soinside.com 2019 - 2024. All rights reserved.