我喜欢用_。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 +删除+未定义值+ + +对象

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

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

使用纯JavaScript:(尽管Object。entries是ES7, Object。assign是ES6;但是等效的ES5使用Object。键也应该是可行的);还要注意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对象的版本。但一般来说，在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月更新:在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可以做到，我会避免任何第三方库依赖:

对于那些想要从对象数组中删除并使用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' }]

注意:如果你不想销毁，你不必销毁。

省略所有假值，但保留布尔原语，这个解决方案有帮助。

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

让田野= str:’CAD’, numberStr:’123’, 123号， boolStrT:’true’, boolStrF:’false’, 假的，假的， 真实， undef: undefined, mo:零, emptyStr:”, 阵列:[1,2,3], emptyArr: [] ); 让诺布= _。omitBy (fields, v = > (_ isBoolean (v) | | _ isFinite (v)) ?伪造:_.isEmpty(v); 游戏机。log (nobj); < script src =“https://cdn.jsdelivr.net/npm/lodash@4。11月17日/ lodash min。主持人" > / < script >

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

注意，双重不相等(!= null)是有意的，因为它也将匹配undefined, typeof 'object'检查也是如此，因为它将匹配object和array。

这只用于不包含类的普通数据对象。

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