如何使用LINQ按语言索引对列表项进行分组？

嘿，这个需求其实挺好实现的，核心就是按Languages的索引来分组就行~ 我给你分两种常见场景讲，你可以对应自己的实际情况来用：

这种情况需要先从字符串里提取出Languages[x]里的索引x，然后按这个索引分组。我给你几个主流语言的实现示例：

JavaScript 实现 #

// 假设你的原始数据是这样的数组
const data = [
  { path: 'model.Languages[0].Employer', value: '字节跳动' },
  { path: 'model.Languages[0].Title', value: '前端开发' },
  { path: 'model.Languages[1].Employer', value: '腾讯', },
  { path: 'model.Languages[1].Title', value: '后端开发' }
];

// 用reduce做分组
const groupedResult = data.reduce((acc, item) => {
  // 用正则匹配出Languages后面的索引数字
  const indexMatch = item.path.match(/Languages\[(\d+)\]/);
  if (indexMatch) {
    const indexNum = parseInt(indexMatch[1]);
    const groupKey = `Group-${indexNum + 1}`; // 转成Group-1、Group-2的格式
    // 如果组不存在就新建，然后把当前项的path加进去
    if (!acc[groupKey]) acc[groupKey] = [];
    acc[groupKey].push(item.path);
    // 如果你需要存值而不是路径，就把item.path换成item.value就行
  }
  return acc;
}, {});

console.log(groupedResult);

C# 实现（用LINQ） #

// 先定义数据模型
public class DataItem {
    public string Path { get; set; }
}

// 原始数据列表
var rawData = new List<DataItem> {
    new DataItem { Path = "model.Languages[0].Employer" },
    new DataItem { Path = "model.Languages[0].Title" },
    new DataItem { Path = "model.Languages[1].Employer" },
    new DataItem { Path = "model.Languages[1].Title" }
};

// 分组逻辑
var groupedData = rawData.GroupBy(item => {
    var match = System.Text.RegularExpressions.Regex.Match(item.Path, @"Languages\[(\d+)\]");
    return match.Success ? $"Group-{int.Parse(match.Groups[1].Value) + 1}" : "Uncategorized";
})
.ToDictionary(g => g.Key, g => g.Select(i => i.Path).ToList());

// 输出结果就是你要的分组结构

Python 实现 #

import re

# 原始数据
data_list = [
    {"path": "model.Languages[0].Employer"},
    {"path": "model.Languages[0].Title"},
    {"path": "model.Languages[1].Employer"},
    {"path": "model.Languages[1].Title"}
]

grouped = {}
for item in data_list:
    # 提取索引数字
    match = re.search(r'Languages\[(\d+)\]', item['path'])
    if match:
        idx = int(match.group(1))
        group_name = f"Group-{idx + 1}"
        if group_name not in grouped:
            grouped[group_name] = []
        grouped[group_name].append(item['path'])

print(grouped)

这种情况更简单，直接遍历数组，按索引生成分组就行，不用正则：

JavaScript 示例 #

// 假设你的model结构是这样的
const model = {
  Languages: [
    { Employer: '字节跳动', Title: '前端开发' },
    { Employer: '腾讯', Title: '后端开发' }
  ]
};

const groupedObj = {};
model.Languages.forEach((langItem, index) => {
  const groupKey = `Group-${index + 1}`;
  // 把当前元素的Employer和Title放到对应组里
  groupedObj[groupKey] = [langItem.Employer, langItem.Title];
});

console.log(groupedObj);

C# 示例 #

// 定义Languages的元素模型
public class LanguageItem {
    public string Employer { get; set; }
    public string Title { get; set; }
}

// 假设你的model对象
var model = new {
    Languages = new List<LanguageItem> {
        new LanguageItem { Employer = "字节跳动", Title = "前端开发" },
        new LanguageItem { Employer = "腾讯", Title = "后端开发" }
    }
};

var grouped = new Dictionary<string, List<string>>();
for (int i = 0; i < model.Languages.Count; i++) {
    var key = $"Group-{i + 1}";
    grouped[key] = new List<string> { model.Languages[i].Employer, model.Languages[i].Title };
}

不管哪种场景，核心逻辑都是找到Languages的索引值，将相同索引的Employer和Title归为一组，你可以根据自己用的语言和数据格式来调整~

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