Upload New Files to Github Using Command Line

Git Add

The git add command adds new or changed files in your working directory to the Git staging area.

git add is an of import command - without it, no git commit would ever do anything. Sometimes, git add tin take a reputation for being an unnecessary step in development. But in reality, git add is an important and powerful tool. git add allows you to shape history without changing how you work.

When do you lot utilise git add?

As you're working, you change and save a file, or multiple files. Then, before y'all commit, y'all must git add. This pace allows yous to cull what y'all are going to commit. Commits should be logical, diminutive units of change - just not everyone works that style. Maybe yous are making changes to files that aren't logical or diminutive units of change. git add allows yous to systematically shape your commits and your history anyway.

What Does Git Add Practise?

git add [filename] selects that file, and moves it to the staging expanse, marker information technology for inclusion in the side by side commit. You lot can select all files, a directory, specific files, or even specific parts of a file for staging and commit.

This means if you git add together a deleted file the deletion is staged for commit. The linguistic communication of "add" when you lot're actually "deleting" tin can be confusing. If you think or use git stage in place of git add, the reality of what is happening may exist more clear.

git add and git commit go together hand in hand. They don't piece of work when they aren't used together. And, they both work all-time when used thinking of their joint functionality.

How to Use git add

Common usages and options for git add

• git add <path>: Stage a specific directory or file
• git add .: Stage all files (that are not listed in the .gitignore) in the entire repository
• git add -p: Interactively stage hunks of changes

You can see all of the many options with git add together in git-scm's documentation.

Examples of git add

git add usually fits into the workflow in the following steps:

1. Create a branch: git co-operative update-readme
2. Checkout to that branch: git checkout update-readme
3. Change a file or files
4. Save the file or files
5. Add the files or segments of code that should exist included in the next commit: git add README.md
6. Commit the changes: git commit -m "update the README to include links to contributing guide"
7. Push button the changes to the remote branch: git push -u origin update-readme

But, git add could besides exist used like:

1. Create a co-operative: git branch update-readme
2. Checkout to that branch: git checkout update-readme
3. Change a file or files
4. Save the file or files
5. Add but one file, or i office of the changed file: git add README.md
6. Commit the first set of changes: git commit -m "update the README to include links to contributing guide"
7. Add together another file, or another office of the changed file: git add CONTRIBUTING.md
8. Commit the 2nd set of changes: git commit -m "create the contributing guide"
9. (Repeat every bit necessary)
10. Push the changes to the remote branch: git push -u origin update-readme

git add All Files

Staging all available files is a popular, though risky, functioning. This tin can relieve time, but the risks are two-fold:

Poorly idea out history

Past staging all available changes, the clarity of your history volition probable suffer. Existence able to shape your history is 1 of the greatest advantages of using Git. If your commits are too large, contain unrelated changes, or are unclearly described in the commit bulletin, you will lose the benefits of viewing and changing history.

Accidentally staging and committing files

By using an option to add all files at once, you may accidentally stage and commit a file. Most common flags don't add together files tracked in the .gitignore file. Just, whatsoever file non listed in the .gitignore file will be staged and committed. This applies to large binary files, and files containing sensitive data like passwords or authentication tokens.

Deciding to stage all files

If the time is correct to stage all files, at that place are several commands that you tin choose from. As always, it's very important to know what you are staging and committing.

• git add together -A: stages all files, including new, modified, and deleted files, including files in the electric current directory and in higher directories that all the same belong to the same git repository
• git add together .: adds the unabridged directory recursively, including files whose names begin with a dot
• git add -u: stages new and modified files only, Not deleted files

	New files	Modified files	Deleted files	Files with names beginning with a dot	Current directory	Higher directories
git add -A	Yeah	Yes	Yes	Yes	Yes	Yeah
git add .	Yes	Yes	Aye	Yes	Yes	No
git add -u	No	Yep	Yes	Yes	Yeah	Aye

git add together A Binder or Specific File

The safest and clearest way to utilise git add together is by designating the specific file or directory to exist staged. The syntax for this could look like:

git add directory/: Phase all changes to all files within a directory titled directory
git add README.md: Phase all changes within the README.physician file

Disengage Added Files

Before undoing a git add, you should offset be sure that you won't lose any piece of work. There'south no way to "revert" an add together in the same way y'all can revert a commit, but yous can move the files out of the staging area.

For example, if you accept a staged file, then you make more changes to that file in your working directory. At present, the versions in your working directory and your staging area are different. If you take action to remove the changed version of the file from the staging area, the changes that were in your working directory merely not staged will be overwritten.

To avoid this, first stage all changes, then unstage them together, or commit the changes and reset back before the commit happened.

Using git reset to undo git add

git reset is a flexible and powerful command. I of its many use cases is to movement changes out of the staging area. To do this, utilise the "mixed" level of reset, which is the default.

To movement staged changes from the staging expanse to the working directory without affecting committed history, first brand sure that you don't have any additional changes to the files in question as mentioned in a higher place. Then, blazon git reset HEAD (aka git reset --mixed HEAD).

Related Terms

• git condition: Always a good idea, this control shows you what branch y'all're on, what files are in the working or staging directory, and whatsoever other important information.
• git checkout [branch-name]: Switches to the specified co-operative and updates the working directory.
• git commit -grand "descriptive message": Records file snapshots permanently in version history.
• git push button: Uploads all local branch commits to the remote.

Contribute to this article on GitHub.

Get started with git and GitHub

Review code, manage projects, and build software alongside 40 million developers.

Sign upwardly for GitHub Sign in

brayoves1986.blogspot.com

Source: https://github.com/git-guides/git-add