Question

我有一个像这样的数组：

 const appoint =[
  { a: "asas",
    b:{au: false, h:false,l:true}
  },
  { a: "avd",
    b:{au: true, h:false,l:true}
  },
  { a: "as", b:{au: true, h:false,l:false}
  }];

当我访问b时，我想过滤伪造的值，到目前为止，我对诸如此类的map（）系列还没有成功实现：

const result = appoint.map(elem => elem.b.)
const finalresult = result.map(
         item =>item.filter(
              (item, value)=> item[value] === false )
          )

Answer 1

elem.b是一个对象，而不是数组，因此不能在其上使用过滤器。您可以执行以下操作：

const bArray = appoint.map(elem => elem.b)
const finalresult = bArray.map(b => {
  bKeys = Object.keys(b)
  const filtered = {}
  bKeys.forEach(key => {
    if (!b[key]) filtered[key] = false
  })
  return filtered
})

Answer 2

您可以创建一个function function0(sizevar) { s = sizevar * 2; return function function1() { console.log(s); console.log(sizevar); }; } var size12 = function0(12); var size14 = function0(14); size12() size14()函数，该函数接受一个对象和一个谓词，并返回通过谓词检查的键。

现在，您可以将getKeysBy()与Array.flatMap()结合使用，以获取所有键的数组。

getKeysBy()

Answer 3

您可以首先使用map获取仅包含b的新数组，然后使用reduce并在内部reduce回调中使用for..in来迭代对象并获取正确的键

const appoint = [{
    a: "asas",
    b: {
      au: false,
      h: false,
      l: true
    }
  },
  {
    a: "avd",
    b: {
      au: true,
      h: false,
      l: true
    }
  },
  {
    a: "as",
    b: {
      au: true,
      h: false,
      l: false
    }
  }
];


let filtered = appoint.map(function(item) {
  return item.b;
}).reduce(function(acc, curr) {
  for (let keys in curr) {
    if (curr[keys]) {
      acc.push(keys)
    }
  }

  return acc;
}, []);
console.log(filtered)

Answer 4

您可以这样做

let array = [{
    a: "asas",
    b: {
        au: false,
        h: false,
        l: true
    }
}, {
    a: "avd",
    b: {
        au: true,
        h: false,
        l: true
    }
}, {
    a: "as",
    b: {
        au: true,
        h: false,
        l: false
    }
}, {
    a: "ab",
    b: {
        au: false,
        h: false,
        l: false
    }
}]

let output = array.filter((element) => {
    let keys = Object.keys(element.b)
    element.b = keys.filter((key) => {
        if (element.b[key]) {
            return key
        }
    })
    if (!Object.keys(element.b).length) {
        element.b = []
    }
    return element;
})
console.log(output)

这会给你

[
    {
        "a": "asas",
        "b": [
            "l"
        ]
    },
    {
        "a": "avd",
        "b": [
            "au",
            "l"
        ]
    },
    {
        "a": "as",
        "b": [
            "au"
        ]
    },
    {
        "a": "ab",
        "b": []
    }
]

如果所有值都不为真，我假设您可能需要一个空数组。

在对象数组中过滤布尔值

4 个答案: