objetos - Eliminar atributos en blanco de un objeto en Javascript

recorrer array de objetos javascript

Question

¿Cómo elimino todos los atributos que son undefined o null en un objeto JavaScript?

(La pregunta es similar a esta para Arrays)

Answer 1

Con Lodash:

_.omitBy({a: 1, b: null}, (v) => !v)

Answer 2

Debajo de la solución se eliminan empty object null y empty object
El empty object o {} es un residuo debido a una limpieza null

Para limpiar un objeto usa el siguiente

/**
* Delete all null (or undefined) properties from an object.
* Set ''recurse'' to true if you also want to delete properties in nested objects.
*/
function delete_null_properties(test, recurse) {
for (var i in test) {
if (test[i] === null || test[i] === undefined) {
delete test[i];
}
// recurse for array and object
else if (recurse && typeof test[i] === ''object'') {
test[i] = delete_null_properties(test[i], recurse);
}
if((test[i] && typeof(test[i]) === ''object'') &&
(Object.keys(test[i]).length === 0 || test[i] == [{}])) {
// delete the child property if its empty
delete test[i]
}
if(test == {}){
// delete empty ''parent'' object when there is a residue due to deletion
// of its child properties
delete test
} else if(test instanceof Array && test[i] == undefined) {
// in the case of array removed null childs by splicing it off
test.splice(i,1)
// however if the parent array itself goes empty remove it off
if(test instanceof Array && test.length == 0) {
test = null
}
}
}
return test
}
delete_null_properties(obj, true)

Answer 3

En lugar de eliminar la propiedad, también puede crear un nuevo objeto con las claves que no son nulas.

const removeEmpty = (obj) => {
return Object.keys(obj).filter(key => obj[key]).reduce(
(newObj, key) => {
newObj[key] = obj[key]
return newObj
}, {}
)
}

Answer 4

Esta función puede limpiar el objeto vacío después de eliminar los vacíos invidivales dentro del objeto o matriz. esto garantiza que no tenga un conjunto u objeto vacío.

function removeNullsInObject(obj) {
if( typeof obj === ''string'' || obj === "" ){
return;
}
$.each(obj, function(key, value){
if (value === "" || value === null){
delete obj[key];
} else if ($.isArray(value)) {
if( value.length === 0 ){
delete obj[key];
return;
}
$.each(value, function (k,v) {
removeNullsInObject(v);
});
if( value.length === 0 ){
delete obj[key];
}
} else if (typeof value === ''object'') {
if( Object.keys(value).length === 0 ){
delete obj[key];
return;
}
removeNullsInObject(value);
if( Object.keys(value).length === 0 ){
delete obj[key];
}
}
});
}

Answer 5

Existe una manera fácil de ejecutar esta tarea. Esto lo logra usando el método jQuery $.grep .

var test = {
a: null,
b: ''hello world'',
c: 12345
}
var newTest = $.grep(
test,
function(element, index) {
return (test[element] && test[element] != null);
}
);
// newTest = { b: ''hello world'', c: 12345 }

$.grep encuentra los elementos de una matriz que satisfacen una función de filtro. En este caso, cualquier atributo que no sea nulo

Answer 6

JSON.stringify elimina las claves indefinidas.

removeUndefined = function(json){
return JSON.parse(JSON.stringify(json))
}

Answer 7

La solución Lodash más simple posible para devolver un objeto con los valores null e undefined filtrados.

_.omitBy(obj, _.isNil)

Answer 8

Para cargar la respuesta de Ben sobre cómo resolver este problema usando _.pickBy de _.pickBy , también puede resolver este problema en la biblioteca hermana: _.pick Underscore.js .

var obj = {name: ''John'', age: null};
var compacted = _.pick(obj, function(value) {
return value !== null && value !== undefined;
});

Ver: Ejemplo JSFiddle

Answer 9

Para una búsqueda profunda usé el siguiente código, tal vez sea útil para cualquiera que mire esta pregunta (no se puede usar para dependencias cíclicas):

function removeEmptyValues(obj) {
for (var propName in obj) {
if (!obj[propName] || obj[propName].length === 0) {
delete obj[propName];
} else if (typeof obj === ''object'') {
removeEmptyValues(obj[propName]);
}
}
return obj;
}

Answer 10

Probablemente estés buscando la palabra clave delete .

var obj = { };
obj.theProperty = 1;
delete obj.theProperty;

Answer 11

Puede recorrer el objeto:

var test = {
test1 : null,
test2 : ''somestring'',
test3 : 3,
}
function clean(obj) {
for (var propName in obj) {
if (obj[propName] === null || obj[propName] === undefined) {
delete obj[propName];
}
}
}
clean(test);

Si le preocupa que esta eliminación de propiedad no ejecute la cadena de proptype del objeto, también puede:

function clean(obj) {
var propNames = Object.getOwnPropertyNames(obj);
for (var i = 0; i < propNames.length; i++) {
var propName = propNames[i];
if (obj[propName] === null || obj[propName] === undefined) {
delete obj[propName];
}
}
}

Algunas notas sobre null vs undefined:

test.test1 === null; // true
test.test1 == null; // true
test.notaprop === null; // false
test.notaprop == null; // true
test.notaprop === undefined; // true
test.notaprop == undefined; // true

Answer 12

Puede usar este componente de limpieza de objeto para limpiar todas las propiedades de falsy de un objeto y devolver un nuevo objeto sin ellas.

Ejemplos:

new cleaned object
clean({ foo: null, bar: ''foo'' }) // => { bar: ''foo'' }

Answer 13

Puede usar una combinación de JSON.stringify , su parámetro JSON.parse y JSON.parse para volver a convertirlo en un objeto. El uso de este método también significa que el reemplazo se realiza a todas las claves anidadas dentro de los objetos anidados.

Objeto de ejemplo

var exampleObject = {
string: ''value'',
emptyString: '''',
integer: 0,
nullValue: null,
array: [1, 2, 3],
object: {
string: ''value'',
emptyString: '''',
integer: 0,
nullValue: null,
array: [1, 2, 3]
},
arrayOfObjects: [
{
string: ''value'',
emptyString: '''',
integer: 0,
nullValue: null,
array: [1, 2, 3]
},
{
string: ''value'',
emptyString: '''',
integer: 0,
nullValue: null,
array: [1, 2, 3]
}
]
};

Función de reemplazo

function replaceUndefinedOrNull(key, value) {
if (value === null || value === undefined) {
return undefined;
}
return value;
}

Limpia el objeto

exampleObject = JSON.stringify(exampleObject, replaceUndefinedOrNull);
exampleObject = JSON.parse(exampleObject);

Ejemplo de CodePen

Answer 14

Si alguien necesita eliminar valores undefined de un objeto con una búsqueda profunda usando lodash , aquí está el código que estoy usando. Es bastante simple modificarlo para eliminar todos los valores vacíos ( null / undefined ).

function omitUndefinedDeep(obj) {
return _.reduce(obj, function(result, value, key) {
if (_.isObject(value)) {
result[key] = omitUndefinedDeep(value);
}
else if (!_.isUndefined(value)) {
result[key] = value;
}
return result;
}, {});
}

Answer 15

Si alguien necesita una versión recursiva de la respuesta de Owen (y de Eric), aquí está:

/**
* Delete all null (or undefined) properties from an object.
* Set ''recurse'' to true if you also want to delete properties in nested objects.
*/
function delete_null_properties(test, recurse) {
for (var i in test) {
if (test[i] === null) {
delete test[i];
} else if (recurse && typeof test[i] === ''object'') {
delete_null_properties(test[i], recurse);
}
}
}

Answer 16

Si está usando lodash o underscore.js, aquí hay una solución simple:

var obj = {name: ''John'', age: null};
var compacted = _.pickBy(obj);

Esto solo funcionará con lodash 4, pre lodash 4 o underscore.js, use _.pick(obj, _.identity) ;

Answer 17

Si no quiere mutar en su lugar, pero devuelve un clon con el nulo / indefinido eliminado, puede utilizar la función de reducción de ES6.

// Helper to remove undefined or null properties from an object
function removeEmpty(obj) {
// Protect against null/undefined object passed in
return Object.keys(obj || {}).reduce((x, k) => {
// Check for null or undefined
if (obj[k] != null) {
x[k] = obj[k];
}
return x;
}, {});
}

Answer 18

Si quieres 4 líneas de una solución pura de ES7:

const clean = e => e instanceof Object ? Object.entries(e).reduce((o, [k, v]) => {
if (typeof v === ''boolean'' || v) o[k] = clean(v);
return o;
}, e instanceof Array ? [] : {}) : e;

O si prefiere una versión más legible:

function filterEmpty(obj, [key, val]) {
if (typeof val === ''boolean'' || val) {
obj[key] = clean(val)
};
return obj;
}
function clean(entry) {
if (entry instanceof Object) {
const type = entry instanceof Array ? [] : {};
const entries = Object.entries(entry);
return entries.reduce(filterEmpty, type);
}
return entry;
}

Esto preservará los valores booleanos y también limpiará las matrices. También conserva el objeto original devolviendo una copia limpia.

Answer 19

Si usa eslint y desea evitar el disparo de la regla no-param-reasignación, puede usar Object.assign junto con .reduce y un nombre de propiedad calculado para una solución ES6 bastante elegante:

const queryParams = { a: ''a'', b: ''b'', c: ''c'', d: undefined, e: null, f: '''', g: 0 };
const cleanParams = Object.keys(queryParams)
.filter(key => queryParams[key] != null)
.reduce((acc, key) => Object.assign(acc, { [key]: queryParams[key] }), {});
// { a: ''a'', b: ''b'', c: ''c'', f: '''', g: 0 }

Answer 20

Solución pura ES6 más corta, conviértala en una matriz, usa la función de filtro y conviértela de nuevo en un objeto. También sería fácil hacer una función ...

Por cierto. con this .length > 0 compruebo si hay un string / array vacío, por lo que eliminará las claves vacías.

const MY_OBJECT = { f: ''te'', a: [] }
Object.keys(MY_OBJECT)
.filter(f => !!MY_OBJECT[f] && MY_OBJECT[f].length > 0)
.reduce((r, i) => { r[i] = MY_OBJECT[i]; return r; }, {});

JS BIN https://jsbin.com/kugoyinora/edit?js,console

Answer 21

Tengo el mismo escenario en mi proyecto y logré usar el siguiente método.

Funciona con todos los tipos de datos, pocos de los mencionados anteriormente no funcionan con la fecha y las matrices vacías.

removeEmptyKeysFromObject.js

removeEmptyKeysFromObject(obj) {
Object.keys(obj).forEach(key => {
if (Object.prototype.toString.call(obj[key])  ===  ''[object Date]'' && obj[key].toString().length === 0) {
delete obj[key];
} else if (obj[key] && typeof obj[key] === ''object'') {
this.removeEmptyKeysFromObject(obj[key]);
} else if (obj[key] == null || obj[key] === "") {
delete obj[key];
}
if (obj[key] && typeof obj[key] === ''object'' && Object.keys(obj[key]).length === 0 && Object.prototype.toString.call(obj[key])  !==  ''[object Date]'') {
delete obj[key];
}
});
return obj;
}

pasar cualquier objeto a esta función removeEmptyKeysFromObject ()

Answer 22

Usando ramda#pickBy :

const obj = {a:1, b: undefined, c: null, d: 1}
R.pickBy(R.identity, obj)

Answer 23

Usando algo de ES6 / ES2015 :

1) Un simple trazador de líneas para quitar los artículos en línea sin asignación:

Object.keys(myObj).forEach((key) => (myObj[key] == null) && delete myObj[key]);

jsbin

2) Este ejemplo fue eliminado ...

3) Primer ejemplo escrito como una función:

const removeEmpty = (obj) => {
Object.keys(obj).forEach((key) => (obj[key] == null) && delete obj[key]);
}

jsbin

4) Esta función usa recursión para eliminar elementos de objetos anidados también:

const removeEmpty = (obj) => {
Object.keys(obj).forEach(key => {
if (obj[key] && typeof obj[key] === ''object'') removeEmpty(obj[key]);
else if (obj[key] == null) delete obj[key];
});
};

jsbin

4b) Esto es similar a 4), pero en lugar de mutar el objeto fuente directamente, devuelve un nuevo objeto.

const removeEmpty = (obj) => {
const o = JSON.parse(JSON.stringify(obj)); // Clone source oect.
Object.keys(o).forEach(key => {
if (o[key] && typeof o[key] === ''object'')
o[key] = removeEmpty(o[key]); // Recurse.
else if (o[key] === undefined || o[key] === null)
delete o[key]; // Delete undefined and null.
else
o[key] = o[key]; // Copy value.
});
return o; // Return new object.
};

5) Un acercamiento funcional a 4b) basado en la respuesta de @ MichaelJ.Zoidl usando filter() y reduce() . Este también devuelve un nuevo objeto:

const removeEmpty = (obj) =>
Object.keys(obj)
.filter(k => obj[k] !== null && obj[k] !== undefined) // Remove undef. and null.
.reduce((newObj, k) =>
typeof obj[k] === ''object'' ?
Object.assign(newObj, {[k]: removeEmpty(obj[k])}) : // Recurse.
Object.assign(newObj, {[k]: obj[k]}), // Copy value.
{});

jsbin

6) Igual que 4) pero con ES7 / 2016 Object.entries() .

const removeEmpty = (obj) =>
Object.entries(obj).forEach(([key, val]) => {
if (val && typeof val === ''object'') removeEmpty(val)
else if (val == null) delete obj[key]
})

7) Igual que 4) pero en ES5 simple:

function removeEmpty(obj) {
Object.keys(obj).forEach(function(key) {
if (obj[key] && typeof obj[key] === ''object'') removeEmpty(obj[key])
else if (obj[key] == null) delete obj[key]
});
};

jsbin

Answer 24

puedes hacer más corto con ! condición

var r = {a: null, b: undefined, c:1};
for(var k in r)
if(!r[k]) delete r[k];

Recuerde en el uso: como @semicolor anunciar en comentarios: Esto también eliminaría las propiedades si el valor es una cadena vacía, falso o cero