Function for verifying presence of empty nested elements (comprising of Arrays, Sets, Strings, and Maps)

Question

Function for verifying presence of empty nested elements (comprising of Arrays, Sets, Strings, and Maps)

I am currently exploring ways to develop a solution using plain JS (without relying on any external libraries) that can determine whether a given input is considered 'empty' or not.

Below are the code snippets and test cases I have prepared for this purpose, with expected outcomes specified as comments alongside each test case.

Despite my efforts in creating functions to thoroughly validate these assertions on stackblitz, I have yet to achieve complete coverage.

https://stackblitz.com/edit/node-ksxnjm

const assert = require('assert');



function isEmpty(obj) {
  return Object.keys(obj).every((k) => !Object.keys(obj[k]).length);
}

const test1 = {};                  // expect true
const test2 = { some: 'value' };   // expect false
const test3 = { some: {} };        // expect true
const test4 = [];                  // expect true
const test5 = [[]];                // expect true
const test6 = { some: [] };        // expect true
const test7 = { some: ['barry'] }; // expect false
const test8 = { some: new Map() }; // expect true
const test9 = {
  response: new Map([['body', new Map([['something', {}]])]]),
};                                 // expect true
const test10 = {
  response: '{"body":{"something":{}}}',
};                                 // expect true

const test11 = {
  something: { somethingElse: {} },
};                                 // expect true

assert.strictEqual(isEmpty(test1), true);
assert.strictEqual(isEmpty(test2), false);
assert.strictEqual(isEmpty(test3), true);
assert.strictEqual(isEmpty(test4), true);
assert.strictEqual(isEmpty(test5), true);
assert.strictEqual(isEmpty(test6), true);
assert.strictEqual(isEmpty(test7), false);
assert.strictEqual(isEmpty(test8), true);
assert.strictEqual(isEmpty(test9), true);
assert.strictEqual(isEmpty(test10), true);
assert.strictEqual(isEmpty(test11), true);

While my current function adequately handles most of the provided test cases, it falls short when dealing with nested objects and stringified objects. I find myself at an impasse on how to address this issue.

What approach should I take to accommodate these specific scenarios?

EDIT:

const test12 = {
  something: {
    somethingElse: {
      number: 1,
      someSet: new Set(['garry']),
    },
  },
}; // should evaluate to false

const test13 = new Map([
    ['something', new Map([
        ['somethingElse', new Map([
            ['number', 1],
            ['someSet', new Set(['garry'])]
        ])]
    ])]
]); // should also evaluate to false

javascript arrays json string set

Answer 1

Answer №1

To determine if a value is empty, you can utilize a recursive function structured as follows:

Begin by verifying if the passed value is an object
If the object contains a values function, fetch the values using Array.from(o.values()) (This works for Set, Map, and Array objects)
Recursively invoke the isEmpty function on each value
If the input value is a string, validate if it is truthy (You may customize this part accordingly)

function isEmpty(o) {
  if (typeof o === "object") {
    let values = typeof o.values === "function"
                  ? Array.from(o.values())
                  : Object.values(o)
    
    return values.every(isEmpty)
  } else {
    var parsed = parseJsonString(o)
    return parsed ? isEmpty(parsed) : !o
  }
};

function parseJsonString(str) {
    try {
        return typeof str === 'string' && JSON.parse(str);
    } catch (e) {
        return '';
    }
}

Here's a snippet that you can run to test the function:

...
(additional code snippets for testing purposes)
...

Answer 2

To determine if a value is empty, you can utilize a recursive function structured as follows:

Begin by verifying if the passed value is an object
If the object contains a values function, fetch the values using Array.from(o.values()) (This works for Set, Map, and Array objects)
Recursively invoke the isEmpty function on each value
If the input value is a string, validate if it is truthy (You may customize this part accordingly)

function isEmpty(o) {
  if (typeof o === "object") {
    let values = typeof o.values === "function"
                  ? Array.from(o.values())
                  : Object.values(o)
    
    return values.every(isEmpty)
  } else {
    var parsed = parseJsonString(o)
    return parsed ? isEmpty(parsed) : !o
  }
};

function parseJsonString(str) {
    try {
        return typeof str === 'string' && JSON.parse(str);
    } catch (e) {
        return '';
    }
}

Here's a snippet that you can run to test the function:

...
(additional code snippets for testing purposes)
...

Answer 3

Answer №2

In order to tackle this challenge effectively, I believe utilizing Recursion is the best approach.

Firstly, it's crucial to determine the type of data you are currently dealing with and then check if there is any content within it. If there is, you will need to recursively call the isEmpty function to examine the inner data type and content.

const isEmpty = value  =>{
  if(typeof value === 'object'){
    if(Object.keys(value).length === 0) return true
    for (const property in value) {
     isEmpty(property)
    }
    
    
  }
  else if(typeof value === 'string'){
    //check for string 
  }
  //...
  //...
  //...
  //other data types
}

Answer 4

In order to tackle this challenge effectively, I believe utilizing Recursion is the best approach.

Firstly, it's crucial to determine the type of data you are currently dealing with and then check if there is any content within it. If there is, you will need to recursively call the isEmpty function to examine the inner data type and content.

const isEmpty = value  =>{
  if(typeof value === 'object'){
    if(Object.keys(value).length === 0) return true
    for (const property in value) {
     isEmpty(property)
    }
    
    
  }
  else if(typeof value === 'string'){
    //check for string 
  }
  //...
  //...
  //...
  //other data types
}

Function for verifying presence of empty nested elements (comprising of Arrays, Sets, Strings, and Maps)

Answer №1

Answer №2

Similar questions

Discover the steps to update the information displayed on a tab through $stateProvider

Tips for clearing an observable in Angular version 4

Unable to call component method after exporting with connect in React Redux

Tips for modifying the color of a query term in HTML

Retrieving a JSON string by looping through an array nested inside an object

Searching for specific items within an array of objects using Mongoose

The tooltip content is a little too narrow

Discover the complete guide on incorporating a JavaScript library with additional dependencies in Angular 2

Bootbox Dialog Form

Executing a JavaScript function without passing arguments does not yield the desired result

Merging data between two JsonBuilder objects

Guide on designing a navigation list with unique buttons that alter the displayed content based on the selected button

Tips for adding a placeholder in a login form on Drupal 7

Guide to changing the background color of material ui drawer component using styled-components

Using jQuery to target the td:nth-child selector inside a document.ready function is not viable

Searching for a file using Powershell in one directory and replacing it with a different file in another directory based on

HTML script tag without a specified type

Improve the organization of my JavaScript code

I've been attempting to develop a React application, but I consistently encounter the following error: "npm ERR! cb() function was never invoked!"

Trouble with linking an external JavaScript file in HTML document