大厂前端面试分享：如何让6000万数据包和300万数据包在仅50M内存环境中求交集

时间 2020-03-04

原文原文链接

因为最近疫情的影响，相信最近不少小伙伴都忙于线上办公或者面试😭，笔者这里分享一道发生在大厂前端线上编程面试中的一道题目，前端

如何让 6000 万数据包和 300 万数据包在仅 50M 内存环境中求交集，请简单说出您解决这问题的思路

咱们假设如今有两份庞大的数据，而这两份数据包的数据结构均以下，仔细观察里面的数据咱们不难发现，里面有 QQ 号，地址和年龄，如题目的要求咱们须要是求交集，因此咱们暂时能够忽略地址和年龄，以 QQ 号做为惟一标识：git

QQ:40645253 地址：xxx 年龄：xxx
QQ:49844525 地址：xxx 年龄：xxx
QQ:51053984 地址：xxx 年龄：xxx
QQ:15692967 地址：xxx 年龄：xxx
QQ:39211026 地址：xxx 年龄：xxx
// 如下省略 6000 万条数据
...

梳理了上面的数据包结构以后，咱们就得看看 50M 内存是什么状况了，因为面试在线上进行，只能短期在本地测试下上面这个数据量在本地会占有有多大空间，那因为限因而场前端面试，因此笔者选用了 NodeJS 去制造这些庞大的数据了，当时线上编写的时候是没注释的，这里为了方便小伙伴理解，在写这篇文章的时候我自觉加上了😁github

const fs = require("fs");
const path = require('path');
const writer = fs.createWriteStream(path.resolve(__dirname, 'data-60M.txt'), { highWaterMark: 1 });

const writeSixtyMillionTimes = (writer) => {
    const write = () => {
        let data = Buffer.from(`${parseInt(Math.random() * 60000000)}\n`)
        let ok = true;
        do {
            i--;
            if (i === 0) {
                // 最后一次写入。
                writer.write(data);
            } else {
                // 检查是否能够继续写入。 
                // 不要传入回调，由于写入尚未结束。
                ok = writer.write(data);
            }
        } while (i > 0 && ok);
        if (i > 0) {
            // 被提早停止。
            // 当触发 'drain' 事件时继续写入。
            writer.once('drain', write);
        }
    }
    // 初始化6000万数据
    let i = 600000;
    write();
}

writeSixtyMillionTimes(writer)

首先在本地新建一份 data-60M.txt 文件，而后新建一份 data-60M.js 把上面代码写入并执行，这里我最主要是使用了一个递归，因为当时为了快速写入文件测试大小，当时模拟的 QQ 号，是使用 ${parseInt(Math.random() * 60000000)}\n 随机数生成的，在实际测试表现中会有极小概率重复 QQ 号，但影响不大，实际影响最大的是当你在生成 6000 万数据的时候，电脑疯狂运做，运气很差的时候直接卡死，而后远程面试直接断线。面试

这里笔者仍是建议小伙伴在远程面试中手机随时待命，当电脑 GG 的时候还能联系面试官抢救一下，通过与电脑性能的多轮斗争，和面试官尴尬重连的状况下，终于发现实际文件大小规律以下，这里为了方便小伙伴调试源代码，我也把代码传到 Github 上，连接放在最后，只放了 6000 条数据，实际 300MB 实在是传不上去了，小伙伴们能够下载源代码自行测试，祈祷电脑能熬过去o(╥﹏╥)o：npm

数据量	内存占用
6000条数据(Git版本)	>=30KB
6000万条数据(实际版本)	>=300MB
300条数据(Git版本	>=15KB
300万条数据(实际版本)	>=15MB

到了这个地方，笔者渐渐地看出这个问题的坑点可能在那里了，6000 万条数据在测试文件中大小大概在 300MB 左右，而 300 万条数据大小大概在 15 MB，在 50MB 的内存限制下，咱们能够把 300 万条约 15MB 的数据彻底放入内存中，剩余大概 35MB 空间是不容许咱们彻底放入 6000 万条约 300MB 的数据，因此咱们须要把数据切割成10块左右，大概每块控制在 30MB ，而后分别读取出来跟内存中的 300 万条数据进行比对并求出交集，50MB 状况也太极端苛刻了，难道是手机而且仍是老人机吗，我也不敢问啊o(╥﹏╥)o编程

在思考上面这一连串的逻辑时候，为了避免耽误面试官宝贵的时间，边想边随手创建好下面几份文件和文件夹，好梳理代码，给本身思考时间和回旋的余地，如下是我当时临时的目录结构。缓存

databasebash
- data-3M.txt - 模拟的3百万数据包
- data-60M.txt - 模拟的6千万数据包
library数据结构
- data-3M.js - 处理3百万数据包的逻辑
- data-60M.js - 处理6千万数据包的逻辑
- intersect.js - 处理数据包的交集
- create-60M.js - 生成大数据的文件
result.txt 最终数据包的交集结果
index.js 主逻辑文件

在不急不慢的分类好目录结构以后，总得再弄点代码给面试官瞧瞧吧o(╥﹏╥)o，不能让人家空等啊app

固然既然是面试用 NodeJS 第三方模块解决也不够好，当时是先屡一下用什么原生模块实现比较好，要知足上面这些要求，想到这里能使用到的原生 Node 内置模块关键有以下两个：

fs - 文件系统
readline - 逐行读取

fs.createReadStream(path[, options])方法中，其中 options 能够包括 start 和 end 值，以从文件中读取必定范围的字节而不是整个文件。 start 和 end 都包含在内并从 0 开始计数，这种是方法方便咱们分段读取 6000 万条数据。当时快速写了一个示例去验证，从一个大小为 100 个字节的文件中读取最后 10 个字节：

fs.createReadStream('data-60M.txt', { start: 90, end: 99 });

通过短暂的测试，发现这个方案可行，心理淡定了一点。

起码这个备用方案起码能够给本身留点操做空间，但当时讨论到的是下面这种方案：

fs.createReadStream() 提供 highWaterMark 选项，它容许咱们将以大小等于 highWaterMark 选项的块读取流，highWaterMark 的默认值为: 64 * 1024(即64KB)，咱们能够根据须要进行调整，当内部的可读缓冲的总大小达到 highWaterMark 设置的阈值时，流会暂时中止从底层资源读取数据，直到当前缓冲的数据被消费，咱们就能够触发readline.pause()暂停流，处理完以后继续触发readline.resume()恢复流，而后不断重复以上步骤，将 6000 万数据分别处理完。

readline 模块提供了一个接口，用于一次一行地读取可读流中的数据。它可使用如下方式访问，而且咱们的数据包，每条数据之间是使用\n、\r 或 \r\n隔开，因此这样方便咱们使用readline.on('line', (input) => {})来接受每一行数据包的字符串。

这里自我感受有些丢分项，是当时忘记了 fs.createReadStream 里面一些配置项，在现场临时翻阅 NodeJS 的官方 API 文档，这里很是感谢当时面试官的理解(^▽^)

下面，咱们就要写最关键的代码了，就是如何处理那 6000 万条数据，打开刚才新建好的data-60M.js文件，该文件就是用于专门处理 6000 万数据的，咱们使用readline和createReadStream二者配合，将数据按必定条数分别缓存在内存中，这里代码正如上面提到，因为提交的代码不适合太大(Git传上去太慢)，因此把数据量减小到 6000 条，那么分红 10 份的话，每份缓存就须要读 600 条左右，读完每份数据以后调用intersect函数求交集，并存入硬盘result.txt文件中，而后释放内存：

// 写入结果
const writeResult = (element) => {
    appendFile('./result.txt', `${element}\n`, (err) => {
        err ? () => console.log('写入成功') : () => console.log('写入失败');
    })
}

这里最关键是要定义一个空的容器lineCount来存放每段数据，而且使用if (lineCount === 6000) {}语句判断内存超过限制的空间后作释放内存的处理：

const { createReadStream, appendFile } = require('fs');
const readline = require('readline');
const intersect = require('./intersect');

module.exports = (smallData) => {
    return new Promise((resolve) => {
        const rl = readline.createInterface({
            // 6000条数据流
            input: createReadStream('./database/data60M.txt', {
                // 节流阀
                highWaterMark: 50
            }),
            // 处理分隔符
            crlfDelay: Infinity
        });
        // 缓存次数
        let lineCount = 0;
        // 缓存容器
        let rawData = [];
        // 逐行读取
        rl.on('line', (line) => {
            rawData.push(line);
            lineCount++;
            // 限制每一次读取6000条数据，分十次读取
            if (lineCount === 6000) {
                // 释放内存
                // ...
            }
        );
        rl.on('close', () => {
            resolve('结束');
        })
    })
}

释放内存后前须要使用rl.pause()暂停流，而后作两步逻辑:

求交集结果
写入每段交集结果到硬盘

而后须要使用rl.resume()重启流：

if (lineCount === 6000) {
    // 暂停流
    rl.pause();
    // 获取交集
    let intersectResult = intersect(rawData, smallData);
    // 遍历交集并写入结果
    intersectResult.forEach(element => {
        writeResult(element)
    });
    // 释放缓存
    rawData = null;
    intersectResult = null;
    rawData = [];
    // 重置读取次数
    lineCount = 0;
    // 重启流
    rl.resume();
}

上面这个过程实际很是耗时和缓慢，这里建议就是在代码长时间运行的时候不要冷落了面试官o(╥﹏╥)o

在处理完上面 6 千万数据以后，就剩下 3百万份的了，这里的数据因为是3百万，因此能够把所有数据放入内存，咱们在data-3M.js写入如下代码，这里用Promise封装，方便在外部配合async和await使用：

const fs = require('fs');
const readline = require('readline');
module.exports = () => {
    return new Promise((resolve) => {
        const rl = readline.createInterface({
            input: fs.createReadStream('./database/data-3M.txt'),
            crlfDelay: Infinity
        });
        let check = [];
        rl.on('line', (line) => {
            check.push(line);
        });
        rl.on('close', () => {
            resolve(check)
        })
    })
}

而后就是交集了，在intersect.js代码中写入一下代码，这里简单的使用Set和filter方法来求交集：

// 交集方法
module.exports = (a, b) => {
    return a.filter(x => new Set(b).has(x));
}

分别把上面两份处理关键数据在index.js逻辑引入，而后执行逻辑，就能够乖乖地等待面试官的检阅和指导了：

const data3M = require('./library/data-3M');
const data60M = require('./library/data-60M');
(async () => {
    let smallData = await data3M();
    let result = await data60M(smallData);
    console.log(result);
})();

这里附上源代码地址方便小伙伴测试：https://github.com/Wscats/intersect

也使用如下命令运行测试，运行成功后结果会在result.txt中展示结果：

git clone https://github.com/Wscats/intersect
# 运行
npm start
# 查看结果
npm run dev
# 生成新的大数据
npm run build

最后若是文章能带您一丝帮助或者启发，请不要吝啬你的赞和收藏，你的确定是我前进的最大动力😁

笔记本原文 https://github.com/Wscats/intersect
阅读往期更多优质文章可移步个人 GitHub 查看