In this movie we're going to learn how to compare two different commits.
Now when I say compare commits, we're not actually comparing the commit snapshot, just
those changes that were made that are stored with that commit. We're comparing the directory
that that commit references; the actual state of all the files in the repository at that point in time.
And that makes sense because a commit is not just a snapshot of those changes, but it includes
all of the ancestors all the way back to the beginning of the repository as well.
And the sum total of all those ancestors is the directory, or tree, at that point in time
where the commit is.
So when we compare commits what we're actually doing is comparing two directories and seeing
what has changed between those two directories.
Now it might be comparing what's changed over time.
For example, I might be comparing a commit that I made on Monday morning with a commit
that I made on Friday afternoon, and comparing those two directories will show me all of
the changes that have been made during that one week.
Or once we learn about branches, which we'll do in the next chapter, we can compare two
different branches to see how they differ.
What's changed in each of these branches? In order to make these comparisons we're going
to use a tool that's already familiar to us, and that is diff.
When we used it the first time, we just used it simply by saying git diff.
And what that did was it returned the changes that were made between our working directory
and the staging index.
So it's all the things that could be put into our staging area, changes that we had made
recently that were not yet staged.
Once we put them into the staging area, they didn't show up in git diff anymore, you'll
remember we had to add another option to it, which was staged or cached, and those are synonymous.
And what those do is they show us the difference between the staging index and the repository
or HEAD, where the HEAD pointer is pointing.
Well, the diff tool is very flexible and allows us to pass in other things as well so that
we can compare more than just our working directory, staging index, and repository.
If we pass in a SHA that references a commit, it will show us the difference between our
working directory and the directory at the point in time that that commit was made.
So for example, let's do git log --oneline, and let's get a list here, and I'm going to
use this one right here, cdae0ed.
If we say git diff, and then we just pass in that SHA, that reference to the commit,
Moved sunglasses higher in list of suggested outdoor items, now it returns to me all the
differences between the directory at that point in time and my current working directory.
Let's take a look at another one.
Let's go up here, let's pick out one further back, this has lots of changes.
Let's clear our screen, git diff, and in that one, 1506576, hit Return.
And now you see I get lots of changes.
It's showing me all the different things that have changed, including renaming files and
things like that.
I'll hit Q to quit.
Okay, that's nice, because then what we can do is we can compare where we are now against
a previous point in time, basically just looking back. What's changed since this point in time?
And we can be more specific by passing in a specific file.
For example, if we wanted to use that same commit and find out what's different about
the tours.html file only, look it up and tell us.
This is a comparison between this previous point in time and your working directory now.
It's a very handy tool.
Now we don't just have to use our working directory, we can actually compare any two commits at all.
We can just pass in two different tree-ishes using a range.
We saw the range before when we were working with the log file, so it's just between two arbitrary commits.
Let's do git log --oneline again, so we can see a list of those commits.
Let's compare these two commits right here, the two that start with c.
What changed between these two? Let's do git diff and the first one, followed by dot dot
and then the second one, and that's it.
The snapshot at this point in time versus the snapshot at another point in time, show
me what changed between them, and this will give us a summary of all the things that have changed.
Now if we're only interested in what changed in the tours file, same thing html, look them up
and tell us nothing actually changed between those two points in time.
Now again, you can pass in any tree-ish here, so if you wanted to say git log --oneline,
and we want to compare this versus HEAD, git diff ..HEAD, we can compare that.
If we want to say git diff ..HEAD parent-parent, we can do that, all those tricks that we learned
about how to reference commits, we can use here.
You can look through the help documentation, and there are lots of modifiers and options
that you can use with diff.
However, I just want to show you a couple that I think are especially useful.
Let's just get our git log --oneline again, and let's just go ahead and start from almost
the beginning, git diff, and then we'll just go from there to HEAD.
The first options that I think are useful is that we can do stat and summary, and you
can use either one of these or both together, and they'll show you summary of what's changed,
a list of the files with an idea of how many things changed in there, things that were
added, things that were removed.
And then the other two that I think are especially useful are the b and w options.
Let's take this out.
And you won't actually see any difference here, because I don't have any, but the -b
option is the same thing as the longer ignore-space-change.
So it changes to white space.
So it will ignore whether or not someone changed one space to two spaces, four spaces to five
spaces, it ignores that, that's the b option.
The other one that you can use is the w option, which is ignore-all-space. It ignores every
single change that could be made to space, it just says forget about it.
Now that's a long thing to type, so the shorter one for each one is just to type b and w.
So b is for ignore-space-changes, w is to ignore-all-spaces, everything having to do
with space whatsoever completely forgotten about.
This can be helpful, because most of the time simple space changes are not something that
you really care about that much when you're looking at your code. You really care more
about the characters that have changed, spacing is often insignificant.
So we now have some powerful tools at our disposal for navigating the commit tree.
We can take a look at the directory structure, we can look through the logs, we can view
commits, and we can compare two different commits at to two different points in time.
These are powerful tools and learning how to use them well is going to help you get
the most out of Git.