Wie entferne ich mit Hilfe von lodash Undefinierte und Nullwerte aus einem Objekt?

Sie können _.omit() einfach mit _.isUndefined- und _.isNull-Kompositionen verketten und erhalten das Ergebnis mit einer langsamen Auswertung.

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 Funktion _.omitBy() verwenden, da sie anstelle einer Eigenschaft ein Prädikat verwendet. Sie sollten dies für die lodash-Version 4.0.0 und höher verwenden.

DEMO

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

Update 1. Juni 2016:

Wie von Max Truxa kommentiert, hat lodash bereits einen alternativen _.isNil angegeben.

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

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

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

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

Gerade: 

_.omit(my_object, _.isUndefined)

Die obigen Angaben berücksichtigen keine null-Werte, 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 verwendet wird.

Hier ist das vollständige Beispiel, weniger prägnant, 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 undefined und null (und keine Eigenschaften wie false) zu ignorieren, ein Prädikat in _.pickBy Verwenden:

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

Nach Angaben von lodash: 

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

Sie können auch alle Nullen herausfiltern

Da einige von Ihnen möglicherweise zu der Frage gelangt sind, dass onlyundefined gezielt entfernt werden soll, können Sie Folgendes verwenden:

• eine Kombination von Lodash-Methoden

  _.omitBy(object, _.isUndefined)
  

• das Paket rundef , das nur undefined-Eigenschaften entfernt

  rundef(object)
  

Wenn Sie rekursivundefined -Eigenschaften entfernen müssen, verfügt das Paket rundef ebenfalls über die Option recursive.

rundef(object, false, true);

Siehe Dokumentation für weitere Details.

Ich hatte ein ähnliches Problem beim Entfernen von undefined aus einem Objekt (tief) und stellte fest, dass eine schnelle und schmutzige Hilfsfunktion so aussehen würde, wenn Sie Ihr einfaches altes Objekt konvertieren und JSON verwenden möchten:

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

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

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

Unter Berücksichtigung dieser undefined == null können wir wie folgt schreiben:

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

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

JSBin Beispiel

Hier ist der lodash-Ansatz, den ich ergreifen würde:

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

Die Funktion pairs () wandelt das Eingabeobjekt in ein Array von Key/Value-Arrays um. Sie tun dies, um die Verwendung von reject () zu vereinfachen, um die undefined- und null-Werte zu entfernen. Danach bleiben Paare übrig, die nicht abgelehnt wurden, und diese werden für zipObject () eingegeben, wodurch Ihr Objekt für Sie rekonstruiert wird.

mit reinem JavaScript: (obgleich Object.entries ES7 ist, Object.assign ist ES6; äquivalente ES5 verwendet jedoch nur Object.keys). Beachten Sie auch v != null prüft auf null und 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 }

Edit: hier ist nur die Version mit ES5 Object.keys: aber generell mit ES7 in Node v8 ist es ziemlich angenehm ;-)

> 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 nun ein Objekt-Spreading-Konstrukt:

> 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 eines 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: jemand will rekursiv? ist auch nicht so schwer, braucht nur eine zusätzliche Überprüfung von isObject und ruft sich selbst 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 } }

meine Schlussfolgerung: Wenn reines Javascript funktioniert, würde ich jegliche Abhängigkeiten von Bibliotheken von Drittanbietern vermeiden:

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

Um keinen Falsey-Test zu verwenden, 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, entschied ich mich für den expliziten Vergleich wie oben beschrieben.

Die richtige Antwort ist:

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

Das ergibt:

{b: 1, d: false}

Die Alternative, die hier von anderen Leuten gegeben wurde:

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

Entfernt auch false Werte, die hier nicht gewünscht sind.

pickBy verwendet standardmäßig identity :

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

Um alle falsey Werte aber zu ignorieren, die booleschen Primitive 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 auch auf leere Zeichenfolgen achten:

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

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