Three-way merge in Git - Mini Project: Build & Apply

Three-way Merge with Git

📖 Scenario: You are working on a team project using Git. Two team members have made changes to the same file in different branches. You need to merge these branches using a three-way merge to combine their changes safely.

🎯 Goal: Learn how to perform a three-way merge in Git to combine changes from two branches into one, resolving conflicts if they appear.

📋 What You'll Learn

Create a Git repository with an initial file

Create and switch to a new branch

Make changes in both branches

Perform a three-way merge to combine changes

💡 Why This Matters

🌍 Real World

Teams use three-way merges daily to combine code changes from multiple developers safely.

💼 Career

Understanding three-way merges is essential for software developers, DevOps engineers, and anyone collaborating on code using Git.

1

Initialize Git repository and create initial file

Run git init to create a new Git repository. Then create a file named project.txt with the content Hello World. Add and commit this file with the message Initial commit using git add project.txt and git commit -m "Initial commit".

Git

# Run git init and create project.txt with 'Hello World'
# Add and commit the file
# Your code here

Hint

Use git init to start the repo. Use echo to create the file. Then add and commit.

2

Create and switch to a new branch

Create a new branch called feature using git branch feature. Then switch to this branch using git checkout feature.

Git

git init

echo "Hello World" > project.txt

git add project.txt

git commit -m "Initial commit"

# Create and switch to branch 'feature'
# Your code here

Hint

Use git branch feature to create and git checkout feature to switch branches.

3

Make changes in both branches

On the feature branch, change project.txt content to Hello from feature branch and commit with message Feature update. Then switch back to main branch using git checkout main, change project.txt content to Hello from main branch and commit with message Main update.

Git

git init

echo "Hello World" > project.txt

git add project.txt

git commit -m "Initial commit"

git branch feature

git checkout feature

# Change project.txt on feature branch and commit
# Switch to main branch
# Change project.txt on main branch and commit
# Your code here

Hint

Use echo to overwrite the file content. Commit changes on each branch separately.

4

Perform a three-way merge

Merge the feature branch into main using git merge feature. If there are conflicts, resolve them by editing project.txt to contain Hello from both branches, then add and commit the merge with message Merge feature branch. Finally, print the content of project.txt using cat project.txt.

Git

git init

echo "Hello World" > project.txt

git add project.txt

git commit -m "Initial commit"

git branch feature

git checkout feature

echo "Hello from feature branch" > project.txt

git add project.txt

git commit -m "Feature update"

git checkout main

echo "Hello from main branch" > project.txt

git add project.txt

git commit -m "Main update"

# Merge feature branch into main
# If conflict, edit project.txt to 'Hello from both branches'
# Add and commit the merge
# Print project.txt content
# Your code here

Hint

Use git merge feature. If conflict occurs, fix the file manually, then add and commit.

Practice

1. What is the main purpose of a three-way merge in Git?

easy

A. To combine changes from two branches using a common base

B. To delete a branch after merging

C. To create a new branch from the current branch

D. To reset the current branch to a previous commit

Solution

1. Step 1: Understand the concept of three-way merge

   A three-way merge uses the common ancestor of two branches to combine their changes safely.

2. Step 2: Identify the purpose in Git workflow

   This process helps merge changes from two branches without losing work, especially when both branches have edits.

3. Final Answer:

   To combine changes from two branches using a common base -> Option A

4. Quick Check:

   Three-way merge = combine changes safely [OK]

Hint: Three-way merge combines two branches with a common ancestor [OK]

Common Mistakes:

• Confusing merge with branch deletion
• Thinking merge creates new branches
• Mixing merge with reset commands

2. Which Git command automatically performs a three-way merge when integrating changes from a remote branch?

easy

A. git pull

B. git merge

C. git commit

D. git branch

Solution

1. Step 1: Recall commands that fetch and merge

   git pull fetches changes from a remote branch and merges them locally, often using a three-way merge.

2. Step 2: Differentiate from other commands

   git merge merges branches locally but does not fetch remote changes; git branch manages branches; git commit records changes.

3. Final Answer:

   git pull -> Option A

4. Quick Check:

   git pull = fetch + merge (three-way) [OK]

Hint: git pull fetches and merges remotely with three-way merge [OK]

Common Mistakes:

• Choosing git merge without fetching first
• Confusing git commit with merge
• Using git branch for merging

3. Given the following scenario:

Branch A has file.txt with content: "Hello World"
Branch B modifies file.txt to: "Hello Git"
Common base has file.txt: "Hi World"

What will be the content of file.txt after a successful three-way merge of Branch B into Branch A?

medium

A. "Hello"

B. "Hello Git"

C. "Hello World Git"

D. "Hello World"

Solution

1. Step 1: Identify changes from base to each branch

   Base has "Hi World". Branch A changed "Hi" to "Hello". Branch B changed "Hi" to "Hello" and "World" to "Git".

2. Step 2: Understand three-way merge result

   Since the change "Hi" -> "Hello" is common to both branches, and Branch B has an additional change "World" -> "Git", Git's three-way merge automatically combines them, resulting in "Hello Git".

3. Final Answer:

   "Hello Git" -> Option B

4. Quick Check:

   Three-way merge picks combined changes, here "Hello Git" [OK]

Hint: Merged content reflects changes from both branches via base [OK]

Common Mistakes:

• Assuming content concatenates both changes
• Ignoring base version in merge
• Confusing which branch's changes apply

4. You ran git merge feature but got a conflict in app.js. What should you do to resolve this three-way merge conflict?

medium

A. Run git reset --hard immediately to discard all changes

B. Delete app.js and run git merge --abort

C. Edit app.js to fix conflicts, then run git add app.js and git commit

D. Run git branch -d feature to delete the feature branch

Solution

1. Step 1: Understand merge conflict resolution

   When a conflict occurs, you must manually edit the conflicting file to resolve differences.

2. Step 2: Stage and commit resolved file

   After fixing conflicts in app.js, use git add to stage and then git commit to complete the merge.

3. Final Answer:

   Edit app.js, then git add and git commit -> Option C

4. Quick Check:

   Fix conflicts, stage, commit to resolve merge [OK]

Hint: Fix conflicts manually, then add and commit [OK]

Common Mistakes:

• Deleting files instead of resolving conflicts
• Aborting merge without fixing conflicts
• Deleting branches to fix conflicts

5. You have two branches, main and feature. Both modified the same function in utils.py differently. After running git merge feature into main, a three-way merge conflict occurs. Which approach best resolves this conflict while preserving both changes?

hard

A. Delete feature branch and continue with main unchanged

B. Force merge with git merge --strategy=ours to keep main version only

C. Reset main to the common ancestor commit and retry merge

D. Manually edit utils.py to combine both changes logically, then stage and commit

Solution

1. Step 1: Recognize conflict in same function

   Both branches changed the same function differently, causing a conflict during merge.

2. Step 2: Choose best resolution method

   Manually editing the file to combine both changes logically preserves work from both branches, which is the best practice.

3. Step 3: Stage and commit after resolving

   After editing, stage the file with git add and commit to complete the merge.

4. Final Answer:

   Manually edit utils.py to combine changes, then stage and commit -> Option D

5. Quick Check:

   Manual merge preserves both changes best [OK]

Hint: Edit conflicts to combine changes, then add and commit [OK]

Common Mistakes:

• Using --strategy=ours loses feature changes
• Deleting branches to avoid conflicts
• Resetting loses recent work