¿Cómo adelantar una rama hacia la cabeza?

Cambié a maestro después de desarrollar en una rama durante mucho tiempo. El registro muestra:

Su sucursal está detrás de 'origin / master' por 167 commits, y puede reenviarse rápidamente.

Lo intenté:

git checkout HEAD

No tiene efecto. Esto se debe a que he finalizado un commit intermedio en master.

¿Cómo hacer que el maestro se quede en la cabeza?

Haciendo:

git checkout master
git pull origin

buscará y fusionará la origin/masterrama (puede decir git pullque el origen es el predeterminado).

Tratar git merge origin/master. Si quiere estar seguro de que solo hace un avance rápido, puede decir git merge --ff-only origin/master.

En su situación, git rebasetambién haría el truco. Como no tiene cambios que el maestro no tenga, git solo avanzará rápidamente. Si está trabajando con un flujo de trabajo de rebase, eso podría ser más recomendable, ya que no terminaría con una confirmación de fusión si se equivoca.

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

Debería hacer el trabajo.

Recibirá el mensaje "Su rama está detrás" cada vez que trabaje en una rama diferente a la maestra , alguien hace cambios a la maestra y usted obtiene git pull.

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

ahora se extrae la referencia de origen / maestro, pero su maestro no se fusiona con él

(branch) $ git checkout master
(master) $ 

ahora el maestro está detrás del origen / maestro y puede reenviarse rápidamente

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

ahora tu maestro y origen / maestro están sincronizados

Si está parado en una rama diferente y desea verificar la versión más nueva de master, también puede hacerlo

git checkout -B master origin/master

Para cualquiera que quiera avanzar rápidamente no está en otra rama remota (incluida ella misma) sin verificar esa rama, puede hacer lo siguiente:

git fetch origin master:other

Esto básicamente adelanta rápidamente el índice de othera origin/mastersi no está en la otherrama. Puede avanzar rápidamente varias ramas de esta manera.

Si trabaja en otra rama durante algún tiempo y desea actualizar las ramas obsoletas desde el control remoto a sus respectivos cabezales:

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

No se requieren complejidades, solo párate en tu sucursal y haz un git pull trabajo, funcionó para mí

O, como segundo intento, git pull origin master solo en caso de que no tengas suerte con el primer comando

Para cambiar la base de la rama del rastreador local actual que mueve los cambios locales sobre el último estado remoto:

$ git fetch && git rebase

De manera más general, para avanzar rápidamente y soltar los cambios locales ( restablecimiento completo ) *:

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

para avanzar rápidamente y mantener los cambios locales ( rebase ):

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

* - para deshacer el cambio causado por el reinicio forzado involuntario primero git reflog, que muestra el estado de la CABEZA en orden inverso, busque el hash al que apuntaba la CABEZA antes de la operación de reinicio (generalmente obvio) y reinicie la rama a ese hash.

En su caso, para avanzar rápidamente, ejecute:

$ git merge --ff-only origin/master

Esto utiliza la --ff-onlyopción de git merge, ya que la pregunta específicamente pide "avance rápido".

Aquí hay un extracto de git-merge(1)que muestra más opciones de avance 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.

Avanzo lo suficiente como para garantizar un alias:

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

Ahora puedo ejecutar esto para avanzar rápidamente:

$ git ff

Mueva el puntero de su rama a la CABEZA:

git branch -f master

Su rama masterya existe, por lo que git no le permitirá sobrescribirla, a menos que use ... -f(este argumento significa --force)

O puede usar rebase:

git rebase HEAD master

Hazlo bajo tu propio riesgo;)