比较 Node.js 中两个大文件的最佳实践

Question

我想比较两个大文件（5GB+），看看它们是否相同。 我考虑的一种解决方案是使用加密进行散列，然后比较散列。 但这将花费很多时间，因为我将不得不通过整个文件 go 而不是在发现差异时停止。
我认为的另一个解决方案是在文件与fs.createReadStream()流式传输时比较文件，并在发现差异时中断。

stream.on('data', (data) => {
   //compare the data from this stream with the other stream
})

但我不太确定如何让两个流同步。

Answer 1

根据您的评论中的要求，如果您想了解如何编写实现来执行此操作，这里有一个。 以下是它的工作原理：

1. 打开两个文件中的每一个
2. 比较两个文件的大小。 如果不一样，解决false。
3. 分配两个 8k 的缓冲区（可以选择使用的缓冲区大小）
4. 将每个文件的 8k （如果文件中没有 8k 则更少）读入缓冲区
5. 比较这两个缓冲区。 如果不相同，则解析为 false。
6. 完成所有字节的比较后，解析 true

这是代码：

const fs = require('fs');
const fsp = fs.promises;

// resolves to true or false
async function compareFiles(fname1, fname2) {
    const kReadSize = 1024 * 8;
    let h1, h2;
    try {
        h1 = await fsp.open(fname1);
        h2 = await fsp.open(fname2);
        const [stat1, stat2] = await Promise.all([h1.stat(), h2.stat()]);
        if (stat1.size !== stat2.size) {
            return false;
        }
        const buf1 = Buffer.alloc(kReadSize);
        const buf2 = Buffer.alloc(kReadSize);
        let pos = 0;
        let remainingSize = stat1.size;
        while (remainingSize > 0) {
            let readSize = Math.min(kReadSize, remainingSize);
            let [r1, r2] = await Promise.all([h1.read(buf1, 0, readSize, pos), h2.read(buf2, 0, readSize, pos)]);
            if (r1.bytesRead !== readSize || r2.bytesRead !== readSize) {
                throw new Error("Failed to read desired number of bytes");
            }
            if (buf1.compare(buf2, 0, readSize, 0, readSize) !== 0) {
                return false;
            }
            remainingSize -= readSize;
            pos += readSize;
        }
        return true;
    } finally {
        if (h1) {
            await h1.close();
        }
        if (h2) {
            await h2.close();
        }
    }
}

// sample usage
compareFiles("temp.bin", "temp2.bin").then(result => {
    console.log(result);
}).catch(err => {
    console.log(err);
});

这可以通过使用Promise.allSettled()并行打开和关闭文件来加快速度，以跟踪它们何时打开然后都关闭，尽管因为如果一个成功打开而另一个没有打开和你不想泄露一个打开的文件句柄，需要更多的代码才能完美地做到这一点，所以我在这里保持简单。

而且，如果您真的想优化性能，那么值得测试更大的缓冲区，看看它是否能让事情变得更快。

也有可能buf1.equals(buf2)可能比buf1.compare(buf2)快，但是您必须确保在文件末尾读取的部分缓冲区在使用时仍然可以正常工作，因为.equals()总是比较整个缓冲区。 您可以构建两个版本并比较它们的性能。

---

这是一个更复杂的版本，可以并行打开和关闭文件，可能会稍微快一些：

const fs = require('fs');
const fsp = fs.promises;

async function compareFiles(fname1, fname2) {
    const kReadSize = 1024 * 8;
    let h1, h2;
    try {
        let openResults = await Promise.allSettled([fsp.open(fname1), fsp.open(fname2)]);
        let err;
        if (openResults[0].status === "fulfilled") {
            h1 = openResults[0].value;
        } else {
            err = openResults[0].reason;
        }
        if (openResults[1].status === "fulfilled") {
            h2 = openResults[1].value;
        } else {
            err = openResults[1].reason;
        }
        // after h1 and h2 are set (so they can be properly closed)
        // throw any error we got
        if (err) {
            throw err;
        }

        const [stat1, stat2] = await Promise.all([h1.stat(), h2.stat()]);
        if (stat1.size !== stat2.size) {
            return false;
        }
        const buf1 = Buffer.alloc(kReadSize);
        const buf2 = Buffer.alloc(kReadSize);
        let pos = 0;
        let remainingSize = stat1.size;
        while (remainingSize > 0) {
            let readSize = Math.min(kReadSize, remainingSize);
            let [r1, r2] = await Promise.all([h1.read(buf1, 0, readSize, pos), h2.read(buf2, 0, readSize, pos)]);
            if (r1.bytesRead !== readSize || r2.bytesRead !== readSize) {
                throw new Error("Failed to read desired number of bytes");
            }
            if (buf1.compare(buf2, 0, readSize, 0, readSize) !== 0) {
                return false;
            }
            remainingSize -= readSize;
            pos += readSize;
        }
        return true;
    } finally {
        // does not return file close errors
        // but does hold resolving the promise until the files are closed
        // or had an error trying to close them
        // Since we didn't write to the files, a close error would be fairly 
        // unprecedented unless the disk went down
        const closePromises = [];
        if (h1) {
            closePromises.push(h1.close());
        }
        if (h2) {
            closePromises.push(h2.close());
        }
        await Promise.allSettled(closePromises);
    }
}

compareFiles("temp.bin", "temp2.bin").then(result => {
    console.log(result);
}).catch(err => {
    console.log(err);
});

Answer 2

确实有一些库可以做到这一点， file-sync-cmp非常受欢迎（每周下载 27 万次）。 它 以最简单的方式进行比较，通过从不同缓冲区中的两个文件中读取相同数量的字节，然后逐字节比较缓冲区。

还有一个更现代的库filecompare ，“使用原生 Promises 和原生 BufferTools（alloc 和 Buffer 比较）”。

只要可行，就不要重新发明轮子:)

Answer 3

由于差异可能在文件的最后，我想计算文件的 hash 是最直接（但成本最高）的简单和安全的过程。

您是否尝试过MD5-File npm package 并获得一些性能指标？