如何使用 lodash 從對象中刪除未定義和空值？

Question

我有一個 Javascript 對象，例如：

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

如何刪除所有未定義的屬性？ 虛假屬性應該保留。

Answer 1

您可以簡單地將_.omit()與_.isUndefined和_.isNull組合鏈接起來，並通過延遲評估獲得結果。

演示

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

2016 年 3 月 14 日更新：

正如dyants在評論部分提到的，您應該使用_.omitBy()函數，因為它使用謂詞而不是屬性。 你應該在 lodash 4.0.0及更高版本中使用它。

演示

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

2016 年 6 月 1 日更新：

正如Max Truxa所評論的，lodash 已經提供了一個替代_.isNil ，它檢查null和undefined ：

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

Answer 2

如果要刪除所有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 3

正確答案是：

_.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 4

如果您使用 lodash，則可以使用_.compact(array)從數組中刪除所有錯誤值。

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

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

Answer 5

要完成其他答案，在 lodash 4 中只忽略 undefined 和 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 6

只是：

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

根據 lodash 文檔：

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

您也可以過濾掉所有空值

Answer 8

對於深層嵌套對象，您可以使用我的 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 9

我在從對象中刪除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（在數組中找到時）。”

Answer 10

使用純 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 11

由於有些人可能在尋求專門去除，唯一的問題已經到了undefined ，你可以使用：

• Lodash 方法的組合

  _.omitBy(object, _.isUndefined)

• rundef包，它只刪除undefined屬性

  rundef(object)

---

如果需要遞歸刪除undefined屬性， rundef包也有recursive選項。

rundef(object, false, true);

有關更多詳細信息，請參閱文檔。

Answer 12

這是我采用的 lodash 方法：

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

pair()函數將輸入對象轉換為鍵/值數組的數組。 這樣做是為了更容易使用reject()來消除undefined和null值。 之后，您會得到未被拒絕的對，這些是zipObject() 的輸入，它為您重建您的對象。

Answer 13

考慮到undefined == null我們可以這樣寫：

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

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

JSB 示例

Answer 14

pickBy默認使用身份：

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

Answer 15

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

最短的方式（lodash v4）：

_.pickBy(my_object)

Answer 17

從對象中刪除未定義、空和空字符串

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

Answer 18

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

不要使用虛假測試，因為不僅“未定義”或“空”會被拒絕，其他虛假值如“假”、“0”、空字符串、{}也會被拒絕。 因此，為了簡單易懂，我選擇使用上面編碼的顯式比較。

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

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 21

我會使用下划線並處理空字符串：

 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 22

對於深度嵌套的對象和數組。 並從字符串和 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 23

對於那些想要從對象數組中刪除並使用 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 24

如果您不想刪除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 25

您還可以將Object.entries與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 刪除空對象和未定義對象，但您應該知道需要使用什么 lodash 方法，許多開發人員使用 isNil 刪除空對象和未定義對象，但此函數不會刪除空對象（''）

您可以使用 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); 

你將擁有這個對象：{ "e": "test1", "f": "test2 }