Javascript 过滤对象数组中的布尔值

我有这样一个数组：

 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}
  }];

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

当我访问b时，我想过滤falsy值，到目前为止，我还没有成功地使用一系列map（）来进行过滤，比如：

 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}
  }];

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

---

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

---

您可以创建一个

getKeysBy（）

函数，该函数接受一个对象和一个谓词，并返回通过谓词检查的键

现在，您可以使用

Array.flatMap（）

和

getKeysBy（）

来获取所有键的数组

const assign=[{“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}]
const getKeysBy=（谓词，obj）=>
Object.entries（obj）
.filter（（[，v]）=>谓词（v））
.map（（[k]）=>k）
const result=appoint.flatMap（o=>getKeysBy（v=>v！==false，o.b））
console.log（result）

您可以首先使用

map

获得一个只包含

b

的新数组，然后使用

reduce

和内部reduce callback使用

for..in

迭代对象并获取为true的键

const指定=[{
a:“只要”，
b:{
欧：错，
h:错，
l:是的
}
},
{
a:“avd”，
b:{
欧：是的，
h:错，
l:是的
}
},
{
a:“作为”，
b:{
欧：是的，
h:错，
l:错
}
}
];
let filtered=appoint.map（函数（项）{
返回项目b；
}).减少（功能（acc、curr）{
for（以当前格式输入键）{
如果（当前[键]）{
附件按钮（按键）
}
}
返回acc；
}, []);
console.log（过滤）

您可以这样做

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": []
    }
]

---

我假设如果没有一个值是真的，您可能需要一个空数组

elem.b.

预期的输出是什么样子的？要详细说明，您想从相关对象中删除任何具有

false

作为值的属性吗？或者创建一个新对象，该对象具有所有属性，除了那些值为

false

的属性之外？请注意，imho，如果前一个名称至少不是

intermediateresult

，则名称

finalresult

不好。接下来，您将添加一个

finalfinalresult

或一个

endresult

，这里的可读性只会下降。这个问题是，您正在映射一个数组，然后过滤一个对象，而对象不能被过滤。结果应该是这样：[l，l，au]这很有用，如果我想过滤成一个数组呢？一个什么数组？具有假值的键名称<代码>常量筛选=[]；bKeys.forEach（key=>{if（！b[key]）filtered.push（key）}）或

const filtered=bKeys.filter（key=>！b[key]）