Easy-to-follow video tutorials help you learn software, creative, and business skills.Become a member
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.
Get unlimited access to all courses for just $25/month.Become a member
82 Video lessons · 98788 Viewers
61 Video lessons · 86110 Viewers
71 Video lessons · 69964 Viewers
56 Video lessons · 102206 Viewers
Access exercise files from a button right under the course name.
Search within course videos and transcripts, and jump right to the results.
Remove icons showing you already watched videos if you want to start over.
Make the video wide, narrow, full-screen, or pop the player out of the page into its own window.
Click on text in the transcript to jump to that spot in the video. As the video plays, the relevant spot in the transcript will be highlighted.
Your file was successfully uploaded.