navigating through a JSON to find an empty array field

Question

navigating through a JSON to find an empty array field

Can someone assist me with the following JSON problem?

{
"loanDetails": [
{
  "vehicleDetail": {
    "RCBookImageReferences": {
      "imagePathReferences": [
        {

        }
      ]
    }
  },
  "chargeDetails": [
    {

    }
  ],
  "commissionDetails": [
    {

    }
  ],
  "disbursementDetails": [
    {

    }
  ]
}

] } In the above JSON, I am looking to iterate through each key and if it's empty, then set the parent as an empty array. The desired output is:

{"loanDetails":[]}

I tried using the code snippet below:

function isEmpty(obj) {
for(var prop in obj) {
    if(obj.hasOwnProperty(prop))
        return false;
}

return true;
}

However, this code did not give me the expected result. I seem to be stuck at this point. Any help will be greatly appreciated.

javascript json object

Answer 1

Answer №1

In the wipedClean function, we take a closer look at an object by iterating through its keys and recursively applying the wipedClean function to any nested objects. If after cleaning an object, it turns out to be empty, we remove the key associated with that object. If the main object itself ends up being empty, we return undefined, prompting the deletion of the property containing this empty object.

function wipedClean(obj) {
    var isVacant = true;
    for (var index in obj) {
        var content = obj[index];
        if (content === null || typeof content !== 'object' || (obj[index] = wipedClean(content))) {
            isVacant = false;
        } else {
            delete obj[index];
        }
    }
    return isVacant ? undefined : obj;
}

>> data = { name: "John", age: 30, address: { city: "New York" }, info: { date: { year: 2023 } } }
>> wipedClean(data)
<< Object {name: "John", age: 30}

Answer 2

In the wipedClean function, we take a closer look at an object by iterating through its keys and recursively applying the wipedClean function to any nested objects. If after cleaning an object, it turns out to be empty, we remove the key associated with that object. If the main object itself ends up being empty, we return undefined, prompting the deletion of the property containing this empty object.

function wipedClean(obj) {
    var isVacant = true;
    for (var index in obj) {
        var content = obj[index];
        if (content === null || typeof content !== 'object' || (obj[index] = wipedClean(content))) {
            isVacant = false;
        } else {
            delete obj[index];
        }
    }
    return isVacant ? undefined : obj;
}

>> data = { name: "John", age: 30, address: { city: "New York" }, info: { date: { year: 2023 } } }
>> wipedClean(data)
<< Object {name: "John", age: 30}

Answer 3

Answer №2

To create recursion, two solutions are provided.

Solution 1: Implementing an empty test function

var boolValue = true;
for(var prop in obj) {
    if(obj.hasOwnProperty(prop) && typeof obj[prop] === 'object')
    {
        boolValue = recursiveIsEmpty(obj[prop]);
    }
    else
    {
        return false;
    }
}

return boolValue;

//check and set empty string
recursiveIsEmpty(jsonDataObj['loanDetails']) ? jsonDataObj['loanDetails'] = [] : null;

Solution 2: Utilizing a recursive empty function that clears the parent object

function recursiveIsEmpty(obj) {
    var boolValue = true;
    for(var prop in obj) {
        if(obj.hasOwnProperty(prop) && typeof obj[prop] === 'object')
        {
            boolValue = recursiveIsEmpty(obj[prop]);
            if (boolValue)
            {
                delete obj[prop]; //empty object detected, so remove from parent;
            }
        }
        else
        {
            return false;
        }
    }

    return boolValue; //returns an empty object
}

recursiveIsEmpty(jsonDataObj['loanDetails']); //results in jsonDataObj['loanDetails'] being emptied []

This method determines if an object has properties that are objects. If it does, it drills down into those objects to check their properties. If a non-object property is encountered, return false is triggered, indicating that the object is not empty.

Answer 4

To create recursion, two solutions are provided.

Solution 1: Implementing an empty test function

var boolValue = true;
for(var prop in obj) {
    if(obj.hasOwnProperty(prop) && typeof obj[prop] === 'object')
    {
        boolValue = recursiveIsEmpty(obj[prop]);
    }
    else
    {
        return false;
    }
}

return boolValue;

//check and set empty string
recursiveIsEmpty(jsonDataObj['loanDetails']) ? jsonDataObj['loanDetails'] = [] : null;

Solution 2: Utilizing a recursive empty function that clears the parent object

function recursiveIsEmpty(obj) {
    var boolValue = true;
    for(var prop in obj) {
        if(obj.hasOwnProperty(prop) && typeof obj[prop] === 'object')
        {
            boolValue = recursiveIsEmpty(obj[prop]);
            if (boolValue)
            {
                delete obj[prop]; //empty object detected, so remove from parent;
            }
        }
        else
        {
            return false;
        }
    }

    return boolValue; //returns an empty object
}

recursiveIsEmpty(jsonDataObj['loanDetails']); //results in jsonDataObj['loanDetails'] being emptied []

This method determines if an object has properties that are objects. If it does, it drills down into those objects to check their properties. If a non-object property is encountered, return false is triggered, indicating that the object is not empty.

Answer 5

Answer №3

The JSON-string you provided is invalid and needs to be corrected before proceeding. You can utilize a reviver function parameter (refer to the MDN) to eliminate 'empty' arrays based on specific criteria.

To elaborate, the reviver function handles the traversal of all levels within the parsed object. If it returns undefined, the property will be removed from the object. The provided snippet showcases how the reviver function removes properties containing empty arrays or objects.

This demonstration highlights the process:

// Corrected JSON string
var foo = '{"loanDetails": [{"vehicleDetail": {"RCBookImageReferences": '+
          '{"imagePathReferences": [{}]}}, "chargeDetails": [{}],'+
          '"commissionDetails": [{}],"disbursementDetails": [{}]}]}';

// Parsing with reviver parameter
var fooparsed = JSON.parse(foo,
                            function (key, value) { 
                                return (value.length && value.length == 1 && 
                                        value[0] instanceof Object && 
                                        Object.keys(value[0]).length == 0) ||
                                        value instanceof Array && !value.length
                                    ? undefined : value; 
                            }
                );
// Printing the result
Helpers.log2Screen(Object.print(fooparsed));

<script src="http://kooiinc.github.io/JSHelpers/Helpers-min.js"></script>

Answer 6

The JSON-string you provided is invalid and needs to be corrected before proceeding. You can utilize a reviver function parameter (refer to the MDN) to eliminate 'empty' arrays based on specific criteria.

To elaborate, the reviver function handles the traversal of all levels within the parsed object. If it returns undefined, the property will be removed from the object. The provided snippet showcases how the reviver function removes properties containing empty arrays or objects.

This demonstration highlights the process:

// Corrected JSON string
var foo = '{"loanDetails": [{"vehicleDetail": {"RCBookImageReferences": '+
          '{"imagePathReferences": [{}]}}, "chargeDetails": [{}],'+
          '"commissionDetails": [{}],"disbursementDetails": [{}]}]}';

// Parsing with reviver parameter
var fooparsed = JSON.parse(foo,
                            function (key, value) { 
                                return (value.length && value.length == 1 && 
                                        value[0] instanceof Object && 
                                        Object.keys(value[0]).length == 0) ||
                                        value instanceof Array && !value.length
                                    ? undefined : value; 
                            }
                );
// Printing the result
Helpers.log2Screen(Object.print(fooparsed));

<script src="http://kooiinc.github.io/JSHelpers/Helpers-min.js"></script>

Answer 7

Answer №4

When utilizing Ajax, it is recommended to serialize the JSON array using JavaScript.

When passing data through JSON:

data: "your data",

Instead, use:

data: $(form).serialize(),

This will pass all the keys of the form being submitted.

To view the result, try printing it on the console.

Answer 8

When utilizing Ajax, it is recommended to serialize the JSON array using JavaScript.

When passing data through JSON:

data: "your data",

Instead, use:

data: $(form).serialize(),

This will pass all the keys of the form being submitted.

To view the result, try printing it on the console.

Answer 9

Answer №5

let data = {
  "loanDetails": [{
      "vehicleDetail": {
        "RCBookImageReferences": {
          "imagePathReferences": [{}]
        }
      },
      "chargeDetails": [{}],
      "commissionDetails": [{}],
      "disbursementDetails": [{}]
    },
    {
      "vehicleDetail": {
        "RCBookImageReferences": {
          "imagePathReferences": [{
            "Valid": "Working"
          }]
        }
      },
      "chargeDetails": [{}],
      "commissionDetails": [{}],
      "disbursementDetails": [{}]
    }],
  "Superman": {
    "Name": ""
  },
  "SpiderMan": {
    "Name": "Senthil"
  }
}

function flattenObject(target, opts) {
  let output = {},
    options = opts || {},
    delimiter = options.delimiter || '.'

  function getKey(key, prev) {
    return prev ? prev + delimiter + key : key
  };

  function step(object, prev) {
    Object.keys(object).forEach((key) => {
      let isArray = options.safe && Array.isArray(object[key]),
        type = Object.prototype.toString.call(object[key]),
        isObject = (type === "[object Object]" || type === "[object Array]")

      if (!isArray && isObject) {
        return step(object[key], getKey(key, prev))
      }

      output[getKey(key, prev)] = object[key]
    });
    if (Object.keys(object) == "") {
      if (object instanceof Array) {
        output[prev] = [];
      } else {
        output[prev] = {};
      }
    }
  };
  step(target)
  return output
};

function unflattenObject(target, opts) {
  let options = opts || {},
    delimiter = options.delimiter || '.',
    result = {}

  if (Object.prototype.toString.call(target) !== '[object Object]') {
    return target
  }

  function getKeyValue(key) {
    let parsedKey = parseInt(key)
    return (isNaN(parsedKey) ? key : parsedKey)
  };

  Object.keys(target).forEach((key) => {
    let splitKey = key.split(delimiter),
      firstPart, secondPart, recipient = result

    firstPart = getKeyValue(splitKey.shift())
    secondPart = getKeyValue(splitKey[0])

    while (secondPart !== undefined) {
      if (recipient[firstPart] === undefined) {
        recipient[firstPart] = ((typeof secondPart === 'number') ? [] : {})
      }

      recipient = recipient[firstPart]
      if (splitKey.length > 0) {
        firstPart = getKeyValue(splitKey.shift())
        secondPart = getKeyValue(splitKey[0])
      }
    }

    // unflatten again for messy objects
    recipient[firstPart] = unflattenObject(target[key])
  });

  // Check for arrays
  let keysArray = Object.keys(result);
  if (keysArray.length > 0 && keysArray[0] === "0") {
    let outputArr = [];
    keysArray.forEach((arrKey) => {
      outputArr.push(result[arrKey])
    });
    return outputArr;
  }
  return result
};

let flattenedData = flattenObject(data);
let dataKeys = Object.keys(flattenedData);
dataKeys.forEach((key) => {
  if (JSON.stringify(flattenedData[key]) === "{}" || JSON.stringify(flattenedData[key]) == "") {
    delete flattenedData[key];
    let pathsArr = key.split(".");
    if (pathsArr.length >= 2) {
      let intVal = parseInt(pathsArr[1])
      if (isNaN(intVal)) {
        key = pathsArr[0];
        flattenedData[key] = {};
      } else {
        key = pathsArr[0] + "." + intVal;
        flattenedData[key] = {};
      }
      let newKeysArr = Object.keys(flattenedData);
      for (var j = 0; j < newKeysArr.length; j++) {
        let tempKey = newKeysArr[j];
        if (tempKey.indexOf(key) != -1 && tempKey.length > key.length) {
          delete flattenedData[key];
        }
      }
    }
  }
})
console.log(flattenedData)
let finalResult = unflattenObject(flattenedData);
alert(JSON.stringify(finalResult))

Answer 10

let data = {
  "loanDetails": [{
      "vehicleDetail": {
        "RCBookImageReferences": {
          "imagePathReferences": [{}]
        }
      },
      "chargeDetails": [{}],
      "commissionDetails": [{}],
      "disbursementDetails": [{}]
    },
    {
      "vehicleDetail": {
        "RCBookImageReferences": {
          "imagePathReferences": [{
            "Valid": "Working"
          }]
        }
      },
      "chargeDetails": [{}],
      "commissionDetails": [{}],
      "disbursementDetails": [{}]
    }],
  "Superman": {
    "Name": ""
  },
  "SpiderMan": {
    "Name": "Senthil"
  }
}

function flattenObject(target, opts) {
  let output = {},
    options = opts || {},
    delimiter = options.delimiter || '.'

  function getKey(key, prev) {
    return prev ? prev + delimiter + key : key
  };

  function step(object, prev) {
    Object.keys(object).forEach((key) => {
      let isArray = options.safe && Array.isArray(object[key]),
        type = Object.prototype.toString.call(object[key]),
        isObject = (type === "[object Object]" || type === "[object Array]")

      if (!isArray && isObject) {
        return step(object[key], getKey(key, prev))
      }

      output[getKey(key, prev)] = object[key]
    });
    if (Object.keys(object) == "") {
      if (object instanceof Array) {
        output[prev] = [];
      } else {
        output[prev] = {};
      }
    }
  };
  step(target)
  return output
};

function unflattenObject(target, opts) {
  let options = opts || {},
    delimiter = options.delimiter || '.',
    result = {}

  if (Object.prototype.toString.call(target) !== '[object Object]') {
    return target
  }

  function getKeyValue(key) {
    let parsedKey = parseInt(key)
    return (isNaN(parsedKey) ? key : parsedKey)
  };

  Object.keys(target).forEach((key) => {
    let splitKey = key.split(delimiter),
      firstPart, secondPart, recipient = result

    firstPart = getKeyValue(splitKey.shift())
    secondPart = getKeyValue(splitKey[0])

    while (secondPart !== undefined) {
      if (recipient[firstPart] === undefined) {
        recipient[firstPart] = ((typeof secondPart === 'number') ? [] : {})
      }

      recipient = recipient[firstPart]
      if (splitKey.length > 0) {
        firstPart = getKeyValue(splitKey.shift())
        secondPart = getKeyValue(splitKey[0])
      }
    }

    // unflatten again for messy objects
    recipient[firstPart] = unflattenObject(target[key])
  });

  // Check for arrays
  let keysArray = Object.keys(result);
  if (keysArray.length > 0 && keysArray[0] === "0") {
    let outputArr = [];
    keysArray.forEach((arrKey) => {
      outputArr.push(result[arrKey])
    });
    return outputArr;
  }
  return result
};

let flattenedData = flattenObject(data);
let dataKeys = Object.keys(flattenedData);
dataKeys.forEach((key) => {
  if (JSON.stringify(flattenedData[key]) === "{}" || JSON.stringify(flattenedData[key]) == "") {
    delete flattenedData[key];
    let pathsArr = key.split(".");
    if (pathsArr.length >= 2) {
      let intVal = parseInt(pathsArr[1])
      if (isNaN(intVal)) {
        key = pathsArr[0];
        flattenedData[key] = {};
      } else {
        key = pathsArr[0] + "." + intVal;
        flattenedData[key] = {};
      }
      let newKeysArr = Object.keys(flattenedData);
      for (var j = 0; j < newKeysArr.length; j++) {
        let tempKey = newKeysArr[j];
        if (tempKey.indexOf(key) != -1 && tempKey.length > key.length) {
          delete flattenedData[key];
        }
      }
    }
  }
})
console.log(flattenedData)
let finalResult = unflattenObject(flattenedData);
alert(JSON.stringify(finalResult))

navigating through a JSON to find an empty array field

Answer №1

Answer №2

Solution 1: Implementing an empty test function

Solution 2: Utilizing a recursive empty function that clears the parent object

Answer №3

Answer №4

Answer №5

Similar questions

Mastering the art of properly connecting Angular HttpPromise

The greedy behavior of jquery UI is not behaving as expected

Error Alert: Duplicate Status Detected While Posting on Twitter via API

Utilizing Vue's computed function to filter values from a JSON dataset

Arrange information according to MLA names

Load data from a MySQL Database into a DataTable

What is the process for calling app.vue methods from an ES6 module?

How can I implement select2 4.0 AJAX pre-filling?

What is the best way to ensure a table is responsive while maintaining a fixed header? This would involve the table scrolling when it reaches the maximum viewpoint, while also keeping

Error encountered in Jest mockImplementation: Incompatible types - 'string[]' cannot be assigned to 'Cat[]' type

Analyzing JSON data and creating a tailor-made array

Transmit information to Flask server using an AJAX POST call

Tips for creating visually appealing text on a web browser with the help of open-source libraries

What could be causing the inability to move down on this page?

Any property modified by an event handler will consistently appear in its original form

It is more beneficial to utilize jQuery instead of directly accessing form element values using document.formname

Transferring PHP array data to JavaScript without being exposed in the source code

JSON File in a Hive Shell

Exploring PostgreSQL Nested JSON Queries

My GraphQL Query is throwing a JSON error when using the curlopt_postfields option. What could be causing this