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

假设您的JavaScript引擎保留了成员的排序(大多数都保留了，但是它们不必，参见这个问题):

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，它保证保留条目顺序:

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

好的，假设:

• 你的对象有任意键
• 每个值有一个数值索引属性和一个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和'A'的对象，它们的值是index属性的值(我们说过是连续的和排他的)。

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

我将迭代groups，对于每个组，如果它有单个元素或它是组0，我将跳过验证。

如果它有多于1个元素，并且它不是组0，那么我将对它的元素排序并迭代它们。由于索引是连续的，因此这些排序数组中的每一个都不能有差值> 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');
            }
        }
    }
});