Git-版本控制使用总结

Git的历史在这就不做赘述了，下面直接介绍git的使用：

在Linux上安装Git

不同的系统不同的安装命令，基础的就不说来，centos直接yum就ok。

安装完成后，还需要最后一步设置，在命令行输入：

  1.  git config --global user.email "[email protected]"
  2.  git config --global user.name "Your Name"

因为Git是分布式版本控制系统，所以，每个机器都必须自报家门：你的名字和Email地址。你也许会担心，如果有人故意冒充别人怎么办？这个不必担心，首先我们相信大家都是善良无知的群众，其次，真的有冒充的也是有办法可查的。

注意git config命令的--global参数，用了这个参数，表示你这台机器上所有的Git仓库都会使用这个配置，当然也可以对某个仓库指定不同的用户名和Email地址。

Git常用的命令：

add        添加文件内容至索引

bisect     通过二分查找定位引入 bug 的变更

branch     列出、创建或删除分支

checkout   检出一个分支或路径到工作区

clone      克隆一个版本库到一个新目录

commit     记录变更到版本库

diff       显示提交之间、提交和工作区之间等的差异

fetch      从另外一个版本库下载对象和引用

grep       输出和模式匹配的行

init       创建一个空的 Git 版本库或重新初始化一个已存在的版本库

log        显示提交日志

merge      合并两个或更多开发历史

mv         移动或重命名一个文件、目录或符号链接

pull       获取并合并另外的版本库或一个本地分支

push       更新远程引用和相关的对象

rebase     本地提交转移至更新后的上游分支中

reset      重置当前HEAD到指定状态

rm         从工作区和索引中删除文件

show       显示各种类型的对象

status     显示工作区状态

tag        创建、列出、删除或校验一个GPG签名的 tag 对象

创建版本库

什么是版本库呢？版本库又名仓库，英文名repository，你可以简单理解成一个目录，这个目录里面的所有文件都可以被Git管理起来，每个文件的修改、删除，Git都能跟踪，以便任何时刻都可以追踪历史，或者在将来某个时刻可以“还原”。

所以，创建一个版本库非常简单，首先，选择一个合适的地方，创建一个空目录：

第一步：创建一个仓库的目录

  1. [[email protected] /]# mkdir git_test
  2. [[email protected] /]# cd git_test/
  3. [[email protected] git_test]# pwd
  4. /git_test

第二步：通过git init 命令把这个目录变成git可以管理的仓库

  1. [[email protected] git_test]# git init
  2. 初始化空的 Git 版本库于 /git_test/.git/
  3. [[email protected] git_test]# ls -al
  4. 总用量 12
  5. drwxr-xr-x   3 root root 4096 5月  10 13:53 .
  6. drwxr-xr-x. 19 root root 4096 5月  10 13:50 ..
  7. drwxr-xr-x   7 root root 4096 5月  10 13:53 .git

瞬间Git就把仓库建好了，而且告诉你是一个空的仓库（empty Git repository），细心的读者可以发现当前目录下多了一个.git的目录，这个目录是Git来跟踪管理版本库的，没事千万不要手动修改这个目录里面的文件，不然改乱了，就把Git仓库给破坏了。也不一定必须在空目录下创建Git仓库，选择一个已经有东西的目录也是可以的。

第三步：把文件添加到版本库

首先这里再明确一下，所有的版本控制系统，其实只能跟踪文本文件的改动，比如TXT文件，网页，所有的程序代码等等，Git也不例外。版本控制系统可以告诉你每次的改动，比如在第5行加了一个单词“Linux”，在第8行删了一个单词“Windows”。而图片、视频这些二进制文件，虽然也能由版本控制系统管理，但没法跟踪文件的变化，只能把二进制文件每次改动串起来，也就是只知道图片从100KB改成了120KB，但到底改了啥，版本控制系统不知道，也没法知道。

现在我们编写一个readme.txt文件，内容如下

  1. [[email protected] git_test]# cat readme.txt
  2. Git is veryt good tool
  3. auth :cgt

一定要放到git_test目录下面，子目录也可以，放到其他地方git找不到文件。

把一个文件放到Git仓库只需要两步。

第一步，用命令git add告诉git，把文件添加到仓库

  1. [[email protected] git_test]# git add readme.txt

执行上面的命令，没有任何的显示就对了。Linux的哲学思想：没有消息就是最好的消息，说明添加成功。

第二步，用命令git commit告诉git，把文件提交到仓库

  1. [[email protected] git_test]# git commit -m "cgt write a readme file"
  2. [master（根提交） 87818f5] cgt write a readme file
  3. 1 file changed, 2 insertions(+)
  4. create mode 100644 readme.txt

简单解释一下git commit命令，-m后面输入的是本次提交的说明，可以输入任意内容，当然最好是有意义的，这样你就能从历史记录里方便地找到改动记录。

嫌麻烦不想输入-m "xxx"行不行？确实有办法可以这么干，但是强烈不建议你这么干，因为输入说明对自己对别人阅读都很重要。实在不想输入说明的童鞋请自行Google，我不告诉你这个参数。

git commit命令执行成功后会告诉你，1个文件被改动（我们新添加的readme.txt文件），插入了两行内容（readme.txt有两行内容）。

为什么Git添加文件需要add，commit一共两步呢？因为commit可以一次提交很多文件，所以你可以多次add不同的文件，比如：

  1. [[email protected] git_test]# touch file1 file2 file3
  2. [[email protected] git_test]# ls
  3. file1  file2  file3  readme.txt
  4. [[email protected] git_test]# git add file1 file2 file3
  5. [[email protected] git_test]# git commit -m "add 3 files"
  6. [master 827526e] add 3 files
  7. 3 files changed, 0 insertions(+), 0 deletions(-)
  8. create mode 100644 file1
  9. create mode 100644 file2
  10. create mode 100644 file3

再次插足一下，说明一下git的工作流

你的本地仓库由 git 维护的三棵"树"组成。第一个是你的 工作目录，它持有实际文件；第二个是 暂存区（staging），它像个缓存区域，临时保存你的改动；最后是 HEAD，它指向你最后一次提交的结果。

你可以提出更改（把它们添加到暂存区），使用如下命令：
git add <filename>
git add *
这是 git 基本工作流程的第一步；使用如下命令以实际提交改动：
git commit -m "代码提交信息"
现在，你的改动已经提交到了 HEAD，但是还没到你的远端仓库。

回滚－让我去哪我去哪

我们已经创建了一个readme.txt文件，现在我们对他进行一些改动操作。

  1. [[email protected] git_test]# cat readme.txt
  2. Git is veryt good tool
  3. auth :cgt
  4. date:2016-5-10

执行git status

  1. [[email protected] git_test]# git status
  2. # 位于分支 master
  3. # 尚未暂存以备提交的变更：
  4. #   （使用 "git add <file>..." 更新要提交的内容）
  5. #   （使用 "git checkout -- <file>..." 丢弃工作区的改动）
  6. #
  7. # 修改：      readme.txt
  8. #
  9. 修改尚未加入提交（使用 "git add" 和/或 "git commit -a"）

git status命令可以让我们时刻掌握仓库当前的状态，上面的命令告诉我们，readme.txt被修改过了，但还没有准备提交的修改。

虽然Git告诉我们readme.txt被修改了，但如果能看看具体修改了什么内容，自然是很好的。比如你第二天上班时，已经记不清上次怎么修改的readme.txt，所以，需要用git diff这个命令看看，然后add之后在看一下status，是显示要commit的文件，现在再回想一下那个工作流图

  1. [[email protected] git_test]# git diff
  2. diff --git a/readme.txt b/readme.txt
  3. index b7cffdb..43b7253 100644
  4. --- a/readme.txt
  5. +++ b/readme.txt
  6. @@ -1,2 +1,3 @@
  7. Git is veryt good tool
  8. auth :cgt
  9. +date:2016-5-10
  1. [[email protected] git_test]# git add readme.txt
  2. [[email protected] git_test]# git status
  3. # 位于分支 master
  4. # 要提交的变更：
  5. #   （使用 "git reset HEAD <file>..." 撤出暂存区）
  6. #
  7. # 修改：      readme.txt

接下来进行commit操作

  1. [[email protected] git_test]# git commit -m "add date"
  2. [master de00305] add date
  3. 1 file changed, 1 insertion(+)

提交之后，在查看status

  1. [[email protected] git_test]# git status
  2. # 位于分支 master
  3. 无文件要提交，干净的工作区

版本的回退

现在，你已经学会了修改文件，然后把修改提交到Git版本库，现在，再练习一次，修改readme.txt文件如下：

  1. [[email protected] git_test]# cat readme.txt
  2. Git is veryt good tool
  3. auth :cgt
  4. date:2016-5-10
  5. version:1
  1. [[email protected] git_test]# git add readme.txt
  2. [[email protected] git_test]# git commit -m "version"
  3. [master 8b7d4ee] version
  4. 1 file changed, 1 insertion(+)

目前我们已经提交了三次，暂时你还能记住，但是在实际工作中我们是记不住的，不然要版本控制系统干什么。版本控制系统肯定有某个命令可以告诉我们历史记录，在Git中，我们用git log命令查看：

  1. [[email protected] git_test]# git log
  2. commit 8b7d4eebe4e03809162f8193d6b2338926896ab4
  3. Author: caoxiaojian <[email protected]>
  4. Date:   Tue May 10 14:59:16 2016 +0800
  6.    version
  8. commit de003058c91312f695b57f42724f826f6ef42f17
  9. Author: caoxiaojian <[email protected]>
  10. Date:   Tue May 10 14:52:10 2016 +0800
  12.    add date
  14. commit 827526ee243c93bfaf8f4f2f9dc22d31325cb47a
  15. Author: caoxiaojian <[email protected]>
  16. Date:   Tue May 10 14:23:08 2016 +0800
  18.    add 3 files
  20. commit 87818f5454a2bc41cfbeca4b923a510d11fe72ac
  21. Author: caoxiaojian <[email protected]>
  22. Date:   Tue May 10 14:19:08 2016 +0800
  24.    cgt write a readme file

git log 显示从最近到最远的提交日志，我们可以看到四次提交，最近的一次是version，上一次是date，最早的一次是cgt write a readme  file 。

如果嫌输出的信息太多，可以使用--pretty=oneline

  1. [[email protected] git_test]# git log --pretty=oneline
  2. 8b7d4eebe4e03809162f8193d6b2338926896ab4 version
  3. de003058c91312f695b57f42724f826f6ef42f17 add date
  4. 827526ee243c93bfaf8f4f2f9dc22d31325cb47a add 3 files
  5. 87818f5454a2bc41cfbeca4b923a510d11fe72ac cgt write a readme file

需要友情提示的是，你看到的一大串8b7d4eebe4e03809162f8193d6b2338926896ab4类似的是commit id（版本号），和SVN不一样，Git的commit id不是1，2，3……递增的数字，而是一个SHA1计算出来的一个非常大的数字，用十六进制表示，而且你看到的commit id和我的肯定不一样，以你自己的为准。为什么commit id需要用这么一大串数字表示呢？因为Git是分布式的版本控制系统，后面我们还要研究多人在同一个版本库里工作，如果大家都用1，2，3……作为版本号，那肯定就冲突了。

我们现在开始回滚，

准备把readme.txt回退到上一个版本，也就是“date”的那个版本，怎么做呢？

首先，Git必须知道当前版本是哪个版本，在Git中，用HEAD表示当前版本，也就是最新的提交3628164...882e1e0（注意我的提交ID和你的肯定不一样），上一个版本就是HEAD^，上上一个版本就是HEAD^^，当然往上100个版本写100个^比较容易数不过来，所以写成HEAD~100。

回滚，我们可以使用git reset这个命令

  1. [[email protected]-kx987cmz git_test]# git reset --hard HEAD^
  2. HEAD 现在位于 de00305 add date
  3. [[email protected]-kx987cmz git_test]# cat readme.txt
  4. Git is veryt good tool
  5. auth :cgt
  6. date:2016-5-10

可以看出，他没有version那行，说明回滚成功。

在看git log

  1. [[email protected]-kx987cmz git_test]# git log
  2. commit de003058c91312f695b57f42724f826f6ef42f17
  3. Author: caoxiaojian <[email protected].com>
  4. Date:   Tue May 10 14:52:10 2016 +0800
  6.    add date
  8. commit 827526ee243c93bfaf8f4f2f9dc22d31325cb47a
  9. Author: caoxiaojian <[email protected].com>
  10. Date:   Tue May 10 14:23:08 2016 +0800
  12.    add 3 files
  14. commit 87818f5454a2bc41cfbeca4b923a510d11fe72ac
  15. Author: caoxiaojian <[email protected].com>
  16. Date:   Tue May 10 14:19:08 2016 +0800
  18.    cgt write a readme file

没有了之前的version，那我要怎么才能恢复呢，回你的终端上，看看version的commit id，我们找到了：

8b7d4eebe4e03809162f8193d6b2338926896ab4 version，执行恢复。恢复的时候ID不需要写全部的。

  1. [[email protected]-kx987cmz git_test]# git reset --hard 8b7d4eebe4
  2. HEAD 现在位于 8b7d4ee version
  3. [[email protected]-kx987cmz git_test]# cat readme.txt
  4. Git is veryt good tool
  5. auth :cgt
  6. date:2016-5-10
  7. version:1

回滚原理解析：

Git的版本回退速度非常快，因为Git在内部有个指向当前版本的HEAD指针，当你回退版本的时候，Git仅仅是把HEAD从当前的version，指到date

回滚后

然后顺便把工作区的文件更新了。所以你让HEAD指向哪个版本号，你就把当前版本定位在哪。

到了这里肯定有童鞋要问，那我要是不知道我前面的ID了，我去哪里回滚，我是不是该收拾工位回滚到家中了，git早就替你想好了，可以使用git reflog，把之前的ID都显示出来

  1. [[email protected]-kx987cmz git_test]# git reflog
  2. 8b7d4ee [email protected]{0}: reset: moving to 8b7d4eebe4
  3. de00305 [email protected]{1}: reset: moving to HEAD^
  4. 8b7d4ee [email protected]{2}: commit: version
  5. de00305 [email protected]{3}: commit: add date
  6. 827526e [email protected]{4}: commit: add 3 files
  7. 87818f5 [email protected]{5}: commit (initial): cgt write a readme file

工作区和暂存区

不知道你是不是理解了我之前说的那个工作流，咱们这里再来啰嗦一遍。

Git和其他版本控制系统如svn不同之处是有暂存区的概念

先弄清楚这几个名次

工作区：

就是在你的电脑里能看到的目录，比如咱们创建的git_test

版本库：

工作区中???一个隐藏目录.git（之前已经给童鞋们提到过这个文件），它不算工作区，而是git的版本库。

git的版本库里面存放了很多的东西，其中最重要的就是称为stage（index）的暂存区，还有git为我们自动创建的第一个分支master，以及指向master的一个指针叫head。

当我们在工作区创建了文件后，执行add后，再来看这个图

当你执行commit后，暂存区的内容就没有

管理修改

为什么Git比其他版本控制系统设计得优秀，因为Git跟踪并管理的是修改，而非文件。

你会问，什么是修改？比如你新增了一行，这就是一个修改，删除了一行，也是一个修改，更改了某些字符，也是一个修改，删了一些又加了一些，也是一个修改，甚至创建一个新文件，也算一个修改。

为什么说Git管理的是修改，而不是文件呢？我们还是做实验。第一步，对readme.txt做一个修改，第二步，添加到暂存区。第三步，查看状态

  1. [[email protected]-kx987cmz git_test]# cat readme.txt
  2. Git is veryt good tool
  3. auth :cgt
  4. date:2016-5-10
  5. version:1
  6. modify----------1
  7. [[email protected]-kx987cmz git_test]# git add readme.txt
  8. [[email protected]-kx987cmz git_test]# git status
  9. # 位于分支 master
  10. # 要提交的变更：
  11. #   （使用 "git reset HEAD <file>..." 撤出暂存区）
  12. #
  13. # 修改：      readme.txt
  14. #

第四步，再次编辑readme.txt，然后直接commit，再次查看status

  1. [[email protected]-kx987cmz git_test]# cat readme.txt
  2. Git is veryt good tool
  3. auth :cgt
  4. date:2016-5-10
  5. version:1
  6. modify----------1
  7. modify----------2
  8. [[email protected]-kx987cmz git_test]# git commit -m "modify"
  9. [master 766baac] modify
  10. 1 file changed, 1 insertion(+)
  11. [[email protected]-kx987cmz git_test]# git status
  12. # 位于分支 master
  13. # 尚未暂存以备提交的变更：
  14. #   （使用 "git add <file>..." 更新要提交的内容）
  15. #   （使用 "git checkout -- <file>..." 丢弃工作区的改动）
  16. #
  17. # 修改：      readme.txt
  18. #
  19. 修改尚未加入提交（使用 "git add" 和/或 "git commit -a"）

发现第二次的修改没有commit，那是因为你没有add

提交后，用git diff HEAD -- readme.txt命令可以查看工作区和版本库里面最新版本的区别：

  1. [[email protected]-kx987cmz git_test]# git diff HEAD -- readme.txt
  2. diff --git a/readme.txt b/readme.txt
  3. index 4416460..07c12e7 100644
  4. --- a/readme.txt
  5. +++ b/readme.txt
  6. @@ -3,3 +3,4 @@ auth :cgt
  7. date:2016-5-10
  8. version:1
  9. modify----------1
  10. +modify----------2

撤销修改

编辑了readme，

  1. [[email protected]-kx987cmz git_test]# cat readme.txt
  2. Git is veryt good tool
  3. auth :cgt
  4. date:2016-5-10
  5. version:1
  6. modify----------1
  7. modify----------2
  8. caoxiaojian is xiaojianjian

已经编辑完成，忽然发现了问题，最后一行，道出了笔者的心声。既然已经发现错误，那就很容易纠正它，你可以删除掉最后一行，手动把文件恢复到上一个版本的状态，如果用git status查看一下，

  1. [[email protected]-kx987cmz git_test]# git status
  2. # 位于分支 master
  3. # 尚未暂存以备提交的变更：
  4. #   （使用 "git add <file>..." 更新要提交的内容）
  5. #   （使用 "git checkout -- <file>..." 丢弃工作区的改动）
  6. #
  7. # 修改：      readme.txt
  8. #
  9. 修改尚未加入提交（使用 "git add" 和/或 "git commit -a"）

你可以发现上面提示你使用 "git checkout -- <file>..." 丢弃工作区的改动，那我们执行下

  1. [[email protected]-kx987cmz git_test]# git checkout -- readme.txt
  2. [[email protected]-kx987cmz git_test]# cat readme.txt
  3. Git is veryt good tool
  4. auth :cgt
  5. date:2016-5-10
  6. version:1
  7. modify----------1

已经回来了。

命令git checkout -- readme.txt意思就是，把readme.txt文件在工作区的修改全部撤销，这里有两种情况：

一种是readme.txt自修改后还没有被放到暂存区，现在，撤销修改就回到和版本库一模一样的状态；

一种是readme.txt已经添加到暂存区后，又作了修改，现在，撤销修改就回到添加到暂存区后的状态。

总之，就是让这个文件回到最近一次git commit或git add时的状态。

git checkout -- file命令中的--很重要，没有--，就变成了“切换到另一个分支”的命令，我们在后面的分支管理中会再次遇到git checkout命令。

刚刚咱们没有将修改提交到暂存区，那假如你提交到了呢？？？？？？你说咋整呢？？？？？是不是吓尿了？？？？

  1. [[email protected]-kx987cmz git_test]# cat readme.txt
  2. Git is veryt good tool
  3. auth :cgt
  4. date:2016-5-10
  5. version:1
  6. modify----------1
  7. caoxiaojian is xiaojianjian
  8. [[email protected]-kx987cmz git_test]# git add readme.txt
  9. [[email protected]-kx987cmz git_test]# git status
  10. # 位于分支 master
  11. # 要提交的变更：
  12. #   （使用 "git reset HEAD <file>..." 撤出暂存区）
  13. # 修改：      readme.txt

你要是聪明的话，你应该已经知道要怎么做了。。。。对是的，就是你想的那样。

  1. [[email protected]-kx987cmz git_test]# git reset HEAD readme.txt
  2. 重置后撤出暂存区的变更：
  3. M readme.txt
  4. [[email protected]-kx987cmz git_test]# git status
  5. # 位于分支 master
  6. # 尚未暂存以备提交的变更：
  7. #   （使用 "git add <file>..." 更新要提交的内容）
  8. #   （使用 "git checkout -- <file>..." 丢弃工作区的改动）
  9. #
  10. # 修改：      readme.txt
  11. #
  12. 修改尚未加入提交（使用 "git add" 和/或 "git commit -a"）

已经退出了暂存区。你可能要问，那要是已经commit了呢？？你小子胆子还真不小啊，教你一招，之前不是讲过回滚嘛，直接回滚。不过这个也是有条件的，就是你还没有把自己的本地版本库推送到远程。Git是一个分布式版本控制，他还有远程版本库，一旦你提交到远程版本库，那你就可以git go home

删除文件

先创建文件，后add，在commit，然后删除工作区的文件

  1. [[email protected]-kx987cmz git_test]# cat test.txt
  2. qwertyuiop[
  3. adfghjjljh
  4. fdgscvxz
  5. [[email protected]-kx987cmz git_test]# git add test.txt
  6. [[email protected]-kx987cmz git_test]# git commit -m "del test"
  7. [master 63d3bf7] del test
  8. 1 file changed, 3 insertions(+)
  9. create mode 100644 test.txt
  10. [[email protected]-kx987cmz git_test]# rm -rf test.txt
  11. [[email protected]-kx987cmz git_test]# git status
  12. # 位于分支 master
  13. # 尚未暂存以备提交的变更：
  14. #   （使用 "git add/rm <file>..." 更新要提交的内容）
  15. #   （使用 "git checkout -- <file>..." 丢弃工作区的改动）
  16. #
  17. # 修改：      readme.txt
  18. # 删除：      test.txt
  19. #
  20. 修改尚未加入提交（使用 "git add" 和/或 "git commit -a"）

现在你有两个选择，一是确实要从版本库中删除该文件，那就用命令git rm删掉，并且git commit：

  1. [[email protected]-kx987cmz git_test]# git rm test.txt
  2. rm ‘test.txt‘
  3. [[email protected]-kx987cmz git_test]# git commit -m "remove test.txt"
  4. [master 5f04ee2] remove test.txt
  5. 1 file changed, 3 deletions(-)
  6. delete mode 100644 test.txt

现在文件就从版本库中彻底的删除了。

命令git rm用于删除一个文件。如果一个文件已经被提交到版本库，那么你永远不用担心误删，但是要小心，你只能恢复文件到最新版本，你会丢失最近一次提交后你修改的内容。

另一种情况是删错了，因为版本库里还有呢，所以可以很轻松地把误删的文件恢复到最新版本：

使用

git checkout -- test.txt

git checkout其实是用版本库里的版本替换工作区的版本，无论工作区是修改还是删除，都可以“一键还原”。

远程仓库

我们可以使用github给我们提供的服务，作为我们的一个远程仓库。但是需要做一下的设置。

由于你的本地Git仓库和GitHub仓库之间的传输是通过SSH加密的，所以我们首先生成秘钥。

第1步：创建SSH Key。

在用户主目录下，看看有没有.ssh目录，如果有，再看看这个目录下有没有id_rsa和id_rsa.pub这两个文件，如果已经有了，可直接跳到下一步。如果没有，打开Shell（Windows下打开Git Bash），创建SSH Key：

  1. ssh-keygen -t rsa -C "[email protected]"

你需要把邮件地址换成你自己的邮件地址，然后一路回车，使用默认值即可，由于这个Key也不是用于军事目的，所以也无需设置密码。

如果一切顺利的话，可以在用户主目录里找到.ssh目录，里面有id_rsa和id_rsa.pub两个文件，这两个就是SSH Key的秘钥对，id_rsa是私钥，不能泄露出去，id_rsa.pub是公钥，可以放心地告诉任何人。

第2步：添加公钥到你的

登陆GitHub，打开“Account settings”，“SSH Keys”页面，然后将你的key添加上。

为什么GitHub需要SSH Key呢？因为GitHub需要识别出你推送的提交确实是你推送的，而不是别人冒充的，而Git支持SSH协议，所以，GitHub只要知道了你的公钥，就可以确认只有你自己才能推送。

添加远程库

你原本在本地已经创建了一个Git仓库，现在又想在github上也创建一个仓库，让这两个仓库可以远程同步。这样github的仓库既可以作为备份，又可以让其他人通过该仓库来协作。

第一步：创建一个新的仓库repository

右上角有个?，然后现在new repository

然后进入创建页面

仓库内容的提交

接下来咱们看如何使用

本地没有仓库的情况下，要先创建仓库。

  1. [email protected]-PC MINGW64 /
  2. $ mkdir /test
  3. [email protected]-PC MINGW64 /
  4. $ cd /test

使用git init 创建定义仓库

  1. [email protected]-PC MINGW64 /test
  2. $ git init
  3. Initialized empty Git repository in C:/Program Files/Git/test/.git/
  4. [email protected]-PC MINGW64 /test (master)
  5. $ ls -al
  6. total 8
  7. drwxr-xr-x 1 cgt 197121 0 五月 16 06:11 ./
  8. drwxr-xr-x 1 cgt 197121 0 五月 16 06:11 ../
  9. drwxr-xr-x 1 cgt 197121 0 五月 16 06:11 .git/

在仓库中创建一个文件，然后add commit

  1. [email protected]-PC MINGW64 /test (master)
  2. $ echo "# test " >> README.md
  3. [email protected]-PC MINGW64 /test (master)
  4. $ git add README.md
  5. warning: LF will be replaced by CRLF in README.md.
  6. The file will have its original line endings in your working directory.
  7. [email protected]-PC MINGW64 /test (master)
  8. $ git commit -m "first commit"
  9. [master (root-commit) 7eeb945] first commit
  10. warning: LF will be replaced by CRLF in README.md.
  11. The file will have its original line endings in your working directory.
  12. 1 file changed, 1 insertion(+)
  13. create mode 100644 README.md

至此，提交到本地的head中。也就是本地仓库中，然后从本地仓库向远程仓库提交。

使用remote关联一个远程库，add是定义一个远程的名称，默认一般使用origin，后面跟的是远程仓库的名称

  1. [email protected]-PC MINGW64 /test (master)
  2. $ git remote add origin [email protected].com:caoxiaojian/test.git

把本地库的内容推送到远程，实际上是将本地的当前分支master，推送到远程

  1. [email protected]-PC MINGW64 /test (master)
  2. $ git push -u origin master
  3. Warning: Permanently added the RSA host key for IP address ‘192.30.252.128‘ to the list of known hosts.
  4. Counting objects: 3, done.
  5. Writing objects: 100% (3/3), 210 bytes | 0 bytes/s, done.
  6. Total 3 (delta 0), reused 0 (delta 0)
  7. To [email protected].com:caoxiaojian/test.git
  8. * [new branch]      master -> master
  9. Branch master set up to track remote branch master from origin.

由于远程库是空的，我们第一次推送master分支时，加上了-u参数，Git不但会把本地的master分支内容推送的远程新的master分支，还会把本地的master分支和远程的master分支关联起来，在以后的推送或者拉取时就可以简化命令。

再次修改README.md

  1. [email protected]-PC MINGW64 /test (master)
  2. $ echo "# this is my test file " >> README.md
  3. [email protected]-PC MINGW64 /test (master)
  4. $ git add README.md
  5. warning: LF will be replaced by CRLF in README.md.
  6. The file will have its original line endings in your working directory.
  7. [email protected]-PC MINGW64 /test (master)
  8. $ git commit -m "2 commit"
  9. [master warning: LF will be replaced by CRLF in README.md.
  10. The file will have its original line endings in your working directory.
  11. 80bc0e7] 2 commit
  12. warning: LF will be replaced by CRLF in README.md.
  13. The file will have its original line endings in your working directory.
  14. 1 file changed, 1 insertion(+)
  15. [email protected]-PC MINGW64 /test (master)
  16. $ git push origin master
  17. Warning: Permanently added the RSA host key for IP address ‘192.30.252.120‘ to the list of known hosts.
  18. Counting objects: 3, done.
  19. Writing objects: 100% (3/3), 257 bytes | 0 bytes/s, done.
  20. Total 3 (delta 0), reused 0 (delta 0)
  21. To [email protected].com:caoxiaojian/test.git
  22.   7eeb945..80bc0e7  master -> master

到github下面对应的仓库里查看

每次本地提交后，只要有必要，就可以使用命令git push origin master推送最新修改

克隆远程库

在刚创建的仓库中创建新文件

创建文件

创建完成后可以看见你的新文件

因为之前已经创建了test这个本地仓库，所以先删除，然后再clone

  1. [email protected]-PC MINGW64 /
  2. $ rm -rf /test/
  3. [email protected]-PC MINGW64 /
  4. $ git clone [email protected].com:caoxiaojian/test.git
  5. Cloning into ‘test‘...
  6. Warning: Permanently added the RSA host key for IP address ‘192.30.252.121‘ to the list of known hosts.
  7. remote: Counting objects: 9, done.
  8. remote: Compressing objects: 100% (4/4), done.
  9. remote: Total 9 (delta 0), reused 6 (delta 0), pack-reused 0
  10. Receiving objects: 100% (9/9), done.
  11. Checking connectivity... done.
  12. [email protected]-PC MINGW64 /
  13. $ cd /test/
  14. [email protected]-PC MINGW64 /test (master)
  15. $ ls
  16. new_file  README.md
  17. [email protected]-PC MINGW64 /test (master)
  18. $ cat new_file
  19. make a new file for clone test

分支管理

分支在实际中有什么用呢？假设你准备开发一个新功能，但是需要两周才能完成，第一周你写了50%的代码，如果立刻提交，由于代码还没写完，不完整的代码库会导致别人不能干活了。如果等代码全部写完再一次提交，又存在丢失每天进度的巨大风险。

现在有了分支，就不用怕了。你创建了一个属于你自己的分支，别人看不到，还继续在原来的分支上正常工作，而你在自己的分支上干活，想提交就提交，直到开发完毕后，再一次性合并到原来的分支上，这样，既安全，又不影响别人工作。

时间： 2024-10-05 06:19:19

Git-版本控制使用总结的相关文章

git版本控制的常用指令

使用git版本控制之前,首先安装好git,安装方式比如可以通过下载客户等方式来安装:这里提供网址:http://windows.github.com/ 1.登入远程仓库,创建仓库2.复制仓库地址3.在终端中,选择目录克隆远程仓库:git clone https://github.com/************/**********.git4.等待完成即可;5.git status:查看文件状态:这里注意:文件有4个状态,工作区,暂存区,master分支,远程master分支:6,工作区-->g

Git版本控制工具学习

Git代码管理工具学习 分布式管理工具:git 相比较svn它更加的方便,基本上我们的操作都是在本地进行的. Git文件的三种状态:已提交,已修改,以暂存. 已提交:表示文件已经被保存到本地数据库. 已修改:修改了某个文件. 以暂存:把修改的文件放到了下次提交保存的清单中. Git只关心文件系统的整体是否发生了变化,其它的版本控制工具更多的关心文件的内容是否发生变化. Git基本的工作流程 1:在工作目录中修改某些文件,2:对修改后的文件进行快照,然后保存到暂存区域.3:提交更新,将保存在暂存区

Git版本控制与工作流

基本概念 Git是什么? Git是分布式版本控制系统,与SVN类似的集中化版本控制系统相比,集中化版本控制系统虽然能够令多个团队成员一起协作开发,但有时如果中央服务器宕机的话,谁也无法在宕机期间提交更新和协同开发.甚至有时,中央服务器磁盘故障,恰巧又没有做备份或备份没及时,那就可能有丢失数据的风险. 但Git是分布式的版本控制系统,客户端不只是提取最新版本的快照,而且将整个代码仓库镜像复制下来.如果任何协同工作用的服务器发生故障了,也可以用任何一个代码仓库来恢复.而且在协作服务器宕机期间,你也可

Git版本控制教程

Git 版本控制入门 不了解Git请查看权威Git书籍 ProGit(中文版). 一份很好的 Git 入门教程,点击这里查看. Git客户端下载地址: 官方Git - TortoiseGit - SourceTree 常用工具及插件教程 eclipse中egit插件使用-图文并茂-详细 Visual Studio 2012连接到[email protected] TortoiseGit配合msysGit在[email protected]代码托管的傻瓜教程 利用eclipse的git插件EGit

GIT 版本控制常用命令汇总

[转自]:http://www.cnblogs.com/sawyerzhu/p/3578268.html GIT 版本控制常用命令汇总 git version 查看当前git版本信息 git help 获取全部命令帮助信息 git help <command> 获取指定命令帮助信息 git config user.name "Your Name Comes Here" 设置当前项目git用户名 git config --global user.name "Your

Git版本控制工具---本地版本库的常用操作

  [正文] 在上一章节中,我们学习了关于Git最基本的用法,包括安装Git.创建版本库,以及提交本地代码.本章节中将学习更多的使用技巧.即:Git版本控制工具(一)----git的安装及创建版本库 我们先要做好准备工作,将某个项目创建版本库,我这里就新建一个Android项目GitTest,创建一个版本库.打开Git Bash,进入到这个项目的根目录下,然后执行git init命令,如下图所示: 这样,准备工作就做好了. 一.忽略文件: 版本库已经创建好了,接下来我们需要提交项目中的代码,但是

Git版本控制工具使用:Error pulling origin: error: Your local changes to the following files would be overwritten by merge

摘自: CSDN 逆觞 git在pull时,出现这种错误的时候,可能很多人进进行stash,相关stash的请看:Error pulling origin: error: Your local changes to the following files would be overwritten by merge 但是发现stash后还是会出现:Error pulling origin: error: The following untracked working tree files woul

Linux系统CentOS6.5 64位注册、安装git版本控制工具

一.描述 本文描述Linux系统CentOS6.5 64位注册.安装git版本控制工具整个过程,其中Git是一个分布式的版本控制系统,最初由Linus Torvalds编写,用作Linux内核代码的管理.作为开源代码库以及版本控制系统,Github拥有140多万开发者用户.随着越来越多的应用程序转移到了云上,Github已经成为了管理软件开发以及发现已有代码的首选方法. 二.git安装和使用步骤 1.在GitHub官网上注册免费账号并且建立自己代码仓库(Repository) GitHub官网注

学习使用Git 版本控制 代码管理

Git 版本控制 学习教程 Git版本控制器,可以作为程序员.计算机科学和软件工程的研究人员在编写代码.工程开发过程中的文件管理和代码管理的工具.在基本的Git Bash和Git GUI之外,有很多在MacOS.Linux和Windows下的Git 管理工具以可视化的方法辅助版本控制和代码控制. 在我的实际工作和学习中,需要用到Git实现本地代码的版本管理和代码控制,在坚果云上进行代码同步和迁移,使得实验室的台式机和个人笔记本上都有最新版的代码,并且可以记录每天修改和新增代码的进度. 由于jav

精通Git(第2版)+Git团队协作+GitHub入门与实践+Git版本控制管理(第2版)

资源链接:https://pan.baidu.com/s/1FElckzWH6sqyugNK5o8b7w搜集并整理了网上有关GitHub学习的9本书籍,如下:<精通Git (第2版)>中英文PDF<Git团队协作>中英文PDF<Git权威指南(第2版)>和第1版PDF<Git版本控制管理 (第2版)>中英文PDF<GitHub入门与实践>PDF,以及Git桌面Win64bit版最新安装包目录及截图如下: 原文地址:http://blog.51ct