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

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

Prueba esto:

git reset --hard HEAD
git pull

Debería hacer lo que quieras.

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

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.

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?

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

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}

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

En lugar de fusionarse con git pull, intente esto:

git fetch --all

seguido por:

git reset --hard origin/master.

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 .

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.

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

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.

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

Tuve un problema similar. Tuve que hacer esto:

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

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.

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

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)

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

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!

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.

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!

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

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.

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

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.

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.

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.

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

git reset origin/master

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