Debugging
git bisect
Description
It is used to perform a binary search to find the commit that introduced a bug or issue in the codebase. By systematically checking out and testing commits, git bisect
helps to narrow down the exact commit where the problem started. This process significantly speeds up the debugging process, especially in large projects with many commits.
Usage
git bisect [<subcommand> | <options>]
-- Start the Bisecting Process
git bisect start
-- Mark a Commit as Bad
-- Marks the current commit (or specified commit) as containing the bug
git bisect bad [<commit>]
-- Mark a Commit as Good
-- Marks the current commit (or specified commit) as not containing the bug
git bisect good [<commit>]
-- Skip a Commit
-- Skips the current commit (or specified commit) if it can't be tested (e.g., doesn't compile)
git bisect skip [<commit>]
-- Visualize the Bisecting Process
git bisect visualize
-- Reset the Bisecting Process
-- Ends the bisecting process and returns to the original branch
git bisect reset
Example Workflow
-- Start the Bisecting Process
git bisect start
-- Mark the Current Commit as Bad
-- This is the commit where we know the bug is present
git bisect bad
-- Mark an Older Commit as Good
-- This is a commit where we know the bug is not present.
git bisect good <known-good-commit>
-- Test the Suggested Commit
-- git bisect will now check out a commit halfway between the good and bad commits. We test this commit (e.g., run your tests or check if the bug is present) and then mark it as good or bad.
-- If the commit is good
git bisect good
-- If the commit is bad
git bisect bad
-- If the commit cannot be tested (e.g., it doesn't compile)
git bisect skip
--Repeat:
-- Continue the process until git bisect identifies the first bad commit. git bisect will narrow down the commit range step by step until it finds the problematic commit.
-- Reset the Bisecting Process:
-- Once we have identified the bad commit, reset the bisecting process
git bisect reset
Example Output
During the bisecting process

git grep
Description
It is used to search through the contents of files in a Git repository. It is similar to the Unix grep
command but specifically optimized for searching within a Git repository. This command is useful for finding specific text patterns, code snippets, or occurrences of keywords across your codebase.
Usage
git grep [<options>] <pattern> [-- <paths>…]
Options
-i
: Perform a case-insensitive search.
-n
: Show line numbers of matches.
-c
: Count the number of matches in each file.
-v
: Invert match to show lines that do not match the pattern.
-l
: Show only the names of files containing matches.
-L
: Show only the names of files not containing matches.
--and
: Combine multiple patterns with a logical AND
--or
: Combine multiple patterns with a logical OR.
--not
: Exclude matches for a pattern
--recurse-submodules
: Search in submodules recursively
git grep -i "search_term"
git grep -n "search_term"
git grep -c "search_term"
git grep -v "search_term"
git grep -l "search_term"
git grep -L "search_term"
git grep --and -e "pattern1" -e "pattern2"
git grep --or -e "pattern1" -e "pattern2"
git grep --not -e "exclude_pattern"
git grep --recurse-submodules "search_term"
What It Does
Searches for Patterns: Finds occurrences of a specified pattern in the files tracked by Git.
Filters by Path: Limits the search to specific directories or files if paths are provided.
Supports Various Options: Offers a range of options to customize the search, such as case-insensitivity, counting matches, and showing line numbers.
Common Use Cases
-- Search for a Pattern in the Repository
-- Finds all occurrences of search_term in the repository
git grep "search_term"
-- Search in a Specific Directory or File
-- Limits the search to the specified directory or file
git grep "search_term" -- path/to/directory
git grep "search_term" -- path/to/file.txt
-- Search Case-Insensitive
-- Performs a case-insensitive search for search_term
git grep -i "search_term"
-- Count the Number of Matches
-- Displays the number of matches in each file
git grep -c "search_term"
-- Show Line Numbers
-- Shows the line numbers of matches in the output
git grep -n "search_term"
Example Workflow
-- finds all occurrences of "TODO" in the repository
git grep "TODO"
-- searches for "main" in src/main.c
git grep "main" -- src/main.c
-- case-insensitive search for "error"
git grep -i "error"
-- count the number of matches for "def" in each file
git grep -c "def"
-- show line numbers for each match of "function"
git grep -n "function"
Example Output
When running git grep "search_term"

git fsck
Description
It is used to perform an integrity check on a Git repository. It verifies the connectivity and validity of the objects in the database, ensuring that everything is intact and that there are no corrupted objects. This command is particularly useful for diagnosing issues within the repository, such as broken links between commits, missing objects, and other potential data integrity problems.
Usage
git fsck [<options>]
Options
--full
: Perform a full check, including looking for missing objects.
--unreachable
: Print objects that are unreachable from any of the reference nodes.
--lost-found
: Write dangling objects into .git/lost-found
--name-objects
: Show object names
--progress
: Show progress information during the check.
--strict
: Enable more strict checking
--dangling
: Show dangling objects
git fsck --full
git fsck --unreachable
git fsck --lost-found
git fsck --name-objects
git fsck --progress
git fsck --strict
git fsck --dangling
What It Does
Verifies Object Connectivity: Ensures that all objects referenced by commits, trees, and other objects are present and properly linked.
Checks Object Validity: Validates the contents of each object to make sure they are correct and uncorrupted.
Reports Issues: Identifies and reports any issues found during the integrity check, such as dangling commits, missing blobs, or corrupted objects.
Common Use Cases
-- Basic integrity check on the repository, reporting any issues found
git fsck
-- Performs a more thorough check, including looking for missing objects and ensuring all objects are correctly linked.
git fsck --full
-- Shows progress information during the integrity check, useful for large repositories
git fsck --progress
Example Output
When running git fsck

Last updated
Was this helpful?