Benchmark: cleanObjectFromEmptyData impl vs fast-clean

Script Preparation code:
var isPlainObject = (value) => value !== null && typeof value === 'object' && !Array.isArray(value);
var isEmpty = (value) => {
    return (value === undefined ||
        value === null ||
        value === '' ||
        (typeof value === 'object' && Object.keys(value).length === 0));
};

var cleanObjectFromEmptyData1 = (obj, allowEmpty, deleteEmptyValues = false) => {
    const result = {};
    for (const [key, value] of Object.entries(obj)) {
        if (allowEmpty === null || allowEmpty === void 0 ? void 0 : allowEmpty.includes(key)) {
            result[key] = value;
            continue;
        }
        if (value === undefined) {
            continue;
        }
        if (isPlainObject(value)) {
            const cleanedValue = cleanObjectFromEmptyData1(value, allowEmpty, deleteEmptyValues);
            if (!isEmpty(cleanedValue)) {
                result[key] = cleanedValue;
            }
            continue;
        }
        if (Array.isArray(value)) {
            const cleanedArray = value
                .map((item) => (isPlainObject(item) ? cleanObjectFromEmptyData1(item, allowEmpty, deleteEmptyValues) : item))
                .filter((item) => !isEmpty(item));
            if (cleanedArray.length > 0 || !deleteEmptyValues) {
                result[key] = cleanedArray;
            }
            continue;
        }
        if (!deleteEmptyValues || !isEmpty(value)) {
            result[key] = value;
        }
    }
    return result;
};


var cleanObjectFromEmptyData2 = (obj, allowEmpty, deleteEmptyValues = false) => {
    return Object.entries(obj).reduce((acc, [key, value]) => {
        if (allowEmpty === null || allowEmpty === void 0 ? void 0 : allowEmpty.includes(key)) {
            acc[key] = value;
            return acc;
        }
        if (value === undefined) {
            return acc;
        }
        if (isPlainObject(value)) {
            const cleanedValue = cleanObjectFromEmptyData2(value, allowEmpty, deleteEmptyValues);
            if (isEmpty(cleanedValue)) {
                return acc;
            }
            acc[key] = cleanedValue;
            return acc;
        }
        if (Array.isArray(value)) {
            acc[key] = value.map((array) => cleanObjectFromEmptyData2(array, allowEmpty, deleteEmptyValues));
            return acc;
        }
        if (deleteEmptyValues && isEmpty(value)) {
            return acc;
        }
        acc[key] = value;
        return acc;
    }, {});
};

class Cleaner {
  constructor(options) {
    this.options = options
  }

  clean(data) {
    if(!data) return data;
    
    if(Array.isArray(data)) return this._cleanArray(data);

    if(this._isObject(data)) return this.options.cleanInPlace? this._cleanObjectInPlace(data) : this._cleanObject(data);

    return data;
  }

  _cleanArray(arr) {
    return this.options.cleanInPlace ? this._getFilteredArrayInPlace(arr) : this._getFilteredArray(arr)
  }

  _cleanObjectInPlace(object) {
    Object.keys(object).forEach((key) => {
      const value = object[key];

      if (Array.isArray(value)) {
        const mappedArr = this._cleanArray(value);
        if(this._shouldReturnArray(mappedArr)) object[key] = mappedArr;
        else delete object[key];
      } else if (this._isObject(value)) {
        const subFiltered = this.clean(value);
        if(this._shouldReturnObject(subFiltered)) object[key] = subFiltered;
        else delete object[key];
      } else {
        if (this._shouldRemoveValue(value)) delete object[key]
      }
    })

    return object
  }

  _cleanObject(object) {
    const filtered = {};
  
    Object.keys(object).forEach(key => {
      const value = object[key];

      if (Array.isArray(value)) {
        const mappedArr = this._cleanArray(value);
        if (this._shouldReturnArray(mappedArr)) filtered[key] = mappedArr;
      } else if (this._isObject(value)) {
        const subFiltered = this.clean(value);
        if (this._shouldReturnObject(subFiltered)) filtered[key] = subFiltered;
      } else {
        if (!this._shouldRemoveValue(value)) filtered[key] = value;
      }
    });
  
    return filtered;
  }

  _getFilteredArrayInPlace (arr) {
    for (let i = arr.length - 1; i >= 0; i--) {
      const item = arr[i];
      const filteredItem = this.clean(item);

      if(this._isObject(filteredItem)) {
        if(this._shouldReturnObject(filteredItem)) arr[i] = filteredItem
        else arr.splice(i , 1);
      }
      else if(Array.isArray(filteredItem)) {
        if (this._shouldReturnArray(filteredItem)) arr[i] = filteredItem
        else arr.splice(i, 1);
      }
      else if(this._shouldRemoveValue(filteredItem)) arr.splice(i, 1);
    }

    return arr;
  }

  _getFilteredArray (arr) {
    const filteredArr = [];
    arr.forEach(item => {
      const filteredItem = this.clean(item);
      if(this._isObject(filteredItem)) {
        if(this._shouldReturnObject(filteredItem)) filteredArr.push(filteredItem);
      }
      else if(Array.isArray(filteredItem)) {
        if (this._shouldReturnArray(filteredItem)) filteredArr.push(filteredItem);
      }
      else if(!this._shouldRemoveValue(filteredItem)) filteredArr.push(filteredItem);
    });
  
    return filteredArr;
  }

  _isObject (value) {
    return Object.prototype.toString.call(value) === "[object Object]"
  }

  _shouldReturnArray (arr) {
    return !this.options.emptyArraysCleaner || arr.length !== 0
  }

  _shouldReturnObject (object) {
    return !this.options.emptyObjectsCleaner || Object.keys(object).length !== 0
  }

  _shouldRemoveValue (value) {
    if(value === null) return this.options.nullCleaner
  
    if(value === "") return this.options.emptyStringsCleaner
  
    if(Number.isNaN(value)) return this.options.nanCleaner

    if(value === undefined) return true
  
    return false
  }
}

const getDefaultOptions = (options) => {
  const optionsToRead = options || {}

  const defaultedOptions = {
    nullCleaner: optionsToRead.hasOwnProperty('nullCleaner') ? optionsToRead.nullCleaner : true,
    emptyArraysCleaner: optionsToRead.hasOwnProperty('emptyArraysCleaner') ? optionsToRead.emptyArraysCleaner : true,
    emptyObjectsCleaner: optionsToRead.hasOwnProperty('emptyObjectsCleaner') ? optionsToRead.emptyObjectsCleaner : true,
    emptyStringsCleaner: optionsToRead.hasOwnProperty('emptyStringsCleaner') ? optionsToRead.emptyStringsCleaner : true,
    nanCleaner: optionsToRead.hasOwnProperty('nanCleaner') ? optionsToRead.nanCleaner : true,
    cleanInPlace: optionsToRead.hasOwnProperty('cleanInPlace') ? optionsToRead.cleanInPlace : true,
  }

  return defaultedOptions
}

var clean = (object, options) => {
    const defaultedOptions = getDefaultOptions(options)
    const cleaner = new Cleaner(defaultedOptions);
    return cleaner.clean(object);
  };


 var obj = {
      a: {
        b: {
          c: '',
          d: {
            e: null,
            f: 'value',
            g: {
              h: '',
              i: 'value2',
            },
            j: undefined,
            k: 0,
          },
        },
      },
      j: undefined,
    };
Tests:
cleanObjectFromEmptyData1
cleanObjectFromEmptyData1(obj, undefined, true);
cleanObjectFromEmptyData2
cleanObjectFromEmptyData2(obj, undefined, true);
clean
clean(obj, undefined, true);
Rendered benchmark preparation results:
Suite status: <idle, ready to run>

Previous results
Test case name	Result
cleanObjectFromEmptyData1
cleanObjectFromEmptyData2
clean
cleanObjectFromEmptyData impl vs fast-clean (version: 0)

Comparing performance of: cleanObjectFromEmptyData1 vs cleanObjectFromEmptyData2 vs clean

Created: one year ago by: Registered User

Jump to the latest result

cleanObjectFromEmptyData1

cleanObjectFromEmptyData2

clean

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

No previous run results
