如何深入删除对象中的键？

Question

我从一个有一些怪癖的API返回这个json对象，我想对它进行规范化，这样我就可以为每个响应处理相同的输入。这意味着摆脱多余的键：

响应：

{
  _links: {...},
  _embedded: {
    foo: [
      {
        id: 2,
        _embedded: {
          bar: []
        }
      }
    ]
  }
}

所以我想删除所有_embedded键并将其展平，如下所示：

{
  _links: {...},
  foo: [
    {
      id: 2,
      bar: []
    }
  ]
}

这就是我目前所拥有的，但它只适用于顶层，而且我认为它不会与数组配合使用。

_.reduce(temp1, function(accumulator, value, key) {
  if (key === '_embedded') {
    return _.merge(accumulator, value);
  }
  return accumulator[key] = value;
}, {})

Answer 1

一旦看到以_开头的密钥，就会递归所有密钥的递归 只需删除它。

的 Code:

var
// The keys we want to remove from the Object
        KEYS_TO_REMOVE = ['_embedded'],

// The data which we will use
        data = {
            _links: {'a': 1},
            _embedded: {
                foo: [
                    {
                        id: 2,
                        _embedded: {
                            bar: []
                        }
                    },
                    {
                        id: 3,
                        _embedded: {
                            bar: [
                                {
                                    id: 4,
                                    _embedded: {
                                        bar: []
                                    }
                                }
                            ]
                        }
                    }
                ]
            }
        };

/**
 * Flatten the given object and remove the desired keys if needed
 * @param obj
 */
function flattenObject(obj, flattenObj) {

    var key;

    // Check to see if we have flatten obj or not
    flattenObj = flattenObj || {};

    // Loop over all the object keys and process them
    for (key in obj) {

        // Check that we are running on the object key
        if (obj.hasOwnProperty(key)) {

            // Check to see if the current key is in the "black" list or not
            if (KEYS_TO_REMOVE.indexOf(key) === -1) {

                // Process the inner object without this key
                flattenObj[key] = flattenObject(obj[key], flattenObj[key]);
            } else {
                flattenObject(obj[key], flattenObj);
            }

        }
    }

    return flattenObj;


}

console.log(flattenObject(data));

Answer 2

所以，基本上你已经拥有了所需的几乎所有代码。我们所要做的就是将它包装在一个函数中，以便我们可以使用递归。您将看到我们只添加一个检查以查看它是否是一个对象，如果是，我们已经有一个知道如何展平该对象的函数，所以我们只需要用关键字再次调用它。我们需要压扁。

function flatten(temp1) {  // Wrap in a function so we can use recursion
  return _.reduce(temp1, function(accumulator, value, key) {
    if (key === '_embedded') {
      return _.merge(accumulator, value);
    } else if (value !== null && typeof value === 'object') // Check if it's another object
      return _.merge(accumulator, flatten(value)) // Call our function again
    return accumulator[key] = value;
  }, {})
}

我可以稍微测试一下，但这应该是你需要的。

Answer 3

知道了！

function unEmbed(data) { 
  return _.reduce(data, function(accumulator, value, key) {
    const returnableValue = _.isObject(value) ? unEmbed(value) : value;
    if (key === 'embedded') {
      return _.merge(accumulator, returnableValue);
    }
    accumulator[key] = returnableValue;
    return accumulator;
  }, {});
}

在我返回return accumulator[key] = returnableValue之前的问题，其结果是return returnableValue。