начиная с мая 2014 года, можно обновить вилку непосредственно из GitHub. Это все еще работает по состоянию на сентябрь 2017 года,но это приведет к грязной историей коммитов.

1. откройте вилку на GitHub.
2. нажать на кнопку Запросы.
3. нажать на кнопку Новый Pull-Запрос. По умолчанию GitHub будет сравнивать оригинал с вашей вилкой, и сравнивать нечего, если вы ничего не сделали изменения.
4. клик переключение базы если вы видите эту ссылку. В противном случае вручную установите базовая вилка упадите вниз к вашей вилке, и глава вилка в апстрим. Теперь GitHub будет сравнивать вилку с оригиналом, и вы увидите все последние изменения.
5. создать pull-запрос и назначьте предсказуемое имя вашему запросу pull (например,Update from original).
6. свиток до слияние тянуть запрос, но пока ничего не нажимайте.

теперь у вас есть три варианта, но каждый приведет к менее-чем-очистить историю коммитов.

1. по умолчанию будет создана некрасивая фиксация слияния.
2. если вы нажмете раскрывающийся список и выберите "сквош и слияние", все промежуточные коммиты будут раздавлены в один. Чаще всего это то, чего вы не хотите.
3. если вы выберите Rebase и объединить все коммиты будут сделаны "с" вами, оригинальный PRs будет ссылаться на ваш PR, и GitHub отобразит This branch is X commits ahead, Y commits behind <original fork>.

Так что да, вы можете сохранить свое РЕПО обновленным с его восходящим использованием веб-интерфейса GitHub, но это запятнает вашу историю фиксации. Палкой командная строка вместо этого-это просто.

вот официальный документ GitHub на синхронизация вилки:

синхронизация вилки

Настройки

прежде чем вы сможете синхронизировать, вам нужно добавить пульт, который указывает на вышестоящий репозиторий. Возможно, вы сделали это, когда первоначально раздвоились.

Совет: синхронизация вилки обновляет только локальную копию репозитория; она не обновляет репозиторий на GitHub.

$ git remote -v
# List the current remotes
origin  https://github.com/user/repo.git (fetch)
origin  https://github.com/user/repo.git (push)

$ git remote add upstream https://github.com/otheruser/repo.git
# Set a new remote

$ git remote -v
# Verify new remote
origin    https://github.com/user/repo.git (fetch)
origin    https://github.com/user/repo.git (push)
upstream  https://github.com/otheruser/repo.git (fetch)
upstream  https://github.com/otheruser/repo.git (push)

синхронизация

есть два шага, необходимые для синхронизации репозитория с восходящим: сначала вы должны извлечь из удаленного, затем вы должны объединить нужную ветвь в локальную ветвь.

Fetching

извлечение из удаленного репозитория приведет к его филиалам и их соответствующим коммитам. Они хранятся в вашем локальном репозитории в специальных ветвях.

$ git fetch upstream
# Grab the upstream remote's branches
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/otheruser/repo
 * [new branch]      master     -> upstream/master

теперь у нас есть главная ветвь вверх по течению хранится в локальной ветви, вверх по течению / master

$ git branch -va
# List all local and remote-tracking branches
* master                  a422352 My local commit
  remotes/origin/HEAD     -> origin/master
  remotes/origin/master   a422352 My local commit
  remotes/upstream/master 5fdff0f Some upstream commit

слияние

теперь, когда мы получили вышестоящий репозиторий, мы хотим объединить его изменения в нашей локальной ветви. Это приведет к синхронизации этой ветви с восходящим потоком, не теряя наших локальных изменений.

$ git checkout master
# Check out our local master branch
Switched to branch 'master'

$ git merge upstream/master
# Merge upstream's master into our own
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/master
Updating 34e91da..16c56ad
Fast-forward
 README.md                 |    5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

Совет: Если вы хотите обновить свой репозиторий на GitHub, следуйте инструкциям здесь

много ответов в конечном итоге перемещение вилки один коммит впереди родительского репозитория. Этот ответ суммирует найденные шаги здесь что будет переместите вилку на ту же фиксацию, что и родительский.

1. измените каталог на локальный репозиторий.

   • переключитесь на главную ветку, если вы не git checkout master

2. добавить родителя в качестве удаленного репозитория, git remote add upstream <repo-location>

3. вопрос git fetch upstream

4. вопрос git rebase upstream/master

   • на этом этапе вы проверяете, что фиксирует то, что будет объединено, набрав git status

5. вопрос git push origin master

дополнительные сведения об этих командах см. В разделе Шаг 3.

С ноября 2013 года был неофициальный запрос функции открыт с GitHub, чтобы попросить их добавить очень простой и интуитивно понятный метод, чтобы сохранить локальную вилку в синхронизации с восходящим:

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

Примечание: поскольку запрос функции является неофициальным, также рекомендуется связаться с support@github.com чтобы добавить поддержку такой функции, которая будет реализована. Неофициальный запрос может быть использован в качестве доказательства из суммы процентов на это реализуются.

предисловие: вилка-это "происхождение" и репозитории вы раскошелились на "вверх".

предположим, что вы клонировали уже свою вилку на свой компьютер с помощью такой команды:

git clone git@github.com:your_name/project_name.git
cd project_name

если это дано, то вам нужно продолжить в этом порядке:

1. добавьте "upstream" в свой клонированный репозиторий ("origin"):

   git remote add upstream git@github.com:original_author/project_name.git
   

2. выборка коммитов (и ветви) от "вверх по течению":

   git fetch upstream
   

3. переключитесь на ветку "master" вашей вилки ("origin"):

   git checkout master
   

4. Stash изменения вашей ветви "master":

   git stash
   

5. слияние изменений из ветки "мастер" "вверх" на ваш "мастер" филиал "происхождения":

   git merge upstream/master
   

6. разрешить конфликты слияния, если таковые имеются, и зафиксировать слияние

   git commit -am "Merged from upstream"
   

7. нажмите изменения на вилку

   git push
   

8. верните свои спрятанные изменения (если они есть)

   git stash pop
   

9. ты молодец! Поздравляю!

GitHub также предоставляет инструкции по этой теме: синхронизация вилки

Если, как я, вы никогда ничего не поручайте непосредственно мастеру, который вы действительно должны, вы можете сделать следующее.

из местного клона вилку, создать свой апстрим пульт. Вам нужно сделать это только один раз:

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

затем, когда вы хотите догнать главную ветвь восходящего репозитория, вам нужно:

git checkout master
git pull upstream master

предполагая, что вы никогда ничего не совершали на мастере себя, вы должны быть уже сделаны. Теперь вы можете нажать ваш местный мастер к вашей исходной удаленной вилке GitHub. Вы также можете переназначить свою ветку разработки на своем обновленном локальном мастере.

таким образом, после начальной установки вверх по течению и master checkout, все, что вам нужно сделать, это запустить следующую команду для синхронизации вашего мастера с upstream:git тянуть вверх по течению master.

на дату этого ответа GitHub не имеет (или мне больше не говорить?) эта функция в веб-интерфейсе. Вы можете, однако, спросить support@github.com чтобы добавить свой голос за это.

тем временем, пользователь Github bardiharborow создал инструмент для этого: https://upriver.github.io/

источник здесь:https://github.com/upriver/upriver.github.io

Если вы используете GitHub для Windows, то теперь у них есть функция одного клика для обновления вилок:

1. выберите репозиторий в пользовательском интерфейсе.
2. Нажмите кнопку" Обновить от пользователя/филиала " вверху.

выполните следующие действия. Я попробовал, и мне это помогло.

выезд в ваш филиал

синтаксис: git филиал yourDevelopmentBranch
пример: git checkout master

Pull source repository branch для получения последнего кода

синтаксис: git pull https://github.com/tastejs/awesome-app-ideas мастер!--10-->пример: git pull https://github.com/ORIGINAL_OWNER/ORIGINAL_REPO.git BRANCH_NAME

на самом деле, можно создать ветку в вашей вилке из любой фиксации восходящего потока в браузере:

• открыть https://github.com/<repo>/commits/<hash>, где РЕПО ваша вилка, а хэш полный хэш коммита, который вы можете найти в веб-интерфейсе вверх. Например, я могу открыть https://github.com/max630/linux/commits/0aa0313f9d576affd7747cc3f179feb097d28990, что указывает на linux master как время написания.
• нажмите на дерево. :..." кнопка.
• введите название новой ветви и нажмите Enter

затем вы можете получить эту ветвь в свой локальный клон, и вам не придется возвращать все эти данные обратно в GitHub, когда вы нажимаете изменения поверх этой фиксации. Или использовать веб-интерфейс, чтобы изменить что-то в этой ветке.

как это работает (это догадка, я не знаю, как именно GitHub это делает): forks share object хранение и использование пространства имен для разделения ссылок пользователей. Таким образом, вы можете получить доступ ко всем коммитам через свою вилку, даже если они не существовали к моменту разветвления.

Я обновляю свои раздвоенные репозитории с помощью этой строки:

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

используйте это, если вы не хотите добавлять другую удаленную конечную точку в свой проект, как и другие решения, размещенные здесь.

в дополнение к этому ответу я искал способ обновить все удаленные ветви моего клонированного РЕПО (происхождения) от вверх по течению ветки на одном дыхании. Вот как я это сделал.

это предполагает, что вы уже настроили вверх по течению удаленное указание на исходный репозиторий (где происхождения был раздвоен) и синхронизировали его с git fetch upstream.

запустите:

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/<branch> на локальной стороне) непосредственно в удаленную ветку на происхождения (refs/heads/<branch> на удаленной стороне).

любая из этих команд синхронизации ветвей может завершиться неудачей по одной из двух причин: либо вверх по течению ветку были переписаны, или вы нажали коммиты на этой ветке на свою вилку. В первом случае, когда вы ничего не сделали с веткой на вашей вилке, безопасно нажимать насильно (добавьте - f переключатель; т. е. git push -f в команды выше). В другом случае это нормально, так как ваша ветвь вилки разошлась, и вы не можете ожидать, что команда синхронизации будет работать, пока ваши коммиты не будут объединены обратно в вверх по течению.

Android Studio теперь научилась работать с репозиториями GitHub fork (вам даже не нужно добавлять удаленный репозиторий "вверх по течению" консольной командой).

открыть меню VCS → Git

и обратите внимание на два последних пункта всплывающего меню:

• Перебазируйте мою вилку GitHub

• Создать Pull-Запрос

попробовать их. Я использую первый для синхронизации моего локального репозитория. В любом случае ветви из родительского удаленного репозитория ("upstream") будут доступны в Android Studio после нажатия кнопки "Rebase my GitHub fork", и вы сможете легко работать с ними.

(Я использую Android Studio 3.0 с плагинами" git integration "и" GitHub".)

когда вы клонировали свой раздвоенный репозиторий, перейдите в путь к каталогу, где находится ваш клон, и несколько строк в терминале 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

и вы хорошо идти. Все обновленные изменения в главном репозитории будут помещены в ваш репозиторий fork.

команда" fetch "необходима для того, чтобы оставаться в курсе проекта: только при выполнении "git fetch" вы будете проинформированы об изменениях, которые ваши коллеги подтолкнули к удаленному сервер.

вы все еще можете посетить здесь для дальнейших запросов

Это зависит от размера вашего репозитория и того, как вы его раздвоили.

Если это довольно большой репозиторий, вы, возможно, хотели бы управлять им особым образом (например, история падения). В основном вы можете получить различия между текущей и восходящей версиями, зафиксировать их, а затем cherry pick обратно в master.

попробуйте прочитать этот. В нем описывается, как обрабатывать большие репозитории Git и как использовать их с последними изменениями.