Last modified: June 11, 2024

This article is written in: 🇺🇸

Checking and Understanding Changes in Git

Git's powerful suite of commands offers an insightful look into your codebase's progression. By probing changes, tracking progress, identifying anomalies, and fostering effective collaboration becomes easier.

Viewing Changes

Different commands in Git allow you to peek into modifications:

• List Uncommitted Files:

git status

This reveals which files have changed, added, or deleted but haven't been committed yet.

• View Unstaged Changes:

git diff

Displays differences in files not yet staged.

• See Staged but Uncommitted Changes:

git diff --cached

Unveils differences in files staged but not yet committed.

• Inspect All Changes Since the Last Commit:

git diff HEAD

Shows both staged and unstaged changes.

• Highlight Word-Level Changes:

git diff --word-diff

Rather than line-by-line diffs, this pinpoints changes at the word level.

• Audit a File's Change History:

git blame filename

Provides annotations for each line in a specified file, indicating the last commit that modified the line.

Comparing Commits

Dive deeper into differences between commits:

• Visualize Commit History:

git log

Showcases a chronological list of commits with messages, authors, and dates.

• Contrast Two Specific Commits:

git diff commit_1 commit_2

Details differences between two specified commit IDs.

• Review a File's State at a Given Commit:

git show commit_id:filename

Reveals the state and changes of a specified file at a particular commit.

Tips and Best Practices

1. Descriptive Commit Messages: Ensure your commit messages are clear and descriptive. They serve as a guide to team members and your future self.

2. Review Before Committing: Use git diff before you stage or commit. This helps catch unintended changes.

3. Branching for Large Tasks: For major or extended changes, consider branching. This makes merging easier and allows for concurrent development.

4. Understand the Git Workflow: Get to know Git's stages (working directory, staging area, and commit history). Being familiar with these stages helps avoid errors and streamlines processes.