Как заставить перезаписать локальные файлы на git pull?

Сценарий следующий:

• Член команды модифицирует шаблоны для сайта, над которым мы работаем
• Они добавляют некоторые изображения в каталог изображений (но забывают добавить их под контролем исходного кода)
• Они отправляют изображения по почте, позже, мне
• Я добавляю изображения под контроль исходного кода и помещаю их в GitHub вместе с другими изменениями.
• Они не могут получать обновления из GitHub, потому что Git не хочет перезаписывать свои файлы.

Это ошибка, которую я получаю:

ошибка: неотслеживаемый файл рабочего дерева 'public / images / icon.gif' будет перезаписан слиянием

Как заставить Git перезаписать их? Этот человек дизайнер. Обычно я разрешаю все конфликты вручную, поэтому на сервере установлена ​​самая последняя версия, которую им просто нужно обновить на своем компьютере.

Важно: если у вас есть какие-либо локальные изменения, они будут потеряны. С --hardопцией или без нее любые локальные коммиты, которые не были переданы, будут потеряны. ^[*]

Если у вас есть файлы, которые не отслеживаются Git (например, загруженный пользовательский контент), эти файлы не будут затронуты.

Я думаю, что это правильный путь:

git fetch --all

Тогда у вас есть два варианта:

git reset --hard origin/master

ИЛИ Если вы находитесь в другой ветке:

git reset --hard origin/<branch_name>

Объяснение:

git fetch загружает последние с удаленного, не пытаясь объединить или перебазировать что-либо.

Затем git resetсбрасывает основную ветку к тому, что вы только что получили. --hardОпция изменяет все файлы в вашем рабочем дереве , чтобы соответствовать файлам вorigin/master

Поддерживать текущие локальные коммиты

^[*] : Стоит отметить, что можно сохранить текущие локальные коммиты, создав ветку masterперед сбросом:

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

После этого все старые коммиты будут сохранены new-branch-to-save-current-commits.

Незавершенные изменения

Однако незафиксированные изменения (даже поэтапные) будут потеряны. Убедитесь, что вы спрятали и передали все, что вам нужно. Для этого вы можете запустить следующее:

git stash

А затем повторно применить эти незафиксированные изменения:

git stash pop

Попробуй это:

git reset --hard HEAD
git pull

Это должно делать то, что вы хотите.

ВНИМАНИЕ: git cleanудаляет все ваши неотслеживаемые файлы / каталоги и не может быть отменен.

Иногда просто clean -fне помогает. Если у вас нет отслеживаемых каталогов, опция -d также необходима:

# WARNING: this can't be undone!

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

ВНИМАНИЕ: git cleanудаляет все ваши неотслеживаемые файлы / каталоги и не может быть отменен.

Сначала рассмотрите использование флага -n( --dry-run). Это покажет вам, что будет удалено, фактически ничего не удаляя:

git clean -n -f -d

Пример вывода:

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

Как и Ежик, я думаю, что ответы ужасны. Но хотя ежик может быть лучше, я не думаю, что он такой элегантный, как мог бы быть. Я нашел способ сделать это с помощью «выборки» и «слияния» с определенной стратегией. Что должно сделать так, чтобы ваши локальные изменения сохранялись до тех пор, пока они не являются одним из файлов, которые вы пытаетесь перезаписать.

Сначала сделайте коммит ваших изменений

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

Затем извлеките изменения и перезапишите, если есть конфликт

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

«-X» - это имя опции, а «их» - значение для этой опции. Вы решаете использовать «свои» изменения, а не «свои», если есть конфликт.

Вместо того, чтобы делать:

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

Я бы посоветовал сделать следующее:

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

Не нужно извлекать все пульты и ветки, если вы собираетесь сбросить в исходную / основную ветку, верно?

Похоже, лучше всего сначала сделать:

git clean

Чтобы удалить все неотслеживаемые файлы, а затем продолжить с обычного git pull...

Внимание, это навсегда удалит ваши файлы, если в вашем файле gitignore есть записи каталога / *.

Некоторые ответы кажутся ужасными. Ужасно в смысле того, что случилось с @Lauri, следуя предложению Давида Авсаджанишвили.

Скорее (git> v1.7.6):

git stash --include-untracked
git pull

Позже вы можете очистить тайник истории.

Вручную, один за другим:

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

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

Жестоко, все сразу:

$ git stash clear

Конечно, если вы хотите вернуться к тому, что вы спрятали:

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

Эта команда может оказаться полезной для удаления локальных изменений:

git checkout <your-branch> -f

А затем выполните очистку (удаляет неотслеживаемые файлы из рабочего дерева):

git clean -f

Если вы хотите удалить неотслеживаемые каталоги в дополнение к неотслеживаемым файлам:

git clean -fd

Вместо слияния git pullпопробуйте это:

git fetch --all

с последующим:

git reset --hard origin/master,

Единственное, что сработало для меня, было:

git reset --hard HEAD~5

Это вернет вам пять коммитов, а затем

git pull

Я нашел это, посмотрев, как отменить слияние Git .

Проблема со всеми этими решениями заключается в том, что они все либо слишком сложны, либо, что еще важнее, они удаляют все неотслеживаемые файлы с веб-сервера, что нам не нужно, поскольку всегда есть необходимые файлы конфигурации, которые находятся на сервер а не в репозитории Git.

Вот самое чистое решение, которое мы используем:

# 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

• Первая команда выбирает новейшие данные.

• Вторая команда проверяет, есть ли какие-либо файлы, которые добавляются в хранилище, и удаляет те неотслеживаемые файлы из локального хранилища, которые могут вызвать конфликты.

• Третья команда проверяет все файлы, которые были локально изменены.

• Наконец, мы делаем попытку обновления до последней версии, но на этот раз без каких-либо конфликтов, так как неотслеживаемые файлы, которые находятся в репозитории, больше не существуют, и все локально измененные файлы уже такие же, как в репозитории.

Прежде всего, попробуйте стандартный способ:

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

^{Предупреждение : вышеуказанные команды могут привести к потере данных / файлов, только если они не зафиксированы! Если вы не уверены, сначала сделайте резервную копию всей вашей папки репозитория.}

Тогда потяните это снова.

Если вышеперечисленное не поможет и вам не нужны ваши неотслеживаемые файлы / каталоги (на всякий случай сделайте резервную копию сначала), попробуйте выполнить следующие простые шаги:

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

Это удалит все файлы git (за исключением .git/dir, где у вас есть все коммиты) и извлечет его снова.

Почему git reset HEAD --hardв некоторых случаях может произойти сбой?

1. Пользовательские правила в .gitattributes file

   Наличие eol=lfправила в .gitattributes может привести к тому, что git изменит некоторые изменения файла, преобразовав окончания строк CRLF в LF в некоторых текстовых файлах.

   Если это так, вы должны зафиксировать эти изменения CRLF / LF (просмотрев их git status) или попробовать: git config core.autcrlf falseвременно игнорировать их.

2. Несовместимость файловой системы

   Когда вы используете файловую систему, которая не поддерживает атрибуты разрешений. Например, у вас есть два репозитория, один для Linux / Mac ( ext3/ hfs+) и другой для файловой системы на основе FAT32 / NTFS.

   Как вы заметили, существует два разных типа файловых систем, поэтому та, которая не поддерживает разрешения Unix, в основном не может сбросить разрешения для файлов в системе, которая не поддерживает такого рода разрешения, поэтому независимо от того, как --hardвы пытаетесь, git всегда обнаруживать некоторые «изменения».

У меня такая же проблема. Никто не дал мне это решение, но оно сработало для меня.

Я решил это:

1. Удалить все файлы. Оставьте только .gitкаталог.
2. git reset --hard HEAD
3. git pull
4. git push

Теперь это работает.

Бонус:

Говоря о pull / fetch / merge в предыдущих ответах, я хотел бы поделиться интересным и продуктивным приемом:

git pull --rebase

Эта команда является самой полезной командой в моей жизни в Git, которая сэкономила много времени.

Перед отправкой вашего нового коммита на сервер, попробуйте эту команду, и она автоматически синхронизирует последние изменения сервера (с выборкой + слиянием) и поместит ваш коммит наверху в журнале Git. Нет необходимости беспокоиться о ручном извлечении / слиянии.

Найти детали в Что делает "git pull --rebase"? ,

У меня была аналогичная проблема. Я должен был сделать это:

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

Я суммировал другие ответы. Вы можете выполнить git pullбез ошибок:

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

Предупреждение : этот скрипт очень мощный, поэтому вы можете потерять свои изменения.

Исходя из моего собственного подобного опыта, решение, предложенное Страхиной Кустудич, выше, безусловно, является лучшим. Как уже отмечали другие, простой сброс настроек удалит все неотслеживаемые файлы, которые могут включать в себя множество вещей, которые вы не хотите удалять, например файлы конфигурации. Более безопасным является удаление только тех файлов, которые будут добавлены, и в этом отношении вы, вероятно, также захотите извлечь любые локально-модифицированные файлы, которые будут обновлены.

Имея это в виду, я обновил сценарий Кустудича, чтобы сделать именно это. Я также исправил опечатку (отсутствует в оригинале).

#/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

Я полагаю, что есть две возможные причины конфликта, которые должны быть устранены отдельно, и, насколько я могу судить, ни один из приведенных выше ответов не касается обоих:

• Локальные файлы, которые не были отслежены, необходимо удалить вручную (безопаснее) или, как предлагается в других ответах, путем git clean -f -d

• Локальные коммиты, которые не находятся в удаленной ветке, также должны быть удалены. ИМО самый простой способ добиться этого с помощью: git reset --hard origin/master(замените 'master' на ту ветку, над которой вы работаете, и запустите git fetch originпервую)

Более простым способом было бы:

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

Это заменит ваш локальный файл на файл в git

Кажется, что большинство ответов здесь сосредоточены на masterотрасли; однако бывают случаи, когда я работаю над одной и той же веткой функций в двух разных местах, и я хочу, чтобы ребаз в одной из них отражался в другой, не перепрыгивая через обручи.

На основе сочетания ответа РНКА и ответ Торека к подобному вопросу , я придумал это , который работает отлично:

git fetch
git reset --hard @{u}

Запустите это из ветки, и она будет только сбрасывать вашу локальную ветку на исходную версию.

Это также можно поместить в git alias ( git forcepull):

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

Или в вашем .gitconfigфайле:

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

Наслаждайтесь!

У меня была такая же проблема и по какой-то причине даже не стал git clean -f -dбы это делать. И вот почему: по какой-то причине, если Git игнорирует ваш файл (я полагаю, через запись .gitignore), он все еще беспокоится о перезаписи этого с более поздним извлечением , но очистка не удалит его, если вы не добавите -x.

Я знаю гораздо более простой и менее болезненный метод:

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

Это оно!

Я просто решил это сам:

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

где последняя команда дает список ваших локальных изменений. Продолжайте изменять ветку «tmp» до тех пор, пока она не станет приемлемой, а затем вернитесь к master с помощью:

git checkout master && git merge tmp

В следующий раз вы, вероятно, сможете справиться с этим более понятным способом, посмотрев «ветку git stash», хотя stash, вероятно, доставит вам неприятности с первых нескольких попыток, поэтому проведите первый эксперимент на некритическом проекте ...

У меня странная ситуация , что ни git cleanили git resetработы. Я должен удалить конфликтующий файл git index, используя следующий скрипт для каждого неотслеживаемого файла:

git rm [file]

Тогда я могу тянуть просто отлично.

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

Несмотря на исходный вопрос, ответы на часто задаваемые вопросы могут вызвать проблемы у людей, которые имеют аналогичную проблему, но не хотят терять свои локальные файлы. Например, см. Комментарии Аль-Панка и crizCraig.

Следующая версия фиксирует ваши локальные изменения во временной ветке ( tmp), проверяет исходную ветку (я так полагаю master) и объединяет обновления. Вы можете сделать это с помощью stash, но я обнаружил, что обычно проще использовать подход ветвления / слияния.

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

где мы предполагаем , что другой репозиторий находится origin master.

Эти четыре команды работают для меня.

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

Проверить / вытащить после выполнения этих команд

git pull origin master

Я много пробовал, но наконец-то добился успеха с этими командами.

Просто делать

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

Таким образом, вы избегаете всех нежелательных побочных эффектов, таких как удаление файлов или каталогов, которые вы хотели сохранить, и т. Д.

Сбросьте индекс и заголовок до origin/master, но не сбрасывайте рабочее дерево:

git reset origin/master

Требования:

1. Отслеживайте локальные изменения, чтобы никто их здесь не потерял.
2. Сделайте так, чтобы локальный репозиторий соответствовал удаленному репозиторию источника.

Решение:

1. Копите местные изменения.

2. Принесите с чистым из файлов и каталогов , игнорирующих .gitignore и жесткий сброс к происхождению .

   git stash --include-untracked
   git fetch --all
   git clean -fdx
   git reset --hard origin/master