⚠ Warning:
Any uncommitted local change to tracked files will be lost, even if staged.
But any local file that's not tracked by Git will not be affected.
First, update all origin/<branch> refs to latest:
git fetch --all
Backup your current branch (e.g. main):
git branch backup-main
Jump to the latest commit on origin/main and checkout those files:
git reset --hard origin/main
Explanation:
git fetch downloads the latest from remote without trying to merge or rebase anything.
git reset resets the master branch to what you just fetched. The --hard option changes all the files in your working tree to match the files in origin/main.
Maintain current local commits
[*]: It's worth noting that it is possible to maintain current local commits by creating a branch from main before resetting:
git checkout main
git branch new-branch-to-save-current-commits
git fetch --all
git reset --hard origin/main
After this, all of the old commits will be kept in new-branch-to-save-current-commits.
Uncommitted changes
Uncommitted changes, even if staged (with git add), will be lost. Make sure to stash or commit anything you need. For example, run the following:
git stash
And later (after git reset), reapply these uncommitted changes:
git stash pop
Answer from RNA on Stack OverflowWhich may create merge conflicts.
⚠ Warning:
Any uncommitted local change to tracked files will be lost, even if staged.
But any local file that's not tracked by Git will not be affected.
First, update all origin/<branch> refs to latest:
git fetch --all
Backup your current branch (e.g. main):
git branch backup-main
Jump to the latest commit on origin/main and checkout those files:
git reset --hard origin/main
Explanation:
git fetch downloads the latest from remote without trying to merge or rebase anything.
git reset resets the master branch to what you just fetched. The --hard option changes all the files in your working tree to match the files in origin/main.
Maintain current local commits
[*]: It's worth noting that it is possible to maintain current local commits by creating a branch from main before resetting:
git checkout main
git branch new-branch-to-save-current-commits
git fetch --all
git reset --hard origin/main
After this, all of the old commits will be kept in new-branch-to-save-current-commits.
Uncommitted changes
Uncommitted changes, even if staged (with git add), will be lost. Make sure to stash or commit anything you need. For example, run the following:
git stash
And later (after git reset), reapply these uncommitted changes:
git stash pop
Which may create merge conflicts.
This will remove all uncommitted changes, even if staged,
and then pull:
git reset --hard HEAD
git pull
But any local file that's not tracked by Git will not be affected.
Does git pull not overwrite local code always?
How can I use `git pull` while ignoring local changes? - Stack Overflow
How to overwrite local changes from remote repository?
Git fetch overwrote my local changes, what happened exactly?
A fetch is quite safe. One of the problems with these GUIs that attempt to make git easier is that they tend to do a lot more in the background than you expect, like whatever happened here. I was once working on a project with someone who was using the official GitHub Desktop app, and every time they fetched, it would fetch, merge, and push the result, so I was getting all their half-baked changes even though they just thought they were pulling in mine.
You're really best off only using the commands directly, or using wrappers that you've read the source code for and understand.
More on reddit.comOur team has a project repo setup and all of us devs have forked that repo and cloned it to our local machines. So all of us have origin and root configured respectively where root is the actual repo and origin is our individual forks.
We always take a pull from root before pushing to origin and raising a merge request. The good practice.
Now I had some task on which I had to work on which will take me 2 days to complete. Before starting to work on it, I took a pull from root and started coding. After 2 days as I finished, before pushing to my origin, I took a pull from root because I saw other devs had some commits of their own and I will resolve the merge conflicts (if any) on my local before raising my own merge request. However , I did not commit my local changes, just saved them.
But git pull was successful and it did not prompt me to commit local changes else it'll be lost in the pull operation. So i checked those other commits and I saw none of them pertained to the files I changed, but were to different files. So i committed my changes, pushed to origin, the usual steps.
So will git pull not overwrite changes in my uncommitted local when the same file has not been modified in root? Technically git tracks these changes and must be unsure what to do as I haven't committed them. Either I should stash or commit? What am I missing or lacking the understanding of?
If you mean you want the pull to overwrite local changes, doing the merge as if the working tree were clean, well, clean the working tree:
git reset --hard
git pull
If there are untracked local files you could use git clean to remove them.
git clean -fto remove untracked files-dfto remove untracked files and directories-xdfto remove untracked or ignored files or directories
If on the other hand you want to keep the local modifications somehow, you'd use stash to hide them away before pulling, then reapply them afterwards:
git stash
git pull
git stash pop
I don't think it makes any sense to literally ignore the changes, though - half of pull is merge, and it needs to merge the committed versions of content with the versions it fetched.
For me the following worked:
First fetch all changes:
$ git fetch --allThen reset the master:
$ git reset --hard origin/masterNote - For users of github, "master" was replaced with "main" in October 2020. For projects created since then you may need to use "main" instead, like:
$ git reset --hard origin/mainPull/update:
$ git pull