Question

我有一个对象，例如：

var dataObj = {
'hre': {groupID: 1},
'bla': {groupID: 1},
3: {groupID: 0},
4: {groupID: 2},
16: {groupID: 2},
6: {groupID: 2},
7: {groupID: 0},
64893: {groupID: 0},
9: {groupID: 1}
}

当组为0时，表示该字段不属于任何组。

同一组的字段必须相邻。否则它应该抛出错误。

因此，例如上面的对象会抛出错误，因为组1的字段不相邻。

寻找一种有效的方法来完成这项任务（或任何方式，因为我在一段时间后没有找到）。

var error = false;
var previousGroupID = null;
var thisGroupID = null;
var previousFieldGroupID = null;

for (index in dataArray) {
    if (dataObj[index]['groupID'] > 0) {
        thisGroupID = dataObj[index]['groupID'];
        if (previousFieldGroupID == 0 && thisGroupID ==  previousGroupID) {
            error = true;
        }
    }
    previousFieldGroupID = dataObj[index]['groupID'];
}

小提琴http://jsfiddle.net/zq2w7w9t/1/

Answer 1

假设您的JavaScript引擎保留了成员的排序（大部分都是，但他们不必，请参阅this question）：

function hasError(dataObj) {
  var error = false;
  var previousGroupID = -1;
  var thisGroupID = -1;
  var seenGroups = new Set();

  for (index in dataArray) {
    thisGroupID = dataObj[index].groupID;
    if (previousGroupID !== thisGroupID) {
      if (seenGroups.has(thisGroupID)) {
        if (thisGroupID !== 0) error = true;
      } else {
        seenGroups.add(thisGroupID);
      }
    }
    previousGroupID = thisGroupID;
  }
  return error;
}

否则，您可以Map使用guaranteed to retain entry ordering：

function hasError(dataMap) {
  var error = false;
  var previousGroupID = -1;
  var thisGroupID = -1;
  var seenGroups = new Set();
  var thisGroup = null;
  for (thisGroup of dataMap.values()) {
    thisGroupID = thisGroup.groupID;
    if (previousGroupID !== thisGroupID) {
      if (seenGroups.has(thisGroupID)) {
        if (thisGroupID !== 0) error = true;
      } else {
        seenGroups.add(thisGroupID);
      }
    }
    previousGroupID = thisGroupID;
  }
  return error;
}

var m = new Map();
m.set('hre', { groupID: 1 });
m.set('bla', { groupID: 1 });
m.set(3, { groupID: 0 });
m.set(4, { groupID: 2 });
m.set(5, { groupID: 0 });
m.set(1, { groupID: 1 });
console.log(hasError(m));

或者您可以将其分解为单独的函数：

function listHasError(list) {
  var error = false;
  var previousGroupID = -1;
  var thisGroupID = -1;
  var seenGroups = new Set();
  var thisGroup = null;
  list.forEach(function(thisGroupID) {
    if (previousGroupID !== thisGroupID) {
      if (seenGroups.has(thisGroupID)) {
        if (thisGroupID !== 0) error = true;
      } else {
        seenGroups.add(thisGroupID);
      }
    }
    previousGroupID = thisGroupID;
  });
  return error;
}
function extractGroupsFromMap(dataMap) {
  var res = [];
  for (thisGroup of dataMap.values()) {
    res.push(thisGroup.groupID);
  }
  return res;
}
function extractGroupsFromObj(dataObj) {
  var res = [];
  for (index in dataObj) {
    res.push(dataObj[index].groupID);
  }
  return res;
}

var dataObj = {
  'hre': {groupID: 1},
  'bla': {groupID: 1},
  3: {groupID: 0},
  4: {groupID: 2},
  16: {groupID: 2},
  6: {groupID: 2},
  7: {groupID: 0},
  64893: {groupID: 0},
  9: {groupID: 1}
};
console.log(listHasError(extractGroupsFromObj(dataObj)));

Answer 2

好的，假设：

您的对象有任意键
每个值都有一个数字索引属性和一个groupId
具有组0的非连续元素不是错误
索引属性是独占的和连续的

然后让我们说你的对象如下：

var    yourObject = {
    'a1': {     index: 1,       groupId: 1  },
    'b2': {     index: 2,       groupId: 1  },
    'c3': {     index: 3,       groupId: 0  },
    'd4': {     index: 4,       groupId: 5  },
    'e5': {     index: 5,       groupId: 5  },
    'g6': {     index: 6,       groupId: 5  },
    'h7': {     index: 7,       groupId: 'A'},
    'i8': {     index: 8,       groupId: 0  },
    'j9': {     index: 9,       groupId: 'A'}
    };

（请注意我故意使用非连续或非专有的数字组ID。）

然后我会使用以下方法对您的对象进行分组：

var groups={};
Object.keys(yourObject)
    .forEach(function (key) {
        var thevalue = yourObject[key],
            groupId = thevalue.groupId;

        groups[groupId] = groups[groupId] || [];

        groups[groupId].push(thevalue.index);
});

此时，groups是一个对象，其键为0,1,5和＆＃39; A＆＃39;，它们的值是index属性的值（我们说是连续的和独家的。

{
    0: [3,8],
    1: [1,2],
    5: [4,5,6],
    'A':[7,9]
}

我将在groups上进行迭代，对于每个组，如果它有一个元素或者它的组为零，我将跳过验证。

如果它有超过1个元素，并且它不是0，那么我将对它们的元素进行排序并对它们进行迭代。由于索引是连续的，因此这些排序的数组中的每一个都不能具有差异> gt的项目。其中1个

var hasError = false;

Object.keys(groups).forEach(function (groupId) {
    if (groupId !== 0 && groups[groupId] && groups[groupId].length > 1) {

        var sortedElements = groups[groupId].sort(function (a, b) {
            return a > b;
        });
        console.log('Group ' + groupId, sortedElements);

        for (var index = 1; index < sortedElements.length; index++) {
            if ((sortedElements[index] - sortedElements[index - 1]) > 1) {
                hasError = true;
                console.warn('Error detected');
            }
        }
    }
});

如果对象中的某些“熟悉”字段不相邻，则返回错误

2 个答案: