Javascript 为空数组值遍历json

我有一个问题

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

        }
      ]
    }
  },
  "chargeDetails": [
    {

    }
  ],
  "commissionDetails": [
    {

    }
  ],
  "disbursementDetails": [
    {

    }
  ]
}

] } 在上面的json中，我需要遍历每个键，如果我发现它是emty，则将父项设置为空数组，即输出如下

{"loanDetails":[]}

我使用了下面的代码

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

return true;
}

---

但是它没有给我预期的结果。我被困在这里了。任何帮助都会非常有用。

如果您使用ajax进行此操作，那么您应该使用javascript序列化jason数组

在通过json传递数据时

data: "your data",

用这个

data:$(form).serialize(),

它会传递你所传递的所有形式的钥匙

---

如果要查看其结果，请尝试在控制台上打印它

您的JSON字符串无效。更正后，您可以使用

恢复器

函数参数（请参阅）删除“空”数组（即具有指定条件的属性）

更清楚的是，revivier函数负责遍历解析对象的所有级别。如果返回

undefined

，则该属性将从对象中删除。因此，代码段中使用的恢复程序将删除包含空对象数组或空数组的所有属性

这个片段演示了这一点

//已更正json字符串
var foo='{“LoandDetails”：[{“VehicleDetails”：{“RCBookImageReferences”：+
“{”imagePathReferences:[{}]}，”chargeDetails:[{}]，'+
““佣金明细”：[{}]，“付款明细”：[{}]}”；
//使用reviver参数解析它
var fooparsed=JSON.parse（foo，
函数（键，值）{/这应该使它递归。有两个解决方案

解决方案1：空测试函数
解决方案2清空父对象的递归空函数
这将检查obj是否具有对象属性。如果是，则加载该对象并检查其属性。如果不是，则返回false，因为这将是字符串或数字，并确认对象不是空的。

var inputObj={
“借条”：[{
“车辆详情”：{
“RCBookImageReferences”：{
“imagePathReferences”：[{}]
}
},
“chargeDetails”：[{}]，
“佣金明细”：[{}]，
“付款详情”：[{}]
}, {
“车辆详情”：{
“RCBookImageReferences”：{
“imagePathReferences”：[{
“有效”：“正在工作”
}]
}
},
“chargeDetails”：[{}]，
“佣金明细”：[{}]，
“付款详情”：[{}]
}],
“超人”：{
“名称”：”
},
“蜘蛛侠”：{
“名称”：“Senthil”
}
}
函数展平（目标、选项）{
变量输出={}，
opts=opts |{}，
delimiter=opts.delimiter | |'。'
函数getkey（key，prev）{
返回上一个？上一个+分隔符+键：键
};
功能步骤（对象，上一步）{
Object.keys（对象）.forEach（函数（键）{
var isarray=opts.safe&&Array.isarray（对象[key]），
type=Object.prototype.toString.call（Object[key]），
isobject=（类型==“[对象对象]”| |类型==“[对象数组]”）
如果（！isarray&&isobject）{
返回步骤（对象[key]，getkey（key，prev））
}
输出[getkey（key，prev）]=对象[key]
});
if（Object.keys（Object）==“”）{
if（数组的对象实例）{
输出[prev]=[]；
}否则{
输出[prev]={}；
}
}
};
步骤（目标）
返回输出
};
功能取消平台（目标、选项）{
var opts=opts | |{}，
delimiter=opts.delimiter | |'，
结果={}
if（Object.prototype.toString.call（target）！=='[Object Object]'）{
返回目标
}
函数getkey（key）{
var parsedKey=parseInt（键）
返回（isNaN（parsedKey）？键：parsedKey）
};
Object.keys（目标）.forEach（函数（键）{
var split=key.split（分隔符），
第一个半字节，第二个半字节，收件人=结果
firstNibble=getkey（split.shift（））
secondNibble=getkey（拆分[0]）
while（secondNibble！==未定义）{
if（收件人[firstNibble]==未定义）{
收件人[firstNibble]=（（第二Nibble的类型=='number'）？[]：{}）
}
收件人=收件人[第一个字节]
如果（拆分长度>0）{
firstNibble=getkey（split.shift（））
secondNibble=getkey（拆分[0]）
}
}
//对于“凌乱的物体”再次取消设置
收件人[firstNibble]=取消设置（目标[key]）
});
//数组检查
var keys=Object.keys（结果）；
如果（keys.length>0&&keys[0]=“0”）{
var输出=[]；
键。forEach（功能（键）{
output.push（结果[键]）
});
返回输出；
}
返回结果
};
var flatted=展平（inputObj）；
变量键=对象键（扁平化）；
键。forEach（功能（键）{
if（JSON.stringify（flatted[key]）==“{}”| JSON.stringify（flatted[key]）==”）{
//console.log（键）
删除扁平的[键]；
变量路径=键。拆分（“.”）；
如果（路径长度>=2）{
var int=parseInt（路径[1]）
if（isNaN（int））{
键=路径[0]；
平坦的[键]={}；
}否则{
键=路径[0]+“+int；
平坦的[键]={}；
}
var newKeys=Object.keys（扁平化）；
对于（var j=0；jkey.length）{
删除扁平的[键]；
}
}
}
}
})
控制台日志（扁平化）
var输出=不平坦（平坦）；
alert（JSON.stringify（output））
函数
clean
获取对象并在其键上循环，递归调用
clean
在每个对象值属性上。
如果清理结果为空对象，请删除相关密钥。
如果对象本身为空，则返回undefined，从而触发在更高级别上删除保存该对象的属性

function clean(obj) {
    var isEmpty = true;
    for (var key in obj) {
        var val = obj[key];
        if (val === null || typeof val !== 'object' || (obj[key] = clean(val))) {
            isEmpty = false;
        } else {
            delete obj[key];
        }
    }
    return isEmpty ? undefined : obj;
}

>> a = { x: 1, b: { y: [] }, c: { d: { } } }
>> clean(a)
<< Object {x: 1}

功能清理（obj）{
var isEmpty=true；
for（obj中的var键）{
var val=对象[键]；
如果（val==null | | typeof val！==“object”| |（obj[key]=clean（val）））{
isEmpty=false；
}否则{
删除obj[key]；
}
}
返回i
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]; //an object is empty. Delete from parent;
                }
            }
            else
            {
                return false;
            }
        }

    return boolValue; //returns an empty object
}

recursiveIsEmpty(jsonDataObj['loanDetails']) //returns jsonDataObj['loanDetails'] = [];

function clean(obj) {
    var isEmpty = true;
    for (var key in obj) {
        var val = obj[key];
        if (val === null || typeof val !== 'object' || (obj[key] = clean(val))) {
            isEmpty = false;
        } else {
            delete obj[key];
        }
    }
    return isEmpty ? undefined : obj;
}

>> a = { x: 1, b: { y: [] }, c: { d: { } } }
>> clean(a)
<< Object {x: 1}