从递归的对象数中选择一个字段

Question

I am looking for a way using JavaScript / Lodash to retrieve the same hirearchy as the input array of objects but want to retain only selected fields.

I could also formulate this question as doing a deep copy of an array of objects retaining only certain fields.

For example, given the following array:

[
    {
        "id": "q1",
        "text": "Q1 text",
        "children": [
            {
                "id": "q11",
                "text": "t",
                "children": [
                    {
                        "id": "q111",
                        "text": "t"
                    },
                    {
                        "id": "q112",
                        "text": "t"
                    }
                ]
            }
        ]
    },
    {
        "id": "q2",
        "text": "e",
        "children": [
            {
                "id": "q22",
                "text": "e"
            }
        ]
    },
    {
        "id": "q3",
        "text": "e"
    }
]

The output should be as below. This is exactly the same as array of objects above but keeps only id and children's ids. The children can be any level deep.

[
        {
            "id": "q1",
            "children": [
                {
                    "id": "q11",
                    "children": [
                        {
                            "id": "q111",
                        },
                        {
                            "id": "q112"
                        }
                    ]
                }
            ]
        },
        {
            "id": "q2",
            "children": [
                {
                    "id": "q22",
                }
            ]
        },
        {
            "id": "q3"
        }
]

Answer 1

You can make a function that takes an array and maps it to objects with just the id and children . To set the id, just copy the id, to set the children on the returned object pass the children array back into the function recursively:

 let arr = [{"id": "q1","text": "Q1 text","children": [{"id": "q11","text": "t","children": [{"id": "q111","text": "t"},{"id": "q112","text": "t"}]}]},{"id": "q2","text": "e","children": [{"id": "q22","text": "e"}]},{"id": "q3","text": "e"}] const justIDs = (arr) => arr.map(({id, children}) => { let ret = {id} if(children) ret.children = justIDs(children) return ret }) let filtered = justIDs(arr) console.log(filtered) 

Answer 2

Here's a non-recursive approach that uses an explicit stack and a set for fast lookup in cases when you have many keys to prune out. This is a general solution that should work on any keys you throw at it and doesn't mutate the original array.

 const data = [ { "id": "q1", "text": "Q1 text", "children": [ { "id": "q11", "text": "t", "children": [ { "id": "q111", "text": "t" }, { "id": "q112", "text": "t" } ] } ] }, { "id": "q2", "text": "e", "children": [ { "id": "q22", "text": "e" } ] }, { "id": "q3", "text": "e" } ]; const removeKeys = (arr, keys) => { const keep = new Set(keys); const res = []; const stack = [[arr, res]]; while (stack.length) { const [curr, cpy] = stack.pop(); if (Array.isArray(curr)) { curr.forEach((e, i) => { cpy[i] = {}; for (const k in e) { if (keep.has(k)) { cpy[i][k] = e[k]; stack.push([e[k], cpy[i][k]]); } } }); } } return res; }; console.log(JSON.stringify(removeKeys(data, ["id", "children"]), null, 4)); 

Answer 3

and lodash, love lodash, learn lodash ...

function omitKeysDeep(input, keys) {
  if(!_.isArray(keys)) throw new Error('omitKeys expected an array');
  return _.map(input, (elem) => {
    if(elem.children) elem.children = omitKeysDeep(elem.children, keys);
    return _.omit(elem, keys);
  });
}

omitKeysDeep(a, ['text']);

OR... instead of _.omit(..) to remove unwanted keys you could use _.pick(...) to specify only wanted keys:

function pickKeysDeep(input, keys) {
  if(!_.isArray(keys)) throw new Error('pickKeys expected an array');
  return _.map(input, (elem) => {
    if(elem.children) elem.children = pickKeysDeep(elem.children, keys);
    return _.pick(elem, keys);
  });
}

pickKeysDeep(a, ['id', 'children']);

Answer 4

Here's my version which does work recursively.

/**
 * Like _.pick() but will also map over arrays implicitly.
 * ie. path 'a.b.c' will transform {a:[{b:{c:1,d:2}}]} => {a:[{b:{c:1}}]}
 *
 * @param {object} o - Object to copy.
 * @param {string[]} paths - List of paths to include.
 * @returns {mixed} - Copied object.
 */
Utils.pickDeep = (o, paths) => {
    if (Array.isArray(o)) {
        return _.map(o, v=>
            Utils.pickDeep(v, paths));
    }
    else if (null != o && 'object' === typeof o) {
        const result = {};
        for (const path of paths) {
            const parts = path.split('.');
            const part  = parts.shift();
            result[part] = o[part];
            if (parts.length < 1) {
                // do not recurse
            }
            else {
                // recurse
                result[part] = Utils.pickDeep(_.get(o, [part]), [parts.join('.')]);
            }
        }
        return result;
    }
    else {
        return o;
    }
};

and

/**
 * Like _.omit() but will also map over arrays implicitly.
 * ie. path 'a.b.c' will transform {a:[{b:{c:1,d:2}}],e:4} => {a:[{b:{d:2}}],e:4}
 *
 * @param {object} o - Object to copy.
 * @param {string[]} paths - List of paths to exclude.
 * @returns {mixed} - Copied object.
 */
Utils.omitDeep = (o, paths) => {
    if (Array.isArray(o)) {
        return _.map(o, v=>
            Utils.omitDeep(v, paths));
    }
    else if (null != o && 'object' === typeof o) {
        const result = { ...o };
        for (const path of paths) {
            const parts = path.split('.');
            const part  = parts.shift();
            delete result[part];
            if (parts.length < 1) {
                // do not recurse
            }
            else {
                // recurse
                result[part] = Utils.omitDeep(_.get(o, [part]), [parts.join('.')]);
            }
        }
        return result;
    }
    else {
        return o;
    }
};