Question

我得到一个具有动态属性的对象，但它的所有属性值都是对象（此级别的键可以不同，这很好）。但是对于这些对象中的每一个，我都希望确保所有这些对象具有相同的密钥并递归。例如

鉴于A

A = {
    'en' : {
        's1' : '',
        's2' : {
            's3' : '',
            's4' : ''
        }
    },
    'fr' : {
        's1' : '',
        's2' : {
            's3' : '',
            's4' : ''
        }
    }
}

这两个是相同的，因为它们递归地具有相同的键值。

A = {
    'en' : {
        's1' : '',
        's2' : {
            's3' : '',
            's4' : ''
        }
    },
    'fr' : {
        's1' : '',
        's2' : {
            's3' : '',
            's5' : ''
        }
    }
}

这是错误的，因为s5是不同的，至少在另一个中不存在。

本质上，目的是创建一个内部有语言对象的对象，我可以放置我想要的任何语言对象，因此它的动态。但是对于每个语言对象，它的所有键应该是同步的，并且与所有其他语言对象相同。

我有这个

this.compareKeys = function(dataObj) {
    var checkObj = {};
    for(var prop in dataObj) {
        if (dataObj.hasOwnProperty(prop)) {
            var obj = dataObj[prop];
            var keysStr = JSON.stringify(Object.keys(obj).sort());
            var keys = Object.keys(checkObj);
            if (keys.length == 0) {
                checkObj[keysStr] = true;
            } else if (!checkObj.hasOwnProperty(keysStr)) {
                return false;
            }
        }
    }
    return true;
}

但是如何让它递归？这只检查1级深度。

由于

Answer 1

你可以比较 lang对象和结构对象：

var struct = {
    's1' : '',
    's2' : {
        's3' : '',
        's4' : ''
    }
}

var lang = {
    'en' : {
        's1' : '',
        's2' : {
            's3' : '',
            's4' : ''
        }
    },
    'fr' : {
        's1' : '',
        's2' : {
            's3' : '',
            's4' : ''
        }
    }
}

因此，获取lang对象中的所有键递归：

function getAllKeys(obj, res) { // Get all keys in string format
    for(k in obj) {
        res.push(k);
        if(typeof(obj[k]) === "object") {
            var o = obj[k];
            getAllKeys(o, res);
        } 
    }

    return res.join("");
}

你给这个函数一个对象和一个结果数组作为争论：

function f(obj, []) { ... }

检查值是否为对象：

if(typeof(obj[k]) === "object") { ... }

如果是这样，再次使用obj[k]作为新对象运行该功能，依此类推。

出于比较原因，该函数输出一个字符串！

下一步是比较 lang对象与结构对象：

function compareObjWithStructure(obj, struct) {
    var s = getAllKeys(struct, []);
    for(k in obj) {
        var ks = getAllKeys(obj[k], []);
        if(ks !== s) {
            return false;
        } else {
            return true;
        }
    }
}

JSFiddle

Answer 2

您可以逐级比较两个对象与传递键数组。

if (obj1.constructor === Array && obj2.constructor === Array) {
  flag = obj1.length === obj2.length;
  if (flag) {
    obj1.forEach(function(key) {
      map[key] = (map[key] || 0) + 1;
    });
    obj2.forEach(function(key) {
      flag = flag && (map[key] !== undefined);
    });
  }

  return flag;
}

如果这个等级键是相同的，那么检查他们的孩子。

Object.keys(obj1).forEach(function(key) {
  if (typeof obj1[key] === 'object') {
    flag = flag && compareKeys(obj1[key], obj2[key]);
  }
});

以下是jsfiddle link

希望这很有用。

如何检查动态的对象集合是否递归具有相同的键？

2 个答案: