基于多个搜索词过滤对象数组

Question

假设我有一个搜索词：const searchTerms = ['sarasota', 'fl']

还有一个位置列表，

const selectedRestaurants = [{
  city: "Orlando",
  name: "Dons Food Place",
  state: "FL",
  id: 1
},
{
  city: "Sarasota",
  name: "Rons World",
  state: "FL",
  id: 2
}]

如果我搜索'Sarasota FL'，我希望只返回一个'Sarasota FL'位置。但是如果我基于多个参数（城市和州）进行搜索，则搜索会返回两个位置，因为在第二次迭代期间它与州匹配。

编辑：当我仅搜索'Sarasota'时，我也需要这个功能。

以下是我的代码：

filterBySearchTerm(searchTerms) {
   let searchedRestaurants = [];

      for (var j = 0; j < selectedRestaurants.length; j++) {
        searchTerms.forEach(term => {
          if (term.toLowerCase() === this.state.selectedRestaurants[j].city.toLowerCase()) {
            searchedRestaurants.push(this.state.selectedRestaurants[j])
          }
          if (term.toLowerCase() === this.state.selectedRestaurants[j].state.toLowerCase()) {
            searchedRestaurants.push(this.state.selectedRestaurants[j])
          }
          if (term.toLowerCase() === this.state.selectedRestaurants[j].name.toLowerCase()) {
            searchedRestaurants.push(this.state.selectedRestaurants[j])
          }
        })
      }

      //I use Set to remove duplicates ^^
      searchedRestaurants = [...new Set(searchedRestaurants)]
      
      return searchedRestaurants;
  }

我一直在这个问题上卡了一会儿...有人能帮忙吗？可能不会有什么区别，但我使用的是ReactJS。

- Cody Smith

Answer 1

const selectedRestaurants = [
  {
    city: "Orlando",
    name: "Dons Food Place",
    state: "FL",
    id: 1,
  },
  {
    city: "Sarasota",
    name: "Rons World",
    state: "FL",
    id: 2,
  },
  {
    city: "Sarasota",
    name: "Rons World",
    state: "SL",
    id: 3,
  },
];

function search(searchTerms) {
  let isCity = !!selectedRestaurants.filter((i) =>
    searchTerms.includes(i.city.toLowerCase())
  ).length;

  let isState = !!selectedRestaurants.filter((i) =>
    searchTerms.includes(i.state.toLowerCase())
  ).length;

  return selectedRestaurants.filter((r) => {
    if (isCity && isState) {
      return (
        searchTerms.includes(r.city.toLowerCase()) &&
        searchTerms.includes(r.state.toLowerCase())
      );
    } else {
      return searchTerms.includes(r.city.toLowerCase());
    }
  });

}

// All city match with sarasota
console.log(search( ["sarasota"]));

// All city match with sarasota and state f1
console.log(search( ["sarasota", "fl"]));

- MUHAMMAD ILYAS

---

这非常接近，但现在当我只按一个参数（sarasota）搜索时，什么也没有出现。当我将&&切换为||时，它对于像我在此帖子中拥有的多个术语并不起作用。 - Cody Smith

@CodySmith 在这种情况下，有必要知道筛选器是基于一个属性还是多个属性，这样我们才能轻松地搜索它，更新的答案可能会对您有所帮助。 - MUHAMMAD ILYAS

Answer 2

const restaurants = [
  {
    city: 'Orlando',
    name: 'Dons Food Place',
    state: 'FL',
    id: 1,
  },
  {
    city: 'Sarasota',
    name: 'Rons World',
    state: 'FL',
    id: 2,
  },
];
const searchTerms = ['sarasota', 'fl'];
const lowerCasedTerms = searchTerms.map((term) => term.toLowerCase());
const params = ['city', 'state'];

const result = restaurants.filter((restaurant) =>
  lowerCasedTerms.every((lowerCasedTerm) =>
    params.some((param) => restaurant[param].toLowerCase().includes(lowerCasedTerm)),
  ),
);

console.log(result);

- Alex Chuev

Answer 3

你对这种方法有什么看法？它将所有对象值合并以检查是否包含所有搜索项。

const selectedRestaurants = [
  {
    city: "Orlando",
    name: "Dons Food Place",
    state: "FL",
    id: 1
  },
  {
    city: "Sarasota",
    name: "Rons World",
    state: "FL",
    id: 2
  }
];

const searchTerms = ['sarasota', 'fl'];

const foundRestaurants = selectedRestaurants.filter((restaurant) => {
  const valuesAsString = Object.values(restaurant).join(' ').toLowerCase();
  const allTermsMatching = searchTerms
    .map(term => valuesAsString.includes(term.toLowerCase()))
    .every(match => !!match);
  return allTermsMatching;
});

console.log(foundRestaurants);

- luscala