JavaScript中遍历对象并查找同y值的有序序列[A,B,C]

嘿，我明白你的问题了——你要从给定的数组里找出按顺序出现的A→B→C，且三者属于同一个y值的序列，之前用普通for循环没法保证它们共享同一个y，对吧？其实换个思路，先把数据按y值分组，再在每个组里找有序的目标序列就好办多了。

步骤1：按y值分组 #

首先我们把数组里的元素按y值归类，这样每个分组里的元素都拥有相同的y，从根源上解决“同y”的问题。用JavaScript的reduce方法就能轻松实现：

const test = [ { x: 'A', y:'1' }, { x: 'A', y:'2' }, { x: 'B', y:'1' }, { x: 'A', y:'3' }, { x: 'C', y:'1' }, ];

// 将数组按y值分组，每组存储对应的x值列表
const groupedByY = test.reduce((acc, item) => {
  // 如果当前y值还没创建分组，就初始化一个空数组
  if (!acc[item.y]) {
    acc[item.y] = [];
  }
  // 把当前元素的x值加入对应分组
  acc[item.y].push(item.x);
  return acc;
}, {});

执行完这段代码后，groupedByY的结构会是这样：

{
  '1': ['A', 'B', 'C'],
  '2': ['A'],
  '3': ['A']
}

步骤2：检查每组是否存在有序的[A,B,C] #

接下来我们需要写一个辅助函数，用来判断某个数组里是否按顺序包含目标序列[A,B,C]。这个函数会遍历数组，依次匹配序列中的元素，只要能按顺序走完整个序列，就说明符合条件：

// 检查数组是否按顺序包含目标序列
function hasOrderedSequence(arr, targetSequence) {
  let sequenceIndex = 0;
  for (const value of arr) {
    // 如果当前元素匹配序列的下一个元素，就移动序列指针
    if (value === targetSequence[sequenceIndex]) {
      sequenceIndex++;
      // 如果指针走到序列末尾，说明找到了完整的有序序列
      if (sequenceIndex === targetSequence.length) {
        return true;
      }
    }
  }
  // 遍历完数组都没匹配完序列，返回false
  return false;
}

// 我们要找的目标序列
const target = ['A', 'B', 'C'];

// 遍历所有分组，筛选出符合条件的y值
const validYValues = Object.keys(groupedByY).filter(y => {
  return hasOrderedSequence(groupedByY[y], target);
});

console.log('符合条件的y值：', validYValues); // 输出：['1']

额外扩展：获取完整的元素对象 #

如果你需要的不只是y值，而是对应的完整元素对象，只需要调整分组逻辑，存储整个元素而不是x值，再在检查时跟踪匹配的元素即可：

// 按y分组，存储完整元素
const groupedByYFull = test.reduce((acc, item) => {
  if (!acc[item.y]) {
    acc[item.y] = [];
  }
  acc[item.y].push(item);
  return acc;
}, {});

// 修改辅助函数，返回匹配的元素序列
function getOrderedSequence(arr, targetSequence) {
  const result = [];
  let seqIndex = 0;
  for (const item of arr) {
    if (item.x === targetSequence[seqIndex]) {
      result.push(item);
      seqIndex++;
      if (seqIndex === targetSequence.length) {
        return result;
      }
    }
  }
  return null;
}

// 获取符合条件的元素序列
const validSequences = Object.values(groupedByYFull)
  .map(group => getOrderedSequence(group, target))
  .filter(seq => seq !== null);

console.log('符合条件的完整序列：', validSequences);
// 输出：[[{x:'A',y:'1'}, {x:'B',y:'1'}, {x:'C',y:'1'}]]

这种方法的优势在于，先通过分组把同y的元素聚在一起，再在小范围内查找有序序列，逻辑清晰且效率更高，避免了嵌套循环带来的冗余计算。

内容的提问来源于stack exchange，提问作者BlueishVelvet