фильтрация логических значений внутри массива объектов

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

Вы можете создать функцию getKeysBy(), которая принимает объект и предикат и возвращает ключи, которые проходят проверку предикатом.

Теперь вы можете использовать Array.flatMap() с getKeysBy(), чтобы получить массив всех ключей.

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 getKeysBy = (predicate, obj) => 
  Object.entries(obj)
  .filter(([, v]) => predicate(v))
  .map(([k]) => k)
  
const result = appoint.flatMap(o => getKeysBy(v => v !== false, o.b))

console.log(result)

Answer 2

Вы можете сначала использовать map, чтобы получить новый массив, который содержит только b, затем использовать 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 3

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

Я предполагаю, что вам может понадобиться пустой массив, если ни одно из значений не является истинным.