Git Ignore and .gitignore

Last Updated : 26 Jul, 2025

Git Ignore is an important feature in Git that allows you to specify which files and directories should be excluded from being tracked in a repository. This is particularly useful when you want to keep your repository clean and free from unnecessary files, such as log files, compiled binaries, or sensitive configuration files.

Importance of Ignoring Files in Git

  • Prevent accidental commits of sensitive or irrelevant data
  • Reduce clutter from local environment or temporary files
  • Improve collaboration by using consistent ignore rules

Understanding the .gitignore File

The .gitignore file is a simple text file that tells Git which files or directories to ignore in a project. It can be placed at the root of your repository or in any subdirectory. Each line in the .gitignore file specifies a pattern that matches one or more files.

When Git sees a file that matches a pattern in the .gitignore file, it will not track changes to that file. This means the file will not be added to the staging area, committed or included in the version history.

Creating and Configuring a .gitignore File

Before we start creating .gitignore file, firstly we will understand Basic Syntax, Patterns and Rules.

Basic Syntax and Rules in .gitignore

The syntax used in a .gitignore file is simple yet powerful. Here are some basic rules to follow:

  • Each line in the file is treated as a separate pattern.
  • Empty lines or lines starting with # are ignored and can be used for comments.
  • Patterns can be specified using wildcards, negation, and directory matching.

Common Patterns in .gitignore

1. Wildcards (*, **)

Wildcards allow you to match multiple files or directories:

  • * matches any number of characters (except for /).
  • ** matches directories recursively.

Syntax:

# Ignore all files with the .log extension
*.log

# Ignore all files in any subdirectory named temp
temp/**/*

2. Negation (!)

You can use negation to include files that would otherwise be ignored. This is useful when you want to ignore all files in a directory but keep a specific file.

Syntax:

# Ignore all .log files
*.log

# But do not ignore important.log
!important.log

3. Directory Matching (/)

Using / at the beginning of a pattern specifies that the pattern is relative to the root of the repository. It helps to distinguish between files with the same name in different directories.

Syntax:

# Ignore only the log.txt file in the root directory
/log.txt

# Ignore all log.txt files in all subdirectories
**/log.txt

Steps to Create a .gitignore File

Before we start make sure to initialize the project by using following command:

git init

Step 1: Create the File

At the root of your project directory, create a file named .gitignore. You can use a text editor or command line to create the file.

touch .gitignore

Step 2: Add Patterns to Ignore

Open the .gitignore file in your text editor and add file or directory patterns that you want Git to ignore. 

# Ignore node_modules directory
node_modules/

# Ignore log files
*.log

# Ignore environment files
.env

# Ignore OS-specific files
.DS_Store
Thumbs.db

Step 3: Verify Ignored Files

You can verify which files are being ignored by using the following command. Before using that command make sure to execute git init then git add . command to see the ignored file in a status.

ignored-files

Examples of .gitignore Usage

Here, we will see the example of different scenarios.

Ignoring Specific Files and Directories

To ignore specific files or directories, simply specify their paths or patterns in the .gitignore file. 

# Ignore the config file
config.yaml

# Ignore all files in the cache directory
cache/

Ignoring Files by Extension

You can ignore all files of a specific extension. For instance to ignore all .tmp files:

# Ignore temporary files
*.tmp

*.log

Common .gitignore Patterns

Here are some common patterns used in .gitignore files:

# Node.js Project

# Ignore node_modules directory
node_modules/

# Ignore logs
npm-debug.log*


#Python Project

# Ignore Python bytecode
__pycache__/
*.py[cod]

# Ignore virtual environments
venv/

Ignoring Files Across Different Operating Systems

Different operating systems create specific files that are often unnecessary to include in your repository. To ignore these system files, you can add the following patterns:

# macOS
.DS_Store

# Windows
Thumbs.db

Advanced .gitignore Techniques

Using Multiple .gitignore Files

You can have multiple .gitignore files in different directories within your project. Patterns defined in a subdirectory's .gitignore will apply only to files in that directory and its subdirectories.

Global .gitignore Configuration

You can set up a global .gitignore file that applies to all repositories on your machine. This is useful for ignoring files like IDE settings or OS-specific files.

Steps to Configure .gitignore global:

Step 1: Create a global .gitignore

 touch ~/.gitignore_global

Step 2: Configure Git to use it

git config --global core.excludesfile ~/.gitignore_global

Step 3: Add common patterns to the global .gitignore:

# Ignore macOS specific files
.DS_Store

# Ignore Visual Studio Code settings
.vscode/

Excluding Files Already Tracked by Git

If you want to ignore files that are already tracked by Git, you need to untrack them first.

Step 1: Stop tracking the file while keeping it locally

 git rm --cached <file>

Step 2: Add the file to .gitignore

echo "secrets.json" >> .gitignore

Step 3: Commit the changes

git commit -m "Stop tracking secrets.json"

Note: Here secrets.json is a filename.

Additional Ignore Mechanisms

.git/info/exclude

Works like .gitignore but is local-only and not versioned.

echo "local.env" >> .git/info/exclude

Path Depth Matching

logs/**/*.log    # Recursively ignore all .log in logs/
/logs/*.log      # Only top-level logs

Best Practices for Using .gitignore

  • Adding .gitignore Early in Project Development: It's best to create and configure your .gitignore file before starting development to prevent unnecessary files from being tracked from the beginning.
  • Treating .gitignore as Source Code: Keep your .gitignore file in version control, just like any other source code file so it can be shared with collaborators.
  • Reusing Existing .gitignore Templates: You can find pre-made .gitignore templates for various programming languages and frameworks on sites like GitHub.
  • Regularly Updating and Reviewing .gitignore: As your project evolves, regularly review and update your .gitignore file to ensure it still meets your needs.

Common Pitfalls and Troubleshooting

  • Issues with Tracking and Ignoring Files: If you find that a file is still being tracked despite being added to .gitignore, ensure that the file was not already committed before it was added to the .gitignore file.
  • Debugging .gitignore Patterns: If you’re having trouble with patterns in your .gitignore file. you can use the git check-ignore command to see why a file is being ignored:
git check-ignore -v <file>
  • Case Sensitivity in .gitignore: Be mindful of case sensitivity in your patterns, as Git is case-sensitive. For instance, *.jpg will not match image.JPG. To handle this, specify both cases if necessary.
Comment

Explore