如下有val数组，如何处理，能够将model 和 defect相同的内容json 合并，并且将checkpoint 字段处理成内容合并，用" | "分格，将level_score，num_score，repeat_score，cycle_score字段处理成新的数组字段，total_score字段做和
val = [
{
production_date: '2023-04-18',
checkpoint: 'ZP',
model: 'one',
defect: '坑',
dept: 'AAA',
level_score: '',
num_score: '',
repeat_score: 'ZP复发',
cycle_score: '',
total_score: 25
},
{
production_date: '2023-04-18',
checkpoint: 'ZQ',
model: 'two',
defect: '包',
dept: 'AAA',
level_score: '',
num_score: '',
repeat_score: 'ZQ复发',
cycle_score: '',
total_score: 25
},
{
production_date: '2023-04-18',
checkpoint: 'ZW',
model: 'one',
defect: '坑',
dept: 'AAA',
level_score: 'ZW等级',
num_score: '',
repeat_score: 'ZW复发',
cycle_score: '',
total_score: 45
},
]
生成结果：
new_val = [
{
production_date: '2023-04-18',
checkpoint: 'ZP | ZW',
model: 'one',
defect: '坑',
dept: 'AAA',
tags:[ 'ZW等级', 'ZP复发', 'ZW复发'],
total_score: 70
},
{
production_date: '2023-04-18',
checkpoint: 'ZQ',
model: 'two',
defect: '包',
dept: 'AAA',
tags:['ZQ复发'],
total_score: 25
},
]
这不就遍历就完事了吗？model 和 defect 的值相同的就该求和的求和 该字符串拼接的拼接 该转数组转数组
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta http-equiv="X-UA-Compatible" content="IE=edge">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Document</title>
</head>
<body>
</body>
<script>
val = [
{
production_date: '2023-04-18',
checkpoint: 'ZP',
model: 'one',
defect: '坑',
dept: 'AAA',
level_score: '',
num_score: '',
repeat_score: 'ZP复发',
cycle_score: '',
total_score: 25
},
{
production_date: '2023-04-18',
checkpoint: 'ZQ',
model: 'two',
defect: '包',
dept: 'AAA',
level_score: '',
num_score: '',
repeat_score: 'ZQ复发',
cycle_score: '',
total_score: 25
},
{
production_date: '2023-04-18',
checkpoint: 'ZW',
model: 'one',
defect: '坑',
dept: 'AAA',
level_score: 'ZW等级',
num_score: '',
repeat_score: 'ZW复发',
cycle_score: '',
total_score: 45
},
]
// 定义一个空对象用于存放处理后的结果
const result = {};
// 遍历val数组，将model和defect相同的内容合并，checkpoint字段处理成内容合并，用" | "分隔
val.forEach(item => {
const key = `${item.model}-${item.defect}`;
if (!result[key]) {
result[key] = {
production_date: item.production_date,
model: item.model,
defect: item.defect,
dept: item.dept,
checkpoint: item.checkpoint,
level_score: [],
num_score: [],
repeat_score: [],
cycle_score: [],
total_score: 0
};
}
result[key].checkpoint += ` | ${item.checkpoint}`;
result[key].level_score.push(item.level_score);
result[key].num_score.push(item.num_score);
result[key].repeat_score.push(item.repeat_score);
result[key].cycle_score.push(item.cycle_score);
result[key].total_score += item.total_score;
});
// 将处理后的结果转换成数组形式
const finalResult = Object.values(result);
console.log(finalResult)
</script>
</html>
const val = [
{
production_date: '2023-04-18',
checkpoint: 'ZP',
model: 'one',
defect: '坑',
dept: 'AAA',
level_score: '',
num_score: '',
repeat_score: 'ZP复发',
cycle_score: '',
total_score: 25,
},
{
production_date: '2023-04-18',
checkpoint: 'ZQ',
model: 'two',
defect: '包',
dept: 'AAA',
level_score: '',
num_score: '',
repeat_score: 'ZQ复发',
cycle_score: '',
total_score: 25,
},
{
production_date: '2023-04-18',
checkpoint: 'ZW',
model: 'one',
defect: '坑',
dept: 'AAA',
level_score: 'ZW等级',
num_score: '',
repeat_score: 'ZW复发',
cycle_score: '',
total_score: 45,
},
];
const new_val = val.reduce((result, item) => {
const exists = result.find(
({ model, defect }) => model === item.model && defect === item.defect
);
if (exists) {
exists.checkpoint += ` | ${item.checkpoint}`;
exists.tags.push(item.level_score, item.num_score, item.repeat_score, item.cycle_score)
exists.tags = exists.tags.filter(Boolean)
exists.total_score += item.total_score;
} else {
const { production_date, checkpoint, model, defect, dept, level_score, num_score, repeat_score, cycle_score, total_score } = item;
result.push({ production_date, checkpoint, model, defect, dept, tags:[level_score, num_score, repeat_score, cycle_score].filter(Boolean), total_score });
}
return result;
}, []);
console.log(new_val);
解决方案:
// 定义一个对象用于存储最终的结果
let result = {};
// 循环遍历数组
array.forEach(item => {
// 检查是否符合我们的要求
if (!result[item.checkpoint]) {
// 如果不存在该 checkpoint，则创建一个新的对象，并将level_score、num_score、repeat_score、cycle_score字段处理成新的数组字段，并计算总分数（total_score）
result[item.checkpoint] = {
checkpoint: item.checkpoint,
contents: [],
level_scores: [item.level_score],
num_scores: [item.num_score],
repeat_scores: [item.repeat_score],
cycle_scores: [item.cycle_score],
total_scores: [item.total_score]
};
// 将内容存入新的对象中
result[item.checkpoint].contents.push({
id: item.id,
content: item.content
});
} else {
// 如果已经存在该 checkpoint，则将level_score、num_score、repeat_score、cycle_score字段处理成新的数组字段，并计算总分数（total_score），并合并内容并将checkpoint字段的内容用 "|" 分隔
result[item.checkpoint].level_scores.push(item.level_score);
result[item.checkpoint].num_scores.push(item.num_score);
result[item.checkpoint].repeat_scores.push(item.repeat_score);
result[item.checkpoint].cycle_scores.push(item.cycle_score);
result[item.checkpoint].total_scores.push(item.total_score);
result[item.checkpoint].contents.push({
id: item.id,
content: item.content
});
}
});
// 循环遍历新的对象并计算总分数
Object.values(result).forEach(r => {
r.level_score = r.level_scores.reduce((a, b) => a + b, 0);
r.num_score = r.num_scores.reduce((a, b) => a + b, 0);
r.repeat_score = r.repeat_scores.reduce((a, b) => a + b, 0);
r.cycle_score = r.cycle_scores.reduce((a, b) => a + b, 0);
r.total_score = r.total_scores.reduce((a, b) => a + b, 0);
r.content = r.contents.map(c => c.content).join(" | ");
delete r.contents;
delete r.level_scores;
delete r.num_scores;
delete r.repeat_scores;
delete r.cycle_scores;
delete r.total_scores;
});
// 最终结果存储在result对象中
console.log(result);
{
"a": {
"checkpoint": "a",
"level_score": 30,
"num_score": 15,
"repeat_score": 10,
"cycle_score": 15,
"total_score": 70,
"content": "Hello world | Nice to meet you"
},
"b": {
"checkpoint": "b",
"level_score": 20,
"num_score": 10,
"repeat_score": 15,
"cycle_score": 25,
"total_score": 70,
"content": "How are you? | Fine, thank you"
}
}