so-git-fetch-vs-pull

Answer

Git Fetch vs Git Pull — Complete Explanation

git fetch downloads new commits, branches, and tags from a remote repository without touching your working tree. It safely updates your remote-tracking branches (e.g., origin/main) so you can inspect changes before integrating them.

git pull is a shortcut for git fetch followed immediately by git merge (or git rebase if --rebase is used). It downloads changes and integrates them into your current branch in one step.

Reproducible Shell Script Demo

#!/usr/bin/env bash
set -euo pipefail

# =============================================================================
# git fetch vs git pull — Reproducible Shell Script Demo
# =============================================================================

DEMO_DIR="/tmp/git_demo_$$"
UPSTREAM_DIR="${DEMO_DIR}/upstream"
CLONE1_DIR="${DEMO_DIR}/clone1"   # developer A
CLONE2_DIR="${DEMO_DIR}/clone2"   # developer B

cleanup() { rm -rf "${DEMO_DIR}"; }
trap cleanup EXIT

# Determine default branch name
if git config --global init.defaultBranch &>/dev/null; then
    DEFAULT_BRANCH="$(git config --global init.defaultBranch)"
else
    DEFAULT_BRANCH="main"
fi
echo "Default branch: ${DEFAULT_BRANCH}"

# ---- SETUP ----
mkdir -p "${DEMO_DIR}"
git init --bare "${UPSTREAM_DIR}" >/dev/null 2>&1

git clone "${UPSTREAM_DIR}" "${CLONE1_DIR}" >/dev/null 2>&1
cd "${CLONE1_DIR}"
git config user.email "<email>"
git config user.name "Dev One"
echo "# Project README" > README.md
git add README.md
git commit -m "Initial commit" >/dev/null
git push origin "HEAD:${DEFAULT_BRANCH}" >/dev/null 2>&1

git clone "${UPSTREAM_DIR}" "${CLONE2_DIR}" >/dev/null 2>&1
cd "${CLONE2_DIR}"
git config user.email "<email>"
git config user.name "Dev Two"

# ---- DEMO 1: Fetch downloads WITHOUT merging ----
cd "${CLONE1_DIR}"
echo "feature-a" > feature-a.txt
git add feature-a.txt
git commit -m "Add feature A" >/dev/null
git push origin "HEAD:${DEFAULT_BRANCH}" >/dev/null 2>&1

cd "${CLONE2_DIR}"
echo "[BEFORE FETCH] files: $(ls -1)"
git fetch origin 2>&1
echo "[AFTER FETCH] files: $(ls -1)"
echo "feature-a.txt is NOT present — fetch only downloaded objects."
echo "Remote-tracking ref updated:"
git log "origin/${DEFAULT_BRANCH}" --oneline -3

# ---- DEMO 2: Pull = fetch + merge ----
git pull origin "${DEFAULT_BRANCH}" 2>&1
echo "[AFTER PULL] files: $(ls -1)"
echo "feature-a.txt now exists — pull merged changes into working tree."

# ---- DEMO 3: git pull --rebase ----
echo "local-work" > local-work.txt
git add local-work.txt
git commit -m "WIP: local work" >/dev/null

cd "${CLONE1_DIR}"
echo "feature-b" > feature-b.txt
git add feature-b.txt
git commit -m "Add feature B" >/dev/null
git push origin "HEAD:${DEFAULT_BRANCH}" >/dev/null 2>&1

cd "${CLONE2_DIR}"
git log --oneline -3 --all
git pull --rebase origin "${DEFAULT_BRANCH}" 2>&1
echo "[AFTER REBASE] Local commits now on top:"
git log --oneline -4 --all

# ---- DEMO 4: Inspect fetched changes with git diff ----
cd "${CLONE1_DIR}"
echo "feature-c" > feature-c.txt
git add feature-c.txt
git commit -m "Add feature C" >/dev/null
git push origin "HEAD:${DEFAULT_BRANCH}" >/dev/null 2>&1

cd "${CLONE2_DIR}"
git fetch origin 2>&1
echo "Inspect changes before merge:"
git diff "HEAD..origin/${DEFAULT_BRANCH}" --stat
git merge "origin/${DEFAULT_BRANCH}" >/dev/null 2>&1

# ---- DEMO 5: Why fetch is SAFER ----
cd "${CLONE2_DIR}"
echo "uncommitted-important-work" > important.txt  # dirty working tree

cd "${CLONE1_DIR}"
echo "remote-important-work" > important.txt
git add important.txt
git commit -m "Add important.txt from remote" >/dev/null
git push origin "HEAD:${DEFAULT_BRANCH}" >/dev/null 2>&1

cd "${CLONE2_DIR}"
git fetch origin 2>&1
git log "origin/${DEFAULT_BRANCH}" --oneline -2
git diff "HEAD..origin/${DEFAULT_BRANCH}" important.txt
echo "Dev2 inspects the diff before deciding what to do."
echo "A direct git pull would fail with:"
echo "  error: Your local changes to important.txt would be overwritten."
echo ""
echo "| Operation       | Downloads objects? | Updates working tree? |"
echo "|-----------------|-------------------|----------------------|"
echo "| git fetch       | Yes               | No                   |"
echo "| git pull        | Yes               | Yes (merge)          |"
echo "| pull --rebase   | Yes               | Yes (rebase)         |"

Key Differences Explained

5 Core Concepts

1. Fetch downloads without merging — git fetch pulls new objects into .git/objects and updates refs/remotes/origin/main, but leaves your working directory untouched. The new files are invisible to ls until you merge.

2. Pull = fetch + merge — git pull runs git fetch then git merge FETCH_HEAD (or origin/main). Both the download and integration happen atomically.

3. git pull --rebase — Instead of merge, it uses git rebase, replaying your local commits on top of the fetched tip. The result is a linear history with no merge commits.

4. Inspect fetched changes with git diff — After git fetch, run git diff HEAD..origin/main or git log origin/main --oneline -5 to see exactly what the remote has. You can review every commit before choosing to merge.

5. Fetch is safer — If your working tree is dirty (uncommitted WIP), git pull will refuse to run or force you to stash. With git fetch, you can always download and inspect without touching local state. In team workflows, this gives you the chance to review teammates' changes, coordinate, and resolve conflicts on your terms.