javascript - from - ¿Cómo eliminar valores indefinidos y nulos de un objeto usando lodash?

lodash pluck

Question

Tengo un objeto Javascript como:

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

¿Cómo eliminar todas las propiedades indefinidas? Los atributos falsos deberían permanecer.

Answer 1

Aquí está el enfoque lodash que tomaría:

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

La función pairs() convierte el objeto de entrada en una matriz de matrices de clave / valor. Usted hace esto para que sea más fácil usar el reject() para eliminar valores undefined y null . Después, te quedan pares que no fueron rechazados, y estos son datos de entrada para zipObject() , que reconstruye tu objeto por ti.

Answer 2

Dado que algunos de ustedes podrían haber llegado a la pregunta buscando eliminar específicamente solo undefined , pueden usar:

• una combinación de métodos de Lodash

  _.omitBy(object, _.isUndefined)

• el paquete rundef , que elimina solo propiedades undefined

  rundef(object)

Si necesita eliminar recursivamente propiedades undefined , el paquete rundef también tiene una opción recursive .

rundef(object, false, true);

Consulte la documentation para más detalles.

Answer 3

De acuerdo con lodash docs:

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

También puedes filtrar todos los nulos

Answer 4

Encontré un problema similar con la eliminación de undefined de un objeto (profundamente), y descubrí que si está bien para convertir su objeto antiguo simple y usar JSON, una función auxiliar rápida y sucia se vería así:

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

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

"... Si no se define, se encuentra una función o un símbolo durante la conversión, se omite (cuando se encuentra en un objeto) o se censura a nulo (cuando se encuentra en una matriz)".

Answer 5

La respuesta correcta es:

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

Eso da como resultado:

{b: 1, d: false}

La alternativa dada aquí por otras personas:

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

Eliminará también false valores false que no se desean aquí.

Answer 6

Para completar las otras respuestas, en lodash 4 para ignorar solo indefinido y nulo (y no propiedades como false ) puede usar un predicado en _.pickBy :

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

Ejemplo a continuación:

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 7

Para objetos anidados profundos, puede usar mi fragmento para 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 8

Para omitir todos los valores de falsey pero mantener las primitivas booleanas, esta solución ayuda.

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

Answer 9

Sólo:

_.omit(my_object, _.isUndefined)

Lo anterior no tiene en cuenta null valores null , ya que faltan en el ejemplo original y se mencionan solo en el tema, pero lo dejo ya que es elegante y podría tener sus usos.

Aquí está el ejemplo completo, menos conciso, pero más completo.

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 10

Si desea eliminar todos los valores de falsey , la forma más compacta es:

_.pick(obj, _.identity);

Por ejemplo (Lodash 3.x):

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

Para Lodash 4.x:

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

Answer 11

Simplemente puede encadenar _.omit() con _.isUndefined y _.isNull composiciones, y obtener el resultado con una evaluación diferida.

Demo

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

Actualización 14 de marzo de 2016 :

Como mencionan los dylants en la sección de comentarios, debe usar la función _.omitBy() ya que usa un predicado en lugar de una propiedad. Debe usar esto para lodash versión 4.0.0 y superior.

DEMO

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

Actualización 1 de junio de 2016 :

Como comentó Max Truxa , lodash ya proporcionó una alternativa _.isNil .

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

Answer 12

Teniendo en cuenta que undefined == null podemos escribir de la siguiente manera:

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

JSBin ejemplo

Answer 13

Usaría guión bajo y me ocuparía de las cadenas vacías también:

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 14

con JavaScript puro: (aunque Object.entries es ES7, Object.assign es ES6; pero ES5 equivalente usa Object.keys solo debería ser factible); también observe v != null comprobaciones nulas tanto para nulo como para indefinido;

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

Editar: esta a continuación es la versión con ES5 Object.keys solamente: pero en general con ES7 en el Nodo v8 es bastante agradable ;-)

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

Actualización en octubre de 2017 : con el Nodo v8 (desde v8.3 más o menos) ahora tiene una construcción de difusión de objetos:

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

o dentro de una reducción solamente:

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

Actualización: alguien quiere recursivo? tampoco es tan difícil, solo necesito una verificación adicional de isObject y recursivamente se llama a sí mismo:

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

Mi conclusión: si JavaScript puro puede hacer, evitaría cualquier dependencia de la biblioteca de terceros:

Answer 15

si está usando lodash, puede usar _.compact(array) para eliminar todos los valores _.compact(array) de una matriz.

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

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

Answer 16

pickBy usa identity por defecto:

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

Answer 17

Con lodash (o guión bajo) puede hacer

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

De lo contrario, con JavaScript vainilla, puede hacer

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

No usar una prueba de falsey, porque no solo se rechazará "indefinido" o "nulo" , sino también otros valores de falsey como "falso", "0", cadena vacía, {}. Por lo tanto, solo para hacerlo simple y comprensible, opté por usar una comparación explícita como se codificó anteriormente.

Answer 18

Para objetos anidados profundos y matrices. y excluir valores vacíos de cadena y 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)

resultado:

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

Answer 19

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 }