从对象中删除空对象

Question

从对象中删除空对象

javascriptnode.jsunderscore.js

13

我正在尝试删除对象内的空对象，这里是一个带有预期输出的示例：

var object = {
    a: {
        b: 1,
        c: {
            a: 1,
            d: {},
            e: {
              f: {} 
            }
        }
    },
    b: {}
}


var expectedResult = {
    a: {
        b: 1,
        c: {
            a: 1,
        }
    }
}

我尝试使用其他 StackOverflow 问题中的一些示例，但这些示例仅适用于单层对象。

- Georgi Kirilov

使用递归函数。如果您有一个函数，它接收一个对象并迭代查找空对象并将其删除，那么当它遇到一个非空对象时，只需使用该内部对象作为参数调用相同的函数即可。 - user1106925

@squint请给我一个例子，我在JavaScript方面还是新手，正在努力赶上。 - Georgi Kirilov

3个回答

2

我遇到了同样的问题，而且我的对象可能包含需要删除的空元素数组。

最终我得出了这个简单粗暴的解决方案。

如果您想定义“空”是什么意思，我还添加了另一个函数。在我的情况下，我还需要空字符串。

  function isEmpty(obj) {
        if (obj === '' || obj === null || JSON.stringify(obj) === '{}' || JSON.stringify(obj) === '[]' || (obj) === undefined || (obj) === {}) {
            return true
        } else {
            return false
        }
    }
    function removeEmpty(o) {
        if (typeof o !== "object") {
            return o;
        }
        let oKeys = Object.keys(o)
        for (let j = 0; j < oKeys.length; j++) {
            let p = oKeys[j]
            switch (typeof (o[p])) {
                case 'object':
                    if (Array.isArray(o[p])) {
                        for (let i = 0; i < o[p].length; i++) {
                            o[p][i] = removeEmpty(o[p][i])
                            if (isEmpty(o[p][i])) {
                                o[p].splice(i, 1)
                                i--
                            }
                        }
                        if (o[p].length === 0) {
                            if (Array.isArray(o)) {
                                o.splice(parseInt(p), 1)
                                j--
                            } else {
                                delete o[p]
                            }
                        }
                    } else {
                        if (isEmpty(o[p])) {
                            delete o[p]
                        } else {
                            o[p] = removeEmpty(o[p])
                            if (isEmpty(o[p])) {
                                delete o[p]
                            }
                        }
                    }
                    break
                default:
                    if (isEmpty(o[p])) {
                        delete o[p]
                    }
                    break
            }
    
        }
        if (Object.keys(o).length === 0) {
            return
        }
        return o
    }

输入：

var a = {
b: 1,
c: {
    d: [1, [[], [], [[[1], []]]], [2, [[], [[]]]], [], [[]]]
},
e: {
    f: [{}, { g: 1 }]
},
h: {
    i: { j: { k: undefined, l: null, m: { n: "", o: 1 } } }
},
p: { q: { r: 1 } }
}
removeEmpty(a)

输出：

   {
    "b": 1,
    "c": {
        "d": [1, [[[[1]]]], [2]]
    },
    "e": {
        "f": [{"g": 1}]
    },
    "h": {
        "i": {
            "j": {
                "m": {
                    "o": 1
                }
            }
        }
    },
    "p": {
        "q": {
            "r": 1
        }
    }
}

- Rubén Vega

-2

function clean(obj) {
  for (var propName in obj) { 
    if (obj[propName] === null || obj[propName] === undefined) {
      delete obj[propName];      }
  }
}

编辑：

function clean(obj) {
      for (var propName in obj) {
        if(typeof obj[propName]=="object")
          clean(obj[propName])
        if (obj[propName] === null || obj[propName] === undefined) 
          delete obj[propName];      
       }
    }

- JustARandomProgrammer

你可以使用 if (obj[propName] == null) { 来同时处理这两种情况。如果属性是 null 或 undefined，它将为 true。然而，你的解决方案没有检查 OP 所寻找的内容，也没有处理嵌套对象。 - user1106925

仍然没有清理我的 {}，它们还是原样。:( - Georgi Kirilov

现在应该怎么做？你展示了两个完全不同的版本，却没有任何书面解释。 - charlietfl

@charlietfl，你有解决方案吗？ - Georgi Kirilov

@GeorgiK，你有没有注意到你忘记在 b 后面加一个“，”了？ - JustARandomProgrammer

显示剩余2条评论

网页内容由stack overflow 提供, 点击上面的

可以查看英文原文，
原文链接

- user1106925 · Accepted Answer

删除空对象的基本函数

首先，编写一个只适用于单层嵌套的函数。

此函数删除所有引用空对象的属性：

function clearEmpties(o) {
  for (var k in o) {
    if (!o[k] || typeof o[k] !== "object") {
      continue // If null or not an object, skip to the next iteration
    }

    // The property is an object
    if (Object.keys(o[k]).length === 0) {
      delete o[k]; // The object had no properties, so delete that property
    }
    return o;
  }
}

使用递归处理嵌套对象

现在你想使它递归，以便它可以操作嵌套对象。我们已经测试了 o[k] 是否为对象，并且已经测试了它是否有属性。因此，如果有属性，我们只需要再次使用该嵌套对象调用函数。

function clearEmpties(o) {
  for (var k in o) {
    if (!o[k] || typeof o[k] !== "object") {
      continue // If null or not an object, skip to the next iteration
    }

    // The property is an object
    clearEmpties(o[k]); // <-- Make a recursive call on the nested object
    if (Object.keys(o[k]).length === 0) {
      delete o[k]; // The object had no properties, so delete that property
    }
  }
    return o;
}

因此，就像对clearEmpties的最初调用会删除引用空对象的给定对象的属性一样，递归调用也将对嵌套对象执行相同操作。

实时演示：

var object = {
  a: {
    b: 1,
    c: {
      a: 1,
      d: {},
      e: { // will need to be removed after f has been removed
         f: {} 
      }
    }
  },

  b: {}
};

clearEmpties(object);
console.log(object);

function clearEmpties(o) {
  for (var k in o) {
    if (!o[k] || typeof o[k] !== "object") {
      continue
    }

    clearEmpties(o[k]);
    if (Object.keys(o[k]).length === 0) {
      delete o[k];
    }
  }
  return o;
}

使用Underscore和函数式风格的简短版本

function clearEmpties(o) {
  if (_.isFunction(o) || !_.isObject(o)) return o;
  return _.chain(o)
    .mapObject(clearEmpties)
    .pick(p => !(_.isObject(p) && _.isEmpty(p)))
    .value();
}

使用lodash和函数式编程的简化版本 - 适用于树摇

import { isFunction, isObject, isEmpty, isArray, isPlainObject, fromPairs } from "lodash-es";

const removeEmtpyObjects = (o) => {
    if (isFunction(o) || !isPlainObject(o)) return o;

    if (isArray(o)) return o.map(removeEmtpyObjects);

    return fromPairs(
        Object.entries(o)
            .map(([k, v]) => [k, removeEmtpyObjects(v)])
            .filter(([k, v]) => !(v == null || (isObject(v) && isEmpty(v))))
    );
};