如何使用lodash从对象中删除undefined和null值？

时间：2015-06-12 21:58:25

标签： javascript object lodash

我有一个Javascript对象，如：

var my_object = { a:undefined, b:2, c:4, d:undefined };

var newObject = _.reject(my_collection, function(val){ return _.isUndefined(val) })

//--> newCollection = { b: 2, c: 4 }

如何删除所有未定义的属性？应保留虚假属性。

24 个答案:

答案 0 :(得分：179)

您只需使用_.omit()和_.isUndefined成分链接_.isNull，然后通过延迟评估获得结果。

<强> Demo 

var result = _(my_object).omit(_.isUndefined).omit(_.isNull).value();

2016年3月14日更新：

正如评论部分中dylants所提到的，您应该使用_.omitBy()函数，因为它使用谓词而不是属性。您应该将此用于lodash版本4.0.0及更高版本。

<强> DEMO 

var result = _(my_object).omitBy(_.isUndefined).omitBy(_.isNull).value();

2016年6月1日更新：

正如Max Truxa所评论，lodash已经提供了替代_.isNil。

var result = _.omitBy(my_object, _.isNil);

答案 1 :(得分：139)

如果您要删除所有 falsey 值，那么最紧凑的方式是：

_.pick(obj, _.identity);

例如（Lodash 3.x）：

_.pick({ a: null, b: 1, c: undefined }, _.identity);
>> Object {b: 1}

对于Lodash 4.x：

_.pickBy({ a: null, b: 1, c: undefined }, _.identity);
>> Object {b: 1}

答案 2 :(得分：28)

如果您使用的是lodash，则可以使用_.compact(array)从数组中删除所有错误值。

_.compact([0, 1, false, 2, '', 3]);
// => [1, 2, 3]

https://lodash.com/docs/4.17.4#compact

答案 3 :(得分：13)

只是：

_.omit(my_object, _.isUndefined)

以上并未考虑null个帐号，因为它们在原始示例中缺失，仅在主题中提及，但我保留它，因为它很优雅且可能有其用途。< / p>

以下是完整的示例，不太简洁，但更完整。

var obj = { a: undefined, b: 2, c: 4, d: undefined, e: null, f: false, g: '', h: 0 };
console.log(_.omit(obj, function(v) { return _.isUndefined(v) || _.isNull(v); }));

答案 4 :(得分：11)

要完成其他答案，请在lodash 4中忽略undefined和null（而不是false之类的属性），您可以在_.pickBy中使用谓词：

_.pickBy(obj, v !== null && v !== undefined)

以下示例：

＆＃13;
＆＃13; 
const obj = { a: undefined, b: 123, c: true, d: false, e: null};

const filteredObject = _.pickBy(obj, v => v !== null && v !== undefined);

console.log = (obj) => document.write(JSON.stringify(filteredObject, null, 2));
console.log(filteredObject);
＆＃13; 
<script src="https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.10/lodash.js"></script>
＆＃13;
＆＃13;
＆＃13;

答案 5 :(得分：7)

根据lodash docs：

_.compact(_.map(array, fn))

您也可以过滤掉所有空值

答案 6 :(得分：4)

我从一个对象（深层）中删除了undefined时遇到了类似的问题，并发现如果你可以转换普通旧对象并使用JSON，那么快速而脏的帮助函数将如下所示： 

function stripUndefined(obj) {
  return JSON.parse(JSON.stringify(obj));
}

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON/stringify#Description

“...如果在转换过程中遇到未定义，函数或符号，则省略（当在对象中找到它时）或者删除为null（当在数组中找到它时）。”

答案 7 :(得分：4)

使用纯JavaScript :(虽然Object.entries是ES7，Object.assign是ES6;但是等效的ES5使用Object.keys也应该也是可行的）;还要注意v != null检查null和undefined; 

> var d = { a:undefined, b:2, c:0, d:undefined, e: null, f: 0.3, s: "", t: false };
undefined
> Object.entries(d)
    .filter(([ k, v ]) => (v != null))
    .reduce((acc, [k, v]) => Object.assign(acc, {[k]: v}), {})
{ b: 2, c: 0, f: 0.3, s: '', t: false }

编辑：以下是仅限ES5 Object.keys的版本：但通常在Node v8中使用ES7非常有趣; - ）

> Object.keys(d)
    .filter(function(k) { return d[k] != null; })
    .reduce(function(acc, k) { acc[k] = d[k]; return acc; }, {});
{ b: 2, c: 0, f: 0.3, s: '', t: false }

2017年10月更新：使用Node v8（自v8.3左右开始）现在它具有对象传播结构：

> var d = { a:undefined, b:2, c:0, d:undefined,
    e: null, f: -0.0, s: "", t: false, inf: +Infinity, nan: NaN };
undefined
> Object.entries(d)
    .filter(([ k, v ]) => (v != null))
    .reduce((acc, [k, v]) => ({...acc, [k]: v}), {})
{ b: 2, c: 0, f: -0, s: '', t: false, inf: Infinity, nan: NaN }

或仅在一个减少内：

> Object.entries(d)
   .reduce((acc, [k, v]) => (v==null ? acc : {...acc, [k]: v}), {})
{ b: 2, c: 0, f: -0, s: '', t: false, inf: Infinity, nan: NaN }

更新：有人想要递归吗？也不是那么难，只需要额外检查isObject，并递归调用自己：

> function isObject(o) {
    return Object.prototype.toString.call(o) === "[object Object]"; }
undefined
> function dropNullUndefined(d) {
    return Object.entries(d)
      .reduce((acc, [k, v]) => (
        v == null ? acc :
         {...acc, [k]: (isObject(v) ? dropNullUndefined(v) : v) }
      ), {});
  }
> dropNullUndefined({a: 3, b:null})
{ a: 3 }
> dropNullUndefined({a: 3, b:null, c: { d: 0, e: undefined }})
{ a: 3, c: { d: 0 } }

我的结论：如果纯Javascript可以做，我会避免任何第三方库依赖：

答案 8 :(得分：4)

由于你们中的一些人可能已经找到专门删除 undefined的问题，你可以使用：

  • Lodash方法的组合

    _.omitBy(object, _.isUndefined)

  • rundef包，仅删除undefined个属性

    rundef(object)

如果您需要递归删除undefined属性，rundef包也有recursive选项。

rundef(object, false, true);

有关详细信息，请参阅documentation。

答案 9 :(得分：3)

这是我采取的lodash方法：

_(my_object)
    .pairs()
    .reject(function(item) {
        return _.isUndefined(item[1]) ||
            _.isNull(item[1]);
    })
    .zipObject()
    .value()

pairs()函数将输入对象转换为键/值数组的数组。这样做是为了更容易使用reject()来消除undefined和null值。之后，您离开了不被拒绝的对，这些是zipObject()的输入，为您重建对象。

答案 10 :(得分：3)

考虑到undefined == null我们可以写如下：

let collection = {
  a: undefined,
  b: 2,
  c: 4,
  d: null,
}

console.log(_.omit(collection, it => it == null))
// -> { b: 2, c: 4 }

JSBin example

答案 11 :(得分：2)

最短的方式（lodash v4）：

_.pickBy(my_object)

答案 12 :(得分：2)

对于深层嵌套对象，您可以将我的代码段用于lodash＆gt; 4 

const removeObjectsWithNull = (obj) => {
    return _(obj)
      .pickBy(_.isObject) // get only objects
      .mapValues(removeObjectsWithNull) // call only for values as objects
      .assign(_.omitBy(obj, _.isObject)) // save back result that is not object
      .omitBy(_.isNil) // remove null and undefined from object
      .value(); // get value
};

答案 13 :(得分：1)

从对象中删除未定义的、空的和空的字符串

_.omitBy(object, (v) => _.isUndefined(v) || _.isNull(v) || v === '');

答案 14 :(得分：1)

pickBy默认使用identity：

_.pickBy({ a: null, b: 1, c: undefined, d: false });

答案 15 :(得分：1)

正确的答案是：

_.omitBy({ a: null, b: 1, c: undefined, d: false }, _.isNil)

结果是：

{b: 1, d: false}

其他人在这里提供的替代方法：

_.pickBy({ a: null, b: 1, c: undefined, d: false }, _.identity);

还将删除此处不需要的false值。

答案 16 :(得分：1)

使用lodash（或下划线）您可以 

var my_object = { a:undefined, b:2, c:4, d:undefined, e:null };

var passedKeys = _.reject(Object.keys(my_object), function(key){ return _.isUndefined(my_object[key]) || _.isNull(my_object[key]) })

newObject = {};
_.each(passedKeys, function(key){
    newObject[key] = my_object[key];
});

否则，使用vanilla JavaScript，您可以执行 

var my_object = { a:undefined, b:2, c:4, d:undefined };
var new_object = {};

Object.keys(my_object).forEach(function(key){
    if (typeof my_object[key] != 'undefined' && my_object[key]!=null){
        new_object[key] = my_object[key];
    }
});

不要使用虚假测试，因为不仅仅是＆＃34; undefined＆＃34;或＆＃34; null＆＃34;将被拒绝 ，也是其他虚假值，如＆＃34; false＆＃34;，＆＃34; 0＆＃34;，空字符串，{}。因此，为了使其简单易懂，我选择使用上面编码的显式比较。

答案 17 :(得分：0)

用于深层嵌套的对象和数组。并从字符串和NaN中排除空值 

function isBlank(value) {
  return _.isEmpty(value) && !_.isNumber(value) || _.isNaN(value);
}
var removeObjectsWithNull = (obj) => {
  return _(obj).pickBy(_.isObject)
    .mapValues(removeObjectsWithNull)
    .assign(_.omitBy(obj, _.isObject))
    .assign(_.omitBy(obj, _.isArray))
    .omitBy(_.isNil).omitBy(isBlank)
    .value();
}
var obj = {
  teste: undefined,
  nullV: null,
  x: 10,
  name: 'Maria Sophia Moura',
  a: null,
  b: '',
  c: {
    a: [{
      n: 'Gleidson',
      i: 248
    }, {
      t: 'Marta'
    }],
    g: 'Teste',
    eager: {
      p: 'Palavra'
    }
  }
}
removeObjectsWithNull(obj)

结果：

{
   "c": {
      "a": [
         {
            "n": "Gleidson",
            "i": 248
         },
         {
            "t": "Marta"
         }
      ],
      "g": "Teste",
      "eager": {
         "p": "Palavra"
      }
   },
   "x": 10,
   "name": "Maria Sophia Moura"
}

答案 18 :(得分：0)

我会使用下划线并处理空字符串：

＆＃13;
＆＃13; 
var my_object = { a:undefined, b:2, c:4, d:undefined, k: null, p: false, s: '', z: 0 };

var result =_.omit(my_object, function(value) {
  return _.isUndefined(value) || _.isNull(value) || value === '';
});

console.log(result); //Object {b: 2, c: 4, p: false, z: 0}
＆＃13;
＆＃13;
＆＃13;

jsbin

答案 19 :(得分：0)

要忽略所有 falsey 值，但保留此解决方案有帮助的布尔基元。

_.omitBy(fields, v => (_.isBoolean(v)||_.isFinite(v)) ? false : _.isEmpty(v));


let fields = {
str: 'CAD',
numberStr: '123',
number  : 123,
boolStrT: 'true',
boolStrF: 'false',
boolFalse : false,
boolTrue  : true,
undef: undefined,
nul: null,
emptyStr: '',
array: [1,2,3],
emptyArr: []
};

let nobj = _.omitBy(fields, v => (_.isBoolean(v)||_.isFinite(v)) ? false : _.isEmpty(v));

console.log(nobj);
<script src="https://cdn.jsdelivr.net/npm/lodash@4.17.11/lodash.min.js"></script>

答案 20 :(得分：0)

我喜欢使用_.pickBy，因为您可以完全控制要删除的内容：

var person = {"name":"bill","age":21,"sex":undefined,"height":null};

var cleanPerson = _.pickBy(person, function(value, key) {
  return !(value === undefined || value === null);
});

来源：https://www.codegrepper.com/?search_term=lodash+remove+undefined+values+from+object

答案 21 :(得分：0)

对于那些想要从对象数组中删除并使用lodash的人来说，您可以执行以下操作：


 const objects = [{ a: 'string', b: false, c: 'string', d: undefined }]
 const result = objects.map(({ a, b, c, d }) => _.pickBy({ a,b,c,d }, _.identity))

 // [{ a: 'string', c: 'string' }]

注意：如果您不想破坏，就不必破坏。

答案 22 :(得分：0)

如果您不想删除false值。这是一个示例：

obj = {
  "a": null,
  "c": undefined,
  "d": "a",
  "e": false,
  "f": true
}
_.pickBy(obj, x => x === false || x)
> {
    "d": "a",
    "e": false,
    "f": true
  }

答案 23 :(得分：0)

{{1}}
相关问题
最新问题