What are the differences between git remote prune, git prune, git fetch --prune, etc

Question

My situation is this... someone working on the same repo has deleted a branch from his local & remote repo...

Most people who have asked about this kind of problem on Stack Overflow, or other sites have the issue of branches still showing in their remote tracking branch list git branch -a at the bottom:

* master
  develop
  feature_blah
  remotes/origin/master
  remotes/origin/develop
  remotes/origin/feature_blah
  remotes/origin/random_branch_I_want_deleted

However, in MY situation the branch that shouldn't be there, is local:

* master
  develop
  feature_blah
  random_branch_I_want_deleted
  remotes/origin/master
  remotes/origin/develop
  remotes/origin/feature_blah

When I do any of the following, it doesn't get removed locally:

$ git prune

I also tried:

$ git remote prune origin
$ git fetch --prune

More useful info: When I check git remote show origin this is how it looks:

* remote origin
Fetch URL: utilities:homeconnections_ui.git
Push  URL: utilities:homeconnections_ui.git
HEAD branch: master
Remote branches:
 master                        tracked
 develop                       tracked
 feature_blah                  tracked
 other123                      tracked
 other444                      tracked
 other999                      tracked
Local branches configured for 'git pull':
 develop                      merges with remote develop
 feature_blah                 merges with remote other999
 master                       merges with remote master
 random_branch_I_want_deleted merges with remote random_branch_I_want_deleted
Local refs configured for 'git push':
 develop         pushes to develop     (local out of date)
 master          pushes to master      (up to date)
 feature_blah    pushes to feature_blah(up to date)

Notice that it's only in the section titled Local branches configured for 'git pull':

Why?

Thanks, but I'm just curious as to why it might have occurred. — gogogadgetinternet, Nov 20 '13 at 21:08
There was a subtle difference when dealing with branch hierarchy (`x/y`): it has been fixed (see [my answer below](http://stackoverflow.com/a/21072934/6309)) — VonC, Jan 12 '14 at 08:57

John Szakmeister · Accepted Answer · 2019-01-25T23:36:55.213

732

I don't blame you for getting frustrated about this. The best way to look at is this. There are potentially three versions of every remote branch:

The actual branch on the remote repository
(e.g., remote repo at https://example.com/repo.git, refs/heads/master)
Your snapshot of that branch locally (stored under refs/remotes/...)
(e.g., local repo, refs/remotes/origin/master)
And a local branch that might be tracking the remote branch
(e.g., local repo, refs/heads/master)

Let's start with git prune. This removes objects that are no longer being referenced, it does not remove references. In your case, you have a local branch. That means there's a ref named random_branch_I_want_deleted that refers to some objects that represent the history of that branch. So, by definition, git prune will not remove random_branch_I_want_deleted. Really, git prune is a way to delete data that has accumulated in Git but is not being referenced by anything. In general, it doesn't affect your view of any branches.

git remote prune origin and git fetch --prune both operate on references under refs/remotes/... (I'll refer to these as remote references). It doesn't affect local branches. The git remote version is useful if you only want to remove remote references under a particular remote. Otherwise, the two do exactly the same thing. So, in short, git remote prune and git fetch --prune operate on number 2 above. For example, if you deleted a branch using the git web GUI and don't want it to show up in your local branch list anymore (git branch -r), then this is the command you should use.

To remove a local branch, you should use git branch -d (or -D if it's not merged anywhere). FWIW, there is no git command to automatically remove the local tracking branches if a remote branch disappears.

edited Jan 25 '19 at 23:36

answered Nov 20 '13 at 21:14

John Szakmeister

38,342
9
78
72

25

This does a better job of addressing the overall question by explaining the pertinent differences. It also answers additional questions I had from the one above. – gogogadgetinternet Nov 20 '13 at 21:26
15

This command will show a list of all local branches that don't have a corresponding remote branch. You _could_ pipe this to `xargs git branch -D`, but note that any new branches you've created but never pushed to the server would be deleted, so tread carefully: `git branch -r | awk '{print $1}' | egrep -v -f /dev/fd/0 – Jason Walton Sep 11 '14 at 02:59
I wrote [a script to delete branches already merged into development](https://gist.github.com/bxt/566fd7de151bf73a937d). I guess it is safer than @JasonWalton's approach. Whatever orphans are left under `refs/remotes/...` are then deleted by the occasional [`git-gc`](https://git-scm.com/docs/git-gc). – amoebe Apr 11 '16 at 05:34
4

@Seed No it doesn't. :-( It only deletes the local remote tracking refs. I just double-checked this with version 2.7.0. – John Szakmeister May 09 '16 at 19:29
I put `alias gitcleanup="git fetch --prune && git branch --merged | egrep -v \"(^\*|master|dev)\" | xargs git branch -d"` in my `~/.profile` file. Then I can just run `gitcleanup` in the project root to cleanup all remote tracking and local branches. – BlueRaja - Danny Pflughoeft Mar 07 '17 at 13:27
1

@BlueRaja-DannyPflughoeft Be careful with that approach. For instance, depending on how you do your stable branches, they may appear to be merged into the master branch, and you would end up removing them. It's not a big loss here since you aren't removing them from the server, but if you had any special configuration you set for it then that would be lost when the branch is deleted. – John Szakmeister Mar 07 '17 at 13:34
please do not use git branch for scripting and consider this answer: https://stackoverflow.com/questions/10610327/delete-all-local-git-branches – Yolgie Sep 26 '17 at 08:09
To understand your note on 3 versions of every branch: If I have a remote branch named master...1) would this be the 'remote branch'? and I do `git checkout -b master upstream/master` then 2) would that be 'snapshot'? If those two are right then I don't know what the third one is. Can you explain? – Honey Jan 25 '19 at 20:53
@Honey Good questions. In this case, the term "remote branch" is overloaded in most discussions about Git--people use it to refer to both the local snapshot and the actual branch in the remote repository. If I could have my druthers about it, I'd call the master branch in the remote repository the "remote branch", the last version of that branch fetched into the local repository (with then name origin/master in this case) the "snapshot". And the master branch you have checked out locally the "local branch". Does that help? – John Szakmeister Jan 25 '19 at 21:28
@Honey I updated the 3 bullets to include an example of where to find the 3 versions. I hope that helps. – John Szakmeister Jan 25 '19 at 21:36
You can also just delete them manually through the file explorer – Cloud Apr 30 '19 at 11:39
1

@Cloud Not entirely true. References can be packed (see the `packed-refs` file in the `.git` area), so it's not necessarily a simple matter of deleting them via file explorer. Better to use the commands to make sure both are taken care of correctly. – John Szakmeister Apr 30 '19 at 20:40

CharlesB · Answer 2 · 2014-03-27T09:50:35.753

60

git remote prune and git fetch --prune do the same thing: deleting the refs to the branches that don't exist on the remote, as you said. The second command connects to the remote and fetches its current branches before pruning.

However it doesn't touch the local branches you have checked out, that you can simply delete with

git branch -d  random_branch_I_want_deleted

Replace -d by -D if the branch is not merged elsewhere

git prune does something different, it purges unreachable objects, those commits that aren't reachable in any branch or tag, and thus not needed anymore.

edited Mar 27 '14 at 09:50

answered Nov 20 '13 at 21:04

CharlesB

75,315
26
174
199

1

I know it seems obvious, but `git prune` looks not only for branches and tags, but all other refs as well. – Nov 20 '13 at 21:08
So in my case, why wouldn't git prune work? Because it does't care about local branches, but remote references? Thanks for the concise info. – gogogadgetinternet Nov 20 '13 at 21:12
@hvd what kind of refs are there other than branches and tags? – CharlesB Nov 20 '13 at 21:12
@gogogadgetinternet yes exactly. (supposing you meant `git remote prune`) – CharlesB Nov 20 '13 at 21:13
@CharlesB At the very least, reflog, detached HEAD, replacement refs (`git replace`), but probably more too. (In fairness, I may have made a mistake in calling all of those refs, I'm not sure that's the right term.) – Nov 20 '13 at 21:21
4

IMO the git naming convention of using "prune" for both object-collection *and* reference-cleanup is where the confusion sets in. But that's just one of many UI puzzlements, in git. :-) – torek Nov 20 '13 at 21:37

D.Mill · Answer 3 · 2014-03-28T00:21:49.597

In the event that anyone would be interested. Here's a quick shell script that will remove all local branches that aren't tracked remotely. A word of caution: This will get rid of any branch that isn't tracked remotely regardless of whether it was merged or not.

If you guys see any issues with this please let me know and I'll fix it (etc. etc.)

Save it in a file called git-rm-ntb (call it whatever) on PATH and run:

git-rm-ntb <remote1:optional> <remote2:optional> ...

clean()
{
  REMOTES="$@";
  if [ -z "$REMOTES" ]; then
    REMOTES=$(git remote);
  fi
  REMOTES=$(echo "$REMOTES" | xargs -n1 echo)
  RBRANCHES=()
  while read REMOTE; do
    CURRBRANCHES=($(git ls-remote $REMOTE | awk '{print $2}' | grep 'refs/heads/' | sed 's:refs/heads/::'))
    RBRANCHES=("${CURRBRANCHES[@]}" "${RBRANCHES[@]}")
  done < <(echo "$REMOTES" )
  [[ $RBRANCHES ]] || exit
  LBRANCHES=($(git branch | sed 's:\*::' | awk '{print $1}'))
  for i in "${LBRANCHES[@]}"; do
    skip=
    for j in "${RBRANCHES[@]}"; do
      [[ $i == $j ]] && { skip=1; echo -e "\033[32m Keeping $i \033[0m"; break; }
    done
    [[ -n $skip ]] || { echo -e "\033[31m $(git branch -D $i) \033[0m"; }
  done
}

clean $@

Wouldn't $(git branch -d $i) be safer to only delete merged branches? — user2012677, May 09 '19 at 19:42
The safer options are discussed in https://stackoverflow.com/questions/7726949/remove-tracking-branches-no-longer-on-remote/38404202#38404202 — Michael Freidgeim, May 10 '20 at 00:44

score 13 · Answer 4 · edited May 23 '17 at 12:34

Note that one difference between git remote --prune and git fetch --prune is being fixed, with commit 10a6cc8, by Tom Miller (tmiller) (for git 1.9/2.0, Q1 2014):

When we have a remote-tracking branch named "frotz/nitfol" from a previous fetch, and the upstream now has a branch named "**frotz"**, fetch would fail to remove "frotz/nitfol" with a "git fetch --prune" from the upstream.
git would inform the user to use "git remote prune" to fix the problem.

So: when a upstream repo has a branch ("frotz") with the same name as a branch hierarchy ("frotz/xxx", a possible branch naming convention), git remote --prune was succeeding (in cleaning up the remote tracking branch from your repo), but git fetch --prune was failing.

Not anymore:

Change the way "fetch --prune" works by moving the pruning operation before the fetching operation.
This way, instead of warning the user of a conflict, it automatically fixes it.

What are the differences between git remote prune, git prune, git fetch --prune, etc

4 Answers4

Linked