Hoe verwijder je ongedefinieerde en null-waarden van een object met behulp van lodash?

Ik heb een Javascript-object zoals:

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

Hoe verwijder ik alle ongedefinieerde eigenschappen? Valse attributen moeten blijven.

Antwoord 1, autoriteit 100%

Je kunt eenvoudig _.omit()koppelen aan _.isUndefineden _.isNullcomposities, en het resultaat krijgen met luie evaluatie .

Demo

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

Update 14 maart 2016:

Zoals vermeld door dylantsin het commentaargedeelte, moet u de _.omitBy()functie omdat het een predikaat gebruikt in plaats van een eigenschap. Je moet dit gebruiken voor lodash versie 4.0.0en hoger.

DEMO

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

Update 1 juni 2016:

Zoals commentaar van Max Truxa, lodash heeft al een alternatief gegeven _.isNil, die controleert op zowel nullals undefined:

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

Antwoord 2, autoriteit 84%

Als u alle falsey-waarden wilt verwijderen, is de meest compacte manier:

Voor Lodash 4.x en hoger:

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

Voor erfenisLodash 3.x:

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

Antwoord 3, autoriteit 17%

Het juiste antwoord is:

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

Dat resulteert in:

{b: 1, d: false}

Het alternatief dat hier door andere mensen is gegeven:

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

Verwijdert ook falsewaarden die hier niet gewenst zijn.

Antwoord 4, autoriteit 14%

als je lodash gebruikt, kun je _.compact(array)gebruiken om alle foutieve waarden uit een array te verwijderen.

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

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

Antwoord 5, autoriteit 2%

Ik kwam een ​​soortgelijk probleem tegen met het verwijderen van undefinedvan een object (diep), en ontdekte dat als je OK bent om je gewone oude object te converteren en JSON te gebruiken, een snelle en vuile helperfunctie eruit zou zien zoals dit:

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

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

“…Indien niet gedefinieerd, een functie of een symbool wordt aangetroffen tijdens de conversie, wordt het ofwel weggelaten (wanneer het wordt gevonden in een object) of gecensureerd tot null (wanneer het wordt gevonden in een array).”

p>

Antwoord 6, autoriteit 2%

Aangezien sommigen van jullie misschien op de vraag zijn gekomen die specifiek alleenundefinedwil verwijderen, kun je het volgende gebruiken:

• een combinatie van Lodash-methoden

  _.omitBy(object, _.isUndefined)
  

• het rundef-pakket, dat alleen undefinedeigenschappen

  rundef(object)
  

Als u recursiefundefined-eigenschappen moet verwijderen, wordt de rundefpakket heeft ook een recursiveoptie.

rundef(object, false, true);

Zie de documentatievoor meer details.

Antwoord 7

Dit is de lodash-aanpak die ik zou nemen:

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

De functie pairs()verandert het invoerobject in een reeks sleutel/waarde-arrays. U doet dit zodat het gemakkelijker is om reject()te gebruiken om undefineden nullwaarden. Daarna houdt u paren over die niet zijn afgewezen, en deze worden ingevoerd voor zipObject(), die uw object voor u reconstrueert.

Antwoord 8

Rekening houdend met undefined == nullkunnen we als volgt schrijven:

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

JSBin-voorbeeld

Antwoord 9

Ongedefinieerde, null en lege tekenreeks van object verwijderen

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

Antwoord 10

U kunt ook Object.entries gebruiken met 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}

Als je lodash wilt gebruiken, verwijderen ze weglating uit v5, dus een alternatief is om fp/pickByte gebruiken samen met isNilen 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}

Antwoord 11

pickBygebruikt identiteitstandaard:

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

Antwoord 12

Ik gebruik graag _.pickBy, omdat je volledige controle hebt over wat je verwijdert:

var person = {"name":"bill","age":21,"sex":undefined,"height":null};
var cleanPerson = _.pickBy(person, function(value, key) {
  return !(value === undefined || value === null);
});

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

Antwoord 13

Kortste weg (lodash v4):

_.pickBy(my_object)

Antwoord 14

Met lodash (of onderstrepingsteken) U mag doen

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

Anders, met vanille JavaScript, kunt u doen

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

Gebruik geen falsey-test, omdat niet alleen “undefined” of “null” wordt afgewezen, maar ook andere falsey-waarden zoals “false”, “0 “, lege tekenreeks, {}. Dus, om het eenvoudig en begrijpelijk te maken, heb ik ervoor gekozen om expliciete vergelijking te gebruiken zoals hierboven gecodeerd.

Antwoord 15

Om alle falseywaarden weg te laten maarde booleaanse primitieven te behouden, helpt deze oplossing.

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

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}

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

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

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

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

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