如何使用 lodash 从对象中删除未定义值和空值？

Question

我有一个 Javascript 对象，例如：

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

如何删除所有未定义的属性？错误的属性应该保留。

Answer 1

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 }

Answer 2

用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];
});

否则，使用香草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];
    }
});

不要使用假测试，因为不仅"undefined"或"null"会被拒绝，还有其他虚假值，如 "false"、“0”、空字符串、{}。因此，为了简单易懂，我选择使用上面编码的显式比较。

Answer 3

这是我会采用的 lodash 方法：

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

pairs() function turns the input object into an array of key/value arrays. You do this so that it's easier to use reject() to eliminate undefined and null values. After, you're left with pairs that weren't rejected, and these are input for zipObject()，它为您重建您的对象。

Answer 4

只是：

_.omit(my_object, _.isUndefined)

以上没有考虑 null 值，因为它们在原始示例中缺失并且仅在主题中提到，但我保留它是因为它很优雅并且可能有它的用途。

这是完整的示例，不够简洁，但更完整。

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); }));

Answer 5

您可以简单地将 _.omit() 与 _.isUndefined 和 _.isNull 组合链接起来，并通过惰性求值获得结果。

Demo

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

2016 年 3 月 14 日更新：

如 in the comment section, you should use the _.omitBy() 函数所述，因为它使用谓词而不是属性。您应该将此用于 lodash 版本 4.0.0 及更高版本。

DEMO

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

2016 年 6 月 1 日更新：

正如 , lodash already provided an alternative _.isNil 评论的那样，它同时检查 null 和 undefined：

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

Answer 6

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

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}

jsbin.

Answer 7

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

对于 Lodash 4.x 及更高版本：

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

对于旧版 Lodash 3.x:

_.pick(obj, _.identity);

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

Answer 8

考虑到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

Answer 9

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

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

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

Answer 10

我在从对象中删除 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

“...如果在转换过程中遇到未定义、函数或符号，则将其省略（当在对象中找到时）或截断为空（当在数组中找到时）。”

Answer 11

根据 lodash 文档：

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

您还可以过滤掉所有空值

Answer 12

with pure 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 可以做到，我会避免任何第三方库依赖：

Answer 13

对于深层嵌套对象，您可以使用我的 lodash > 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
};

Answer 14

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

Lodash 方法的组合
```
_.omitBy(object, _.isUndefined)
```
rundef 包，它仅删除 undefined 属性
```
rundef(object)
```

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

rundef(object, false, true);

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

Answer 15

要完成其他答案，在 lodash 4 中仅忽略未定义和 null（而不是像 false 这样的属性），您可以在 _.pickBy 中使用谓词：

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

示例如下：

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);

<script src="https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.10/lodash.js"></script>

Answer 16

对于深层嵌套对象和数组。并从字符串和 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"
}

Answer 17

正确答案是：

_.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 值。

Answer 18

pickBy uses identity 默认：

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

Answer 19

省略所有 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>

Answer 20

我喜欢使用 _.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

Answer 21

对于那些来到这里希望从对象数组中删除并使用 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' }]

注意：不想破坏也可以不破坏。

Answer 22

È=12=shhortest vai (lodash vch):sh=11=sh w=10=sh

Answer 23

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

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

Answer 24

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

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

Answer 25

您也可以使用Object.entries with Array.prototype.filter。

const omitNullish = (object) => 
   Object.fromEntries(
       Object.entries(object).filter(([, value]) => value != null)
   )

omitNullish({ a: null, b: 1, c: undefined, d: false, e: 0 }) // { b: 1, d: false, e: 0}

如果您想使用 lodash，他们会从 v5 中删除 omit，因此另一种方法是使用 fp/pickBy 以及 isNil 和 negate。

import pickBy from 'lodash/fp/pickBy'
import isNil from 'lodash/isNil';
import negate from 'lodash/negate';


const omitNullish = pickBy(negate(isNil))

omitNullish({ a: null, b: 1, c: undefined, d: false, e: 0 }) // { b: 1, d: false, e: 0}

Answer 26

我能够在包含只有一个 lodash 函数的数组的深层对象中做到这一点，transform。

请注意，双不等式 (!= null) 是有意为之的，因为它也将匹配未定义的，typeof 'object' 检查也是如此，因为它将同时匹配对象和数组。

这仅适用于不包含类.

的纯数据对象

const cloneDeepSanitized = (obj) =>
  Array.isArray(obj)
    ? obj.filter((entry) => entry != null).map(cloneDeepSanitized)
    : transform(
        obj,
        (result, val, key) => {
          if (val != null) {
            result[key] =
              typeof val === 'object' ? cloneDeepSanitized(val) : val;
          }
        },
        {},
      );

Answer 27

你可以使用lodash来移除null和undefined对象，但是你应该知道你需要使用什么lodash方法，很多开发者使用isNil来移除Null和undefined对象，但是这个函数不会移除空对象(' ')

您可以使用 isEmpty 删除 Null 、 Undefined 和

import pickBy from 'lodash/fp/pickBy'
import negate from 'lodash/negate';
import isEmpty from 'lodash/isEmpty';

const omitNullish = pickBy(negate(isEmpty));

      addressObject = {
      "a": null,
      "c": undefined,
      "d": "",
      "e": "test1",
      "f": "test2
    }

 const notNullObjects = omitNullish(addressObject);
 
 console.log(notNullObjects);

you will have this object : { "e": "test1", "f": "test2 }

如何使用 lodash 从对象中删除未定义值和空值？

How to remove undefined and null values from an object using lodash?

javascript

object

lodash