Git download specific file

In the first article in this series on getting started with Git, we created a simple Git repo and added a file to it by connecting it with our computer. In this article, we will learn a handful of other things about Git, namely how to clone (download), modify, add, and delete files in a Git repo.

Let's make some clones

Let's clone the repo, called Demo, we created in the last article. (If you have not yet created a Demo repo, jump back to that article and do those steps before you proceed here.) To clone your file, just open your browser and navigate to (where is the name of your own repo. For example, my repo is ). Once you navigate to that URL, click the "Clone or download" button, and your browser should look something like this:

As you can see above, the "Clone with HTTPS" option is open. Copy your repo's URL from that dropdown box (). Open the terminal and type the following command to clone your GitHub repo to your computer:

Then, to see the list of files in the  directory, enter the command:

Your terminal should look like this:

Modify files

Now that we have cloned the repo, let's modify the files and update them on GitHub. To begin, enter the commands below, one by one, to change the directory to , check the contents of , echo new (additional) content to , and check the status with :

This is how it will look in the terminal if you run these commands one by one:

Let's look at the output of and walk through what it means. Don't worry about the part that says:

because we haven't learned it yet. The next line says: ; this is telling you that the files listed below it aren't marked ready ("staged") to be committed. If you run , Git takes those files and marks them as ; in other (Git) words, . Before we do that, let's check what we are adding to Git with the command, then run .

Here is your terminal output:

Let's break this down:

• is what Git is comparing (i.e., in this example).
•  would show anything removed from the file.
•  would show anything added to your file.
• Anything added to the file is printed in green text with a + at the beginning of the line.
• If we had removed anything, it would be printed in red text with a - sign at the beginning.
• Git status now says  and lists the filename (i.e., ) and what happened to that file (i.e., it has been and is ready to be committed).

Tip: If you have already run , and now you want to see what's different, the usual  won't yield anything because you already added the file. Instead, you must use . It will show you the difference between the current version and previous version of files that Git was told to add. Your terminal output would look like this:

Upload a file to your repo

We have modified the file with some new content and it's time to upload it to GitHub.

Let's commit the changes and push those to GitHub. Run:

This tells Git that you are "committing" to changes that you have "added" to it. You may recall from the first part of this series that it's important to add a message to explain what you did in your commit so you know its purpose when you look back at your Git log later. (We will look more at this topic in the next article.) is the message for this commit—if you don't think this is the most logical way to explain what you did, feel free to write your commit message differently.

Run . This will prompt you for your username and password, then upload the file to your GitHub repo. Refresh your GitHub page, and you should see the changes you just made to .

The bottom-right corner of the terminal shows that I committed the changes, checked the Git status, and pushed the changes to GitHub. Git status says:

The first line indicates there is one commit in the local repo but not present in origin/master (i.e., on GitHub). The next line directs us to push those changes to origin/master, and that is what we did. (To refresh your memory on what "origin" means in this case, refer to the first article in this series. I will explain what "master" means in the next article, when we discuss branching.)

Add a new file to Git

Now that we have modified a file and updated it on GitHub, let's create a new file, add it to Git, and upload it to GitHub. Run:

This will create a new file named .

If you it out:

You should see the contents of the file. Now run:

Git reports that you have an untracked file (named ) in your repository. This is Git's way of telling you that there is a new file in the repo directory on your computer that you haven't told Git about, and Git is not tracking that file for any changes you make.

We need to tell Git to track this file so we can commit it and upload it to our repo. Here's the command to do that:

Your terminal output is:

Git status is telling you there are changes to  to be committed, and that it is a to Git, which it was not aware of before this. Now that we have added to Git, we can commit the changes and push it to origin/master.

Git has now uploaded this new file to GitHub; if you refresh your GitHub page, you should see the new file, , in your Git repo on GitHub.

With these steps, you can create as many files as you like, add them to Git, and commit and push them up to GitHub.

Delete a file from Git

What if we discovered we made an error and need to delete from our repo. One way is to remove the file from our local copy of the repo with this command:

If you do now, Git says there is a file that is and it has been from the local copy of the repo. If we now run:

I know we are deleting the file, but we still run because we need to tell Git about the change we are making. can be used when we are adding a new file to Git, modifying contents of an existing file and adding it to Git, or deleting a file from a Git repo. Effectively, takes all the changes into account and stages those changes for commit. If in doubt, carefully look at output of each command in the terminal screenshot below.

Git will tell us the deleted file is staged for commit. As soon as you commit this change and push it to GitHub, the file will be removed from the repo on GitHub as well. Do this by running:

Now your terminal looks like this:

And your GitHub looks like this:

Now you know how to clone, add, modify, and delete Git files from your repo. The next article in this series will examine Git branching.