Rimuovi gli attributi vuoti da un object in Javascript

Come rimuovere tutti gli attributi undefined o null in un object JavaScript?

(La domanda è simile a questa per gli array)

Puoi scorrere l’object:

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

Se sei preoccupato per la rimozione di questa proprietà non eseguendo la catena del proptype dell’object, puoi anche:

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

Alcune note su 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 

Utilizzando alcuni ES6 / ES2015 :

1) Un one-liner semplice per rimuovere gli articoli inline senza incarico:

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

jsbin

2) Questo esempio è stato rimosso …

3) Primo esempio scritto come funzione:

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

jsbin

4) Questa funzione utilizza la ricorsione per eliminare anche gli oggetti nidificati:

 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) Questo è simile a 4), ma invece di mutare direttamente l’object sorgente, restituisce un nuovo object.

 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 approccio funzionale a 4b) basato sulla risposta di @ MichaelJ.Zoidl usando filter() e reduce() . Questo restituisce anche un nuovo object:

 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) Come 4) ma con Object.entries 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) Come 4) ma in ES5 normale:

 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

Se stai usando lodash o underscore.js, ecco una soluzione semplice:

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

Funzionerà solo con lodash 4, pre lodash 4 o underscore.js, usa _.pick(obj, _.identity) ;

Se qualcuno ha bisogno di una versione ricorsiva della risposta di Owen (e di Eric), eccola:

 /** * 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); } } } 

Probabilmente stai cercando la parola chiave delete .

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

JSON.stringify rimuove le chiavi non definite.

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

È ansible utilizzare una combinazione di JSON.stringify , il suo parametro replacer e JSON.parse per trasformarlo in un object. L’utilizzo di questo metodo significa anche che la sostituzione viene eseguita su tutte le chiavi annidate all’interno di oggetti nidificati.

Oggetto di esempio

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

Funzione di sostituzione

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

Pulisci l’object

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

Esempio CodePen

Soluzione pura ES6 più breve, convertirla in un array, utilizzare la funzione filtro e convertirla nuovamente in un object. Sarebbe anche facile fare una funzione …

Btw. con questo .length > 0 controllo se c’è una stringa / matrice vuota, quindi rimuoverà le chiavi vuote.

 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

Per una ricerca approfondita ho usato il seguente codice, forse sarà utile per chiunque guardi questa domanda (non è utilizzabile per le dipendenze cicliche):

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

Se qualcuno ha bisogno di rimuovere valori undefined da un object con ricerca profonda usando lodash ecco il codice che sto usando. È abbastanza semplice modificarlo per rimuovere tutti i valori vuoti ( 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; }, {}); } 

Usando ramda # pickBy :

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

Se non si desidera effettuare la mutazione sul posto, ma restituire un clone con il valore null / undefined rimosso, è ansible utilizzare la funzione di riduzione 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; }, {}); } 

Invece di cancellare la proprietà, puoi anche creare un nuovo object con le chiavi che non sono nulle.

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

puoi accorciare ! condizione

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

Ricorda l’uso: come @semicolor annuncia nei commenti: eliminerebbe anche le proprietà se il valore è una stringa vuota, falsa o uguale a zero

A piggypack sulla risposta di Ben su come risolvere questo problema usando il _.pickBy di _.pickBy , puoi anche risolvere questo problema nella libreria _.pick : _.pick Underscore.js .

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

Vedi: Esempio JSFiddle

La soluzione Lodash più semplice ansible per restituire un object con i valori null e undefined filtrati.

_.omitBy(obj, _.isNil)

Se si utilizza eslint e si desidera evitare di far scattare la regola no-param-riassegna, è ansible utilizzare Object.assign in congiunzione con .reduce e un nome di proprietà calcolato per una soluzione ES6 abbastanza 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 } 

Se vuoi 4 linee di una soluzione ES7 pura:

 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 se preferisci una versione più leggibile:

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

Ciò manterrà valori booleani e pulirà anche gli array. Conserva anche l’object originale restituendo una copia pulita.

Ecco un modo funzionale per rimuovere i nulls da un object usando ES6 senza mutare l’object usando solo reduce :

 const stripNulls = (obj) => { return Object.keys(obj).reduce((acc, current) => { if (obj[current] !== null) { return { ...acc, [current]: obj[current] } } return acc }, {}) } 

Questa funzione può pulire l’object vuoto dopo aver rimosso i vuoti invidival all’interno dell’object o dell’array. questo assicura che non ci sia un array o un object vuoto in giro.

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

Sotto soluzione rimuove null e empty object
L’ empty object o {} è un residuo dovuto alla pulizia null

Per pulire un object usa il sotto

 /** * 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) 

Con Lodash:

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

Ho lo stesso scenario nel mio progetto e ottenuto utilizzando il seguente metodo.

Funziona con tutti i tipi di dati, alcuni di quelli sopra citati non funzionano con gli array data e vuoti.

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; } 
 const sampleObj = { prop1: 1, prop2:'foo', prop3: '', prop4: null, prop5: undefined, }; const filterNullValue = (sampleObj) => { let resultObj = {}; Object.keys(sampleObj).map((propertyKey) => { if (sampleObj[propertyKey]) { resultObj[propertyKey] = sampleObj[propertyKey]; } }); return resultObj; }; console.log(filterNullValue(sampleObj)); 

Approccio puro funzionale utilizzando una funzione astratta

In generale, vorremmo ottenere un nuovo object che non contenga determinati valori. Usa ES7:

 const getObjWithoutVals = (dontReturnValsArr, obj) => ( Object.entries(obj).reduce( (newObj, [key, val]) => { if(!dontReturnValsArr.includes(val)) newObj[key]= val return newObj } , {} ) ) 

Caso privato: rimuovi i valori vuoti

Prima di tutto, rendiamo disponibile la nostra funzione, quindi possiamo usarla per questo scenario.

 const curriedGetObjWithout = R.curry(getObjWithoutVals) 

Ora creiamo una nuova funzione che esclude i valori vuoti

 const getObjWithoutEmpty = curriedGetObjWithout(["", null, undefined]) 

Esiste un modo semplice per eseguire questa attività. Questo si ottiene usando il metodo 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 trova gli elementi di una matrice che soddisfano una funzione di filtro. In questo caso, qualsiasi attributo che non sia nullo