Question

出于某种原因，我有一个看起来像这样的对象：

const obj = [{
    slug: 'something',
    nestedSlug: [{
      slug: 'n1',
      deeplyNestedSlug: [{
          slug: 'n11'
        },
        {
          slug: 'n21'
        }
      ]
    }]
  },
  {
    slug: 'nothing',
    nestedSlug: [{
      slug: 'n2',
      deeplyNestedSlug: [{
          slug: 'n12'
        },
        {
          slug: 'n22'
        }
      ]
    }]
  },
  {
    slug: 'anything',
    nestedSlug: [{
      slug: 'n3',
      deeplyNestedSlug: [{
          slug: 'n13'
        },
        {
          slug: 'n23'
        }
      ]
    }]
  }
]

我想要这样的结果：['n1', 'n22', 'n3']。我尝试了以下方法：

const requiredItems = ['n1', 'n22', 'n3']
let collection = []
const obj = [{
    slug: 'something',
    nestedSlug: [{
      slug: 'n1',
      deeplyNestedSlug: [{
          slug: 'n11'
        },
        {
          slug: 'n21'
        }
      ]
    }]
  },
  {
    slug: 'nothing',
    nestedSlug: [{
      slug: 'n2',
      deeplyNestedSlug: [{
          slug: 'n12'
        },
        {
          slug: 'n22'
        }
      ]
    }]
  },
  {
    slug: 'anything',
    nestedSlug: [{
      slug: 'n3',
      deeplyNestedSlug: [{
          slug: 'n13'
        },
        {
          slug: 'n23'
        }
      ]
    }]
  }
]

let parentIndex,
  childIndex

requiredItems.map(x => {
  const grandParent = obj.nestedSlug.findIndex((y, i) => {
    if (y.slug === x) {
      parentIndex = i
      return true
    } else {
      return false
    }
  })

  if (grandParent !== -1) {
    collection.push(obj.nestedSlug[parentIndex])
  } else {
    const children = obj.nestedSlug[i].deeplyNestedSlug.findIndex((z, i) => {
      if (z.slug === x) {
        childIndex = i
        return true
      } else {
        return false
      }
    })

    if (children !== -1) {
      collection.push(obj.nestedSlug[parentIndex].deeplyNestedSlug[childIndex])
    }
  }
})

console.log(collection)

...这当然根本不起作用。请帮忙！

Answer 1

我建议对嵌套数组使用相同的名称，例如nested，以便更容易访问，并且因为此属性是预先已知的。

然后，您可以在外层迭代对象数组，并对照该对象检查给定的slug。如果相等，则将对象分配给result变量，否则尝试从nested获取对象。

在Array#some内，重用作为短路的返回值。

最后，返回找到的结果。

function getObject(array, slug) {
    var result;
    array.some(o => result = o.slug === slug && o || getObject(o.nested || [], slug));
    return result;
}

var slugs = ['n1', 'n22', 'n3'],
    data = [{ slug: 'something', nested: [{ slug: 'n1', nested: [{ slug: 'n11' }, { slug: 'n21' }] }] }, { slug: 'nothing', nested: [{ slug: 'n2', nested: [{ slug: 'n12' }, { slug: 'n22' }] }] }, { slug: 'anything', nested: [{ slug: 'n3', nested: [{ slug: 'n13' }, { slug: 'n23' }] }] }],
    collection = slugs.map(getObject.bind(null, data));

console.log(collection);

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

Javascript-深度过滤数组

2 个答案: