Como avançar rapidamente um ramo na cabeça?

Eu mudei para mestre depois de desenvolver um ramo por um longo tempo. O log mostra:

Sua ramificação está atrás de 'origem / mestre' por 167 confirmações e pode ser encaminhada rapidamente.

Eu tentei:

git checkout HEAD

Não tem efeito. Isso ocorre porque eu tenho uma verificação intermediária no master.

Como fazer o mestre ficar na cabeça?

Fazendo:

git checkout master
git pull origin

irá buscar e mesclar o origin/masterramo (você pode apenas dizer git pullque a origem é o padrão).

Tente git merge origin/master. Se você quiser ter certeza de que ele faz apenas um avanço rápido, você pode dizer git merge --ff-only origin/master.

Na sua situação, git rebasetambém faria o truque. Como você não possui alterações que o mestre não possui, o git avança rapidamente. Se você estiver trabalhando com um fluxo de trabalho de rebase, isso pode ser mais aconselhável, pois você não terminaria com uma consolidação de mesclagem se errar.

username@workstation:~/work$ git status
# On branch master
# Your branch is behind 'origin/master' by 1 commit, and can be fast-forwarded.
#   (use "git pull" to update your local branch)
#
nothing to commit, working directory clean
username@workstation:~/work$ git rebase
First, rewinding head to replay your work on top of it...
Fast-forwarded master to refs/remotes/origin/master.
# On branch master
nothing to commit, working directory clean

git checkout master
git pull

deve fazer o trabalho.

Você receberá a mensagem "Seu ramo está atrasado" toda vez que você trabalha em um ramo diferente do mestre , alguém muda para mestre e você git pull.

(branch) $ //hack hack hack, while someone push the changes to origin/master
(branch) $ git pull   

agora a referência de origem / mestre é puxada, mas seu mestre não é mesclado a ela

(branch) $ git checkout master
(master) $ 

agora o mestre está por trás da origem / mestre e pode ser encaminhado rapidamente

this will pull and merge (so merge also newer commits to origin/master)
(master) $ git pull 

this will just merge what you have already pulled
(master) $ git merge origin/master

agora seu mestre e origem / mestre estão sincronizados

Se você estiver em um ramo diferente e quiser fazer check-out da versão mais recente do master, também poderá fazer

git checkout -B master origin/master

Para quem deseja avançar rapidamente, eles não estão em outra ramificação remota (incluindo ela mesma) sem verificar essa ramificação, você pode:

git fetch origin master:other

Isso basicamente encaminha o índice de otherpara origin/masterse você não estiver no otherramo. Você pode avançar várias ramificações dessa maneira.

Se você trabalha em outro ramo por algum tempo e deseja atualizar ramos obsoletos do remoto para o respectivo cabeçalho:

git fetch origin master:master other:other etc:etc

Sem complexidades necessárias, basta ficar no seu ramo e fazer um git pull funcionou para mim

Ou, como uma segunda tentativa, tente o git pull origin master apenas no caso de você ter azar com o primeiro comando

Para refazer a ramificação do rastreador local atual, movendo as alterações locais sobre o estado remoto mais recente:

$ git fetch && git rebase

De maneira mais geral, para avançar e descartar as alterações locais ( reinicialização completa ) *:

$ git fetch && git checkout ${the_branch_name} && git reset --hard origin/${the_branch_name}

para avançar e manter as alterações locais ( rebase ):

$ git fetch && git checkout ${the_branch_name} && git rebase origin/${the_branch_name}

* - para desfazer a alteração causada pela reinicialização involuntária não intencional git reflog, que exibe o estado do HEAD em ordem inversa, encontre o hash que o HEAD estava apontando antes da operação de redefinição (geralmente óbvia) e redefina a ramificação para esse hash.

No seu caso, para avançar rapidamente, execute:

$ git merge --ff-only origin/master

Isso usa a --ff-onlyopção degit merge , como a pergunta solicita especificamente "avanço rápido".

Aqui está um trecho git-merge(1)que mostra mais opções de avanço rápido:

--ff, --no-ff, --ff-only
    Specifies how a merge is handled when the merged-in history is already a descendant of the current history.  --ff is the default unless merging an annotated
    (and possibly signed) tag that is not stored in its natural place in the refs/tags/ hierarchy, in which case --no-ff is assumed.

    With --ff, when possible resolve the merge as a fast-forward (only update the branch pointer to match the merged branch; do not create a merge commit). When
    not possible (when the merged-in history is not a descendant of the current history), create a merge commit.

    With --no-ff, create a merge commit in all cases, even when the merge could instead be resolved as a fast-forward.

    With --ff-only, resolve the merge as a fast-forward when possible. When not possible, refuse to merge and exit with a non-zero status.

Avanço com freqüência o suficiente para justificar um alias:

$ git config --global alias.ff 'merge --ff-only @{upstream}'

Agora eu posso executar isso para avançar:

$ git ff

Mova o ponteiro do seu ramo para HEAD:

git branch -f master

Seu ramo masterjá existe, portanto o git não permitirá que você o substitua, a menos que você use ... -f(este argumento significa--force )

Ou você pode usar rebase:

git rebase HEAD master

Faça por sua conta e risco;)