如何合并两个 Git 存储库？

爱被打了一巴掌 2024-03-29 15:34 67阅读 0赞

## 问： ##

考虑以下场景：

我在自己的 Git 存储库中开发了一个小型实验项目 A。它现在已经成熟，我希望 A 成为更大的项目 B 的一部分，它有自己的大存储库。我现在想将 A 添加为 B 的子目录。

如何在不丢失任何历史记录的情况下将 A 合并到 B 中？

> huntsbot.com高效搞钱，一站式跟进超10+任务平台外包需求

## 答1: ##

> 打造属于自己的副业，开启自由职业之旅，从huntsbot.com开始!

如果要将 project-a 合并到 project-b：

cd path/to/project-b
    git remote add project-a /path/to/project-a
    git fetch project-a --tags
    git merge --allow-unrelated-histories project-a/master # or whichever branch you want to merge
    git remote remove project-a

取自：git merge different repositories?

这种方法对我来说效果很好，它更短，在我看来更干净。

如果要将 project-a 放入子目录，可以使用 git-filter-repo（filter-branch 是 discouraged）。在上述命令之前运行以下命令：

cd path/to/project-a
    git filter-repo --to-subdirectory-filter project-a

合并 2 个大型存储库并将其中一个放入子目录的示例：https://gist.github.com/x-yuri/9890ab1079cf4357d6f269d073fd9731

注意： --allow-unrelated-histories 参数仅在 git >= 2.9 后才存在。请参阅Git - git merge Documentation / --allow-unrelated-histories

更新：按照@jstadler 的建议添加了–tags，以保留标签。

`这为我做了生意。第一次像魅力一样工作，在 .gitignore 文件中只有一个冲突！它完美地保留了提交历史。除了简单性之外，其他方法的最大优点是不需要持续引用合并的 repo。但是，需要注意的一件事——如果你是像我这样的 iOS 开发人员——将目标 repo 的项目文件放入工作区时要非常小心。`

`谢谢。为我工作。我需要将合并的目录移动到一个子文件夹中，所以按照上述步骤后，我只使用了 git mv source-dir/ dest/new-source-dir`

`@sg 一种间接的方法是将 project-a 中的所有这些文件移动到 project-a 的子目录中（这样 project-a 的顶层只有一个目录），然后按照上述过程进行操作。`

`git merge 步骤在此处以 fatal: refusing to merge unrelated histories 失败； --allow-unrelated-histories 修复了 docs 中所述的问题。`

`更短：git fetch /path/to/project-a master; git merge --allow-unrelated-histories FETCH_HEAD。`

## 答2: ##

> huntsbot.com精选全球7大洲远程工作机会，涵盖各领域，帮助想要远程工作的数字游民们能更精准、更高效的找到对方。

以下是两种可能的解决方案：

子模块

将存储库 A 复制到较大项目 B 中的单独目录中，或者（也许更好）将存储库 A 克隆到项目 B 中的子目录中。然后使用 git submodule 将此存储库设为 子模块< /strong> 存储库 B.

对于松散耦合的存储库来说，这是一个很好的解决方案，其中存储库 A 中的开发继续进行，并且开发的主要部分是 A 中的单独独立开发。另请参阅 Git Wiki 上的 SubmoduleSupport 和 GitSubmoduleTutorial 页面。

子树合并

您可以使用 subtree merge 策略将存储库 A 合并到项目 B 的子目录中。 Markus Prinz 在 Subtree Merging and You 中对此进行了描述。

git remote add -f Bproject /path/to/B
    git merge -s ours --allow-unrelated-histories --no-commit Bproject/master
    git read-tree --prefix=dir-B/ -u Bproject/master
    git commit -m "Merge B project as our subdirectory"
    git pull -s subtree Bproject master

（Git >= 2.9.0 需要选项 --allow-unrelated-histories。）

或者您可以使用 apenwarr (Avery Pennarun) 的 git subtree 工具 (repository on GitHub)，例如在他的博文 A new alternative to Git submodules: git subtree 中宣布。

我认为在您的情况下（A 将成为较大项目 B 的一部分），正确的解决方案是使用子树合并。

`这有效并且似乎保留了历史记录，但不能让您使用它来区分文件或通过合并一分为二。我错过了一步吗？`

`这是不完整的。是的，您会收到大量提交，但它们不再引用正确的路径。 git log dir-B/somefile 除了一个合并之外不会显示任何内容。请参阅 Greg Hewgill's answer 引用此重要问题。`

`重要提示： git pull --no-rebase -s subtree Bproject master 如果你不这样做，并且你已经将 pull 设置为自动变基，你最终会得到“无法解析对象”。请参阅osdir.com/ml/git/2009-07/msg01576.html`

`这个答案可能会令人困惑，因为它在问题中是 A 时将 B 作为合并的子树。复制和粘贴的结果？`

`如果您试图简单地将两个存储库粘合在一起，则子模块和子树合并是错误的工具，因为它们不会保留所有文件历史记录（正如其他评论者所指出的那样）。请参阅stackoverflow.com/questions/13040958/…。`

## 答3: ##

> huntsbot.com精选全球7大洲远程工作机会，涵盖各领域，帮助想要远程工作的数字游民们能更精准、更高效的找到对方。

另一个存储库的单个分支可以很容易地放置在保留其历史记录的子目录下。例如：

git subtree add --prefix=rails git://github.com/rails/rails.git master

这将显示为单个提交，其中 Rails 主分支的所有文件都添加到“rails”目录中。然而，提交的标题包含对旧历史树的引用：

从提交 添加’rails/’

其中 是 SHA-1 提交哈希。你仍然可以看到历史，责怪一些变化。

git log 
    git blame  -- README.md

请注意，您无法从此处看到目录前缀，因为这是一个完好无损的实际旧分支。您应该将其视为通常的文件移动提交：到达它时您将需要额外的跳转。

# finishes with all files added at once commit
    git log rails/README.md
    
    # then continue from original tree
    git log  -- README.md

有更复杂的解决方案，例如手动执行此操作或重写其他答案中描述的历史记录。

git-subtree 命令是官方 git-contrib 的一部分，一些数据包管理器默认安装它（OS X Homebrew）。但是除了 git 之外，您可能还必须自己安装它。

`以下是有关如何安装 Git SubTree 的说明（截至 2013 年 6 月）：stackoverflow.com/a/11613541/694469（我将 git co v1.7.11.3 替换为 ... v1.8.3）。`

`感谢您对以下答案的提醒。截至 git 1.8.4 'subtree' 仍然不包括在内（至少不在 Ubuntu 12.04 git ppa (ppa:git-core/ppa) 上）`

`我可以确认，在此之后，git log rails/somefile 将不会显示该文件的提交历史记录，但合并提交除外。正如@artfulrobot 建议的那样，检查 Greg Hewgill's answer。您可能需要在要包含的存储库上使用 git filter-branch。`

`或者阅读 Eric Lee 的“将两个 Git 存储库合并到一个存储库而不丢失文件历史记录”saintgimp.org/2013/01/22/…`

`正如其他人所说，git subtree 可能不会像您想的那样！有关更完整的解决方案，请参阅 here。`

## 答4: ##

> huntsbot.com全球7大洲远程工作机会，探索不一样的工作方式

如果您想单独维护项目，则子模块方法很好。但是，如果您真的想将两个项目合并到同一个存储库中，那么您还有更多工作要做。

首先是使用 git filter-branch 将第二个存储库中所有内容的名称重写为您希望它们结束的子目录中。因此，您将拥有 projb/foo.c 和 projb/bar.html，而不是 foo.c、bar.html。

然后，您应该能够执行以下操作：

git remote add projb [wherever]
    git pull projb

git pull 将执行 git fetch，然后执行 git merge。如果您要拉入的存储库还没有 projb/ 目录，则应该没有冲突。

进一步搜索表明进行了类似的操作以将 gitk 合并到 git。 Junio C Hamano 在这里写到：http://www.mail-archive.com/git@vger.kernel.org/msg03395.html

`子树合并将是更好的解决方案，并且不需要重写包含项目的历史记录`

`我想知道如何使用 git filter-branch 来实现这一点。在手册页中它说的是相反的方式：使 subdir/ 成为根，但不是相反。`

`如果它解释了如何使用 filter-branch 来达到预期的结果，这个答案会很棒`

`我在这里找到了如何使用过滤器分支：stackoverflow.com/questions/4042816/…`

`有关 Greg 大纲的实施，请参见 this answer。`

## 答5: ##

> huntsbot.com提供全网独家一站式外包任务、远程工作、创意产品分享与订阅服务!

git-subtree 不错，但可能不是您想要的。

例如，如果 projectA 是在 B 中创建的目录，则在 git subtree 之后，

git log projectA

仅列出一个提交：合并。合并项目的提交用于不同的路径，因此它们不会显示。

Greg Hewgill 的答案最接近，尽管它实际上并没有说明如何重写路径。

解决方案非常简单。

(1) 在 A 中，

PREFIX=projectA #adjust this
    
    git filter-branch --index-filter '
        git ls-files -s |
        sed "s,\t,&'"$PREFIX"'/," |
        GIT_INDEX_FILE=$GIT_INDEX_FILE.new git update-index --index-info &&
        mv $GIT_INDEX_FILE.new $GIT_INDEX_FILE
    ' HEAD

注意：这会改写历史；您可能需要先备份 A。

注意：如果您在文件名或路径中使用非 ascii 字符（或白色字符），则必须修改 sed 命令中的替换脚本。在这种情况下，由“ls-files -s”生成的记录中的文件位置以引号开头。

(2) 然后在 B 中运行

git pull path/to/A

瞧！您在 B 中有一个 projectA 目录。如果您运行 git log projectA，您将看到来自 A 的所有提交。

在我的例子中，我想要两个子目录，projectA 和 projectB。在这种情况下，我也对 B 执行了步骤 (1)。

`您似乎从 stackoverflow.com/a/618113/586086 复制了您的答案？`

`@AndrewMao，我想是的......我实际上不记得了。这个脚本我用过不少。`

`我要补充一点 \t 在 OS X 上不起作用，你必须输入`

`"$GIT_INDEX_FILE" 必须被引用（两次），否则如果路径包含空格，您的方法将失败。`

`如果你想知道，插入一个 在 osx 中，您需要 Ctrl-V`

## 答6: ##

> huntsbot.com洞察每一个产品背后的需求与收益，从而捕获灵感

如果两个存储库具有相同类型的文件（例如不同项目的两个 Rails 存储库），您可以将辅助存储库的数据获取到当前存储库：

git fetch git://repository.url/repo.git master:branch_name

然后将其合并到当前存储库：

git merge --allow-unrelated-histories branch_name

如果您的 Git 版本小于 2.9，请删除 --allow-unrelated-histories。

在此之后，可能会发生冲突。例如，您可以使用 git mergetool 解决它们。 kdiff3 可以单独与键盘一起使用，因此读取代码时只需几分钟就需要 5 个冲突文件。

记得完成合并：

git commit

`我喜欢这个解决方案的简单性，它看起来就像我正在寻找的东西，但它基本上不等同于 git pull --allow-unrelated-histories 吗？`

`@Prometheus 有点像。我现在没有测试它，但可能 pull 需要将远程存储库添加为真正的远程，这只会将必要的内容获取到分支并合并该内容。`

## 答7: ##

> huntsbot.com提供全网独家一站式外包任务、远程工作、创意产品分享与订阅服务!

在使用合并时，我一直在丢失历史记录，所以我最终使用了 rebase，因为在我的情况下，两个存储库不同，以至于不会在每次提交时合并：

git clone git@gitorious/projA.git projA
    git clone git@gitorious/projB.git projB
    
    cd projB
    git remote add projA ../projA/
    git fetch projA 
    git rebase projA/master HEAD

=> 解决冲突，然后继续，根据需要多次…

git rebase --continue

这样做会导致一个项目拥有来自 projA 的所有提交，然后是来自 projB 的提交

## 答8: ##

> 打造属于自己的副业，开启自由职业之旅，从huntsbot.com开始!

在我的例子中，我有一个 my-plugin 存储库和一个 main-project 存储库，我想假设 my-plugin 一直是在 main-project 的 plugins 子目录中开发的。

基本上，我重写了 my-plugin 存储库的历史，以便所有开发都发生在 plugins/my-plugin 子目录中。然后，我将 my-plugin 的发展历史添加到 main-project 历史中，并将两棵树合并在一起。由于 main-project 存储库中没有 plugins/my-plugin 目录，因此这是一个简单的无冲突合并。生成的存储库包含两个原始项目的所有历史记录，并且有两个根源。

TL;博士

$ cp -R my-plugin my-plugin-dirty
    $ cd my-plugin-dirty
    $ git filter-branch -f --tree-filter "zsh -c 'setopt extended_glob && setopt glob_dots && mkdir -p plugins/my-plugin && (mv ^(.git|plugins) plugins/my-plugin || true)'" -- --all
    $ cd ../main-project
    $ git checkout master
    $ git remote add --fetch my-plugin ../my-plugin-dirty
    $ git merge my-plugin/master --allow-unrelated-histories
    $ cd ..
    $ rm -rf my-plugin-dirty

长版

首先，创建 my-plugin 存储库的副本，因为我们将重写此存储库的历史记录。

现在，导航到 my-plugin 存储库的根目录，检查您的主分支（可能是 master），然后运行以下命令。当然，无论您的实际姓名是什么，您都应该替换 my-plugin 和 plugins。

$ git filter-branch -f --tree-filter "zsh -c 'setopt extended_glob && setopt glob_dots && mkdir -p plugins/my-plugin && (mv ^(.git|plugins) plugins/my-plugin || true)'" -- --all

现在解释一下。 git filter-branch --tree-filter (…) HEAD 对可从 HEAD 访问的每个提交运行 (…) 命令。请注意，这直接对每次提交存储的数据进行操作，因此我们不必担心“工作目录”、“索引”、“暂存”等概念。

如果您运行的 filter-branch 命令失败，它会在 .git 目录中留下一些文件，并且下次尝试 filter-branch 时它会抱怨此问题，除非您向 filter-branch 提供 -f 选项.

至于实际的命令，我没有让 bash 做我想做的事，所以我使用 zsh -c 让 zsh 执行命令。首先，我设置了 extended\_glob 选项，它启用了 mv 命令中的 ^(…) 语法，以及 glob\_dots 选项，它允许我选择带有 glob 的点文件（例如 .gitignore） (^(…))。

接下来，我使用 mkdir -p 命令同时创建 plugins 和 plugins/my-plugin。

最后，我使用 zsh“负 glob”功能 ^(.git|plugins) 来匹配存储库根目录中除 .git 和新创建的 my-plugin 文件夹之外的所有文件。 （此处可能不需要排除 .git，但尝试将目录移动到自身是错误的。）

在我的存储库中，初始提交不包含任何文件，因此 mv 命令在初始提交时返回错误（因为没有可移动的内容）。因此，我添加了一个 || true，以便 git filter-branch 不会中止。

–all 选项告诉 filter-branch 重写存储库中 所有 分支的历史记录，并且需要额外的 – 告诉 git 将其解释为选项列表的一部分用于重写分支，而不是作为 filter-branch 本身的选项。

现在，导航到您的 main-project 存储库并检查您想要合并到的任何分支。添加 my-plugin 存储库的本地副本（修改其历史）作为 main-project 的远程：

$ git remote add --fetch my-plugin $PATH_TO_MY_PLUGIN_REPOSITORY

现在，您的提交历史中将有两个不相关的树，您可以使用以下方法很好地可视化它们：

$ git log --color --graph --decorate --all

要合并它们，请使用：

$ git merge my-plugin/master --allow-unrelated-histories

请注意，在 2.9.0 之前的 Git 中，–allow-unrelated-histories 选项不存在。如果您使用的是这些版本之一，只需省略该选项：–allow-unrelated-histories 阻止的错误消息也被添加到 2.9.0 中。

您不应该有任何合并冲突。如果这样做，则可能意味着 filter-branch 命令无法正常工作，或者 main-project 中已经存在 plugins/my-plugin 目录。

确保为任何未来的贡献者输入一个解释性的提交消息，他们想知道黑客正在做什么来创建一个有两个根的存储库。

您可以使用上面的 git log 命令可视化新的提交图，它应该有两个根提交。请注意，只会合并 master 分支。这意味着，如果您在其他 my-plugin 分支上有重要的工作要合并到 main-project 树中，则在完成这些合并之前，您应该避免删除 my-plugin 远程。如果您不这样做，那么来自这些分支的提交仍将位于 main-project 存储库中，但有些将无法访问并且容易受到最终垃圾收集的影响。 （此外，您必须通过 SHA 引用它们，因为删除远程会删除其远程跟踪分支。）

或者，在您合并所有要保留在 my-plugin 中的内容后，您可以使用以下方法删除 my-plugin 远程：

$ git remote remove my-plugin

您现在可以安全地删除您更改了其历史记录的 my-plugin 存储库的副本。就我而言，在合并完成并推送后，我还在真正的 my-plugin 存储库中添加了弃用通知。

在带有 git --version 2.9.0 和 zsh --version 5.2 的 Mac OS X El Capitan 上进行了测试。你的旅费可能会改变。

参考：

https://git-scm.com/docs/git-filter-branch

https://unix.stackexchange.com/questions/6393/how-do-you-move-all-files-include-hidden-from-one-directory-to-another

http://www.refining-linux.org/archives/37/ZSH-Gem-2-Extended-globbing-and-expansion/

从 Git 存储库清除文件失败，无法创建新备份

git，所有分支上的过滤器分支

`--allow-unrelated-histories 来自哪里？`

`@MarceloFilho 检查 man git-merge。 默认情况下，git merge 命令拒绝合并不共享共同祖先的历史。当合并两个独立开始的项目的历史时，此选项可用于覆盖此安全性。由于这种情况很少见，因此默认情况下不存在启用此功能的配置变量，因此不会添加。`

`应该在 git version 2.7.2.windows.1 上可用吗？`

`@MarceloFilho 这是在 2.9.0 中添加的，但在旧版本中，您不必传递该选项（它会起作用）。 github.com/git/git/blob/…`

`这运作良好。而且我能够使用过滤器分支将文件名重写到合并之前树中我想要的位置。我想如果您需要在主分支之外移动历史记录，则需要做更多的工作。`

## 答9: ##

> 打造属于自己的副业，开启自由职业之旅，从huntsbot.com开始!

几天来我一直在尝试做同样的事情，我使用的是 git 2.7.2。子树不保留历史。

如果您不再使用旧项目，您可以使用此方法。

我建议你先分支 B 并在分支中工作。

以下是没有分支的步骤：

cd B
    
    # You are going to merge A into B, so first move all of B's files into a sub dir
    mkdir B
    
    # Move all files to B, till there is nothing in the dir but .git and B
    git mv  B
    
    git add .
    
    git commit -m "Moving content of project B in preparation for merge from A"
    
    
    # Now merge A into B
    git remote add -f A 
    
    git merge A/
    
    mkdir A
    
    # move all the files into subdir A, excluding .git
    git mv  A
    
    git commit -m "Moved A into subdir"
    
    
    # Move B's files back to root    
    git mv B/* ./
    
    rm -rf B
    
    git commit -m "Reset B to original state"
    
    git push

如果您现在在 subdir A 中记录任何文件，您将获得完整的历史记录

git log --follow A/

这是帮助我做到这一点的帖子：

http://saintgimp.org/2013/01/22/merging-two-git-repositories-into-one-repository-without-losing-file-history/

## 答10: ##

> huntsbot.com聚合了超过10+全球外包任务平台的外包需求，寻找外包任务与机会变的简单与高效。

如果您想将 repo B 中的分支中的文件放在 repo A 的子树中并保留历史记录，请继续阅读。 （在下面的示例中，我假设我们希望将 repo B 的 master 分支合并到 repo A 的 master 分支中。）

在 repo A 中，首先执行以下操作以使 repo B 可用：

git remote add B ../B # Add repo B as a new remote.
    git fetch B

现在我们在 repo A 中创建一个全新的分支（只有一个提交），我们称之为 new\_b\_root。生成的提交将包含在 repo B 的主分支的第一次提交中提交的文件，但放在名为 path/to/b-files/ 的子目录中。

git checkout --orphan new_b_root master
    git rm -rf . # Remove all files.
    git cherry-pick -n `git rev-list --max-parents=0 B/master`
    mkdir -p path/to/b-files
    git mv README path/to/b-files/
    git commit --date="$(git log --format='%ai' $(git rev-list --max-parents=0 B/master))"

说明： checkout 命令的 --orphan 选项从 A 的主分支中签出文件，但不创建任何提交。我们可以选择任何提交，因为接下来我们无论如何都会清除所有文件。然后，还没有提交（-n），我们从 B 的主分支中挑选第一个提交。 （cherry-pick 保留了直接签出似乎无法做到的原始提交消息。）然后我们创建子树，我们希望将所有文件从 repo B 中放入其中。然后我们必须移动引入的所有文件樱桃采摘到子树。在上面的示例中，只有一个 README 文件要移动。然后我们提交我们的 B-repo 根提交，同时，我们还保留原始提交的时间戳。

现在，我们将在新创建的 new\_b\_root 之上创建一个新的 B/master 分支。我们将新分支称为 b：

git checkout -b b B/master
    git rebase -s recursive -Xsubtree=path/to/b-files/ new_b_root

现在，我们将 b 分支合并到 A/master：

git checkout master
    git merge --allow-unrelated-histories --no-commit b
    git commit -m 'Merge repo B into repo A.'

最后，您可以删除 B 远程和临时分支：

git remote remove B
    git branch -D new_b_root b

最终的图形将具有如下结构：

https://i.stack.imgur.com/CB80G.png

`很好的答案，谢谢！我真的错过了来自 Andresch Serj 的“git subtree”或“merge --allow-unrelated-histories”的其他答案，即子目录没有日志。`

## 答11: ##

> 保持自己快人一步,享受全网独家提供的一站式外包任务、远程工作、创意产品订阅服务–huntsbot.com

我在这里收集了很多关于 Stack OverFlow 等的信息，并设法将一个脚本放在一起，为我解决了这个问题。

需要注意的是，它只考虑每个存储库的“开发”分支，并将其合并到一个全新存储库中的单独目录中。

标签和其他分支被忽略 - 这可能不是你想要的。

该脚本甚至处理功能分支和标签 - 在新项目中重命名它们，以便您知道它们来自哪里。

#!/bin/bash
    #
    ################################################################################
    ## Script to merge multiple git repositories into a new repository
    ## - The new repository will contain a folder for every merged repository
    ## - The script adds remotes for every project and then merges in every branch
    ##   and tag. These are renamed to have the origin project name as a prefix
    ##
    ## Usage: mergeGitRepositories.sh  
    ## - where  is the name of the new project to create
    ## - and  is a file contaning the URLs to the respositories
    ##   which are to be merged on separate lines.
    ##
    ## Author: Robert von Burg
    ##            eitch@eitchnet.ch
    ##
    ## Version: 0.3.2
    ## Created: 2018-02-05
    ##
    ################################################################################
    #
    
    # disallow using undefined variables
    shopt -s -o nounset
    
    # Script variables
    declare SCRIPT_NAME="${0##*/}"
    declare SCRIPT_DIR="$(cd ${0%/*} ; pwd)"
    declare ROOT_DIR="$PWD"
    IFS=$'\n'
    
    # Detect proper usage
    if [ "$#" -ne "2" ] ; then
      echo -e "ERROR: Usage: $0  "
      exit 1
    fi
    
    
    ## Script variables
    PROJECT_NAME="${1}"
    PROJECT_PATH="${ROOT_DIR}/${PROJECT_NAME}"
    TIMESTAMP="$(date +%s)"
    LOG_FILE="${ROOT_DIR}/${PROJECT_NAME}_merge.${TIMESTAMP}.log"
    REPO_FILE="${2}"
    REPO_URL_FILE="${ROOT_DIR}/${REPO_FILE}"
    
    
    # Script functions
    function failed() {
        
      echo -e "ERROR: Merging of projects failed:"
      echo -e "ERROR: Merging of projects failed:" >>${
        LOG_FILE} 2>&1
      echo -e "$1"
      exit 1
    }
    
    function commit_merge() {
        
      current_branch="$(git symbolic-ref HEAD 2>/dev/null)"
      if [[ ! -f ".git/MERGE_HEAD" ]] ; then
        echo -e "INFO:   No commit required."
        echo -e "INFO:   No commit required." >>${
        LOG_FILE} 2>&1
      else
        echo -e "INFO:   Committing ${sub_project}..."
        echo -e "INFO:   Committing ${sub_project}..." >>${
        LOG_FILE} 2>&1
        if ! git commit -m "[Project] Merged branch '$1' of ${sub_project}" >>${
        LOG_FILE} 2>&1 ; then
          failed "Failed to commit merge of branch '$1' of ${sub_project} into ${current_branch}"
        fi
      fi
    }
    
    
    # Make sure the REPO_URL_FILE exists
    if [ ! -e "${REPO_URL_FILE}" ] ; then
      echo -e "ERROR: Repo file ${REPO_URL_FILE} does not exist!"
      exit 1
    fi
    
    
    # Make sure the required directories don't exist
    if [ -e "${PROJECT_PATH}" ] ; then
      echo -e "ERROR: Project ${PROJECT_NAME} already exists!"
      exit 1
    fi
    
    
    # create the new project
    echo -e "INFO: Logging to ${LOG_FILE}"
    echo -e "INFO: Creating new git repository ${PROJECT_NAME}..."
    echo -e "INFO: Creating new git repository ${PROJECT_NAME}..." >>${
        LOG_FILE} 2>&1
    echo -e "===================================================="
    echo -e "====================================================" >>${
        LOG_FILE} 2>&1
    cd ${
        ROOT_DIR}
    mkdir ${
        PROJECT_NAME}
    cd ${
        PROJECT_NAME}
    git init
    echo "Initial Commit" > initial_commit
    # Since this is a new repository we need to have at least one commit
    # thus were we create temporary file, but we delete it again.
    # Deleting it guarantees we don't have conflicts later when merging
    git add initial_commit
    git commit --quiet -m "[Project] Initial Master Repo Commit"
    git rm --quiet initial_commit
    git commit --quiet -m "[Project] Initial Master Repo Commit"
    echo
    
    
    # Merge all projects into the branches of this project
    echo -e "INFO: Merging projects into new repository..."
    echo -e "INFO: Merging projects into new repository..." >>${
        LOG_FILE} 2>&1
    echo -e "===================================================="
    echo -e "====================================================" >>${
        LOG_FILE} 2>&1
    for url in $(cat ${
        REPO_URL_FILE}) ; do
    
      if [[ "${url:0:1}" == '#' ]] ; then
        continue
      fi
    
      # extract the name of this project
      export sub_project=${
        url##*/}
      sub_project=${
        sub_project%*.git}
    
      echo -e "INFO: Project ${sub_project}"
      echo -e "INFO: Project ${sub_project}" >>${
        LOG_FILE} 2>&1
      echo -e "----------------------------------------------------"
      echo -e "----------------------------------------------------" >>${
        LOG_FILE} 2>&1
    
      # Fetch the project
      echo -e "INFO:   Fetching ${sub_project}..."
      echo -e "INFO:   Fetching ${sub_project}..." >>${
        LOG_FILE} 2>&1
      git remote add "${sub_project}" "${url}"
      if ! git fetch --tags --quiet ${
        sub_project} >>${
        LOG_FILE} 2>&1 ; then
        failed "Failed to fetch project ${sub_project}"
      fi
    
      # add remote branches
      echo -e "INFO:   Creating local branches for ${sub_project}..."
      echo -e "INFO:   Creating local branches for ${sub_project}..." >>${
        LOG_FILE} 2>&1
      while read branch ; do
        branch_ref=$(echo $branch | tr " " "\t" | cut -f 1)
        branch_name=$(echo $branch | tr " " "\t" | cut -f 2 | cut -d / -f 3-)
    
        echo -e "INFO:   Creating branch ${branch_name}..."
        echo -e "INFO:   Creating branch ${branch_name}..." >>${
        LOG_FILE} 2>&1
    
        # create and checkout new merge branch off of master
        if ! git checkout -b "${sub_project}/${branch_name}" master >>${
        LOG_FILE} 2>&1 ; then failed "Failed preparing ${branch_name}" ; fi
        if ! git reset --hard ; then failed "Failed preparing ${branch_name}" >>${
        LOG_FILE} 2>&1 ; fi
        if ! git clean -d --force ; then failed "Failed preparing ${branch_name}" >>${
        LOG_FILE} 2>&1 ; fi
    
        # Merge the project
        echo -e "INFO:   Merging ${sub_project}..."
        echo -e "INFO:   Merging ${sub_project}..." >>${
        LOG_FILE} 2>&1
        if ! git merge --allow-unrelated-histories --no-commit "remotes/${sub_project}/${branch_name}" >>${
        LOG_FILE} 2>&1 ; then
          failed "Failed to merge branch 'remotes/${sub_project}/${branch_name}' from ${sub_project}"
        fi
    
        # And now see if we need to commit (maybe there was a merge)
        commit_merge "${sub_project}/${branch_name}"
    
        # relocate projects files into own directory
        if [ "$(ls)" == "${sub_project}" ] ; then
          echo -e "WARN:   Not moving files in branch ${branch_name} of ${sub_project} as already only one root level."
          echo -e "WARN:   Not moving files in branch ${branch_name} of ${sub_project} as already only one root level." >>${
        LOG_FILE} 2>&1
        else
          echo -e "INFO:   Moving files in branch ${branch_name} of ${sub_project} so we have a single directory..."
          echo -e "INFO:   Moving files in branch ${branch_name} of ${sub_project} so we have a single directory..." >>${
        LOG_FILE} 2>&1
          mkdir ${
        sub_project}
          for f in $(ls -a) ; do
            if  [[ "$f" == "${sub_project}" ]] ||
                [[ "$f" == "." ]] ||
                [[ "$f" == ".." ]] ; then
              continue
            fi
            git mv -k "$f" "${sub_project}/"
          done
    
          # commit the moving
          if ! git commit --quiet -m  "[Project] Move ${sub_project} files into sub directory" ; then
            failed "Failed to commit moving of ${sub_project} files into sub directory"
          fi
        fi
        echo
      done < <(git ls-remote --heads ${
        sub_project})
    
    
      # checkout master of sub probject
      if ! git checkout "${sub_project}/master" >>${
        LOG_FILE} 2>&1 ; then
        failed "sub_project ${sub_project} is missing master branch!"
      fi
    
      # copy remote tags
      echo -e "INFO:   Copying tags for ${sub_project}..."
      echo -e "INFO:   Copying tags for ${sub_project}..." >>${
        LOG_FILE} 2>&1
      while read tag ; do
        tag_ref=$(echo $tag | tr " " "\t" | cut -f 1)
        tag_name_unfixed=$(echo $tag | tr " " "\t" | cut -f 2 | cut -d / -f 3)
    
        # hack for broken tag names where they are like 1.2.0^{
        } instead of just 1.2.0
        tag_name="${tag_name_unfixed%%^*}"
    
        tag_new_name="${sub_project}/${tag_name}"
        echo -e "INFO:     Copying tag ${tag_name_unfixed} to ${tag_new_name} for ref ${tag_ref}..."
        echo -e "INFO:     Copying tag ${tag_name_unfixed} to ${tag_new_name} for ref ${tag_ref}..." >>${
        LOG_FILE} 2>&1
        if ! git tag "${tag_new_name}" "${tag_ref}" >>${
        LOG_FILE} 2>&1 ; then
          echo -e "WARN:     Could not copy tag ${tag_name_unfixed} to ${tag_new_name} for ref ${tag_ref}"
          echo -e "WARN:     Could not copy tag ${tag_name_unfixed} to ${tag_new_name} for ref ${tag_ref}" >>${
        LOG_FILE} 2>&1
        fi
      done < <(git ls-remote --tags --refs ${
        sub_project})
    
      # Remove the remote to the old project
      echo -e "INFO:   Removing remote ${sub_project}..."
      echo -e "INFO:   Removing remote ${sub_project}..." >>${
        LOG_FILE} 2>&1
      git remote rm ${
        sub_project}
    
      echo
    done
    
    
    # Now merge all project master branches into new master
    git checkout --quiet master
    echo -e "INFO: Merging projects master branches into new repository..."
    echo -e "INFO: Merging projects master branches into new repository..." >>${
        LOG_FILE} 2>&1
    echo -e "===================================================="
    echo -e "====================================================" >>${
        LOG_FILE} 2>&1
    for url in $(cat ${
        REPO_URL_FILE}) ; do
    
      if [[ ${
        url:0:1} == '#' ]] ; then
        continue
      fi
    
      # extract the name of this project
      export sub_project=${
        url##*/}
      sub_project=${
        sub_project%*.git}
    
      echo -e "INFO:   Merging ${sub_project}..."
      echo -e "INFO:   Merging ${sub_project}..." >>${
        LOG_FILE} 2>&1
      if ! git merge --allow-unrelated-histories --no-commit "${sub_project}/master" >>${
        LOG_FILE} 2>&1 ; then
        failed "Failed to merge branch ${sub_project}/master into master"
      fi
    
      # And now see if we need to commit (maybe there was a merge)
      commit_merge "${sub_project}/master"
    
      echo
    done
    
    
    # Done
    cd ${
        ROOT_DIR}
    echo -e "INFO: Done."
    echo -e "INFO: Done." >>${
        LOG_FILE} 2>&1
    echo
    
    exit 0

您也可以从 http://paste.ubuntu.com/11732805 获得它

首先创建一个包含每个存储库的 URL 的文件，例如：

git@github.com:eitchnet/ch.eitchnet.parent.git
    git@github.com:eitchnet/ch.eitchnet.utils.git
    git@github.com:eitchnet/ch.eitchnet.privilege.git

然后调用提供项目名称和脚本路径的脚本：

./mergeGitRepositories.sh eitchnet_test eitchnet.lst

脚本本身有很多注释应该解释它的作用。

`与其将读者引导至答案，请在此处发布答案（也就是将您在该评论中所说的内容编辑到此答案中）。`

`当然，只是认为最好不要重复自己... =）`

`如果您认为这个问题与另一个问题相同，那么您可以使用问题本身下方的“标记”链接将其标记为重复，并指出另一个问题。如果它不是重复的问题，但您认为完全相同的答案可用于解决这两个问题，那么只需对这两个问题发布相同的答案（就像您现在所做的那样）。感谢您的贡献！`

`惊人！在 Windows bash 提示符下不起作用，但它完美地从运行 ubuntu 的 Vagrant 盒子中运行。多么节省时间！`

`旧的但是.. 用粗体（和/或更大的字体）警告可能是个好主意？`

原文链接：[https://www.huntsbot.com/qa/7Q53/how-do-you-merge-two-git-repositories?lang=zh\_CN&from=csdn][https_www.huntsbot.com_qa_7Q53_how-do-you-merge-two-git-repositories_lang_zh_CN_from_csdn]

> 保持自己快人一步,享受全网独家提供的一站式外包任务、远程工作、创意产品订阅服务–huntsbot.com

[https_www.huntsbot.com_qa_7Q53_how-do-you-merge-two-git-repositories_lang_zh_CN_from_csdn]: https://www.huntsbot.com/qa/7Q53/how-do-you-merge-two-git-repositories?lang=zh_CN&from=csdn