在对象数组中过滤对象数组

Question

我在试着过滤这个json。

这是json

const json = {
  address: "fdqn",
  pDet: [
    {
      pNam: "pnam1",
      pMem: [
        {
          mIP: "1234",  // search this string '1234'
          gp: "gp1"
        }, {
          mIP: "567", 
          gp: "gp2"
        }, {
          mIP: "890", 
          gp: "gp3"
        }
      ]
    },
    {
      pNam: "pnam1",
      pMem: [
        {
          mIP: "4567", 
          gp: "gp5"
        }, {
          mIP: "5674", 
          gp: "gp7"
        }
      ]
    }
  ]
}

我需要使用mIP = "1234"进行过滤，最后的输出应该是。

const json = {
    address: "fdqn",
    pDet: [
      {
        pNam: "pnam1",
        pMem: [
          {
            mIP: "1234", 
            gp: "gp1"
          }
        ]
      }
    ]
  }

我尝试了过滤器和一些，但似乎我需要在过滤器内迭代。如有任何意见将不胜感激。

Answer 1

利用flatMap仿真filter_map在其他语文中的行为，可以得到如下结果：

​

const json = {address:"fdqn",pDet:[{pNam:"pnam1",pMem:[{mIP:"1234",gp:"gp1"},{mIP:"567",gp:"gp2"},{mIP:"890",gp:"gp3"}]},{pNam:"pnam1",pMem:[{mIP:"4567",gp:"gp5"},{mIP:"5674",gp:"gp7"}]}]};

const search = "1234";

const result = {
    address: json.address,
    // check if there is any match in this pMem
    pDet: json.pDet.flatMap(({ pMem }) => pMem.some(({ mIP }) => mIP === search)
        ? [pMem.filter(({ mIP }) => mIP === search)] // if there is, return filtered array
        : [] // otherwise, return nothing
    ),
};

console.log(result);

​

Answer 2

您可以像这样使用array.reduce()和array.filter()。

​

const json = { address: "fdqn", pDet: [{ pNam: "pnam1", pMem: [{ mIP: "1234", gp: "gp1" }, { mIP: "567", gp: "gp2" }, { mIP: "890", gp: "gp3" }] }, { pNam: "pnam1", pMem: [{ mIP: "4567", gp: "gp5" }, { mIP: "5674", gp: "gp7" }] } ] }

const newJSON = {
    address: json.address,
    pDet: json.pDet.reduce((newArr, obj) => {
        const pMem = obj.pMem.filter(obj2 => obj2.mIP === '1234')
        if (pMem.length) newArr.push({
            pNam: obj.pNam,
            pMem
        })
        return newArr
    }, [])
}

console.log(newJSON)

​

在一个函数中，它可能如下所示：

​

const json = { address: "fdqn", pDet: [{ pNam: "pnam1", pMem: [{ mIP: "1234", gp: "gp1" }, { mIP: "567", gp: "gp2" }, { mIP: "890", gp: "gp3" }] }, { pNam: "pnam1", pMem: [{ mIP: "4567", gp: "gp5" }, { mIP: "5674", gp: "gp7" }] } ] }

function filterArray(jsonObj, searchStr) {
    return {
        address: json.address,
        pDet: json.pDet.reduce((newArr, obj) => {
            const pMem = obj.pMem.filter(obj2 => obj2.mIP === search)
            if (pMem.length) newArr.push({
                pNam: obj.pNam,
                pMem
            })
            return newArr
        }, [])
    }
}

const newJSON = filterArray(json, '1234')

console.log( newJSON )

​

Answer 3

类似于来自@猫的答案中的技术，虽然更通用，但我使用了一个filterMap。在我的例子中，我抓取了一个可重用的函数--我手头有。看起来是这样的：

​

const filterMap = (f, m) => (xs) => xs .flatMap (x => f (x) ? [m (x)] : [])

const searchMIP = ({pDet, ...rest}, query) => ({
  ...rest,
  pDet: filterMap (
    ({pMem}) => pMem .some (({mIP}) => mIP == query),
    ({pMem, ...rest}) => ({...rest, pMem: pMem .filter (({mIP}) => mIP == query)})
  ) (pDet)
})

const obj = {address: "fdqn", pDet: [{pNam: "pnam1", pMem: [{mIP: "1234", gp: "gp1"}, {mIP: "567", gp: "gp2"}, {mIP: "890", gp: "gp3"}]}, {pNam: "pnam1", pMem: [{mIP: "4567", gp: "gp5"}, {mIP: "5674", gp: "gp7"}]}]}

console .log (searchMIP (obj, '1234'))

​

但我对此并不满意，因为filterMap通常的优点之一是它只扫描一次列表。但是在这里，我们使用some在filter部分执行，在map部分使用filter再次执行。

因此，这里有一种稍微不同的方法，仍然使用flatMap来做类似的事情，但是只过滤一次，并使用结果的length来决定我们是否保留对象：

​

const searchMIP = ({pDet, ...rest}, query) => ({
  ...rest,
  pDet: pDet .flatMap (
    ({pMem, kids = pMem .filter (({mIP}) => mIP == query), ...rest}) => kids .length ? [({
      ...rest, 
      pMem: pMem .filter (({mIP}) => mIP == query)
    })] : [] 
  )
})

const obj = {address: "fdqn", pDet: [{pNam: "pnam1", pMem: [{mIP: "1234", gp: "gp1"}, {mIP: "567", gp: "gp2"}, {mIP: "890", gp: "gp3"}]}, {pNam: "pnam1", pMem: [{mIP: "4567", gp: "gp5"}, {mIP: "5674", gp: "gp7"}]}]}

console .log (searchMIP (obj, '1234'))

.as-console-wrapper {max-height: 100% !important; top: 0}

​

这与来自用户@路多芬的答案更相似，但没有可变累加器，而且还是稍微通用一些。