Javascript 如果有些“错误”，则返回错误；“熟悉的”；对象内的字段不相邻

我有一个对象，例如：

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的字段不相邻

寻找一种有效的方法来完成这件事（或者其他任何方法，因为我已经有一段时间没有找到了）

---

Fiddle

假设您的JavaScript引擎保留了成员的顺序（大多数都保留了，但它们不必保留，请参见）：

否则，您可以使用，即：

或者您可以将其分解为单独的功能：

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)));

好的，假设：

• 您的对象具有任意键
• 每个值都有一个数字索引属性和一个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);
});

此时，

组

是一个对象，其键为0,1,5和“A”，它们的值是

索引

阿曲布特的值（我们称之为连续和排他）

我将迭代

组

，对于每个组，如果它有一个元素或它的组为零，我将跳过验证

如果它有多个元素，并且不是零组，那么我将对其元素进行排序并对其进行迭代。由于索引是连续的，所以这些排序数组中的每一个都不能有差异大于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');
            }
        }
    }
});

var hasrerror=false；
Object.keys（groups）.forEach（函数（groupId）{
if（groupId！==0&&groups[groupId]&&groups[groupId]。长度>1）{
var sortedElements=组[groupId]。排序（函数（a，b）{
返回a>b；
});
console.log（'Group'+groupId，sortedElements）；
对于（var索引=1；索引1）{
hasrerror=true；
console.warn（“检测到错误”）；
}
}
}
});

这是不可能的，因为JS对象中的属性不能保证有任何特定的顺序。考虑到对象键是数字，也许你的意思是它是一个数组？我的字段总是从1到9。我们可以循环并确保顺序是正确的。我们可以循环，但我们不能确保顺序是正确的。@Teemu为什么？每次循环时，我都会看到索引从1变为9。

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'}
    };

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

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

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

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

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');
            }
        }
    }
});