In the previous chapters we saw that git does a really good job of noticing new
files as well as changes to existing files in our working directory.
In fact, as soon as we added a new file to our working directory Git noticed and
added it to the list of untracked files.
So, for example, if I take this tempfile.txt and drop it into my
project directory, I can say git status and right away git recognizes
this is an untracked file.
But what if this is in fact a temporary file that we don't care about or what if
it's a log file that's constantly changing, git would constantly be prompting us
to commit those changes to the repository. Instead, what we really want is a way
to tell Git just ignore the files altogether, that's what we're going to learn
how to do in this chapter.
To tell Git which files it ought to ignore, we're going to create a special file in the root of
our project, in the root of the working directory.
And that file is going to be called .gitignore, so it's all run together, no
spaces or punctuation except for the Period
at the beginning, .gitignore this file is going to provide Git with a set
of rules that it can use to know which files to use for commits and which
ones should be ignored.
Those rules can be very simple, just a list of files one for each line or we
can get little fancier, and you some very basic regular expressions.
We can use the Asterisk, the Question Mark, a bracket of characters, a
character set, or a range like 0-9.
So it's really pretty limited, we just have some basic wildcards that we can use.
We can also negate expressions by putting an exclamation point in them.
So, for example, we could say ignore any file that ends in .php. We're using the
asterisk wildcard for one or more characters, so one or more characters
ending in .php will get ignored but don't ignore index.php.
Don't let it confuse you this sort of a double-negative, we're talking about not
ignoring things, that means these would be tracked.
So files ending in .php don't get tracked, but index.php does get tracked.
And you can tell to ignore all files in a directory by just having a trailing
slash at the end, and that will tell that all files in this directory should be ignored.
If you want to add comments to the file, you can start those with the Pound or
Hash sign at the beginning, and blank lines will just be basically skipped.
Let's try creating a gitignore file.
Now you can create the gitignore file a number of different ways. You can simply
open up your Text Editor and create it that way.
But I think because it has a dot
in front of it which makes it hard to see anywhere except from command line,
it's best to create the file from the command line.
So I'm going to use a Unix command nano which will bring up a text editor that I
can use to edit that.
Now if you're doing this on Windows, even though you maybe using a Unix-like
environment, you still may not have access to the nano program.
You can try and see if it works.
But if it doesn't work then you'll need to fallback using another Text Editor,
and Notepad is probably the simplest one that you know you're going to have a
Windows, this is the most basic Text Editor there is, and you can find that in
your applications, and then you just save the file as .gitignore and make sure
you have the Save As type field set to be All files, and then I'll make sure it
doesn't put a file extension at the end or just be .gitignore with nothing after
it, and you'll save that file in your Explore California directory.
Now since I'm on Unix, and I do have access to nano, I'm going to type nano and
then .gitignore. This is going to create a new file called gitignore in the
directory that I'm in right now which you can see is my project directory, so
let's create that new file there, and let's start by just putting in that we
wanted to ignore tempfile.txt, and then you can see down here it says Exit is
this character here followed by the X, that's the Ctrl key, so Ctlr+X, we'll
exit out of there, save changes, and we'll type a Y for Yes, file name to write
it to is gitignore, we'll hit Return to accept that.
And now if we do ls -la, we see gitignore file has been added.
So let's do a git status now, and now you can see that that temp file is no longer listed there.
So we're not seeing the temp file as being a file that's not tracked.
However, we have a new file there, which is gitignore.
Don't ignore that file--or you don't want to tell Git to ignore that--we want to commit
that file to our repository.
We want that to be included with the project, this is the project's gitignore
file, it's the files that may show up in the project that everyone is going to
want to ignore, so we're just always going to include it with the project we
will want to commit that.
And before we actually commit it, though, let's just try a few more things, nano,
let's open up gitignore again.
And this time I'm going to change it to just use the Asterisk, so
anything that is .txt.
Now if I did this, it's going to ignore not just that one file but any other file
in this directory that ends in .txt.
All the .html files would still be tracked, so let's just do Ctrl+X to save the
changes, type a Y and return, and that will save it, git status again, and you
can see that it still is ignoring that temp file.
If you want to do gitignore, we can put a Pound sign at the front that makes
it a comment, right? Comments are done like that.
Now I'll just save it again and git status. Now that rule is no longer in
effect, now it says I see two files there, I see our gitignore file, and I see
that temp file again. All right!
So before we actually committed let's add a few more entries to it now that we
kind of have a feel for how it works.
Now the only file that we really want to ignore at the moment is that temp file,
so let's do tempfile.txt, and let's add a few others in here.
And in the next movie we'll talk about the different kinds of things that you
should can ignore but I am going to give you some samples.
We're going to list the .DS_Store file that's a file that shows up on Macintosh,
that's something that the operating system uses.
We're going to tell it to ignore all files that end in .zip and .gz.
That's files that have been compressed into a single file, and let's say log files.
Let's say we have a directory called log and anything in that directory that
ends in .log we're going to ignore.
In addition to that, if we use log rotate on our log files it's going to append
a number at the end. So anything that is 0-9 at the end we also want to ignore.
Let's imagine that we have in our assets directory some Photoshop files that we
used to create the graphics. Well, we can tell to ignore all Photoshop files that are in there.
Let's say we have some videos, we can tell it to ignore all the videos, but
let's say there are some videos that we do want.
Well, let's tell what videos do we want it to track. We'll tell it
not to ignore videos/tour_*.mp4.
So anything that starts with tour_ and ends in .mp4 in the videos directory is
still going to be tracked.
Okay, so that gives you some idea of some of the kinds of ways that we can use this file.
Now here's my question for you, would log/archive/access.log be ignored?
Look there at the entry for log right here and decide whether you think that it
would be ignored or not.
The answer is no, it would not. This is only going to apply to files.
So this wild card is for characters that would be part of the file name, it would not
include archive and the slash in front of it.
So if you have folders nested inside of folders, you'll need to be careful about that.
So now that we've finished working with our file, I'm going to use Ctrl+X to
exit, Y to save my changes, and Return to save it to the same file name.
Let's do git status again, I'll just clear my screen, so we see our gitignore
file listed, let's now add that to our repository, git add .gitignore and then
git commit -m "Add . gitignore file". So there it is.
Now we do git status, and we don't see it, but as you can see our tempfile.txt
is still in there. It's just being ignored.