Fetch vs pull difference in Git - Practice Questions

Challenge - 5 Problems

🧠 Conceptual

intermediate

Difference between git fetch and git pull

Which statement best describes the difference between git fetch and git pull?

A <code>git fetch</code> downloads changes from the remote repository but does not merge them automatically; <code>git pull</code> downloads and merges changes into the current branch.

B <code>git fetch</code> deletes local branches that are not on the remote; <code>git pull</code> only updates the remote branches.

C <code>git fetch</code> merges changes automatically; <code>git pull</code> only downloads changes without merging.

D <code>git fetch</code> pushes local changes to the remote repository; <code>git pull</code> pulls changes from other developers.

💡 Hint

Think about whether the command updates your working files immediately or just updates remote tracking information.

git fetch downloads new data from the remote repository but does not change your working files or current branch. git pull is like running git fetch followed by git merge, so it updates your current branch with remote changes.

💻 Command Output

intermediate

Output after git fetch

You run git fetch origin on your local repository. What is the immediate effect on your local branches?

A Local branches are automatically merged with origin branches.

B Local branches are reset to match origin branches.

C Local branches are deleted if they differ from origin branches.

D Local branches remain unchanged; remote tracking branches are updated with the latest commits from origin.

💡 Hint

Consider if your working files or local branches change immediately after fetching.

git fetch updates remote tracking branches like origin/main but does not change your local branches or working files until you merge or rebase.

🔀 Workflow

advanced

Choosing between git fetch and git pull in a team workflow

In a team project, you want to review changes from others before merging them into your branch. Which command should you use and why?

A Use <code>git fetch</code> to download changes first, then review and merge manually to avoid unexpected conflicts.

B Use <code>git pull</code> directly to automatically merge changes and save time.

C Use <code>git push</code> to update your branch with others' changes.

D Use <code>git clone</code> to get the latest changes from the remote repository.

💡 Hint

Think about how to avoid automatic merges that might cause conflicts without your knowledge.

git fetch lets you download remote changes without merging. You can inspect changes safely before deciding how to integrate them. git pull merges immediately, which might cause conflicts unexpectedly.

❓ Troubleshoot

advanced

Resolving unexpected merge conflicts after git pull

You ran git pull and got merge conflicts you did not expect. What is the most likely cause?

A Your local repository is not connected to any remote repository.

B You forgot to run <code>git fetch</code> before <code>git pull</code>.

C Local changes conflicted with remote changes because <code>git pull</code> merged automatically without prior review.

D The remote repository was empty, so no changes were pulled.

💡 Hint

Think about what happens when you merge changes automatically without checking first.

git pull runs git fetch then merges. If local and remote changes overlap, conflicts can occur unexpectedly. Fetching first allows review before merging.

✅ Best Practice

expert

Best practice for updating local branches safely

Which practice is best to keep your local branches updated safely without losing work?

A Always run <code>git pull --rebase</code> without checking to keep history linear.

B Run <code>git fetch</code> regularly, review remote changes, then merge or rebase manually to control integration.

C Delete local branches before pulling to avoid conflicts.

D Use <code>git push --force</code> to overwrite remote branches with local changes.

💡 Hint

Consider how to avoid losing work and how to review changes before merging.

Fetching first and reviewing changes before merging or rebasing helps avoid conflicts and accidental overwrites. Force pushing or deleting branches can cause data loss.