使用Node.js打造自己的Git版本控制系统

最近都不知道写点啥了，已经挺久没更新了，也是因为最近比较忙，现在才抽出空来，之前的文章大部分都是给大家普及一些知识点以及技术片段，估计大家平时也很少会用到。

因此我决定教大家一些经常会接触的东西，比如git;

作为一个程序员，大家肯定经常使用Git来进行版本控制。但是你有没有想过自己动手实现一个Git系统呢？今天掌门人就来教大家如何使用Node.js来实现一个简易的Git版本控制系统，我们将其命名为GitX。

创建代码仓库

首先，我们需要创建一个新目录来作为我们的代码仓库，并初始化npm项目：

mkdir gitx
cd gitx
npm init -y

初始化项目（gitx init）

初始化仓库:我们需要在仓库根目录下创建一个.gitx目录来存放我们的版本控制信息。

// init.js
const fs = require('fs');
const path = require('path');

const initRepo = () => {
  const gitxPath = path.join(process.cwd(), '.gitx');
  if (fs.existsSync(gitxPath)) {
    console.log('仓库已存在');
    return;
  }
  fs.mkdirSync(gitxPath);
  console.log('初始化仓库成功');
}

module.exports = initRepo;

实现跟踪文件变化(gitx add)

跟踪文件变化:跟踪文件变化的功能,我们需要监听文件的变化，并将变化记录下来。

// track.js
const fs = require('fs');
const path = require('path');
const crypto = require('crypto');

const trackFiles = (files) => {
  const gitxPath = path.join(process.cwd(), '.gitx');
  if (!fs.existsSync(gitxPath)) {
    console.log('仓库未初始化');
    return;
  }

  files.forEach(file => {
    const filePath = path.join(process.cwd(), file);
    if (!fs.existsSync(filePath)) {
      console.log(`文件${file}不存在`);
      return;
    }
    const fileContent = fs.readFileSync(filePath);
    const fileHash = crypto.createHash('sha1').update(fileContent).digest('hex');
    const trackPath = path.join(gitxPath, fileHash);
    fs.writeFileSync(trackPath, fileContent);
    console.log(`文件${file}变化已跟踪`);
  });
}

module.exports = trackFiles;

提交更新(gitx commit)

提交更新:是版本控制系统中非常重要的功能之一,我们需要将跟踪的文件变化提交到仓库中。

// commit.js
const fs = require('fs');
const path = require('path');
const crypto = require('crypto');

const commitChanges = (message) => {
  const gitxPath = path.join(process.cwd(), '.gitx');
  if (!fs.existsSync(gitxPath)) {
    console.log('仓库未初始化');
    return;
  }

  const commitHash = crypto.createHash('sha1').update(Date.now().toString()).digest('hex');
  const commitPath = path.join(gitxPath, commitHash);
  fs.mkdirSync(commitPath);

  const trackedFiles = fs.readdirSync(gitxPath).filter(file => fs.statSync(path.join(gitxPath, file)).isFile());
  trackedFiles.forEach(file => {
    const trackedFilePath = path.join(gitxPath, file);
    const newFilePath = path.join(commitPath, file);
    fs.copyFileSync(trackedFilePath, newFilePath);
  });

  const commitInfo = {
    message,
    timestamp: new Date(),
    files: trackedFiles
  };
  fs.writeFileSync(path.join(commitPath, 'info.json'), JSON.stringify(commitInfo, null, 2));

  console.log(`提交成功，提交信息：${message}`);
}

module.exports = commitChanges;

分支管理(gitx branch)

分支管理:我们需要实现创建、删除、查看和切换分支的功能。

// branch.js
const fs = require('fs');
const path = require('path');

const createBranch = (name) => {
  const gitxPath = path.join(process.cwd(), '.gitx');
  if (!fs.existsSync(gitxPath)) {
    console.log('仓库未初始化');
    return;
  }

  const branchPath = path.join(gitxPath, 'branches', name);
  if (fs.existsSync(branchPath)) {
    console.log(`分支${name}已存在`);
    return;
  }

  fs.mkdirSync(branchPath, { recursive: true });
  console.log(`分支${name}创建成功`);
}

const deleteBranch = (name) => {
  const gitxPath = path.join(process.cwd(), '.gitx');
  if(!fs.existsSync(gitxPath)) { 
      console.log('仓库未初始化'); 
      return; 
  }

  const branchPath = path.join(gitxPath, 'branches', name); 
  if (!fs.existsSync(branchPath)) { 
    console.log(`分支${name}不存在`); 
    return; 
  }

  fs.rmdirSync(branchPath, { recursive: true }); 
  console.log(`分支${name}删除成功`); 
}

const listBranches = () => { 
  const gitxPath = path.join(process.cwd(), '.gitx'); 
  if (!fs.existsSync(gitxPath)) { 
    console.log('仓库未初始化'); 
    return; 
  }

  const branchesPath = path.join(gitxPath, 'branches'); 
  const branches = fs.readdirSync(branchesPath); console.log('分支列表：');
  branches.forEach(branch => console.log(branch)); 
}

const switchBranch = (name) => { 
  const gitxPath = path.join(process.cwd(), '.gitx'); 
  if (!fs.existsSync(gitxPath)) { 
    console.log('仓库未初始化'); 
    return; 
  }

  const branchesPath = path.join(gitxPath, 'branches'); 
  if (!fs.existsSync(path.join(branchesPath, name))) { 
    console.log(`分支${name}不存在`); 
    return; 
  }
  console.log(`成功切换到分支${name}`); 
}

module.exports = { 
  createBranch, 
  deleteBranch, 
  listBranches, 
  switchBranch 
};

合并分支(gitx merge)

合并分支:是Git中最为复杂的操作之一，我们将实现一个简单版本的合并功能

// merge.js
const fs = require('fs');
const path = require('path');

const mergeBranch = (sourceBranch, targetBranch) => {
  const gitxPath = path.join(process.cwd(), '.gitx');
  if (!fs.existsSync(gitxPath)) {
    console.log('仓库未初始化');
    return;
  }

  const sourceBranchPath = path.join(gitxPath, 'branches', sourceBranch);
  const targetBranchPath = path.join(gitxPath, 'branches', targetBranch);
  if (!fs.existsSync(sourceBranchPath) || !fs.existsSync(targetBranchPath)) {
    console.log(`分支不存在`);
    return;
  }

  const sourceFiles = fs.readdirSync(sourceBranchPath);
  const targetFiles = fs.readdirSync(targetBranchPath);

  sourceFiles.forEach(file => {
    if (!targetFiles.includes(file)) {
      const filePath = path.join(sourceBranchPath, file);
      fs.copyFileSync(filePath, path.join(targetBranchPath, file));
    }
  });

  console.log(`合并分支${sourceBranch}到${targetBranch}成功`);
}

module.exports = mergeBranch;

历史记录(gitx log)

历史记录:查看commit的历史记录以了解版本间的变化。

// log.js
const fs = require('fs');
const path = require('path');

const viewCommitHistory = () => {
  const gitxPath = path.join(process.cwd(), '.gitx');
  if (!fs.existsSync(gitxPath)) {
    console.log('仓库未初始化');
    return;
  }

  const commits = fs.readdirSync(gitxPath).filter(file => fs.statSync(path.join(gitxPath, file)).isDirectory());
  commits.forEach(commitHash => {
    const commitPath = path.join(gitxPath, commitHash, 'info.json');
    if (fs.existsSync(commitPath)) {
      const commitInfo = JSON.parse(fs.readFileSync(commitPath));
      console.log(`提交哈希值：${commitHash}`);
      console.log(`提交信息：${commitInfo.message}`);
      console.log(`提交时间：${commitInfo.timestamp}`);
      console.log('涉及文件：');
      commitInfo.files.forEach(file => {
        console.log(`- ${file}`);
      });
      console.log('-------------------------------------');
    }
  });
}

module.exports = viewCommitHistory;

检出版本(gitx checkout version)

检出版本:检出版本,允许用户切换到不同的版本或分支

// checkout.js
const fs = require('fs');
const path = require('path');

const checkoutVersion = (version) => {
  const gitxPath = path.join(process.cwd(), '.gitx');
  if (!fs.existsSync(gitxPath)) {
    console.log('仓库未初始化');
    return;
  }

  const versionPath = path.join(gitxPath, version);
  if (!fs.existsSync(versionPath)) {
    console.log(`版本${version}不存在`);
    return;
  }

  const files = fs.readdirSync(versionPath);
  files.forEach(file => { 
    const filePath = path.join(versionPath, file); 
    fs.copyFileSync(filePath, path.join(process.cwd(), file)); });
    console.log(`检出版本${version}成功`); 
  }
}
module.exports = checkoutVersion;

搭建入口

现在我们已经实现了所有的基础功能，我们可以创建一个入口文件来集中管理我们的命令。

// index.js
const program = require('commander');

const initRepo = require('./init');
const trackFiles = require('./track');
const commitChanges = require('./commit');
const { createBranch, deleteBranch, listBranches, switchBranch } = require('./branch');
const mergeBranch = require('./merge');
const viewCommitHistory = require('./log');
const checkoutVersion = require('./checkout');

program
  .command('init')
  .description('初始化一个新的gitx仓库')
  .action(initRepo);

program
  .command('track <files...>')
  .description('跟踪指定的文件变化')
  .action(trackFiles);

program
  .command('commit <message>')
  .description('提交变化到仓库')
  .action(commitChanges);

program
  .command('branch <command> [name]')
  .description('创建、删除、查看或切换分支')
  .action((cmd, name) => {
    switch (cmd) {
      case 'create':
        createBranch(name);
        break;
      case 'delete':
        deleteBranch(name);
        break;
      case 'list':
        listBranches();
        break;
      case 'switch':
        switchBranch(name);
        break;
      default:
        console.log('未知的分支命令');
    }
  });

program
  .command('merge <source> <target>')
  .description('合并分支')
  .action(mergeBranch);

program
  .command('log')
  .description('查看提交的历史记录')
  .action(viewCommitHistory);

program
  .command('checkout <version>')
  .description('检出指定版本或分支')
  .action(checkoutVersion);

program.parse(process.argv);

使用测试

现在我们可以通过Node.js来运行我们的命令。这样我们就实现了一个简易的Git版本控制系统GitX。以使用如下命令来测试各功能：

node index.js init
node index.js track file1.txt file2.txt
node index.js commit 'init commit'
node index.js branch create feature1
node index.js branch switch feature1
node index.js merge master feature1
node index.js log
node index.js checkout feature1

要在命令行直接使用gitx init这种命令格式，我们需要将你的Node.js应用程序发布为全局npm包，并设置bin字段在package.json中。下面是步骤详解：

• 在你的package.json文件中，添加一个bin字段，该字段是一个对象，键是你希望用户输入的命令名称，值是该命令对应的文件路径。

{
  "name": "gitx",
  "version": "0.0.1",
  "bin": {
    "gitx": "./index.js"
  },
  //...
}

• 在index.js的开头，添加一个shebang行来指定脚本的解释程序。这行代码告诉系统这个脚本应当使用Node.js执行。

#!/usr/bin/env node

// 其余的代码

• 给你的index.js文件加上可执行权限，通过运行下面的命令：

chmod +x index.js

• 确保你的项目中有正确的package.json文件，并且所有必要的依赖项都已包含在内。 在项目根目录下运行下面的命令，将你的·npm包链接到全局模块，这样就可以通过命令行在任意位置使用了：

npm link

• 这样就可以在命令行中直接使用gitx init来运行我们自己写的gitx了。

发布到npm

当然了，如果你想发布到npm中，让别人也用起来，那就需要发布到npm中，这需要你有npm的账号，需要使用npm发布包的命令：

npm publish

发布完成后使用，就可以通过npm install -g gitx来全局安装你的gitx命令了

总结

至此，你就完成了一个简易的git版本控制系统，当然了，现在我们写的还很粗糙，大家要是有兴趣的话，可以参考一下git的功能，然后在完善一下这个demo，开发出属于自己的版本控制系统。