A place where we can group files together before we "commit" them to Git.
git add <file_name>之后，该文件就被加入「Staging area」，也就是「暂存区」，也叫做「索引区 Index area」。设置暂存区的好处是，可以修改多个文件之后再统一提交。
A "commit" is a snapshot of our repository. This way if we ever need to look back at the changes we've made (or if someone else does), we will see a nice timeline of all changes.
git add '*.txt'
We need quotes so that Git will receive the wildcard before our shell can interfere with it. Without quotes our shell will only execute the wildcard search within the current directory. Git will receive the list of files the shell found instead of the wildcard and it will not be able to add the files inside of the octofamily directory.
When using wildcards you want to be extra careful when doing commits. Make sure to check what files and folders are staged by using
git status before you do the actual commit. This way you can be sure you're committing only the things you want.
Git doesn't care what you name your remotes, but it's typical to name your main one
git remote add origin https://github.com/liyang85/scripts-during-mage-linux-training.git
git push -u origin master
The name of our remote is
origin and the default local branch name is
-u tells Git to remember the parameters, so that next time we can simply run
git push and Git will know what to do.
Sometimes when you go to pull you may have changes you don't want to commit just yet. One option you have, other than committing, is to stash the changes.
Use the command
git stash to stash your changes, and
git stash apply to re-apply your changes after your pull.
Let's take a look at what is different from our last commit by using the
git diff command.
In this case we want the diff of our most recent commit, which we can refer to using the HEAD pointer.
git diff HEAD
diff --git a/f1 b/f1 index 6f8a38c..449b072 100644 --- a/f1 +++ b/f1 @@ -1,7 +1,7 @@ a a a -a +b a a a
diff --git a/f1 b/f1
index 6f8a38c..449b072 100644
--- a/f1 +++ b/f1
diff -u f1 f2
--- f1 2012-08-29 16:45:41.000000000 +0800 +++ f2 2012-08-29 16:45:51.000000000 +0800 @@ -1,7 +1,7 @@ a a a -a +b a a a
--- f1 2012-08-29 16:45:41.000000000 +0800 +++ f2 2012-08-29 16:45:51.000000000 +0800
@@ -1,7 +1,7 @@
The HEAD is a pointer that holds your position within all your different commits. By default HEAD points to your most recent commit, so it can be used as a quick way to reference that commit without having to look up the SHA.
You can unstage files by using the
git reset command. Go ahead and remove
git reset octofamily/octodog.txt
git reset [HEAD] <file_name>可以把文件从暂存区移出，也就是撤销上一次
git add <file_name>操作，前提是
Files can be changed back to how they were at the last commit by using the command:
git checkout -- <target>. Go ahead and get rid of all the changes since the last commit for
git checkout -- octocat.txt
So you may be wondering, why do I have to use this
git checkout seems to work fine without it. It's simply promising the command line that there are no more options after the
--. This way if you happen to have a branch named
octocat.txt, it will still revert the file, instead of switching to the branch of the same name.
When developers are working on a feature or bug they'll often create a copy (aka. branch) of their code they can make separate commits to. Then when they're done they can merge this branch back into their main master branch.
We want to remove all these pesky octocats, so let's create a branch called clean_up, where we'll do all the work:
git branch clean_up
Branches are what naturally happens when you want to work on multiple features at the same time. You wouldn't want to end up with a master branch which has Feature A half done and Feature B half done.
Rather you'd separate the code base into two "snapshots" (branches) and work on and commit to them separately. As soon as one was ready, you might merge this branch back into the master branch and push it to the remote server.
Now if you type
git branch you'll see two local branches: a main branch named master and your new branch named clean_up.
You can switch branches using the
git checkout <branch> command. Try it now to switch to the clean_up branch:
git checkout clean_up
You can use:
git checkout -b new_branch
to checkout and create a branch at the same time. This is the same thing as doing:
git branch new_branch git checkout new_branch
Ok, so you're in the clean_up branch. You can finally remove all those pesky octocats by using the
git rm command which will not only remove the actual files from disk, but will also stage the removal of the files for us.
Removing one file is great and all, but what if you want to remove an entire folder? You can use the recursive option on
git rm -r folder_of_cats
If you happen to delete a file without using
git rm you'll find that you still have to
git rm the deleted files from the working tree. You can save this step by using the
-a option on
git commit, which auto removes deleted files with the commit.
git commit -am "Delete stuff"
Great, you're almost finished with the cat… er the bug fix, you just need to switch back to the master branch so you can copy (or merge) your changes from the clean_up branch back into the master branch.
Go ahead and checkout the master branch:
git checkout master
If you're hosting your repo on GitHub, you can do something called a
A pull request allows the boss of the project to look through your changes and make comments before deciding to merge in the change. It's a really great feature that is used all the time for remote workers and open-source projects.
Check out the pull request help page for more information.
We're already on the master branch, so we just need to tell Git to merge the clean_up branch into it:
git merge clean_up
Merge Conflicts can occur when changes are made to a file at the same time. A lot of people get really scared when a conflict happens, but fear not! They aren't that scary, you just need to decide which code to keep.
Congratulations! You just accomplished your first successful bugfix and merge. All that's left to do is clean up after yourself. Since you're done with the clean_up branch you don't need it anymore.
You can use
git branch -d <branch name> to delete a branch. Go ahead and delete the clean_up branch now:
git branch -d clean_up
What if you have been working on a feature branch and you decide you really don't want this feature anymore? You might decide to delete the branch since you're scrapping the idea. You'll notice that
git branch -d bad_feature doesn't work. This is because
-d won't let you delete something that hasn't been merged.
You can either add the
-f) option or use
-D which combines
-d -f together into one command.