Example Lesson - Git Fundamentals

Lesson Notes
Playlist
Transcript

Lesson Notes

This is an example lesson from our Git Fundamentals course.

Frequently Asked Questions

Do the lesson videos play on iPads and iPhones?

Yes, they work on both desktop/laptop computers and iOS devices.

How can I ask questions or get help?

You can ask questions about the lesson or get help with your assignment by posting to the class discussion forums and attending the weekly live Q&A webinars with the instructor.

Do I need to have my own website or hosting account to work on?

No, we will provide you with an online development environment to work with for the duration of the class. This way you can follow along with the videos without messing up your existing website. Working with our development environment also ensures your experience matches what you see in the lessons and allows us to troubleshoot any issues you may have.

Playlist

Transcript

In this video, I'm going to show you how to move and delete files in your Git repository. We'll continue working with the repository that we've created in previous lessons. Let's start by moving files. To move a file, we can use the "git mv" command move is just "mv", which matches the move command on Linux and other Unix-like systems. So let's do an example. Let's move the hello6 file into the hello folder. So we can type "git mv hello6.txt hello" folder. This command will both move the file in the working directory and it will stage the new file snapshot for commit. If I run a git status right now, I can see that it says this file has been renamed. That might sound a little bit strange because of course, we moved it. But the way Git stores file names internally, it sees the different path as being a different file name. So it sees this move as a rename of this file. It hello6 has also been moved actually on our file system. It's not obvious here in the Code Editor yet, but if we press the refresh button up here, we can see that hello6 moves from here into the hello folder. It's also shown in green in the Code Editor file list with an R next to it. This is Code Editor's built in Git functionality. It's detected that this is a staged file, in Git and it's showing us that with the green text. Now, I'm not going to use the built in Git tools to commit this change, because I want to focus on the command line tools. But just so you know, that's why you might see it in a different color over there. To commit this change, I can just run "git commit", like I do for any other changes. So we can say git commit. And we'll pass in the message, the commit message here, "moved hello6.txt". And we'll see the commit message and we'll see that it's been renamed. So that's one way that you can move a file in your Git repository. Another option is just to move the file on the file system, and then stage those changes like you would normally do for any other modifications. So let's try it that way. With hello5.txt. First, let's just move hello5, inside of move it into the hello folder. And we can do that we could do it here on the command line in the terminal. But let's just do it here in the Code Editor, we can just drag it and drop it right up into the hello folder. And it'll get we'll get this prompt: Are we sure? Yes, go ahead and move it and then we see that it's moved up here. And now if we run git status, we can see that get has detected that we've deleted the file hello5.txt, and that we've added a new untracked file, hello/hello5.txt. Now that's not exactly what we did, but it is somewhat true. The file is gone in one location and it's there's a new file in another location. Let's see what happens when we staged to file so we have two files to stage actually we need to stage the deletion, and the new untracked file. So let's just stage all the changes with "get add .". And now let's look at git status again. And hey look, get has figured out that the two files were actually one file that got moved. Okay, it says it's renamed that's exactly what it said before. Now get can tell that because the file name and the file contents are the same. If there were a lot of other changes to the file, get may have continued to view these, this scenario as the deletion and the addition of a new file. But in practice, whether or not get saves it as a rename or a deletion and an addition, it usually doesn't matter that much. So, in any case, we're now in the same situation as if we used the git mv command. So let's commit this file to finish this process up. So we'll just run get commit with a message hello, moved hello5.txt. Alright, so that's how we move a file. Next, let's see how to delete files. It's similar to moving them, we can either use a Git command, or we can just use the file system and stage our changes normally. Let's try it both ways. First, let's use the Git command to delete hello4.txt and we can do that with the command "git rm" for remove "hello4.txt". All right, this like with the move. This will both delete the file from the working directory, and it will stage that change for commit. So if we run git status, we can see that the deletion is staged for commit. And if I refresh the files over here, you can see that hello4 is deleted. So if we want to commit this change, we would just get commit, deleted hello4.txt. And now like with the move command, we can also just delete a file and then use get add to stage the deletion. So let's delete hello3.txt with the Code Editor. So I'll just hover over it, right click and choose Delete permanently. It'll give me a warning. I'll say yes. And now if I run git status over here, we can see that it sees an untracked deletion. So we need to stage that with "git add .". And then we can commit the change, commit, deleted hello3.txt. And that's all there is to it. You can see that moving and deleting files can work with the exact same loop of commands that you used for adding and modifying files. You make your changes to the working directory you use, git add to stage the changes and then commit to commit them to the repository. Now one less thing I want to show you before we wrap up this video is what if you stage a deletion? But then you decide that you really want the file back like maybe you made a mistake. So how can you get it back? Now I'm specifically talking here about before you commit the change. We'll talk about moving between commits and restoring files from older versions in a different video. But let's say that we delete hello2, and stage that for commit. So I'll do it the short way by just using the built in, Git command, "git rm hello2.txt". And the file has been deleted. If I refresh over here, it's now gone. There is no hello2.txt. And it's staged for commit. If I type git status, I can see that here. But now what if I decided that was a mistake, and I want to get hello2 back. Now in a previous video, I showed you that you could use the git reset command to unstaged changes. So you might think that we could do that here and we can try it. So we could try again: "git reset hello2.txt". All right, and we get an error. That didn't work. Because hello2.txt is no longer in the working tree. So what if we so it doesn't know exactly what we're talking about? So what if we try "git reset ." because that would reset every any all the changes in the the working tree. Okay, so that did something. If I run get status now, I can see that the deletion is no longer staged. However, hello2.txt is still deleted. And we can confirm that if we refresh the files over here, you see that hello2 is still missing. So how do we get this file back now? Well, we can do that by telling Git that we want to restore the currently committed version of that file like the most recently committed version. And we do that with the "git checkout" command. We're going to talk about the "git checkout" command in much more detail in other videos. But for now, I just want to show you one use of it, which is that we can use it in this scenario to recover hello.txt or hello2.txt. And we do that by running get checkout hello2.txt. Now, if we refresh the files over here, you'll see hello2 is back. And it does have the original contents in it that it had before we deleted it. And if we run git status, you can see that our working tree is clean. That "git checkout" command told get that we wanted to basically reset the working directory to match what was in the repository at least as far as hello2.txt is concerned. So that's how you can restore a file if you accidentally delete it with Git. Okay, that's all I want to show you about moving and deleting files. In the next video we'll talk about ignoring files from the working directory.