如何更新或同步 GitHub 上的分叉存储库？

Question

我分叉了一个项目，进行了更改，并创建了一个已接受的拉取请求。新的提交后来被添加到存储库中。我如何将这些提交放入我的分叉中？

Answer 1

如果你设置你的上游。使用 git remote -v 检查，这样就足够了。

git fetch upstream
git checkout master
git merge --no-edit upstream/master
git push

Answer 2

克隆分叉存储库后，转到克隆所在的目录路径和 Git Bash 终端中的几行。

$ cd project-name

$ git remote add upstream https://github.com/user-name/project-name.git
 # Adding the upstream -> the main repo with which you wanna sync

$ git remote -v # you will see the upstream here 

$ git checkout master # see if you are already on master branch

$ git fetch upstream

现在就可以开始了。主存储库中的所有更新更改都将推送到您的分支存储库中。

“fetch”命令对于保持项目最新状态是必不可少的：只有在执行“git fetch”时，您才会获悉同事推送到远程服务器的更改。

您仍然可以访问此处进行进一步查询

Answer 3

Android Studio 现在已经学会了使用 GitHub fork 存储库（您甚至不必通过控制台命令添加“上游”远程存储库）。

打开菜单 VCS → Git

并注意最后两个弹出菜单项：

• Rebase my GitHub fork

• 创建拉取请求

尝试一下。我使用第一个来同步我的本地存储库。无论如何，在单击“Rebase my GitHub fork”后，您将可以在 Android Studio 中访问父远程存储库（“上游”）的分支，并且您将能够轻松地使用它们。

（我使用带有“Git 集成”和“GitHub”插件的 Android Studio 3.0。）

Answer 4

如何在本地计算机上更新分叉存储库？

首先，检查您的远程/主控

git remote -v

您应该有起源和上游。例如：

origin  https://github.com/your___name/kredis.git (fetch)
origin  https://github.com/your___name/kredis.git (push)
upstream    https://github.com/rails/kredis.git (fetch)
upstream    https://github.com/rails/kredis.git (push)

之后转到 main:

git checkout main

并从上游合并到 main:

git merge upstream/main

Answer 5

假设您的分叉是 https://github.com/me/foobar 并且原始存储库是 https://github.com/someone/foobar

1. 访问https://github.com/me/foobar/compare/master...某人：大师

2. 如果您看到绿色文本能够合并，则按创建拉取请求

3. 在下一页上，滚动到页面底部并单击合并拉取请求 和确认合并。

使用此代码片段生成链接以同步您的分叉存储库：

new Vue ({
    el: "#app",
    data: {
      yourFork: 'https://github.com/me/foobar',
      originalRepo: 'https://github.com/someone/foobar'
    },
    computed: {
      syncLink: function () {
        const yourFork = new URL(this.yourFork).pathname.split('/')
        const originalRepo = new URL(this.originalRepo).pathname.split('/')
        if (yourFork[1] && yourFork[2] && originalRepo[1]) {
          return `https://github.com/${yourFork[1]}/${yourFork[2]}/compare/master...${originalRepo[1]}:master`
        }
        return 'Not enough data'
      }
    }
  })

<script src="https://cdnjs.cloudflare.com/ajax/libs/vue/2.5.17/vue.js"></script>
<div id="app">
  Your fork URL: <input size=50 v-model="yourFork" /> <br />
  Original repository URL: <input v-model="originalRepo" size=50 /> <br />
  Link to sync your fork: <a :href="syncLink">{{syncLink}}</a>
</div>

Answer 6

我想添加到 @krlmlr 回答。

最初，分叉存储库有一个名为：master 的分支。如果您正在开发新功能或修复，通常会创建一个新分支 feature 并进行更改。

如果您希望分叉存储库与父存储库同步，您可以为 pull.yml) /pull" rel="nofollow noreferrer">拉取应用程序（在功能分支），如下所示：

version: "1"
rules:
  - base: feature
    upstream: master
    mergeMethod: merge
  - base: master
    upstream: parent_repo:master
    mergeMethod: hardreset

这会保持分叉存储库的 master 分支正常运行- 与父母约会回购。它通过合并分支存储库的 master 分支来保持分支存储库的 feature 分支的更新。这假设 feature 分支是包含配置文件的默认分支。

这里有两种mergemethods发挥作用，一种是hardreset，它有助于强制将分叉存储库的master分支中的更改与父存储库和另一种方法是merge。此方法用于合并您在 feature 分支中完成的更改以及由于 master 分支中强制同步而完成的更改。如果发生合并冲突，拉取应用程序将允许您在拉取请求期间选择下一步操作。

您可以在此处阅读有关基本和高级配置以及各种合并方法的信息。

我目前正在我的分叉存储库此处中使用此配置，以确保请求增强< a href="https://stackoverflow.com/q/20700696/10155936">此处保持更新。

Answer 7

这取决于您的存储库的大小以及您如何分叉它。

如果它是一个相当大的存储库，您可能希望以特殊的方式管理它（例如删除历史记录）。基本上，您可以获取当前版本和上游版本之间的差异，提交它们，然后挑选回主版本。

尝试阅读这个。它描述了如何处理大型 Git 存储库以及如何使用最新更改将其上游。

Answer 8

如果你想让你的 GitHub 分支与相应的上游保持同步，还有专门针对 GitHub 的 Probot 程序： https://probot.github.io/apps/pull/ 完成这项工作。
您需要允许在您的帐户中安装，它将使您的分叉保持最新状态。

Answer 9

尝试一下，单击“获取上游”以从上游主服务器同步您的分叉存储库。

Answer 10

如果使用 GitHub Desktop，只需 6 步（实际上只有 5 步）即可轻松完成。

打开 Github Desktop 并选择存储库后，

1. 转到“历史记录”选项卡
2. 单击搜索栏。它将向您显示所有可用的分支（包括
   来自父存储库的上游分支）
3. 选择相应的上游分支（它将是upstream/master 以同步master
   分支）
4. （可选）它将显示上游分支中的所有提交。您可以点击
   任何提交以查看更改。
5. 根据您的活动分支，在 master / branch-name 中单击“合并”。
6. 等待 GitHub Desktop 施展魔法。

以下面的 GIF 为例：

Answer 11

使用这些命令（幸运的话）

git remote -v
git pull
git fetch upstream
git checkout master
git merge upstream/master --no-ff
git add .
git commit -m"Sync with upstream repository."
git push -v

Answer 12

保持分叉存储库始终更新有两个主要因素。

<强>1。从 fork master 创建分支并在那里进行更改。

因此，当您的拉取请求被接受时，您可以安全地删除该分支，因为当您使用上游更新它时，您贡献的代码将存在于分叉存储库的主版本中。这样你的master将始终处于干净的状态来创建一个新的分支来进行另一个更改。

<强>2。为 fork master 创建一个计划作业以自动更新。

这可以通过 cron 来完成。如果您在 Linux 中执行此操作，这里是示例代码。

$ crontab -e

将此代码放在 crontab 文件 中以每小时执行一次作业。

0 * * * * sh ~/cron.sh

然后创建 cron.sh 脚本文件和 git 交互与ssh-agent和/或预计如下

#!/bin/sh
WORKDIR=/path/to/your/dir   
REPOSITORY=<name of your repo>
MASTER="[email protected]:<username>/$REPOSITORY.git"   
[email protected]:<upstream>/<name of the repo>.git  

cd $WORKDIR && rm -rf $REPOSITORY
eval `ssh-agent` && expect ~/.ssh/agent && ssh-add -l
git clone $MASTER && cd $REPOSITORY && git checkout master
git remote add upstream $UPSTREAM && git fetch --prune upstream
if [ `git rev-list HEAD...upstream/master --count` -eq 0 ]
then
    echo "all the same, do nothing"
else
    echo "update exist, do rebase!"
    git reset --hard upstream/master
    git push origin master --force
fi
cd $WORKDIR && rm -rf $REPOSITORY
eval `ssh-agent -k`

检查您的分叉存储库。有时它总是会显示此通知：

该分支与 :master 相同。

Answer 13

rm -rf oldrepository
git clone ...

可能有更微妙的选择，但这是我确信我的本地存储库与上游相同的唯一方法。

Answer 14

在分叉存储库的本地克隆中，您可以将原始 GitHub 存储库添加为“远程”存储库。 （“Remotes”就像存储库 URL 的昵称 - 例如，origin 就是其中之一。）然后，您可以从该上游存储库获取所有分支，并重新调整您的工作以继续在上游工作版本。就命令而言，可能如下所示：

# Add the remote, call it "upstream":

git remote add upstream https://github.com/whoever/whatever.git

# Fetch all the branches of that remote into remote-tracking branches

git fetch upstream

# Make sure that you're on your main branch:

git checkout main

# Rewrite your main branch so that any commits of yours that
# aren't already in upstream/main are replayed on top of that
# other branch:

git rebase upstream/main

如果您不想重写主分支的历史记录（例如，因为其他人可能已经克隆了它），那么您应该将最后一个命令替换为 git merge upper/主要。然而，为了进一步发出尽可能干净的拉取请求，最好进行变基。

---

如果您已将分支重新设置为 upstream/main，您可能需要强制推送才能将其推送到 GitHub 上您自己的分叉存储库。您可以这样做：

git push -f origin main

您只需在重新设置基础后第一次使用 -f 即可。

Answer 15

从 2014 年 5 月开始，可以直接从 GitHub 更新分支。截至 2017 年 9 月，这仍然有效，但是它将导致脏的提交历史记录。

1. 在 GitHub 上打开您的 fork。
2. 单击拉取请求。
3. 单击新拉取请求。默认情况下，GitHub 会将原始版本与您的分支进行比较，如果您没有进行任何更改，则不应进行任何比较。
4. 如果您看到该链接，请点击切换基础。否则，手动将base fork下拉设置为您的fork，并将head fork设置为上游。现在 GitHub 会将您的分支与原始版本进行比较，您应该会看到所有最新的更改。
   
5. 创建拉取请求并为您的拉取请求分配一个可预测的名称（例如，从原始内容更新）。
6. 向下滚动到合并拉取请求，但不要单击任何内容。

现在您有三个选项，但每个选项都会导致不太干净的提交历史记录。

1. 默认情况下会创建一个丑陋的合并提交。
2. 如果您单击下拉菜单并选择“压缩并合并”，所有介入的提交将被压缩为一个。这通常是您不想要的。
3. 如果您点击Rebase and merge，所有提交都将与您“一起”进行，原始 PR 将链接到您的 PR，并且 GitHub 将显示 Thisbranch is X commits advance, Y commits Behind <原始叉子>。

所以，是的，您可以使用 GitHub Web UI 更新您的存储库及其上游，但这样做会玷污您的提交历史记录。坚持使用命令行 - 它是简单的。

Answer 16

以下是 GitHub 关于同步分叉的官方文档：

同步分叉

设置

在同步之前，您需要添加一个指向上游存储库的远程服务器。您最初分叉时可能已经这样做了。

提示：同步您的分支只会更新您的存储库的本地副本；它不会更新您在 GitHub 上的存储库。

<前><代码>$ git远程-v
# 列出当前的遥控器
来源 https://github.com/user/repo.git (获取)
来源https://github.com/user/repo.git（推送）

$ git 远程添加上游 https://github.com/otheruser/repo.git
# 设置新的遥控器

$ git 远程 -v
# 验证新的远程
来源 https://github.com/user/repo.git (获取)
来源https://github.com/user/repo.git（推送）
上游 https://github.com/otheruser/repo.git （获取）
上游 https://github.com/otheruser/repo.git （推送）

正在同步

将存储库与上游同步需要两个步骤：首先必须从远程获取，然后必须将所需的分支合并到本地分支。

正在获取

从远程存储库中获取将引入其分支及其各自的提交。它们存储在本地存储库的特殊分支下。

$ git fetch 上游
# 获取上游远程分支
远程：计数对象：75，完成。
远程：压缩对象：100% (53/53)，完成。
远程：总计 62 个（增量 27），重复使用 44 个（增量 9）
拆包对象：100% (62/62)，完成。
来自 https://github.com/otheruser/repo
 * [新分支] master ->上游/主控

我们现在将上游的主分支存储在本地分支upstream/master

$ git 分支 -va
# 列出所有本地和远程跟踪分支
* master a422352 我的本地提交
  遥控器/原点/HEAD ->起源/主人
  Remotes/origin/master a422352 我的本地提交
  Remotes/upstream/master 5fdff0f 一些上游提交

合并

现在我们已经获取了上游存储库，我们希望将其更改合并到本地分支中。这将使该分支与上游同步，而不会丢失我们的本地更改。

$ git checkout master
# 查看我们本地的 master 分支
切换到分支“master”

$ git 合并上游/master
# 将上游的 master 合并到我们自己的 master 中
更新a422352..5fdff0f
快进
 自述文件 | 9 --------
 自述文件.md | 7 ++++++
 更改了 2 个文件，插入了 7 个（+），删除了 9 个（-）
 删除模式 100644 自述文件
 创建模式100644 README.md

如果您的本地分支没有任何唯一的提交，git 将执行“快进”：

$ git merge 上游/master
正在更新 34e91da..16c56ad
快进
 自述文件.md | 5 +++--
 1 个文件已更改，3 个插入(+)，2 个删除(-)

提示：如果您想更新 GitHub 上的存储库，请按照说明操作这里

Answer 17

许多答案最终都会将您的分叉提前一次提交移到父存储库之前。此答案总结了此处找到的步骤，这些步骤将将您的分叉移动到与父级相同的提交。

1. 将目录更改为本地存储库。

   • 如果您不是 git checkout master，请切换到 master 分支
2. 将父级添加为远程存储库，git remote add upper

3. Issue git fetch uploaded

4. Issue git rebase upper/master代码>

   • 在此阶段，您可以通过输入 git status 来检查是否提交了要合并的内容

5. Issue git Push origin master

有关这些命令的更多信息，请参阅步骤 3。

Answer 18

如果像我一样，您从不直接向 master 提交任何内容（您确实应该这么做），那么您可以执行以下操作。

从您的分支的本地克隆中，创建您的上游远程。您只需要执行一次：

git remote add upstream https://github.com/whoever/whatever.git

然后每当您想要赶上上游存储库 master 分支时，您需要：

git checkout master
git pull upstream master

假设您自己从未在 master 上提交过任何内容，那么您应该已经完成​​了。现在，您可以将本地 master 推送到原始远程 GitHub 分支。您还可以在当前最新的本地主分支上重新建立您的开发分支。

经过初始上游设置和主节点签出后，您所需要做的就是运行以下命令将主节点与上游同步：git pull upper upper master。

Answer 19

前言：您的分叉是“源”，您分叉的存储库是“上游”。

假设您已经使用如下命令将分叉克隆到计算机上：

git clone [email protected]:your_name/project_name.git
cd project_name

如果给出了该命令，则需要按以下顺序继续：

1. 将“上游”添加到克隆的存储库中（ “起源”）：

   git远程添加上游[电子邮件受保护]：original_author /项目名称.git
   

2. 从“上游”获取提交（和分支）：

   git fetch 上游
   

3. 切换到分支的“master”分支（“源”）：

   git checkout master
   

4. 存储“master”分支的更改：

   git 存储
   

5. 将“上游”的“master”分支的更改合并到“源”的“master”分支：

   git 合并上游/master
   

6. 解决合并冲突（如果有）并提交合并

   git commit -am“从上游合并”
   

7. 将更改推送到您的分支

   <前><代码>git推送

8. 取回您隐藏的更改（如果有）

   git stash pop
   

9. 您完成了！恭喜！

GitHub 还提供了有关此主题的说明：同步 fork

Answer 20

可以通过三种方式执行此操作：从 Web UI（选项 1）、从 GitHub CLI（选项 2）或从命令行（选项 3）。

---

选项 1 - 网页用户界面

1. 在 GitHub 上，导航到您想要与上游存储库同步的分叉存储库的主页。

2. 选择“获取上游”下拉列表。

查看有关上游存储库提交的详细信息，然后单击“获取并合并”。

---

选项 2 - GitHub CLI

要从其父级更新远程分叉，请使用 gh reposync 子命令并提供您的分叉名称作为参数。

$ gh repo sync owner/cli-fork

如果上游存储库的更改导致冲突，则 GitHub CLI 无法同步。您可以设置 -force 标志来覆盖目标分支。

• 如何安装 GitHub CLI

• GitHub CLI 手册

---

选项 3 - 命令行

在将一个分支与某个分支同步之前上游存储库，必须 在 Git 中配置指向上游存储库的远程。

1 打开 Git Bash。

2 将当前工作目录更改为本地项目。

3 从上游存储库获取分支及其各自的提交。对 BRANCHNAME 的提交将存储在本地分支上游/BRANCHNAME 中。

$ git fetch upstream
> remote: Counting objects: 75, done.
> remote: Compressing objects: 100% (53/53), done.
> remote: Total 62 (delta 27), reused 44 (delta 9)
> Unpacking objects: 100% (62/62), done.
> From https://github.com/ORIGINAL_OWNER/ORIGINAL_REPOSITORY
>  * [new branch]      main     -> upstream/main

4 检查您的 fork 的本地默认分支 - 在本例中，我们使用 main。

$ git checkout main
> Switched to branch 'main'

5 将上游默认分支（在本例中为上游/主分支）中的更改合并到本地默认分支中。这将使您的分支的默认分支与上游存储库同步，而不会丢失本地更改。

$ git merge upstream/main
> Updating a422352..5fdff0f
> Fast-forward
>  README                    |    9 -------
>  README.md                 |    7 ++++++
>  2 files changed, 7 insertions(+), 9 deletions(-)
>  delete mode 100644 README
>  create mode 100644 README.md

如果本地分支没有任何唯一提交，Git 将执行“快进”：

$ git merge upstream/main
> Updating 34e91da..16c56ad
> Fast-forward
>  README.md                 |    5 +++--
>  1 file changed, 3 insertions(+), 2 deletions(-)

---

注意：同步分支只会更新存储库的本地副本。
要在 GitHub.com 上更新分支，必须 推送更改。

---

来源：GitHub 文档- 同步分支

---

@Paebbels 实现选项 2

在您的用户空间/GitHub 组织中创建一个存储库，并添加单个 YAML 文件以及多个*.repos 文件。 _All.repos 引用其他 *.repos 文件（存储库组）。语法如下： /=:branch[,branch]*

• .github/workflows /Synchronize.yml

  name：同步分叉存储库
  
  在：
  
    推：
  
    日程：
  
  # 每天 06:20 - 重新运行管道以检查分叉存储库的更新
  
      - 计划任务：'20 6 * * *'
  职位：
  
    同步：
  
      运行：ubuntu-latest
      步骤：
  
        - 名称：“
  

Answer 21

GitHub 现在引入了一项功能，只需单击按钮即可同步分叉。

转到您的分叉，单击获取上游，然后单击获取并合并直接同步您的分叉及其父仓库。

您还可以在合并之前点击比较按钮来比较更改。

参考：GitHub 的 文档

Answer 22

自 2013 年 11 月以来，GitHub 提出了一个非官方功能请求，要求他们添加一个非常简单直观的方法来保持本地分支与上游同步：

https://github.com/isaacs/github/issues/121

注意：由于该功能请求是非官方的，因此建议联系 [email protected] 将您对此类功能的支持添加到予以实施。上述非官方功能请求可以用作对此实施的兴趣程度的证据。

Answer 23

截至本答案发布之日，GitHub 还没有（或者我应该说不再了吗？） Web 界面中的此功能。不过，您可以询问[电子邮件受保护] 对此添加您的投票。

与此同时，GitHub 用户 bardiharborow 创建了一个工具来执行此操作：
https://upriver.github.io/

来源在这里：https://github.com/upriver/upriver.github.io

Answer 24

如果您使用的是 Windows 或 Mac 版 GitHub，那么现在他们具有更新分支的一键功能：

1. 在 UI 中选择存储库。
2. 单击顶部的“从用户/分支更新”按钮。

Answer 25

$ git remote add upstream https://github.com/....

$ git pull upstream main

$ git push

Answer 26

实际上，可以从浏览器中上游的任何提交在分支中创建分支：

• 打开 https://github.com//commits/，其中，repo 是您的分叉，hash 是提交的完整哈希值，您可以在上游 Web 界面中找到它。例如，我可以打开 https://github.com/max630/linux/commits/0aa0313f9d576affd7747cc3f179feb097d28990，在撰写本文时指向 linux master。
• 单击“树：...”按钮。
• 输入新分支的名称，然后按 Enter

然后，您可以将该分支提取到本地克隆，并且当您在此基础上进行编辑 犯罪。或者使用 Web 界面更改该分支中的某些内容。

它是如何工作的（这是一个猜测，我不知道 GitHub 到底是如何做到的）：分叉共享对象存储并使用 命名空间来分隔用户的引用。因此，您可以通过分叉访问所有提交，即使它们在分叉时不存在。

Answer 27

请按照以下步骤操作。我尝试过它们，它对我有帮助。

到您的分行结帐

语法： gitbranch yourDevelopmentBranch
示例： git checkout master

拉取源存储库分支以获取最新代码

语法： git pull https://github.com/tastejs /awesome-app-ideas 大师
示例： git pull https://github.com/ORIGINAL_OWNER/ORIGINAL_REPO.git< /a> BRANCH_NAME

Answer 28

我用这一行更新我的分叉存储库：

git pull https://github.com/forkuser/forkedrepo.git branch

如果您不想向项目添加另一个远程端点，请使用此行，正如此处发布的其他解决方案一样。

Answer 29

作为对这个答案的补充，我一直在寻找一种从上游分支一次性更新我的克隆存储库（来源）的所有远程分支的方法。我就是这样做的。

这假设您已经配置了一个指向源存储库的上游远程（其中起源是从其分叉的），并将其与git fetch上游同步。

然后运行：

for branch in $(git ls-remote --heads upstream|sed 's#^.*refs/heads/##'); do git push origin refs/remotes/upstream/$branch:refs/heads/$branch; done

此命令的第一部分列出上游远程存储库中的所有头，并删除 SHA-1 后跟refs/heads/分支名称前缀。

然后，对于每个分支，它将上游远程跟踪分支（本地端的refs/remotes/upstream/）的本地副本直接推送到源上的远程分支（refs/heads/ 在远程端）。

这些分支同步命令中的任何一个都可能因以下两个原因之一而失败：上游分支已被重写，或者您已将该分支上的提交推送到您的分支。在第一种情况下，如果您没有向分支上的分支提交任何内容，则可以安全地强制推送（添加 -f 开关；即 git push -f上面的命令）。在另一种情况下，这是正常的，因为您的分叉分支已经分叉，并且在您的提交合并回上游之前，您不能指望同步命令起作用。上游。

Answer 30

“Pull”应用是一种自动设置并忘记的解决方案。它将把你的分支的默认分支与上游存储库同步。

访问该 URL，单击绿色的“安装”按钮，然后选择要启用自动同步的存储库。

该分支每小时直接在 GitHub 上更新一次，在本地计算机上，您需要拉取 master 分支以确保本地副本同步。