怎样使用Node.js操作硬链接？

fs

fs.link()

fs.linkSync()

fs.unlink()

fs.link()

fs.linkSync()

const fs = require('fs');
const path = require('path');

const existingFilePath = path.join(__dirname, 'original.txt');
const newLinkPath = path.join(__dirname, 'hardlink.txt');

// 确保原始文件存在，方便测试
fs.writeFileSync(existingFilePath, '这是原始文件的内容。\n');

// 创建硬链接
fs.link(existingFilePath, newLinkPath, (err) => {
    if (err) {
        console.error('创建硬链接失败:', err);
        // 比如，文件不存在，或者权限问题，或者跨文件系统了
        return;
    }
    console.log(`成功创建硬链接：${newLinkPath} -> ${existingFilePath}`);

    // 我们可以验证一下，两个文件内容相同，且修改任意一个都会影响另一个
    fs.readFile(newLinkPath, 'utf8', (readErr, data) => {
        if (readErr) {
            console.error('读取硬链接文件失败:', readErr);
            return;
        }
        console.log('硬链接文件内容:', data); // 应该和原始文件内容一样

        // 尝试修改硬链接文件
        fs.appendFileSync(newLinkPath, '这是通过硬链接修改的内容。\n');
        console.log('修改硬链接文件后，原始文件内容:');
        console.log(fs.readFileSync(existingFilePath, 'utf8')); // 原始文件也变了
    });
});

// 同步版本（不推荐在主线程使用，除非是启动脚本等阻塞无妨的场景）
try {
    // fs.linkSync(existingFilePath, 'hardlink_sync.txt');
    // console.log('同步创建硬链接成功。');
} catch (error) {
    console.error('同步创建硬链接失败:', error);
}

fs.unlink()

unlink

const fs = require('fs');
const path = require('path');

const linkToRemove = path.join(__dirname, 'hardlink.txt'); // 假设这个链接已经存在

fs.unlink(linkToRemove, (err) => {
    if (err) {
        console.error('删除硬链接失败:', err);
        return;
    }
    console.log(`成功删除硬链接：${linkToRemove}`);

    // 此时 original.txt 仍然存在，因为它是另一个硬链接
    // 只有当 original.txt 也被删除了，文件数据才可能被释放
});

const fs = require('fs');
const path = require('path');
const crypto = require('crypto');

async function getFileHash(filePath) {
    return new Promise((resolve, reject) => {
        const hash = crypto.createHash('sha256');
        const stream = fs.createReadStream(filePath);
        stream.on('data', data => hash.update(data));
        stream.on('end', () => resolve(hash.digest('hex')));
        stream.on('error', reject);
    });
}

async function saveFileVersion(sourceFilePath, versionDir, fileName) {
    const targetPath = path.join(versionDir, fileName);
    // 确保版本目录存在
    fs.mkdirSync(versionDir, { recursive: true });

    // 假设我们有一个机制来查找之前版本的相同文件
    // 这里简化处理，直接创建一个新文件或硬链接
    let prevVersionFilePath = null; // 假设通过某种方式找到前一个版本的文件路径

    if (prevVersionFilePath && fs.existsSync(prevVersionFilePath)) {
        const sourceHash = await getFileHash(sourceFilePath);
        const prevHash = await getFileHash(prevVersionFilePath);

        if (sourceHash === prevHash) {
            // 内容相同，创建硬链接
            try {
                fs.linkSync(prevVersionFilePath, targetPath);
                console.log(`文件 '${fileName}' (版本 ${versionDir}) 硬链接到旧版本，节省空间。`);
                return;
            } catch (err) {
                console.error(`创建硬链接失败，将回退到复制: ${err.message}`);
                // 如果硬链接失败（比如跨文件系统），则回退到复制
            }
        }
    }

    // 内容不同，或者硬链接失败，则复制新文件
    fs.copyFileSync(sourceFilePath, targetPath);
    console.log(`文件 '${fileName}' (版本 ${versionDir}) 复制为新版本。`);
}

// 示例用法：
// const currentFile = path.join(__dirname, 'my_document.txt');
// const versionRepo = path.join(__dirname, 'versions');
//
// fs.writeFileSync(currentFile, 'Initial content.');
// saveFileVersion(currentFile, path.join(versionRepo, 'v1'), 'doc.txt');
//
// fs.writeFileSync(currentFile, 'Initial content.'); // 内容不变
// saveFileVersion(currentFile, path.join(versionRepo, 'v2'), 'doc.txt'); // 应该创建硬链接
//
// fs.writeFileSync(currentFile, 'Updated content for v3.'); // 内容变化
// saveFileVersion(currentFile, path.join(versionRepo, 'v3'), 'doc.txt'); // 应该复制

const fs = require('fs');
const path = require('path');
const crypto = require('crypto');

async function getFileHash(filePath) { /* 同上 */ return new Promise(...) }

async function findAndDeduplicate(rootDir) {
    const fileHashes = new Map(); // Map<hash, [filePath1, filePath2, ...]>

    async function walkDir(currentPath) {
        const entries = await fs.promises.readdir(currentPath, { withFileTypes: true });
        for (const entry of entries) {
            const fullPath = path.join(currentPath, entry.name);
            if (entry.isFile()) {
                try {
                    const hash = await getFileHash(fullPath);
                    if (!fileHashes.has(hash)) {
                        fileHashes.set(hash, []);
                    }
                    fileHashes.get(hash).push(fullPath);
                } catch (error) {
                    console.warn(`无法处理文件 ${fullPath}: ${error.message}`);
                }
            } else if (entry.isDirectory()) {
                await walkDir(fullPath);
            }
        }
    }

    await walkDir(rootDir);

    console.log('--- 开始去重 ---');
    let spaceSaved = 0;

    for (const [hash, filePaths] of fileHashes.entries()) {
        if (filePaths.length > 1) {
            const masterFile = filePaths[0]; // 选择第一个作为主副本
            console.log(`发现重复文件 (哈希: ${hash}):`);
            console.log(`  主副本: ${masterFile}`);

            for (let i = 1; i < filePaths.length; i++) {
                const duplicateFile = filePaths[i];
                try {
                    const stats = await fs.promises.stat(duplicateFile);
                    spaceSaved += stats.size; // 统计节省的空间

                    await fs.promises.unlink(duplicateFile); // 删除重复文件
                    await fs.promises.link(masterFile, duplicateFile); // 创建硬链接
                    console.log(`  - '${duplicateFile}' 已替换为硬链接。`);
                } catch (error) {
                    console.error(`  - 无法去重 '${duplicateFile}': ${error.message}`);
                }
            }
        }
    }
    console.log(`--- 去重完成，估计节省了 ${spaceSaved} 字节 ---`);
}

// 示例用法：
// const dataDir = path.join(__dirname, 'data_to_dedupe');
// fs.mkdirSync(dataDir, { recursive: true });
// fs.writeFileSync(path.join(dataDir, 'file1.txt'), '重复内容');
// fs.writeFileSync(path.join(dataDir, 'file2.txt'), '重复内容');
// fs.writeFileSync(path.join(dataDir, 'file3.txt'), '唯一内容');
//
// findAndDeduplicate(dataDir);