lodash를 사용하여 객체에서 정의되지 않은 null 값을 제거하는 방법은 무엇입니까?

lodash를 사용하여 객체에서 정의되지 않은 null 값을 제거하는 방법은 무엇입니까?

---

다음과 같은 Javascript 객체가 있습니다.

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

정의되지 않은 속성을 모두 제거하는 방법? 거짓 속성은 유지해야합니다.

---

모든 잘못된 값 을 제거 하려면 가장 간단한 방법은 다음과 같습니다.

_.pick(obj, _.identity);

예를 들어 (Lodash 3.x) :

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

Lodash 4.x의 경우 :

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

---

간단히 컴포지션 _.omit()과 연결 _.isUndefined하고 _.isNull게으른 평가로 결과를 얻을 수 있습니다.

데모

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

2016 년 3 월 14 일 업데이트 :

주석 섹션에서 dylants 가 언급했듯이 , _.omitBy()함수 대신 속성을 사용하므로 함수를 사용해야합니다 . lodash 버전 4.0.0이상에서 사용해야합니다 .

데모

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

2016 년 6 월 1 일 업데이트 :

Max Truxa가 언급 한 것처럼 lodash는 이미 대안을 제공했습니다 _.isNil.

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

---

lodash를 사용 _.compact(array)하는 경우 배열에서 모든 잘못된 값을 제거 하는 데 사용할 수 있습니다 .

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

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

---

다만:

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

---

다른 답변을 완료하려면 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>

---

lodash 문서에 따르면 :

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

또한 모든 null을 필터링 할 수 있습니다

---

정답은 다음과 같습니다.

_.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여기서 원하지 않는 값 도 제거 합니다.

---

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로 검열됩니다 (배열에서 발견 될 때)."

---

순수한 JavaScript로 : (Object.entries는 ES7이지만 Object.assign은 ES6이지만 동등한 ES5는 Object.keys 만 사용할 수 있습니다); 또한 v != nullnull과 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로 할 수 있다면 타사 라이브러리 종속성을 피할 수 있습니다.

---

귀하 중 일부는 구체적으로 만 제거하려고하는 질문에 도달했을 undefined수 있으므로 다음을 사용할 수 있습니다.

• Lodash 방법의 조합

  _.omitBy(object, _.isUndefined)
  

• 속성 rundef만 제거 하는 패키지undefined

  rundef(object)
  

---

If you need to recursively remove undefined properties, the rundef package also has a recursive option.

rundef(object, false, true);

See the documentation for more details.

---

Here's the lodash approach I'd take:

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

The pairs() function turns the input object into an array of key/value arrays. You do this so that it's easier to use reject() to eliminate undefined and null values. After, you're left with pairs that weren't rejected, and these are input for zipObject(), which reconstructs your object for you.

---

Taking in account that undefined == null we can write as follows:

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

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

JSBin example

---

For deep nested object you can use my snippet for 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
};

---

With lodash (or underscore) You may do

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

Otherwise, with vanilla JavaScript, you can do

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

Not to use a falsey test, because not only "undefined" or "null" will be rejected, also is other falsey value like "false", "0", empty string, {}. Thus, just to make it simple and understandable, I opted to use explicit comparison as coded above.

---

pickBy uses identity by default:

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

---

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 }

---

I would use underscore and take care of empty strings too:

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.

---

For deep nested object and arrays. and exclude empty values from string and 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)

result:

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

---

To omit all falsey values but keep the boolean primitives this solution helps.

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

참고URL : https://stackoverflow.com/questions/30812765/how-to-remove-undefined-and-null-values-from-an-object-using-lodash