Фильтровать массив, используя несколько условий в javascript

Question

У меня есть массив объектов с именем fieldValues. Я хочу удалить объекты, тип которых не начинается с 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"
    }
]

Answer 1

Я пробовал это, и теперь он работает нормально. Здесь FilterArray содержит массив, упомянутый выше. Но я думаю, что это можно сделать лучше.

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 ) );
        },

Answer 2

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)$/);
});

Answer 3

Похоже, что условия можно считать двумя входными данными для 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() возвращает true значения, поэтому нам понадобится НЕ Gate для возврата всех значений 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

---

Демо

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)));

Answer 4

использование

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