Comment faire avancer rapidement une branche à la tête?

Je suis passé au master après avoir longtemps évolué sur une branche. Le journal montre:

Votre branche est derrière 'origin / master' par 167 commits, et peut être avancée rapidement.

J'ai essayé:

git checkout HEAD

Cela n'a aucun effet. C'est parce que j'ai extrait un commit intermédiaire sur le maître.

Comment faire en sorte que le maître reste sur la tête?

Faire:

git checkout master
git pull origin

va récupérer et fusionner la origin/masterbranche (vous pouvez simplement dire git pullque l'origine est la valeur par défaut).

Essayez git merge origin/master. Si vous voulez être sûr qu'il ne fait qu'une avance rapide, vous pouvez le dire git merge --ff-only origin/master.

Dans votre situation, git rebaseferait également l'affaire. Puisque vous n'avez aucun changement que master n'a pas, git avancera simplement rapidement. Si vous travaillez avec un flux de travail de rebase, cela pourrait être plus recommandé, car vous ne vous retrouveriez pas avec un commit de fusion si vous vous trompez.

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

devrait faire le travail.

Vous obtiendrez le message "Votre branche est en retard" à chaque fois que vous travaillez sur une branche différente de master , que quelqu'un change de master et que vous git pull.

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

maintenant la référence origine / master est extraite, mais votre master n'est pas fusionné avec elle

(branch) $ git checkout master
(master) $ 

maintenant le master est derrière l'origine / master et peut être avancé rapidement

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

maintenant votre master et origine / master sont synchronisés

Si vous êtes sur une branche différente et que vous souhaitez vérifier la dernière version de master, vous pouvez également le faire

git checkout -B master origin/master

Pour tous ceux qui veulent avancer rapidement, ils ne sont pas sur une autre branche distante (y compris elle-même) sans vérifier cette branche, vous pouvez faire:

git fetch origin master:other

Cela avance rapidement l'index de otherà origin/mastersi vous n'êtes pas sur une otherbranche. Vous pouvez avancer rapidement plusieurs branches de cette façon.

Si vous travaillez sur une autre branche pendant un certain temps et que vous souhaitez mettre à jour les branches périmées de la télécommande vers leur tête respective:

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

Aucune complexité requise suffit de rester dans votre succursale et de faire un git pull, cela a fonctionné pour moi

Ou, en tant que deuxième essai, essayez git pull origin master uniquement si vous n'avez pas de chance avec la première commande

Pour rebaser la branche actuelle du tracker local en déplaçant les modifications locales au-dessus du dernier état distant:

$ git fetch && git rebase

Plus généralement, pour avancer rapidement et supprimer les modifications locales ( réinitialisation matérielle ) *:

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

pour avancer rapidement et conserver les modifications locales ( rebase ):

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

* - pour annuler le changement provoqué par une réinitialisation matérielle involontaire, commencez git reflogpar afficher l'état du HEAD dans l'ordre inverse, recherchez le hachage vers lequel le HEAD pointait avant l'opération de réinitialisation (généralement évident) et réinitialisez la branche sur ce hachage.

Dans votre cas, pour avancer rapidement, exécutez:

$ git merge --ff-only origin/master

Cela utilise l' --ff-onlyoption de git merge, car la question demande spécifiquement une "avance rapide".

Voici un extrait git-merge(1)qui montre plus d'options d'avance rapide:

--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.

J'avance assez souvent pour justifier un alias:

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

Maintenant, je peux exécuter ceci pour avancer rapidement:

$ git ff

Déplacez le pointeur de votre branche sur la TETE:

git branch -f master

Votre branche masterexiste déjà, donc git ne vous permettra pas de l'écraser, sauf si vous utilisez ... -f(cet argument signifie --force)

Ou vous pouvez utiliser rebase:

git rebase HEAD master

Faites-le à vos risques et périls;)