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

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

Сначала запустите выборку, чтобы обновить все origin/<branch> ссылки до последних:

git fetch --all

Сделайте резервную копию вашей текущей ветки:

git branch backup-master

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

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

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

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

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

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

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

-X - это имя опции, а theirs - значение этой опции. Вы решили использовать their изменений (другой вариант - ours изменений) в случае конфликта.

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

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

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

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

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

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

git clean

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

Внимание! Это приведет к безвозвратно удалите файлы, если в вашем файле gitignore есть записи directory / *.

Некоторые ответы кажутся ужасными. Ужасно в том смысле, что случилось с @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 (_9 _ / _ 10_), а другой в файловой системе на основе 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, которая сэкономила много времени.

Прежде чем отправлять новый коммит на сервер, попробуйте эту команду, и она автоматически синхронизирует последние изменения сервера (с помощью fetch + merge) и поместит вашу фиксацию наверху в журнале 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)

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

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

git fetch
git reset --hard @{u}

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

Это также можно красиво поместить в псевдоним git (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), он все еще беспокоится о перезаписи его более поздним pull, но чистым не удалит его, пока вы не добавите -x.

Более простой способ:

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

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

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

$ 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" до тех пор, пока она не станет приемлемой, а затем снова выполните слияние с мастером с помощью:

git checkout master && git merge tmp

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

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

git rm [file]

Тогда я могу нормально тянуть.

Использовать:

git fetch --all

Затем, если вы находитесь в ветке master,

git reset --hard origin/master

еще

git reset --hard origin/master<branch_name>

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

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

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

Несмотря на исходный вопрос, основные ответы могут вызвать проблемы у людей, у которых есть аналогичная проблема, но которые не хотят терять свои локальные файлы. Например, см. Комментарии Al-Punk и 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.

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

git reset origin/master

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

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

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

git pull origin master

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

Требования:

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

Решение:

1. Спрятать локальные изменения.

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

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

Я прочитал все ответы, но искал единственную команду для этого. Вот что я сделал. Добавлен псевдоним git в .gitconfig

[alias]
      fp = "!f(){ git fetch ${1} ${2} && git reset --hard ${1}/${2};};f"

Запустите вашу команду как

git fp origin master

эквивалентно

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

Это сработало для меня очень хорошо!

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

Это лучший способ отменить изменения:

• git commit Зафиксируйте поэтапные изменения, чтобы они были сохранены в reflog (см. ниже)
• git fetch Получить последние изменения в восходящем направлении
• git reset --hard origin/master Аппаратный сброс на исходную главную ветку