How to Commit Partial Changes of a File with Git

Introduction

In version control systems like Git, it’s common to modify files and want to commit only specific parts of those changes. This ability is particularly useful when you’re working on multiple features or bug fixes in the same file simultaneously. In this tutorial, we’ll explore various methods to commit partial changes of a file in Git.

Understanding Hunks

Git breaks down your changes into "hunks" – logical portions of code that were changed together. This hunk-based system allows you to selectively stage and commit only certain parts of the modifications made to a file. By understanding how to interact with these hunks, you can gain precise control over what changes go into each commit.

Methods for Committing Partial Changes

1. Interactive Staging with git add -p

The command git add --patch <filename> (or its shortcut git add -p <filename>) lets you interactively stage parts of the file. Git will present you with hunks one by one, offering several options:

• y: Stage this hunk.
• n: Do not stage this hunk.
• q: Quit; do not stage any more hunks.
• a: Stage this and all later hunks in the file.
• d: Do not stage this or any later hunks in the file.
• g: Select a specific hunk to go to.
• /: Search for a hunk matching a given regex pattern.
• s: Split the current hunk into smaller ones.
• e: Manually edit this hunk (useful for complex changes).
• ?: Display help on these options.

To ensure Git recognizes unstaged files, use git add -N <filename> before using -p.

2. Interactive Mode with git commit --interactive

Git’s interactive mode allows you to edit commits interactively. Using git commit --interactive, you can:

• Reorder or squash previous commits.
• Amend the last commit message without altering its content.
• Use patches to selectively include changes in your new commit.

3. Editing with git add -e

Using git add -e <filename>, Git opens an editor displaying all modifications as a diff. In this view:

• +: Added lines. Delete these lines to exclude them from staging.
• -: Removed lines. Change - to a space to keep the line in your working directory but not stage it for removal.
• Modified Content: Consists of a pair of - (removed) and + (added) lines. Adjust both to control the staged changes.

4. Using Git GUI Tools

For those who prefer graphical interfaces, tools like git gui, QGit, or GitX provide visual ways to stage specific parts of a file:

• Right-click on the diff view line(s).
• Choose “Stage this line for commit” or "Stage Lines For Commit" to select specific changes.

5. Visual Studio Code Integration

If you use VS Code as your editor, you can easily stage selected lines directly from the editor:

• Select the range of code you want to stage.
• Use the command Git: Stage Selected Ranges to commit these lines selectively.

Best Practices and Tips

1. Review Changes: Always run git diff --staged before committing to ensure only intended changes are staged.
2. Unstage Mistakes: If you accidentally stage unwanted hunks, use git reset -p to unstage them.
3. Commit Message Review: Use git commit -v for a verbose commit message editor to review the staged changes while writing your message.

By mastering these techniques, you can keep your Git history clean and focused on specific changes, making it easier to understand and maintain over time.