解答内容：
- 基线实现（与当前逻辑等价，用于对比）
// baseline.js
const fs = require('fs');
function baseline() {
const t0 = process.hrtime.bigint();
const data = JSON.parse(fs.readFileSync('events.json', 'utf8'));
// O(n^2) 去重（原逻辑）
const uniques = [];
for (let i = 0; i < data.length; i++) {
if (!uniques.some(e => e.id === data[i].id)) uniques.push(data[i]);
}
// 分组（包含重复，原逻辑）
const groups = {};
for (const item of data) {
const k = item.type + '-' + item.timestamp.slice(0, 10);
(groups[k] ||= []).push(item);
}
const t1 = process.hrtime.bigint();
const mem = process.memoryUsage();
console.log('[baseline] time(ms)=', Number(t1 - t0) / 1e6);
console.log('[baseline] rss(MB)=', Math.round(mem.rss / 1024 / 1024));
console.log('[baseline] heapUsed(MB)=', Math.round(mem.heapUsed / 1024 / 1024));
// 输出以保持一致性
fs.writeFileSync('uniques.baseline.json', JSON.stringify(uniques));
fs.writeFileSync('groups.baseline.json', JSON.stringify(groups));
}
baseline();
- 纯内存快速优化（零依赖，保持输出一致）
- 说明：仍一次性读取文件，但去重降为 O(n)，分组使用 Map；整体显著提速，内存峰值略降（因为不再做 O(n^2) 的中间开销），但仍有“同时持有 uniques + groups”的开销。
// optimized_in_memory.js
const fs = require('fs');
function optimizedInMemory() {
const t0 = process.hrtime.bigint();
const data = JSON.parse(fs.readFileSync('events.json', 'utf8'));
// O(n) 去重，保持首次出现的顺序
const seen = new Set();
const uniques = [];
for (const item of data) {
const id = item.id;
if (!seen.has(id)) {
seen.add(id);
uniques.push(item);
}
}
// O(n) 分组（包含重复），使用 Map 保持键插入顺序
const groupsMap = new Map();
for (const item of data) {
const k = item.type + '-' + item.timestamp.slice(0, 10);
let arr = groupsMap.get(k);
if (!arr) groupsMap.set(k, (arr = []));
arr.push(item);
}
const groups = Object.fromEntries(groupsMap);
const t1 = process.hrtime.bigint();
const mem = process.memoryUsage();
console.log('[optimized-mem] time(ms)=', Number(t1 - t0) / 1e6);
console.log('[optimized-mem] rss(MB)=', Math.round(mem.rss / 1024 / 1024));
console.log('[optimized-mem] heapUsed(MB)=', Math.round(mem.heapUsed / 1024 / 1024));
// 输出与原版一致
fs.writeFileSync('uniques.optimized.json', JSON.stringify(uniques));
fs.writeFileSync('groups.optimized.json', JSON.stringify(groups));
}
optimizedInMemory();
- 流式解析优化（推荐，显著降低峰值内存，保持输出一致）
- 说明：不保留 data 数组，直接在解析过程中构建 uniques 和 groups；避免“原始数据的整数组”存在内存中。适用于大文件。
- 需要安装依赖：
npm i stream-json
// optimized_streaming.js
const fs = require('fs');
const { chain } = require('stream-chain');
const { parser } = require('stream-json');
const { streamArray } = require('stream-json/streamers/StreamArray');
async function optimizedStreaming() {
const t0 = process.hrtime.bigint();
const seen = new Set();
const uniques = [];
const groupsMap = new Map();
await new Promise((resolve, reject) => {
const pipeline = chain([
fs.createReadStream('events.json'),
parser(), // 解析 JSON 文本
streamArray() // 针对 JSON 顶层是数组的情况，逐条输出 {key, value}
]);
pipeline.on('data', ({ value: item }) => {
// O(1) 去重
const id = item.id;
if (!seen.has(id)) {
seen.add(id);
uniques.push(item);
}
// O(1) 分组（包含重复）
const k = item.type + '-' + String(item.timestamp).slice(0, 10);
let arr = groupsMap.get(k);
if (!arr) groupsMap.set(k, (arr = []));
arr.push(item);
});
pipeline.on('end', resolve);
pipeline.on('error', reject);
});
const groups = Object.fromEntries(groupsMap);
const t1 = process.hrtime.bigint();
const mem = process.memoryUsage();
console.log('[optimized-stream] time(ms)=', Number(t1 - t0) / 1e6);
console.log('[optimized-stream] rss(MB)=', Math.round(mem.rss / 1024 / 1024));
console.log('[optimized-stream] heapUsed(MB)=', Math.round(mem.heapUsed / 1024 / 1024));
fs.writeFileSync('uniques.optimized.stream.json', JSON.stringify(uniques));
fs.writeFileSync('groups.optimized.stream.json', JSON.stringify(groups));
}
optimizedStreaming().catch(err => {
console.error(err);
process.exit(1);
});
- 简易基准与一致性校验（可用同一数据文件运行）
- 说明：下方脚本分别跑基线与优化版，打印时间/内存，并校验输出一致性（顺序与键一致）。
// benchmark_and_check.js
const fs = require('fs');
function hr() { return Number(process.hrtime.bigint()) / 1e6; }
function memMB() {
const m = process.memoryUsage();
return { rss: Math.round(m.rss / 1024 / 1024), heapUsed: Math.round(m.heapUsed / 1024 / 1024) };
}
function baselineRun() {
const t0 = hr();
const data = JSON.parse(fs.readFileSync('events.json','utf8'));
const uniques = [];
for (let i = 0; i < data.length; i++) {
if (!uniques.some(e => e.id === data[i].id)) uniques.push(data[i]);
}
const groups = {};
for (const item of data) {
const k = item.type + '-' + item.timestamp.slice(0,10);
(groups[k] ||= []).push(item);
}
const t1 = hr();
const m = memMB();
return { uniques, groups, timeMs: t1 - t0, mem: m };
}
function optimizedRun() {
const t0 = hr();
const data = JSON.parse(fs.readFileSync('events.json','utf8'));
const seen = new Set();
const uniques = [];
for (const item of data) {
if (!seen.has(item.id)) { seen.add(item.id); uniques.push(item); }
}
const groupsMap = new Map();
for (const item of data) {
const k = item.type + '-' + item.timestamp.slice(0,10);
let arr = groupsMap.get(k);
if (!arr) groupsMap.set(k, (arr = []));
arr.push(item);
}
const groups = Object.fromEntries(groupsMap);
const t1 = hr();
const m = memMB();
return { uniques, groups, timeMs: t1 - t0, mem: m };
}
function checkEqual(a, b) {
// 检查 uniques：长度与 id 顺序完全相同
if (a.uniques.length !== b.uniques.length) throw new Error('uniques length mismatch');
for (let i = 0; i < a.uniques.length; i++) {
if (a.uniques[i].id !== b.uniques[i].id) throw new Error(`uniques id mismatch at ${i}`);
}
// 检查 groups 键与每组长度相同，且键插入顺序一致
const keysA = Object.keys(a.groups);
const keysB = Object.keys(b.groups);
if (keysA.length !== keysB.length) throw new Error('groups keys length mismatch');
for (let i = 0; i < keysA.length; i++) {
if (keysA[i] !== keysB[i]) throw new Error(`groups key order mismatch at ${i}`);
const ka = keysA[i];
if (a.groups[ka].length !== b.groups[ka].length) throw new Error(`groups[${ka}] length mismatch`);
}
}
const base = baselineRun();
console.log('[baseline] time(ms)=', base.timeMs, 'mem=', base.mem);
const opt = optimizedRun();
console.log('[optimized] time(ms)=', opt.timeMs, 'mem=', opt.mem);
checkEqual(base, opt);
console.log('Outputs are consistent.');
- 复杂度与预期改进
- 去重：由 O(n^2) 降为 O(n)。
- 分组：保持 O(n)。
- 整体：时间从“分钟级”降至“秒级”（取决于硬件与数据结构），流式版本在相同输出下显著降低峰值内存，因为不再保留整份 data 数组。
- 输出顺序与结构保持一致：uniques 保留首次出现顺序；groups 键的插入顺序相同、每组包含所有原始项（含重复）。
