ES6 фильтр и найти те же предметы объекта

Question

У меня есть вопрос о фильтрации с ES6:

У меня есть некоторые данные, которые мне нужно отфильтровать с другими объектами

Мои данные:

let data = [
    {
        id: 1,
        names: ['A', 'B']
    },
    {
        id: 2,
        names: ['C']
    }
]

Iесть другой объект как:

let nameValues = [
    {
        name: 'A',
        selected: false
    },
    {
        name: 'B',
        selected: true
    },
    {
        name: 'C',
        selected: false
    },
    {
        name: 'D',
        selected: true
    }
]

Сначала я получаю selected == true элементов в selectedNames с:

let selectedNames = nameValues.filter(function(item) {
    return item.selected
})

, и я получаю результат:

selectedNames = [
    {
        name: 'A',
        selected: true
    },
    {
        name: 'D',
        selected: true
    }
]

и мне нужно сравнить его с data, получая предметы в data, где item.names содержит selectedNames.

Мне не нужно точное совпадение - мне нужны элементы в объекте данных, которые имеют в своих именах массив мои значения selectedNames object name:

В этом случае мне нужнополучить, как этот результат моего объекта данных:

Здесь элемент не соответствует 100% с моим selectedNames, но у него есть одно из этих значений, которое я ищу

let data = [
    {
        id: 1,
        names: ['A', 'B']
    },
]

Каксделать это с es6?

Answer 1

Ваш подход был правильным. Я просто сохранил selectedNames в виде массива для облегчения поиска.

В файле data.filter вы можете проверить, доступно ли имя some в массиве selectedNames

let data = [
    {
        id: 1,
        names: ['A', 'B']
    },
    {
        id: 2,
        names: ['C']
    }
]

let nameValues = [
    {
        name: 'A',
        selected: false
    },
    {
        name: 'B',
        selected: true
    },
    {
        name: 'C',
        selected: false
    },
    {
        name: 'D',
        selected: true
    }
]

let selectedNames = nameValues.filter(item => item.selected).map(x => x.name);

let result = data.filter(obj => obj.names.some(name => selectedNames.includes(name)));

console.log(result);

Answer 2

Очевидно, что имена будут повторяться в объекте данных

const nameValues = [
  {
    name: "A",
    selected: false
  },
  {
    name: "B",
    selected: true
  },
  {
    name: "C",
    selected: true
  },
  {
    name: "D",
    selected: false
  }
];

let data = [
  {
    id: 1,
    names: ["A", "B"]
  },
  {
    id: 2,
    names: ["C"]
  },
  {
    id: 3,
    names: ["C", "D"]
  }
];

let selectedNames = nameValues
  .filter(item => item.selected)
  .reduce((acc, item) => {
    const selected = data.filter(dataItem => {
      return (
        dataItem.names.includes(item.name) &&
        !acc.some(i => i.id === dataItem.id)
      );
    });
    return [...acc, ...selected];
  }, []);

console.log(selectedNames);

Answer 3

Всего два цикла, например, с использованием reduce:

let data = [
    {
        id: 1,
        names: ['A', 'B']
    },
    {
        id: 2,
        names: ['C']
    }
]

let selectedNames = [
    {
        name: 'A',
        selected: true
    },
    {
        name: 'D',
        selected: true
    }
]

selectedNames.reduce((result, selectedName) => {
    data.forEach(item => {
        if (item.names.includes(selectedName.name)) {
            result.push(item)
        }
    })
    return result
}, [])

Answer 4

Вы можете использовать вложенный цикл for для обоих массивов и проверить, входит ли каждое выбранное имя в какой-либо из элементов данных:

const data = [
    { id: 1, names: ['A', 'B'] },
    { id: 2, names: ['C'] },
]

const selectedNames = [
    { name: 'A', selected: true },
    { name: 'D', selected: true },
    { name: 'B', selected: true },
]

const result = [];
for (const element of data) {
  for (const name of selectedNames) {
    if (element.names.includes(name.name) && !result.includes(element)) {
      result.push(element);
    }
  }
}

console.log( result );