¿Cómo fuerzo "git pull" para sobrescribir los archivos locales?


7191

¿Cómo fuerzo una sobrescritura de archivos locales en un git pull?

El escenario es el siguiente:

  • Un miembro del equipo está modificando las plantillas para un sitio web en el que estamos trabajando
  • Están agregando algunas imágenes al directorio de imágenes (pero olvida agregarlas bajo control de fuente)
  • Me envían las imágenes por correo, más tarde, a mí.
  • Estoy agregando las imágenes bajo el control de fuente y empujándolas a GitHub junto con otros cambios
  • No pueden obtener actualizaciones de GitHub porque Git no quiere sobrescribir sus archivos.

Este es el error que recibo:

error: el archivo de árbol de trabajo no rastreado 'public / images / icon.gif' se sobrescribirá por fusión

¿Cómo fuerzo a Git a sobrescribirlos? La persona es un diseñador; por lo general, resuelvo todos los conflictos a mano, por lo que el servidor tiene la versión más reciente que solo necesitan actualizar en su computadora.


17
cualquiera que lea esto y piense que podría perder archivos, he estado en esta posición y descubrí que el búfer de Sublime Text me ha salvado; si estoy trabajando en algo, elimino accidentalmente todo al tratar de resolver un problema similar a este o al usar una respuesta a esta pregunta y he tenido los archivos abiertos en Sublime (de lo cual hay una buena posibilidad), entonces los archivos seguirán allí, es Sublime, ya sea allí o en el historial de deshacer
Toni Leigh

64
git reset --hard origin/branch_to_overwrite
Andrew Atkinson

1
Básicamente, solo haga una extracción de desarrollo después de la comprobación inicial -b. haz tu trabajo, luego vuelve a
entrar

1
Respuesta corta: eliminar y volver a crear una sucursal. 1. Eliminar rama: git branch <branch> -D2. Restablecer una confirmación antes del conflicto: git reset <commit> --hard3. Volver a crear la rama: git branch <branch>4. Establecer el seguimiento al servidor: git --set-upstream-to=origin/<branch> <branch> 5. Pull: git pull`
Nino Filiu

1
Para cambiar todas las terminaciones de CRLF a LF, (comience limpio)git config core.autocrlf false; git ls-files -z | xargs -0 rm; git checkout .
Chloe

Respuestas:


10044

Importante: si tiene cambios locales, se perderán. Con o sin --hardopción, se perderán todas las confirmaciones locales que no se hayan presionado. [*]

Si tienes archivos que son Git no rastrea (por ejemplo, contenido de usuario cargado), estos archivos no se verán afectados.


Creo que esta es la forma correcta:

git fetch --all

Entonces, tienes dos opciones:

git reset --hard origin/master

O si está en alguna otra rama:

git reset --hard origin/<branch_name>

Explicación:

git fetch descarga lo último desde el control remoto sin intentar fusionar o volver a crear nada.

Luego, git resetrestablece la rama maestra a lo que acaba de obtener. La --hardopción cambia todos los archivos en su árbol de trabajo para que coincidan con los archivos enorigin/master


Mantener compromisos locales actuales

[*] : Vale la pena señalar que es posible mantener las confirmaciones locales actuales creando una rama desde masterantes de reiniciar:

git checkout master
git branch new-branch-to-save-current-commits
git fetch --all
git reset --hard origin/master

Después de esto, todos los compromisos anteriores se mantendrán new-branch-to-save-current-commits.

Cambios no comprometidos

Sin embargo, los cambios no comprometidos (incluso por etapas) se perderán. Asegúrate de guardar y comprometer todo lo que necesites. Para eso puedes ejecutar lo siguiente:

git stash

Y luego para volver a aplicar estos cambios no comprometidos:

git stash pop

14
¡Cuidado! Si tiene confirmaciones locales no eliminadas, esto las eliminará de su sucursal. Esta solución mantiene intactos los archivos no rastreados en el repositorio, pero sobrescribe todo lo demás.
Matthijs P

479
Es una pregunta popular, por lo que me gustaría aclarar el comentario principal aquí. Acabo de ejecutar comandos como se describe en esta respuesta y no ha eliminado TODOS los archivos locales. Solo se sobrescribieron los archivos de seguimiento remoto, y todos los archivos locales que han estado aquí se dejaron intactos.
Rojo

14
en caso de que esté sacando de un repositorio que tiene un nombre de sucursal remoto diferente de "maestro", usegit reset --hard origin/branch-name
Nerrve

97
Dada la cantidad de votos a favor de esta pregunta y respuesta, creo que git debería incorporar un comando comogit pull -f
Sophivorus

77
Los commits que no fueron empujados antes de que se pueda recuperar el hard reset git reflog, que enumera todos los commits, también aquellos sin una base. Hasta que limpie su copia local usando git gc, entonces todo está perdido
Koen.

936

Prueba esto:

git reset --hard HEAD
git pull

Debería hacer lo que quieras.


16
He hecho esto y algunos archivos locales que ya no estaban en repositorio quedaron en el disco.
Piotr Owsiak

26
No creo que esto sea correcto. lo anterior realizará una fusión, no sobrescribirá lo que se solicitó en la pregunta: "¿Cómo forzar a git a sobrescribirlos?" No tengo la respuesta, actualmente la estoy buscando ... en este momento me cambio a la rama con el código que quiero mantener "git checkout BranchWithCodeToKeep", luego hago "git branch -D BranchToOverwrite" y finalmente "git checkout -b BranchToOverwrite". ahora tendrá el código exacto de BranchWithCodeToKeep en la rama BranchToOverwrite sin tener que realizar una fusión.
felbus

252
en lugar de fusionarse usando 'git pull', intente git fetch --todos seguidos de 'git reset --hard origin / master'
Lloyd Moore

55
Sí, la solución @lloydmoore funcionó para mí. Podría ser una respuesta en lugar de solo un comentario.
Max Williams

2
Esto restablecerá los cambios actuales a la última confirmación de rama extraída. Luego, git pull combina los cambios de la última rama. Esto hizo exactamente lo que quería que hiciera ... ¡Gracias!
Codeversed

459

ADVERTENCIA: git cleanelimina todos sus archivos / directorios sin seguimiento y no se puede deshacer.


A veces simplemente clean -fno ayuda. En caso de que haya rastreado DIRECTORIOS, también se necesita la opción -d:

# WARNING: this can't be undone!

git reset --hard HEAD
git clean -f -d
git pull

ADVERTENCIA: git cleanelimina todos sus archivos / directorios sin seguimiento y no se puede deshacer.

Considere usar la bandera -n( --dry-run) primero. Esto le mostrará lo que se eliminará sin eliminar nada:

git clean -n -f -d

Salida de ejemplo:

Would remove untracked-file-1.txt
Would remove untracked-file-2.txt
Would remove untracked/folder
...

33
Impresionante ... Corrí esto contra mi repositorio de archivos de puntos ... En mi directorio de inicio. Es bueno que realmente no tuviera nada importante allí ...
Lauri

77
Creo que la descripción del escenario deja en claro que realmente no quiere tirar el contenido. Más bien, lo que él quiere es detener a git baulking al sobrescribir los archivos. @Lauri, esto no debería haberte sucedido. Desafortunadamente, la gente parece haber leído mal la esencia de la descripción del escenario; vea mi sugerencia.
Erizo

19
POR FIN . git clean -f -d es útil cuando make clean no puede limpiar todo.
earthmeLon

77
@crizCraig a menos que se agreguen.gitignore
Bleeding Fingers

55
@earthmeLon, para eso quizás quieras git clean -dfx. El -xignora .gitignore. Por lo general, sus productos de compilación estarán en .gitignore.
Paul Draper

384

Al igual que Hedgehog, creo que las respuestas son terribles. Pero aunque la respuesta de Hedgehog podría ser mejor, no creo que sea tan elegante como podría ser. La forma en que encontré esto es mediante el uso de "buscar" y "fusionar" con una estrategia definida. Lo que debería hacer que sus cambios locales se conserven siempre que no sean uno de los archivos con los que está intentando forzar una sobrescritura.

Primero haz una confirmación de tus cambios

 git add *
 git commit -a -m "local file server commit message"

Luego busque los cambios y sobrescriba si hay un conflicto

 git fetch origin master
 git merge -s recursive -X theirs origin/master

"-X" es el nombre de una opción, y "suyo" es el valor de esa opción. Está eligiendo usar "sus" cambios, en lugar de "sus" cambios si hay un conflicto.


56
Esta es la mejor respuesta que he visto hasta ahora. No lo he intentado, pero a diferencia de otras respuestas, esto no intenta destruir todos tus archivos no rastreados, lo cual es muy peligroso por razones obvias.
huyz

55
Ditto: esto funcionó para mí cuando hice una fusión muy grande (solicitud de extracción de GitHub) donde solo quería aceptar todo por encima de lo que tenía. ¡Buena respuesta! En mi caso, los dos últimos comandos fueron: 1) get fetch other-repo; 2)git merge -s recursive -X theirs other-repo/master
quux00

2
Esto sobrescribirá cualquier conflicto con los archivos de repositorios y no con los locales, ¿correcto?
Nathan F.

2
La mejor respuesta. La respuesta más aceptada me dejó en mi caso con la cabeza despegada. Volví a la sucursal maestra local y corrígit merge -X theirs origin/master
Peter

2
El problema con esta respuesta (excelente) es que agrega todos los archivos locales, que a veces pueden no ser lo que desea. Es posible que solo desee agregar los archivos específicos que se omitieron. Pero lo mejor de todo es que hace que haga lo que debería haber hecho: agregarlos localmente. Probablemente no necesite la estrategia de -X suyo, ya que son la misma imagen. De hecho, sugeriría dejarlo al principio, solo para averiguar si hay alguna anomalía, y agregarla si la hay, después de revisar que 'la suya' siempre es la opción correcta. Pero entonces, soy paranoico.
Bob Kerns

279

En lugar de hacer:

git fetch --all
git reset --hard origin/master

Aconsejaría hacer lo siguiente:

git fetch origin master
git reset --hard origin/master

No es necesario recuperar todos los controles remotos y ramas si va a restablecer el origen / rama maestra, ¿verdad?


3
Su respuesta es justo lo que necesitaba para su representante. Debo preguntar, ¿esto también elimina todos los archivos no rastreados?
Nicolas De Jay

55
Sí, la mayor parte de mi representante proviene de aquí :) Esto también eliminará todos los archivos no rastreados. Algo que había olvidado y me recordó dolorosamente hace solo 2 días ...
Johanneke

1
Vea los comentarios sobre esta otra respuesta: stackoverflow.com/a/8888015/2151700
Johanneke

Esto no eliminó mis archivos sin seguimiento; que en realidad es lo que esperaría ¿Hay alguna razón para algunas personas y no para otras?
arichards

Los archivos no rastreados no se ven afectados por git reset. Si quieres que también se eliminen, hazlo git add .primero, antesgit reset --hard
Johanneke

131

Parece que la mejor manera es hacer primero:

git clean

Para eliminar todos los archivos no rastreados y luego continuar con lo habitual git pull...


44
Intenté usar "git clean" para resolver el mismo problema, pero no lo resolvió. El estado de git dice "Su rama y 'origen / maestro' han divergido, # y tienen 2 y 9 confirmaciones diferentes cada una, respectivamente". y git pull dice algo similar a lo que tienes arriba.
Slacy

43
git clean es un instrumento bastante contundente, y podría tirar muchas cosas que es posible que desee conservar. Es mejor eliminar o cambiar el nombre de los archivos de los que git se queja hasta que la extracción tenga éxito.
Neil Mayhew

2
No creo que esto funcione en general. ¿No hay una manera de hacer básicamente un control remoto de clon git a través de un tirón git forzado?
mathtick

10
@mathick:git fetch origin && git reset --hard origin/master
Arrowmaster

3
¿Es git cleanla mejor respuesta aquí? Parece que eliminar archivos no es necesariamente lo que quiere el OP. Pidieron 'una sobrescritura de archivos locales', no la eliminación.
JohnAllen

111

Advertencia, hacer esto eliminará permanentemente sus archivos si tiene alguna entrada de directorio / * en su archivo gitignore.

Algunas respuestas parecen ser terribles. Terrible en el sentido de lo que le sucedió a @Lauri siguiendo la sugerencia de David Avsajanishvili.

Más bien (git> v1.7.6):

git stash --include-untracked
git pull

Más tarde puede limpiar el historial de alijo.

Manualmente, uno por uno:

$ git stash list
stash@{0}: WIP on <branch>: ...
stash@{1}: WIP on <branch>: ...

$ git stash drop stash@{0}
$ git stash drop stash@{1}

Brutalmente, todo a la vez:

$ git stash clear

Por supuesto, si quieres volver a lo que escondiste:

$ git stash list
...
$ git stash apply stash@{5}

2
No, no lo creo. El almacenamiento oculto solo elimina los archivos no confirmados. Lo anterior también mueve (almacena) archivos que git no rastrea. Esto evita que los archivos que se han agregado al control remoto, que aún no se hayan desplegado en su máquina, pero que haya creado (!), Se eliminen. Todo sin destruir el trabajo no comprometido. Espero que tenga sentido?
Hedgehog

3
Si no tiene 1.7.6, puede imitarlo --include-untrackedsimplemente haciendo temporalmente git addsu repositorio completo y luego escondiéndolo de inmediato.
nategood

3
Estoy de acuerdo con Hedgehog. Si hace las respuestas populares aquí, es más que probable que descubra que, sin darse cuenta, mató muchas cosas que realmente no quería perder.
Guardius el

1
Tenía otros archivos sin seguimiento, además del que la combinación / extracción quería sobrescribir, por lo que esta solución funcionó mejor. git stash applyrecuperé todos mis archivos no rastreados con la excepción (correctamente) de los que la fusión ya había creado: "ya existe, no hay pago". Funcionó a la perfección.
BigBlueHat

2
Esta es la respuesta más clara, y debería ser la aceptada. Para ahorrar algo de tecleo puede usar la forma corta: git stash -u.
ccpizza

93

Puede encontrar este comando útil para descartar cambios locales:

git checkout <your-branch> -f

Y luego haga una limpieza (elimina los archivos no rastreados del árbol de trabajo):

git clean -f

Si desea eliminar directorios sin seguimiento además de archivos sin seguimiento:

git clean -fd

Creo que la descripción del escenario deja en claro que realmente no quiere tirar el contenido. Más bien, lo que él quiere es detener a git baulking al sobrescribir los archivos. Mira mi sugerencia.
Erizo

3
Aunque esa respuesta podría no coincidir exactamente con la descripción, todavía me salvó de la frustración de git twiddling con los retornos de carro (evento con autocrlf falso). Cuando git reset --hard HEAD no te deja con "no" archivos modificados, estas banderas "-f" son bastante útiles. Gracias un montón.
Kellindil

88

En lugar de fusionarse con git pull, intente esto:

git fetch --all

seguido por:

git reset --hard origin/master.


61

Lo único que funcionó para mí fue:

git reset --hard HEAD~5

Esto te llevará de vuelta cinco commits y luego con

git pull

Descubrí que al buscar cómo deshacer una fusión Git .


Esto fue lo que finalmente funcionó para mí, ya que tenía la fuerza me empujó la rama en el repositorio de origen y cuidado para conseguir conflictos de fusión cuando se trata de tirar de él a mi repo a distancia ..
jwfrench

Hola, en realidad este es un truco para un work aroundpero realmente efectivo. Debido a que algunos conflictos pueden ocurrir solo en pocas confirmaciones, revertir 5 confirmaciones asegurará que no haya conflictos con el código remoto.
Hoang Le

54

El problema con todas estas soluciones es que todas son demasiado complejas o, un problema aún mayor, es que eliminan todos los archivos no rastreados del servidor web, lo que no queremos, ya que siempre se necesitan archivos de configuración que estén activados. el servidor y no en el repositorio de Git.

Aquí está la solución más limpia que estamos usando:

# Fetch the newest code
git fetch

# Delete all files which are being added, so there
# are no conflicts with untracked files
for file in `git diff HEAD..origin/master --name-status | awk '/^A/ {print $2}'`
do
    rm -f -- "$file"
done

# Checkout all files which were locally modified
for file in `git diff --name-status | awk '/^[CDMRTUX]/ {print $2}'`
do
    git checkout -- "$file"
done

# Finally pull all the changes
# (you could merge as well e.g. 'merge origin/master')
git pull
  • El primer comando obtiene los datos más nuevos.

  • El segundo comando verifica si hay archivos que se están agregando al repositorio y elimina esos archivos no rastreados del repositorio local que podrían causar conflictos.

  • El tercer comando desprotege todos los archivos que se modificaron localmente.

  • Finalmente, hacemos un esfuerzo para actualizar a la versión más nueva, pero esta vez sin ningún conflicto, ya que los archivos no rastreados que están en el repositorio ya no existen y todos los archivos modificados localmente ya son los mismos que en el repositorio.


Usar "git merge origin / master" como la última línea (como dices en tu nota) en lugar de "git pull" será más rápido ya que ya has eliminado cualquier cambio del repositorio de git.
Josh

1
Sí, por supuesto, git merge origin/masterserá más rápido y probablemente incluso más seguro. Dado que si alguien empujó nuevos cambios durante la eliminación de archivos de este script (lo que no es probable que suceda, pero es posible), todo el tirón podría fallar. La única razón por la que puse pullallí es porque alguien podría no estar trabajando en la rama maestra, pero alguna otra rama y yo quería que el guión fuera universal.
Strahinja Kustudic

Si ha creado localmente archivos como archivos de opciones, colóquelos .gitignore.
Sebi

52

En primer lugar, pruebe la forma estándar:

git reset HEAD --hard # To remove all not committed changes!
git clean -fd         # To remove all untracked (non-git) files and folders!

Advertencia : ¡Los comandos anteriores pueden provocar la pérdida de datos / archivos solo si no los ha confirmado! Si no está seguro, haga la copia de seguridad primero de toda su carpeta de repositorio.

Luego jálalo de nuevo.

Si lo anterior no ayuda y no le importan sus archivos / directorios sin seguimiento (haga la copia de seguridad primero por si acaso), intente los siguientes pasos simples:

cd your_git_repo  # where 'your_git_repo' is your git repository folder
rm -rfv *         # WARNING: only run inside your git repository!
git pull          # pull the sources again

Esto eliminará todos los archivos git ( .git/directorio exempt , donde tiene todos los commits) y lo extraerá nuevamente.


¿Por qué git reset HEAD --hardpodría fallar en algunos casos?

  1. Reglas personalizadas en .gitattributes file

    Teniendo eol=lf regla en .gitattributes podría hacer que git modifique algunos cambios de archivo al convertir las terminaciones de línea CRLF en LF en algunos archivos de texto.

    Si ese es el caso, debe confirmar estos cambios CRLF / LF (revisándolos git status) o intentar: git config core.autcrlf falseignorarlos temporalmente.

  2. Incompatibilidad del sistema de archivos

    Cuando usa un sistema de archivos que no admite atributos de permiso. Por ejemplo, tiene dos repositorios, uno en Linux / Mac ( ext3/ hfs+) y otro en el sistema de archivos basado en FAT32 / NTFS.

    Como notará, hay dos tipos diferentes de sistemas de archivos, por lo que el que no admite permisos de Unix básicamente no puede restablecer los permisos de archivos en el sistema que no admite ese tipo de permisos, así que no importa cómo --hardlo intente, git detectar siempre algunos "cambios".


47

Yo tuve el mismo problema. Nadie me dio esta solución, pero funcionó para mí.

Lo resolví por:

  1. Eliminar todos los archivos. Deja solo el .gitdirectorio.
  2. git reset --hard HEAD
  3. git pull
  4. git push

Ahora funciona.


1
Igual que aquí. A veces sólo funciona la solución muy duros, sucede a menudo que sólo restablecer y limpia no son suficientes alguna manera ...
jdehaan

41

Prima:

Al hablar de pull / fetch / merge en las respuestas anteriores, me gustaría compartir un truco interesante y productivo,

git pull --rebase

Este comando anterior es el comando más útil en mi vida Git que ahorró mucho tiempo.

Antes de enviar su nueva confirmación al servidor, pruebe este comando y sincronizará automáticamente los últimos cambios del servidor (con una búsqueda + combinación) y colocará su confirmación en la parte superior del registro de Git. No hay necesidad de preocuparse por la extracción / fusión manual.

Encuentre detalles en ¿Qué hace "git pull --rebase"? .


3
En pocas palabras: git pull -r.
kenorb

29

Tuve un problema similar. Tuve que hacer esto:

git reset --hard HEAD
git clean -f
git pull

66
usar git cleancon precaución
nategood

29

Resumí otras respuestas. Puede ejecutar git pullsin errores:

git fetch --all
git reset --hard origin/master
git reset --hard HEAD
git clean -f -d
git pull

Advertencia : este script es muy poderoso, por lo que podría perder sus cambios.


2
Esto sobrescribirá los archivos modificados (archivos que se registraron previamente) y eliminará los archivos no rastreados (archivos que nunca se registraron). Exactamente lo que estaba buscando, gracias!
styfle

3
Sospecho que la tercera línea git reset --hard HEADpuede ser redundante; mi página de manual local (2.6.3) dice que reseten la segunda línea git reset --hard origin/master "el valor predeterminado es HEAD en todas sus formas".
arichards

2
@arichards Creo que su sospechoso tiene razón, pero si la segunda línea no funciona (por cualquier motivo), la tercera línea funcionará bien para restablecer. Esta solución no necesita ser optimizada. Acabo de resumir otras respuestas. Eso es todo. Gracias por tu comentario. :)
Robert Moon

28

Basado en mis propias experiencias similares, la solución ofrecida por Strahinja Kustudic es la mejor con diferencia. Como otros han señalado, simplemente haciendo un restablecimiento completo eliminará todo los archivos no rastreados que podrían incluir muchas cosas que no desea eliminar, como los archivos de configuración. Lo que es más seguro es eliminar solo los archivos que están a punto de agregarse, y para el caso, es probable que también desee verificar cualquier archivo modificado localmente que esté a punto de actualizarse.

Eso en mente, actualicé el guión de Kustudic para hacer precisamente eso. También arreglé un error tipográfico (falta un 'en el original).

#/bin/sh

# Fetch the newest code
git fetch

# Delete all files which are being added,
# so there are no conflicts with untracked files
for file in `git diff HEAD..origin/master --name-status | awk '/^A/ {print $2}'`
do
    echo "Deleting untracked file $file..."
    rm -vf "$file"
done

# Checkout all files which have been locally modified
for file in `git diff HEAD..origin/master --name-status | awk '/^M/ {print $2}'`
do
    echo "Checking out modified file $file..."
    git checkout $file
done

# Finally merge all the changes (you could use merge here as well)
git pull

Usar "git merge origin / master" como la última línea (como dices en tu nota) en lugar de "git pull" será más rápido ya que ya has eliminado cualquier cambio del repositorio de git.
Josh

Se necesita el pago de los archivos modificados, por lo que funciona el 100% de las veces. Actualicé mi script con eso hace mucho tiempo, pero también olvidé actualizarlo aquí. También lo uso un poco diferente a ti. Compruebo los archivos que tienen cualquier tipo de modificación, no solo M, por lo que funciona todo el tiempo.
Strahinja Kustudic

24

Creo que hay dos posibles causas de conflicto, que deben resolverse por separado, y por lo que puedo decir, ninguna de las respuestas anteriores trata con ambas:

  • Los archivos locales sin seguimiento deben eliminarse, ya sea manualmente (más seguro) o como se sugiere en otras respuestas, por git clean -f -d

  • Las confirmaciones locales que no están en la rama remota también deben eliminarse. OMI, la forma más fácil de lograr esto es con: git reset --hard origin/master(reemplace 'maestro' por cualquier rama en la que esté trabajando y ejecute una git fetch originprimera)


22

Una forma más fácil sería:

git checkout --theirs /path/to/file.extension
git pull origin master

Esto anulará su archivo local con el archivo en git


21

Parece que la mayoría de las respuestas aquí se centran en la masterrama; Sin embargo, hay momentos en los que estoy trabajando en la misma rama de características en dos lugares diferentes y quiero que un rebase en uno se refleje en el otro sin tener que saltar muchos aros.

Sobre la base de una combinación de la respuesta de ARN y la respuesta de torek a una pregunta similar , se me ha ocurrido con este que funciona espléndidamente:

git fetch
git reset --hard @{u}

Ejecute esto desde una rama y solo restablecerá su rama local a la versión anterior.

Esto también se puede poner muy bien en un git alias ( git forcepull):

git config alias.forcepull "!git fetch ; git reset --hard @{u}"

O, en su .gitconfigarchivo:

[alias]
  forcepull = "!git fetch ; git reset --hard @{u}"

¡Disfrutar!


¡Esta respuesta también es buena porque funciona independientemente de en qué rama te encuentres!
harina de hoja el

19

Tuve el mismo problema y, por alguna razón, incluso un git clean -f -dno lo haría. Aquí está la razón: por alguna razón, si Git ignora su archivo (a través de una entrada .gitignore, supongo), todavía se molesta en sobrescribir esto con una extracción posterior , pero una limpieza no lo eliminará, a menos que agregue -x.


19

Sé de un método mucho más fácil y menos doloroso:

$ git branch -m [branch_to_force_pull] tmp
$ git fetch
$ git checkout [branch_to_force_pull]
$ git branch -D tmp

¡Eso es!


18

Acabo de resolver esto yo mismo:

git checkout -b tmp # "tmp" or pick a better name for your local changes branch
git add -A
git commit -m 'tmp'
git pull
git checkout master # Or whatever branch you were on originally
git pull
git diff tmp

donde el último comando da una lista de cuáles fueron sus cambios locales. Siga modificando la rama "tmp" hasta que sea aceptable y luego vuelva a fusionarse con el maestro con:

git checkout master && git merge tmp

Para la próxima vez, probablemente pueda manejar esto de una manera más limpia al buscar "git stash branch", aunque es probable que stash le cause problemas en los primeros intentos, así que primero experimente en un proyecto no crítico ...


17

Tengo una situación que ni extraña git cleano git resettrabajos. Tengo que eliminar el archivo en conflicto git indexmediante el siguiente script en cada archivo sin seguimiento:

git rm [file]

Entonces puedo tirar bien.


16

git fetch --all && git reset --hard origin/master && git pull


14

A pesar de la pregunta original, las respuestas principales pueden causar problemas a las personas que tienen un problema similar, pero que no quieren perder sus archivos locales. Por ejemplo, vea los comentarios de Al-Punk y crizCraig.

La siguiente versión confirma los cambios locales en una rama temporal ( tmp), comprueba la rama original (que supongo que es master) y combina las actualizaciones. Puede hacer esto con stash, pero he descubierto que generalmente es más fácil simplemente usar el enfoque de bifurcación / fusión.

git checkout -b tmp
git add *; git commit -am "my temporary files"
git checkout master

git fetch origin master
git merge -s recursive -X theirs origin master

donde suponemos que el otro depósito es origin master.


13

Estos cuatro comandos me funcionan.

git reset --hard HEAD
git checkout origin/master
git branch -D master
git checkout -b master

Para verificar / extraer después de ejecutar estos comandos

git pull origin master

Intenté mucho pero finalmente obtuve éxito con estos comandos.


2
"git branch -D master" borra la rama. así que ten cuidado con eso. Prefiero usar "git checkout origin / master -b <new branch name>", que crea una nueva rama con un nuevo nombre y necesita 3,4 líneas. También se recomienda usar "git clean -f" también.
Chand Priyankara

13

Solo haz

git fetch origin branchname
git checkout -f origin/branchname // This will overwrite ONLY new included files
git checkout branchname
git merge origin/branchname

Por lo tanto, evita todos los efectos secundarios no deseados, como eliminar archivos o directorios que desea conservar, etc.


12

Restablezca el índice y la cabeza origin/master, pero no restablezca el árbol de trabajo:

git reset origin/master

Personalmente, esto me pareció muy útil. Luego mantiene su árbol de trabajo para que pueda volver a registrarlo. Para mi problema, eliminé los mismos archivos que se agregaban, por lo que estaba atascado. Extraño, lo sé.
Jason Sebring

12

Requisitos:

  1. Rastree los cambios locales para que nadie aquí los pierda.
  2. Haga que el repositorio local coincida con el repositorio de origen remoto.

Solución:

  1. Guarda los cambios locales.
  2. Obtenga una limpieza de archivos y directorios ignorando .gitignore y restablecimiento completo al origen .

    git stash --include-untracked
    git fetch --all
    git clean -fdx
    git reset --hard origin/master
    
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.