Let’s break down these two commands, their background processes, and key differences, using your provided outputs as context.

What does git prune do? #

git prune is a focused, single-purpose command that cleans up unreachable loose objects in your Git repository. Unreachable objects are those that aren’t referenced by any branch, tag, commit, or even the reflog—think old commits from deleted branches, leftover objects from aborted merges, or temporary objects that never got committed.

When you run git prune, here’s what happens behind the scenes:

• It starts by traversing all "reachable" objects (everything your repository currently cares about)
• It identifies any loose objects (individual files in .git/objects) that aren’t part of this reachable set
• It deletes those unreachable loose objects to free up space

Your git prune output:

Checking connectivity: 945490, done.

This line simply means Git finished scanning all 945,490 objects to confirm which ones are reachable—no other cleanup steps happen here.

What does git gc do? #

git gc (short for "garbage collection") is a comprehensive maintenance command that wraps multiple Git tools (including git prune) to fully optimize your repository. It’s designed to clean up clutter, reduce disk usage, and improve repository performance.

Looking at your git gc output, let’s walk through each stage of its background process:

1. Counting objects: 945490, done.
   Git first counts all objects in the repository (both loose and already packed) to understand the scope of work.
2. Delta compression using up to 4 threads.
   Git enables multi-threaded delta compression—this means it looks for similarities between objects (like different versions of the same file) and stores only the changes, drastically reducing file size.
3. Compressing objects: 100% (334718/334718), done.
   It compresses all eligible loose objects using the delta compression setup.
4. Writing objects: 100% (945490/945490), done.
   Git packages the compressed objects into .pack files (bundles of objects) which are more efficient to store and access than individual loose files.
5. Total 945490 (delta 483105), reused 944529 (delta 482309)
   This line shows how many objects were reused from existing packs (avoiding redundant work) and the number of delta changes stored—higher reuse means more efficient space savings.
6. Checking connectivity: 948048, done.
   This is where Git runs the same reachability check as git prune, deleting any unreachable objects that weren’t already cleaned up.

Key Differences Between git gc and git prune #

• Scope of work:
  • git prune only deletes unreachable loose objects—no compression, no packing, no other optimizations.
  • git gc does everything git prune does, plus compresses objects, packs them into bundles, cleans up stale reflog entries (by default), and optimizes the overall repository structure.
• Usage frequency:
  • git prune is rarely run manually; it’s usually invoked indirectly via git gc. You’d only run it if you specifically want to delete unreachable objects without doing full repository maintenance.
  • git gc is often triggered automatically by Git (e.g., after pushes/pulls when the repository hits a size threshold) and is the go-to command for manual repository cleanup.
• Output complexity:
  • git prune has minimal output since it only performs one core task.
  • git gc has a multi-stage output because it executes several distinct optimization steps.

内容的提问来源于stack exchange，提问作者L Y E S - C H I O U K H