Shallow clones with depth in Git - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is a shallow clone in Git?

A shallow clone is a copy of a Git repository that contains only the latest commits up to a specified depth, not the full history. It saves time and space.

beginner

How do you create a shallow clone with a depth of 5 commits?

Use the command: git clone --depth 5 <repository_url>. This clones only the last 5 commits.

beginner

Why would you use a shallow clone?

To save time and disk space when you only need recent history, such as for quick builds or testing, not full project history.

intermediate

Can you fetch more history after a shallow clone?

Yes, you can deepen the clone later using git fetch --deepen <number> or fetch the full history with git fetch --unshallow.

beginner

What is the difference between a shallow clone and a full clone?

A full clone downloads the entire commit history, while a shallow clone downloads only a limited number of recent commits.

Which command creates a shallow clone with a depth of 3 commits?

A git clone --depth 3 <repo_url>

B git clone --shallow 3 <repo_url>

C git clone --limit 3 <repo_url>

D git clone --history 3 <repo_url>

The correct syntax to create a shallow clone with limited commits is using --depth followed by the number.

What is a main benefit of using shallow clones?

A Automatic branch creation

B Access to full project history

C Ability to push changes faster

D Faster cloning and less disk space used

Shallow clones reduce the amount of data downloaded, making cloning faster and saving disk space.

How can you get more commits after a shallow clone?

A git fetch --deepen <number>

B git clone --depth <number>

C git pull --shallow

D git reset --depth <number>

You can deepen the history of a shallow clone by fetching more commits with git fetch --deepen.

Which of these is NOT true about shallow clones?

A They save time when cloning

B They can be deepened later

C They include the full commit history

D They download fewer commits

Shallow clones do NOT include the full commit history; they only include recent commits.

What happens if you run git fetch --unshallow?

A It deletes the shallow clone

B It converts a shallow clone into a full clone by downloading all history

C It reduces the depth of the clone

D It creates a new shallow clone

The command downloads the full commit history, making the shallow clone a full clone.

Explain what a shallow clone is and why it might be useful.

Think about cloning only recent changes instead of everything.

Describe how to create a shallow clone and how to get more history later.

Start shallow, then deepen or unshallow as needed.

Practice

1. What does the --depth option do when used with git clone?

easy

A. It compresses the repository to save disk space.

B. It clones all branches including remote ones.

C. It creates a shallow clone with limited commit history.

D. It initializes a new empty repository.

Solution

1. Step 1: Understand the purpose of --depth

   The --depth option limits the number of commits cloned, creating a shallow copy.

2. Step 2: Compare with other clone types

   Unlike a full clone, a shallow clone saves time and space by copying recent commits only.

3. Final Answer:

   It creates a shallow clone with limited commit history. -> Option C

4. Quick Check:

   Shallow clone = limited history [OK]

Hint: Remember: --depth limits commit history depth [OK]

Common Mistakes:

• Thinking --depth clones all branches
• Confusing shallow clone with compression
• Assuming it creates an empty repo

2. Which of the following is the correct syntax to clone a repository with a depth of 5 commits?

easy

A. git clone --depth=5 https://example.com/repo.git

B. git clone -depth 5 https://example.com/repo.git

C. git clone --depth 5 https://example.com/repo.git

D. git clone --deep 5 https://example.com/repo.git

Solution

1. Step 1: Recall correct git clone syntax for depth

   The correct syntax uses --depth with an equals sign or a space and the number, like --depth=5 or --depth 5. Both are valid.

2. Step 2: Identify incorrect options

   git clone -depth 5 https://example.com/repo.git uses a single dash which is invalid. git clone --deep 5 https://example.com/repo.git uses an invalid flag --deep.

3. Final Answer:

   git clone --depth=5 https://example.com/repo.git -> Option A

4. Quick Check:

   Correct syntax = --depth=5 or --depth 5 [OK]

Hint: Use --depth=5 or --depth 5 for shallow clone [OK]

Common Mistakes:

• Using '=' instead of space after --depth (both valid but some prefer equals)
• Typing -depth instead of --depth
• Using --deep instead of --depth

3. What will be the output of the following commands?

git clone --depth 2 https://example.com/repo.git
cd repo
git log --oneline

medium

A. Shows commits from all branches.

B. Shows the full commit history.

C. Shows no commits because depth is too low.

D. Shows only the last 2 commits in the log.

Solution

1. Step 1: Understand shallow clone effect on history

   Using --depth 2 clones only the last 2 commits, so git log shows those.

2. Step 2: Analyze git log --oneline output

   This command lists commits in short form, limited to the shallow clone's depth.

3. Final Answer:

   Shows only the last 2 commits in the log. -> Option D

4. Quick Check:

   Depth 2 clone shows 2 commits [OK]

Hint: Shallow clone limits log to depth commits [OK]

Common Mistakes:

• Expecting full history in shallow clone
• Thinking no commits show if depth is low
• Assuming all branches' commits appear

4. You ran git clone --depth 3 https://example.com/repo.git but later need the full history. What should you do to fix this?

medium

A. Run git fetch --unshallow inside the cloned repo.

B. Delete the repo and clone again without --depth.

C. Run git clone --depth 0 to get full history.

D. Run git pull --depth=full to fetch all commits.

Solution

1. Step 1: Understand how to convert shallow clone to full

   Inside the shallow clone, running git fetch --unshallow downloads the full commit history.

2. Step 2: Evaluate other options

   Deleting the repo and cloning again without --depth works but is inefficient. Options C and D use invalid syntax or commands.

3. Final Answer:

   Run git fetch --unshallow inside the cloned repo. -> Option A

4. Quick Check:

   Use git fetch --unshallow to get full history [OK]

Hint: Use git fetch --unshallow to complete shallow clone [OK]

Common Mistakes:

• Trying to reclone instead of fetching full history
• Using invalid git pull options
• Assuming --depth 0 is valid

5. You want to clone a large repository but only need the last 10 commits of the main branch and no other branches. Which command achieves this efficiently?

hard

A. git clone --depth=10 https://example.com/repo.git

B. git clone --depth 10 --single-branch --branch main https://example.com/repo.git

C. git clone --branch main https://example.com/repo.git

D. git clone --shallow-since=10days https://example.com/repo.git

Solution

1. Step 1: Identify options to limit clone depth and branches

   Use --depth 10 to limit commits and --single-branch --branch main to clone only main branch.

2. Step 2: Check other options for correctness

   git clone --depth=10 https://example.com/repo.git clones all branches shallowly. git clone --branch main https://example.com/repo.git clones full history of main. git clone --shallow-since=10days https://example.com/repo.git uses invalid flag.

3. Final Answer:

   git clone --depth 10 --single-branch --branch main https://example.com/repo.git -> Option B

4. Quick Check:

   Depth + single branch = efficient clone [OK]

Hint: Combine --depth with --single-branch for focused clone [OK]

Common Mistakes:

• Not using --single-branch clones all branches
• Using invalid flags like --shallow-since
• Assuming --depth=10 clones only main branch