Question

此代码段仅用于使用字符串值过滤对象数组。

那么我如何使代码片段满足嵌套对象的需求，以便它既可以过滤对象数组又可以过滤其中的嵌套对象？

mainLogic = (_data, search) => {
   //_data is an array of objects
    let _allsearch = search.trim().toLowerCase();
    if (_allsearch.length > 0) {
      _data = Object.values(_data).filter((obj) => {
        return Object.keys(obj).some((key) => {
       // the code usually breaks at this point. when it encounters a nested object
            return obj[key].toLowerCase().includes(_allsearch); 
        });
      });
    }
    return _data;

  };

这是一个示例对象：

let _data = [
  {
    id: "1",
    firstname: "Precious",
    lastname: "Same",
    age: "29",
    state: "Abia",
    email: "sam@gmail.com",
    country: "Michigan",
    town:{
      name:"Jos"
    }
  },
  {
    id: "2",
    firstname: "Bolu",
    lastname: "Joke",
    age: "32",
    state: "Ogun",
    email: "bolu.joke@outlook.com",
    country: "america",
    town:{
      name:"California"
    }
  }
]

调用函数时：

this.mainLogic(_data, "california")

这是我的期望：

[
  {
    id: "2",
    firstname: "Bolu",
    lastname: "Joke",
    age: "32",
    state: "Ogun",
    email: "bolu.joke@outlook.com",
    country: "america",
    town:{
      name:"Califonia"
    }
  }
]

Answer 1

免责声明：代码主要来源于here

我只是将对象展平，因此每个属性都处于同一级别，并且您不需要照顾嵌套的对象。之后，以与现在相同的方式进行过滤。（保留验证和错误检查功能，您可以修改代码）

let data = [{
    id: "1",
    firstname: "Precious",
    lastname: "Same",
    age: "29",
    state: "Abia",
    email: "sam@gmail.com",
    country: "Michigan",
    town: {
      name: "Jos"
    }
  },
  {
    id: "2",
    firstname: "Bolu",
    lastname: "Joke",
    age: "32",
    state: "Ogun",
    email: "bolu.joke@outlook.com",
    country: "america",
    town: {
      name: "California"
    }
  }
];

function flattenObject(ob) {
  var toReturn = {};

  for (var i in ob) {
    if (!ob.hasOwnProperty(i)) continue;

    if ((typeof ob[i]) == 'object') {
      var flatObject = flattenObject(ob[i]);
      for (var x in flatObject) {
        if (!flatObject.hasOwnProperty(x)) continue;

        toReturn[i + '.' + x] = flatObject[x];
      }
    } else {
      toReturn[i] = ob[i];
    }
  }
  return toReturn;
};

function mainLogic(data, search) {
  for (let obj of data) {
    flattened = flattenObject(obj);
    if (Object.values(flattened).includes(search)) return obj;
  };
};

console.log(mainLogic(data, "California"))

Answer 2

必须平整对象，然后才能轻松过滤数组：

_data.forEach((el, i) => {
  let flattenedObject = flatObject(el);
  if (Object.values(flattenedObject).includes(searchWord))
    _data = _data.filter((f, ind) => ind == i);
})

一个例子：

let _data = [
      {
        id: "1",
        firstname: "Precious",
        lastname: "Same",
        age: "29",
        state: "Abia",
        email: "sam@gmail.com",
        country: "Michigan",
        town:{
          name:"Jos"
        }
      },
      {
        id: "2",
        firstname: "Bolu",
        lastname: "Joke",
        age: "32",
        state: "Ogun",
        email: "bolu.joke@outlook.com",
        country: "america",
        town:{
          name:"California"
        }
      }
    ];


const flatObject = (obj) => {
  return Object.assign(
    {},
    ...function _flatten(o) {
      return [].concat(...Object.keys(o)
        .map(k =>
          typeof o[k] === 'object' ?
            _flatten(o[k]) :
            ({[k]: o[k]})
        )
      );
    }(obj)
  )
}


let searchWord = 'California';

_data.forEach((el, i) => {
  let flattenedObject = flatObject(el);
  if (Object.values(flattenedObject).includes(searchWord))
    _data = _data.filter((f, ind) => ind == i);
})


console.log(_data);

在JavaScript中过滤嵌套对象

2 个答案: