How to ignore certain files in Git

How to ignore new files

Globally

Add the path(s) to your file(s) which you would like to ignore to your .gitignore file (and commit them). These file entries will also apply to others checking out the repository.

Locally

Add the path(s) to your file(s) which you would like to ignore to your .git/info/exclude file. These file entries will only apply to your local working copy.

How to ignore changed files (temporarily)

In order to ignore changed files to being listed as modified, you can use the following git command:

git update-index --assume-unchanged <file1> <file2> <file3>

To revert that ignorance use the following command:

git update-index --no-assume-unchanged <file1> <file2> <file3>

Add the following line to file .gitignore:

/Hello.class

This will exclude Hello.class from Git. If you have already committed it, run the following command:

git rm Hello.class

If you want to exclude all class files from Git, add the following line to .gitignore:

*.class

On Windows

1. Create a .gitignore file. To do that, you just create a .txt file and change the extension as follows:

   

Then you have to change the name, writing the following line in a cmd window:

 rename git.txt .gitignore

Where git.txt is the name of the file you've just created.

Then you can open the file and write all the files you don’t want to add on the repository. For example, mine looks like this:

# OS junk files
[Tt]humbs.db
*.DS_Store

# Visual Studio files
*.[Oo]bj
*.user
*.aps
*.pch
*.vspscc
*.vssscc
*_i.c
*_p.c
*.ncb
*.suo
*.tlb
*.tlh
*.bak
*.[Cc]ache
*.ilk
*.log
*.lib
*.sbr
*.sdf
*.pyc
*.xml
ipch/
obj/
[Bb]in
[Dd]ebug*/
[Rr]elease*/
Ankh.NoLoad

# Tooling
_ReSharper*/
*.resharper
[Tt]est[Rr]esult*

# Project files
[Bb]uild/

# Subversion files
.svn

# Microsoft Office temporary files
~$*

Once you have this, you need to add it to your Git repository. You have to save the file where your repository is.

Then in Git Bash you have to write the following line:

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

If the repository already exists then you have to do the following:

1. git rm -r --cached .
2. git add .
3. git commit -m ".gitignore is now working"

If step 2 doesn’t work, then you should write the whole route of the files that you would like to add.

You can use the below methods for ignoring/not-ignoring changes in tracked files.

1. For ignoring: git update-index --assume-unchanged <file>
2. For reverting ignored files: git update-index --no-assume-unchanged <file>

Create a .gitignore file in the directory where directory .git is. You can list files in it separated by a newline. You also can use wildcards:

*.o
.*.swp

From the official GitHub site:

If you already have a file checked in, and you want to ignore it, Git will not ignore the file if you add a rule later. In those cases, you must untrack the file first, by running the following command in your terminal:

git rm --cached FILENAME

or

git rm --cached .

1. Go to .gitignore file and add the entry for the files you want to ignore
2. Run git rm -r --cached .
3. Now run git add .

You should write something like

*.class

into your .gitignore file.

First create a .gitignore file where we have to store the names of files and directories to be ignored.

To ignore a directory;

name_of_directory/

To ignore a file;

name_of_file

We don't need to provide the complete path of the file or directory to be ignored; we just have to provide its name.

If you want to ignore all files with same extension;

*.pyc  #will ignore all files with pyc extention

Also the above things will only work at the first time when you have not added the files to Git. But if my mistake you added a file to Git and now you want it to be ignored for the rest of the commits, you need to first clear the Git cache regarding that file by running this command;

git rm -r --cached <path_of_the_file>

And the rest is the same, i.e, add the name to the .gitignore file.

Add which files you want to ignore to file .gitignore:

*.class

*.projects

*.prefs

*.project

If you have already committed the file and you are trying to ignore it by adding to the .gitignore file, Git will not ignore it. For that, you first have to do the below things:

git rm --cached FILENAME

If you are starting the project freshly and you want to add some files to Git ignore, follow the below steps to create a Git ignore file:

1. Navigate to your Git repository.
2. Enter "touch .gitignore" which will create a .gitignore file.

By creating a .gitignore file. See here for details: Git Book - Ignoring files

Also check this one out: How do you make Git ignore files without using .gitignore?

Use:

git reset filename
git rm --cached filename

Then add your file which you want to ignore. Then commit and push to your repository.

You can also use .gitattributes (instead of .gitignore) to exclude entire filetypes. The file is pretty self-explanatory, but I'm pasting the contents here for reference. Pay attention to the last line (*.class binary):

# Denote all files that are truly binary and should not be modified.
*.png binary
*.jpg binary
*.gif binary
*.ico binary
*.mo binary
*.pdf binary
*.phar binary
*.class binary

I had a similar issue with file "dump.rdb".
I tried adding this file in various ways to .gitignore file, but only one way worked.

Add your filename, at the end of .gitignore file

NOTE: Adding the file anywhere else didn't work.

For example, see: https://gitlab.com/gitlab-org/gitlab-ce/raw/b3ad3f202478dd88a3cfe4461703bc3df1019f90/.gitignore

I tried this -

1. List files which we want to ignore

   git status .idea/xyz.xml .idea/pqr.iml Output .DS_Store

2. Copy the content of step#1 and append it into the .gitignore file.

   echo " .idea/xyz.xml .idea/pqr.iml Output .DS_Store" >> .gitignore

3. Validate

   git status .gitignore

Likewise, we can add a directory and all of its subdirectories and files which we want to ignore in Git status using directoryname/*. I executed this command from the src directory.

To remove already commited/staged file from GIT git rm --cached <file_name> Add the following line to file .gitignore: /<file_name> If you want to exclude all class files from Git, add the following line to .gitignore:*<file_extension>

To ignore a file in Git, create a .gitignore file in the root directory of your project. This file contains a list of files that should be ignored by Git.

Here are some of my steps for creating and ignoring files.

• Create a .gitignore in your project

• Inside the .gitignore file add a names of a file you want to ignore for example api_keys.txt and add the following lines in your .gitignore file.

• Run the following commands to stage and commit the modifications to your .gitignore file:

  git add .gitignore git commit -m "Add .gitignore file"

• Git will only disregard files that haven't been committed to your Git repository yet, so keep that in mind. If you want to ignore a file that you have already committed, you must first remove it from your Git repository before adding it to your .gitignore file:

  git rm --cached api_keys.txt

The file will no longer be present in the Git repository but will remain on your local file system. After that, you may add it to your .gitignore file and push the modifications.

Add the following line to .git/info/exclude:
Hello.class

This webpage may be useful and time-saving when working with .gitignore.

It automatically generates .gitignore files for different IDEs and operating systems with the specific files/folders that you usually don't want to pull to your Git repository (for instance, IDE-specific folders and configuration files).

If any file is added to Git before, then remove that file and add that file in .gitignore.

Example: if have trouble ignoring the package.resolved file generated during adding an spm dependency.

I have added below lines to my .gitignore file:

Packages/
Package.pins
Package.resolved
*.xcworkspace

and removed the package.resolved file. Now Git starts ignoring my package.resolved file.

If you want to ignore certain files, follow the below steps

1. get inside the .git folder located in your working directory.
2. get inside the "info" folder.
3. you will find a file with the name "exclude".
4. add filenames of which you want to ignore into this file.

If you don't see .git folder in your directory, in the file-explorer view panel just check the Hidden-item field.

I have tried the --assume-unchanged and also the .gitignore but neither worked well. They make it hard to switch branches and hard to merge changes from others. This is my solution:

When I commit, I manually remove the files from the list of changes

Before I pull, I stash the changed files. And after pull, I do a stash pop.

1. git stash
2. git pull
3. git stash pop

Step 3 sometimes will trigger a merge and may result in conflict that you need to resolve, which is a good thing.

This allows me to keep local changes that are not shared with others on the team.

The one case you might be experiencing is that .gitignore won't ignore the files you committed before. You should first remove or move those files from the repository, commit the changes you just did, and then add "*.class" to .gitignore.

Straight from Atlassian: .gitignore

If you want to ignore a file that you've committed in the past, you'll need to delete the file from your repository and then add a .gitignore rule for it.

Using the --cached option with git rm means that the file will be deleted from your repository, but it will remain in your working directory as an ignored file.

You should still have the file in your working directory, but it will not be able to pushed to your remote repository, unless you force it.

You can as well use for example Sourcetree and pressing rmb at files that you added to the branch and was modified, and then select "stop tracking". This file will be now designated with a question mark icon and when you once again rmb at this file, you can now select "Ignore". This will add this certain file to gitgnore by its relative path.

Ignoring a previously committed file

If you want to ignore a file that you've committed in the past, you'll need to delete the file from your repository and then add a .gitignore rule for it. Using the --cached option with git rm means that the file will be deleted from your repository, but will remain in your working directory as an ignored file.

$ echo name_of_file >> .gitignore

$ git rm --cached name_of_file
rm 'name_of_file'

$ git commit -m "Start ignoring name_of_file"

You can omit the --cached option if you want to delete the file from both the repository and your local file system.

Straight from Atlassian: .gitignore

For compiled code, just write:

.class or .o