How to remove a property from an object and/or array if the value is null, undefined or empty?

Question

So I have a fairly complex object like this:

var obj = {
    v1:"ok", 
    v2:[
        {av1:"foo",  av2:null}, // notice there's a null here
        {av1:"thing", av2:"stuff"}
    ], 
    v3: null, 
    v4:{
        ov1:"slim",
        ov2:"shady",
        ov3:null  // null
    }, 
    v5:[], // empty
    v6:{} // empty
}

I'd like to get this back:

var obj = {
    v1:"ok", 
    v2:[{av1:"foo"},{av1:"thing", av2:"stuff"}], 
    v4:{ov1:"slim",ov2:"shady"}
}

I'm trying to write a function that can delete anything that is null, undefined, or empty, but it's quickly becoming a spaghetti nightmare, and doesn't work.

I feel like there's a shorter more elegant way to do this, but this is my code so far:

function deleteNulls(o){
    for(let i in o){
        if(typeof o[i] == "Object"){
            o[i] = deleteNulls(o[i])
        }
        else if(typeof o[i] == "Array"){
            o[i] = deleteNulls(o[i])
        }
        if(o[i] == null || o[i] == "undefined" || o[i] == [] | o[i] == {})
            delete o[i]
        else {
            if(typeof o == "Object"){
                delete this.o[i]
                return o
            }
            else if (typeof o == "Array")
                return o.filter(k => o[k] != null)
        }
    }
    return o
}

var obj = deleteNulls(obj)

I'm not interested in how to fix errors in the code above. I could get this to work if I wanted to,

I'm wondering if there's an easier way.

Answer 1

It helped me writing this solution to split the logic into a recursive clean function (simplifying existing object structures) and a shouldKeep function (which tells you whether a key can be removed entirely from an object structure based on its value).

Demo Snippet:

var object = {
  v1: "ok",
  v2: [{
      av1: "foo",
      av2: null
    }, // notice there's a null here
    {
      av1: "thing",
      av2: "stuff"
    }
  ],
  v3: null,
  v4: {
    ov1: "slim",
    ov2: "shady",
    ov3: null // null
  },
  v5: [], // empty
  v6: {} // empty
}

function shouldKeep (o) {
  if (Array.isArray(o)) {
    return o.length
  } else if (typeof o === 'object') {
    return o && Object.keys(o).length
  }
  return o != null
}


function clean (o) {
  if (Array.isArray(o)) {
    o.forEach(clean)
    var a = o.filter(shouldKeep)
    o.length = a.length
    for (var i = 0; i < a.length; i++) {
      o[i] = a[i]
    }
  } else if (o && typeof o === 'object') {
    Object.keys(o).forEach(function (k) {
      clean(o[k])
      if (!shouldKeep(o[k])) delete o[k]
    })
  }
  return o
}


console.log(clean(object))

.as-console-wrapper { min-height: 100vh; }

Answer 2

Here is my take at it. Should be good enough for most situations.

 var object = {
      v1: "ok",
      v2: [{
          av1: "foo",
          av2: null
        }, // notice there's a null here
        {
          av1: "thing",
          av2: "stuff"
        }
      ],
      v3: null,
      v4: {
        ov1: "slim",
        ov2: "shady",
        ov3: null // null
      },
      v5: [], // empty
      v6: {} // empty
    }

   

    function isEmpty(v) {
      return v == undefined
      || v == null
      || (Array.isArray(v) && v.length === 0)
      || (typeof v === 'object' && Object.keys(v).length === 0)
    }
    
    function removeFalsyFromObject(v) {
      var keys = Object.keys(v);
      keys.forEach(function(k){
        var val = v[k];
        if (isEmpty(val)) {
          delete v[k];
        } else if (Array.isArray(val)) {
          removeFalsyFromArray(val);
        } else if (typeof val === 'object') {
          removeFalsyFromObject(val);
        }
      })
    }
    
    function removeFalsyFromArray(a) {
      for (var i=0; i<a.length; i++) {
        var v = a[i];
        if (isEmpty(v)) {
          a.splice(i,1);
          i--;
        } else if (Array.isArray(v)) {
          removeFalsyFromArray(v);
        } else if (typeof v === 'object') {
          removeFalsyFromObject(v);
        }
      }
    }
    
    function clean(obj) {
      removeFalsyFromObject(obj);
      return obj;
    }

    console.log(clean(object));

Answer 3

I'd suggest using something like lodash. It's tested and peer-reviewed for speed and efficiency.

Something like:

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

This would remove all null values, you'll need to change the second parameter to remove empty objects and arrays.