如何在Elixir中遍历Map列表时对比最后一个元素（递归或reduce实现）

嘿，这个需求我太熟了！你要的不是Enum.group_by/2那种把所有相同cluster值聚合到一起的逻辑，而是按列表顺序追踪cluster的变化，给连续相同的cluster段标记同一个组号——说白了就是把连续的相同cluster归为一组，一旦cluster变了就开启新组，对吧？

我给你两种惯用的Elixir实现方式，都是专门解决这种顺序依赖的遍历问题的：

方法一：用Enum.reduce/3（更简洁的惯用写法） #

reduce天生适合这种需要携带状态遍历的场景，我们可以把当前的组号、上一个cluster的值，还有已经处理好的结果都放在状态里：

defmodule ClusterGrouper do
  def group_by_sequence(list) do
    # 初始状态：组号从0开始，上一个cluster设为nil，结果列表为空
    initial_state = %{current_group: 0, last_cluster: nil, result: []}

    Enum.reduce(list, initial_state, fn item, state ->
      current_cluster = item.cluster

      # 判断是否需要切换组
      {new_group, new_last_cluster} =
        if current_cluster == state.last_cluster do
          # cluster没变化，组号不变
          {state.current_group, state.last_cluster}
        else
          # cluster变了，组号+1，更新上一个cluster的值
          {state.current_group + 1, current_cluster}
        end

      # 这里我选择新增一个`group`字段保留组号（比直接覆盖cluster更合理）
      # 如果一定要修改cluster属性，改成 %{item | cluster: new_group} 即可
      updated_item = Map.put(item, :group, new_group)

      # 更新状态，把新元素加入结果列表
      %{state | current_group: new_group, last_cluster: new_last_cluster, result: state.result ++ [updated_item]}
    end)
    |> Map.get(:result)
  end
end

测试一下 #

比如你有这样的输入列表：

input = [
  %{id: 1, cluster: "A"},
  %{id: 2, cluster: "A"},
  %{id: 3, cluster: "B"},
  %{id: 4, cluster: "B"},
  %{id: 5, cluster: "A"},
  %{id: 6, cluster: "C"}
]

调用ClusterGrouper.group_by_sequence(input)会得到：

[
  %{id: 1, cluster: "A", group: 1},
  %{id: 2, cluster: "A", group: 1},
  %{id: 3, cluster: "B", group: 2},
  %{id: 4, cluster: "B", group: 2},
  %{id: 5, cluster: "A", group: 3},
  %{id: 6, cluster: "C", group: 4}
]

完美符合你的需求：连续的相同cluster属于同一个组，cluster变化时组号递增。

方法二：递归实现（更灵活，性能更优） #

如果你的列表特别长，递归实现会更高效——因为上面的reduce里用了state.result ++ [updated_item]，每次都要遍历结果列表，而递归可以用反向构建列表的方式避免这个开销：

defmodule ClusterGrouper do
  def group_by_sequence_recursive(list), do: do_group(list, 0, nil, [])

  # 递归终止条件：列表为空，反转结果列表（因为我们是反向构建的）
  defp do_group([], _current_group, _last_cluster, result), do: Enum.reverse(result)

  defp do_group([item | rest], current_group, last_cluster, result) do
    current_cluster = item.cluster

    {new_group, new_last_cluster} =
      if current_cluster == last_cluster do
        {current_group, last_cluster}
      else
        {current_group + 1, current_cluster}
      end

    updated_item = Map.put(item, :group, new_group)
    # 把新元素加到结果列表头部（O(1)操作），继续递归处理剩余元素
    do_group(rest, new_group, new_last_cluster, [updated_item | result])
  end
end

这个版本的逻辑和reduce完全一样，但性能更好，尤其是处理大列表的时候。

关键要点 #

• 核心是追踪前一个元素的cluster值，这是实现“按顺序变化分组”的关键——和group_by那种不关心顺序的聚合完全不同
• 如果需要直接修改原来的cluster属性，把Map.put(item, :group, new_group)改成%{item | cluster: new_group}就行，但我更建议保留原cluster值，新增group字段，这样数据更清晰
• 两种方式都可以根据你的需求调整，比如组号从0开始、或者第一个元素的组号逻辑等等，只需要修改初始状态或者判断条件就行

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