Wie entferne ich undefinierte und Nullwerte mit lodash aus einem Objekt?

Ich habe ein Javascript-Objekt wie:

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

Wie entferne ich alle undefinierten Eigenschaften? Falsche Attribute sollten bleiben.

Wenn Sie alle Falsey- Werte entfernen möchten , ist der kompakteste Weg:

Für Lodash 4.x und höher :

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

Für Legacy- Lodash 3.x:

_.pick(obj, _.identity);

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

Sie können einfach _.omit()mit _.isUndefinedund _.isNullKompositionen verketten und das Ergebnis mit einer verzögerten Bewertung erhalten.

Demo

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

Update 14. März 2016 :

Wie von Dylants im Kommentarbereich erwähnt, sollten Sie die _.omitBy()Funktion verwenden, da sie ein Prädikat anstelle einer Eigenschaft verwendet. Sie sollten dies für die lodash-Version 4.0.0und höher verwenden.

DEMO

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

Update 1. Juni 2016 :

Wie von Max Truxa kommentiert , bot lodash bereits eine Alternative _.isNil, die sowohl prüft nullals auch undefined:

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

Wenn Sie lodash verwenden, können Sie _.compact(array)alle falschen Werte aus einem Array entfernen.

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

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

Die richtige Antwort ist:

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

Das ergibt:

{b: 1, d: false}

Die hier von anderen Leuten gegebene Alternative:

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

Entfernt auch falseWerte, die hier nicht erwünscht sind.

Gerade:

_.omit(my_object, _.isUndefined)

Das Obige berücksichtigt keine nullWerte, da sie im ursprünglichen Beispiel fehlen und nur im Betreff erwähnt werden, aber ich lasse es, da es elegant ist und möglicherweise seine Verwendung hat.

Hier ist das vollständige Beispiel, weniger präzise, ​​aber vollständiger.

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

Um die anderen Antworten zu vervollständigen, können Sie in lodash 4, um nur undefiniert und null (und nicht Eigenschaften wie false) zu ignorieren , ein Prädikat verwenden in _.pickBy:

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

Beispiel unten:

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>

Laut lodash docs:

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

Sie können auch alle Nullen herausfiltern

Für tief verschachtelte Objekte können Sie mein Snippet für lodash> 4 verwenden

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

Ich bin auf ein ähnliches Problem beim Entfernen undefinedvon einem Objekt (tiefgreifend) gestoßen und habe festgestellt, dass eine schnelle und schmutzige Hilfsfunktion folgendermaßen aussehen würde, wenn Sie Ihr einfaches altes Objekt konvertieren und JSON verwenden können:

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

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

"... Wenn eine undefinierte Funktion oder ein Symbol während der Konvertierung angetroffen wird, wird es entweder weggelassen (wenn es in einem Objekt gefunden wird) oder auf null zensiert (wenn es in einem Array gefunden wird)."

mit reinem JavaScript: (obwohl Object.entries ES7 ist, ist Object.assign ES6; aber äquivalent ES5 verwendet nur Object.keys sollte auch machbar sein); Beachten Sie auch die v != nullÜberprüfungen auf null und undefiniert.

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

Bearbeiten: Dies unten ist die Version nur mit ES5 Object.keys: aber im Allgemeinen mit ES7 in Node v8 ist ziemlich viel Spaß ;-)

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

Update im Oktober 2017 : Mit Node v8 (seit v8.3 oder so) hat es jetzt ein Objektverbreitungskonstrukt:

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

oder nur innerhalb einer reduzieren:

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

Update: will jemand rekursiv? ist auch nicht so schwer, brauche nur eine zusätzliche Überprüfung von isObject und rufe sich rekursiv auf:

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

Mein Fazit: Wenn reines Javascript dies kann, würde ich jegliche Bibliotheksabhängigkeiten von Drittanbietern vermeiden:

Da einige von Ihnen möglicherweise zu der Frage gekommen sind, nur gezielt zu entfernen undefined, können Sie Folgendes verwenden:

• eine Kombination von Lodash-Methoden

  _.omitBy(object, _.isUndefined)

• das rundefPaket, das nur undefinedEigenschaften entfernt

  rundef(object)

Wenn Sie Eigenschaften rekursiv entfernen müssen undefined, verfügt das rundefPaket auch über eine recursiveOption.

rundef(object, false, true);

Weitere Informationen finden Sie in der Dokumentation .

Hier ist der Lodash-Ansatz, den ich wählen würde:

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

Die Funktion pair () verwandelt das Eingabeobjekt in ein Array von Schlüssel / Wert-Arrays. Sie tun dies, damit es einfacher ist, Reject () zum Eliminieren undefinedund nullWerte zu verwenden. Danach bleiben Paare übrig, die nicht abgelehnt wurden, und diese werden für zipObject () eingegeben , das Ihr Objekt für Sie rekonstruiert.

Unter Berücksichtigung, dass undefined == nullwir wie folgt schreiben können:

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

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

JSBin Beispiel

pickBy verwendet standardmäßig Identität :

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

Kürzester Weg (lodash v4):

_.pickBy(my_object)

Mit lodash (oder Unterstrich) können Sie tun

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

Andernfalls können Sie mit Vanille-JavaScript tun

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

Verwenden Sie keinen Falsey-Test, da nicht nur "undefined" oder "null" abgelehnt wird, sondern auch andere Falsey-Werte wie "false", "0", leere Zeichenfolge, {}. Um es einfach und verständlich zu machen, habe ich mich für den expliziten Vergleich entschieden, wie oben codiert.

Um alle Falsey- Werte wegzulassen , aber die booleschen Grundelemente beizubehalten , hilft diese Lösung.

_.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/[email protected]/lodash.min.js"></script>

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 }

Ich würde Unterstrich verwenden und mich auch um leere Zeichenfolgen kümmern:

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 .

Für tief verschachtelte Objekte und Arrays. und leere Werte von String und NaN ausschließen

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)

Ergebnis:

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

Ich benutze gerne _.pickBy, weil Sie die volle Kontrolle darüber haben, was Sie entfernen:

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

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

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

Für diejenigen unter Ihnen, die hierher kommen, um aus einer Reihe von Objekten zu entfernen und lodash zu verwenden, können Sie Folgendes tun:

 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' }]

Hinweis: Sie müssen nicht zerstören, wenn Sie nicht möchten.