Git命令详解

阅读目录

• 在工作目录中初始化新仓库
• 从现有仓库克隆
• 检查当前文件状态
• 跟踪新文件
• 暂存已修改文件
• 忽略某些文件
• 查看已暂存和未暂存的更新
• 提交更新
• 跳过使用暂存区域
• 移除文件
• 移动文件
• 限制输出长度
• 使用图形化工具查阅提交历史
• 修改最后一次提交
• 取消已经暂存的文件
• 取消对文件的修改
• 查看当前的远程库
• 添加远程仓库
• 从远程仓库抓取数据
• 推送数据到远程仓库
• 查看远程仓库信息
• 远程仓库的删除和重命名
• 列显已有的标签
• 新建标签
• 含附注的标签
• 签署标签
• 轻量级标签
• 验证标签
• 后期加注标签
• 分享标签
• 自动完成
• Git 命令别名

Git 基础

 

读完本章你就能上手使用 Git 了。本章将介绍几个最基本的，也是最常用的 Git 命令，以后绝大多数时间里用到的也就是这几个命令。读完本章，你就能初始化一个新的代码仓库，做一些适当配置；开始或停止跟踪某些文件；暂存或提交某些更 新。我们还会展示如何让 Git 忽略某些文件，或是名称符合特定模式的文件；如何既快且容易地撤消犯下的小错误；如何浏览项目的更新历史，查看某两次更新之间的差异；以及如何从远程仓库 拉数据下来或者推数据上去。

 

 

2.1  取得项目的 Git 仓库

有两种取得 Git 项目仓库的方法。第一种是在现存的目录下，通过导入所有文件来创建新的 Git 仓库。第二种是从已有的 Git 仓库克隆出一个新的镜像仓库来。

在工作目录中初始化新仓库

要对现有的某个项目开始用 Git 管理，只需到此项目所在的目录，执行：

$ git init

初始化后，在当前目录下会出现一个名为 .git 的目录，所有 Git 需要的数据和资源都存放在这个目录中。不过目前，仅仅是按照既有的结构框架初始化好了里边所有的文件和目录，但我们还没有开始跟踪管理项目中的任何一个文件。（在第九章我们会详细说明刚才创建的.git 目录中究竟有哪些文件，以及都起些什么作用。）

如果当前目录下有几个文件想要纳入版本控制，需要先用 git add 命令告诉 Git 开始对这些文件进行跟踪，然后提交：

1. $ git add *.c

2. $ git add README

3. $ git commit -m 'initial project version'

稍后我们再逐一解释每条命令的意思。不过现在，你已经得到了一个实际维护着若干文件的 Git 仓库。

回到顶部

从现有仓库克隆

如果想对某个开源项目出一份力，可以先把该项目的 Git 仓库复制一份出来，这就需要用到 git clone 命令。如果你熟悉其他的 VCS 比如 Subversion，你可能已经注意到这里使用的是 clone 而不是 checkout。这是个非常重要的差别，Git 收取的是项目历史的所有数据（每一个文件的每一个版本），服务器上有的数据克隆之后本地也都有了。实际上，即便服务器的磁盘发生故障，用任何一个克隆出来 的客户端都可以重建服务器上的仓库，回到当初克隆时的状态（虽然可能会丢失某些服务器端的挂钩设置，但所有版本的数据仍旧还在，有关细节请参考第四章）。

克隆仓库的命令格式为 git clone [url]。比如，要克隆 Ruby 语言的 Git 代码仓库 Grit，可以用下面的命令：

$ git clone git://github.com/schacon/grit.git

这会在当前目录下创建一个名为“grit”的目录，其中包含一个 .git 的目录，用于保存下载下来的所有版本记录，然后从中取出最新版本的文件拷贝。如果进入这个新建的grit 目录，你会看到项目中的所有文件已经在里边了，准备好后续的开发和使用。如果希望在克隆的时候，自己定义要新建的项目目录名称，可以在上面的命令末尾指定新的名字：

$ git clone git://github.com/schacon/grit.git mygrit

唯一的差别就是，现在新建的目录成了 mygrit，其他的都和上边的一样。

Git 支持许多数据传输协议。之前的例子使用的是 git:// 协议，不过你也可以用 http(s):// 或者user@server:/path.git表示的 SSH 传输协议。我们会在第四章详细介绍所有这些协议在服务器端该如何配置使用，以及各种方式之间的利弊。

 

 

2.2  记录每次更新到仓库

现在我们手上已经有了一个真实项目的 Git 仓库，并从这个仓库中取出了所有文件的工作拷贝。接下来，对这些文件作些修改，在完成了一个阶段的目标之后，提交本次更新到仓库。

请记住，工作目录下面的所有文件都不外乎这两种状态：已跟踪或未跟踪。已跟踪的文件是指本来就被纳入版本控制管理的文件，在上次快照中有它们的记 录，工作一段时间后，它们的状态可能是未更新，已修改或者已放入暂存区。而所有其他文件都属于未跟踪文件。它们既没有上次更新时的快照，也不在当前的暂存 区域。初次克隆某个仓库时，工作目录中的所有文件都属于已跟踪文件，且状态为未修改。

在编辑过某些文件之后，Git 将这些文件标为已修改。我们逐步把这些修改过的文件放到暂存区域，直到最后一次性提交所有这些暂存起来的文件，如此重复。所以使用 Git 时的文件状态变化周期如图 2-1 所示。

图 2-1. 文件的状态变化周期

回到顶部

检查当前文件状态

要确定哪些文件当前处于什么状态，可以用 git status 命令。如果在克隆仓库之后立即执行此命令，会看到类似这样的输出：

1. $ git status

2. # On branch master

3. nothing to commit (working directory clean)

这说明你现在的工作目录相当干净。换句话说，当前没有任何跟踪着的文件，也没有任何文件在上次提交后更改过。此外，上面的信息还表明，当前目录下没 有出现任何处于未跟踪的新文件，否则 Git 会在这里列出来。最后，该命令还显示了当前所在的分支是 master，这是默认的分支名称，实际是可以修改的，现在先不用考虑。下一章我们就会详细讨论分支和引用。

现在让我们用 vim 编辑一个新文件 README，保存退出后运行 git status 会看到该文件出现在未跟踪文件列表中：

1. $ vim README

2. $ git status

3. # On branch master

4. # Untracked files:

5. # (use "git add

6.  
7.  
8.  
9.  
10.  
11.  
12.  
13.  
14.  

15. ..." to include in what will be committed)

16. #

17. # README

18. nothing added to commit but untracked files present (use "git add" to track)

19.  
20.  
21.  
22.  

就是在“Untracked files”这行下面。Git 不会自动将之纳入跟踪范围，除非你明明白白地告诉它“我需要跟踪该文件”，因而不用担心把临时文件什么的也归入版本管理。不过现在的例子中，我们确实想要跟踪管理 README 这个文件。

回到顶部

跟踪新文件

使用命令 git add 开始跟踪一个新文件。所以，要跟踪 README 文件，运行：

$ git add README

此时再运行 git status 命令，会看到 README 文件已被跟踪，并处于暂存状态：

1. $ git status

2. # On branch master

3. # Changes to be committed:

4. # (use "git reset HEAD

5.  
6.  
7.  
8.  
9.  
10.  
11.  
12.  
13.  

14. ..." to unstage)

15. #

16. # new file: README

17. #

18.  
19.  
20.  
21.  

只要在 “Changes to be committed” 这行下面的，就说明是已暂存状态。如果此时提交，那么该文件此时此刻的版本将被留存在历史记录中。你可能会想起之前我们使用git init 后就运行了git add 命令，开始跟踪当前目录下的文件。在git add 后面可以指明要跟踪的文件或目录路径。如果是目录的话，就说明要递归跟踪该目录下的所有文件。（译注：其实git add 的潜台词就是把目标文件快照放入暂存区域，也就是 add file into staged area，同时未曾跟踪过的文件标记为需要跟踪。这样就好理解后续 add 操作的实际意义了。）

回到顶部

暂存已修改文件

现在我们修改下之前已跟踪过的文件 benchmarks.rb，然后再次运行 status 命令，会看到这样的状态报告：

1. $ git status

2. # On branch master

3. # Changes to be committed:

4. # (use "git reset HEAD

5.  
6.  
7.  
8.  
9.  
10.  
11.  
12.  
13.  

14. ..." to unstage)

15. #

16. # new file: README

17. #

18. # Changed but not updated:

19. # (use "git add

20.  
21.  
22.  
23.  
24.  
25.  
26.  
27.  
28.  

29. ..." to update what will be committed)

30. #

31. # modified: benchmarks.rb

32. #

33.  
34.  
35.  
36.  
37.  
38.  
39.  
40.  
41.  

文件 benchmarks.rb 出现在 “Changed but not updated” 这行下面，说明已跟踪文件的内容发生了变化，但还没有放到暂存区。要暂存这次更新，需要运行git add 命令（这是个多功能命令，根据目标文件的状态不同，此命令的效果也不同：可以用它开始跟踪新文件，或者把已跟踪的文件放到暂存区，还能用于合并时把有冲突的文件标记为已解决状态等）。现在让我们运行git add 将 benchmarks.rb 放到暂存区，然后再看看git status 的输出：

1. $ git add benchmarks.rb

2. $ git status

3. # On branch master

4. # Changes to be committed:

5. # (use "git reset HEAD

6.  
7.  
8.  
9.  
10.  
11.  
12.  
13.  
14.  

15. ..." to unstage)

16. #

17. # new file: README

18. # modified: benchmarks.rb

19. #

20.  
21.  
22.  
23.  

现在两个文件都已暂存，下次提交时就会一并记录到仓库。假设此时，你想要在 benchmarks.rb 里再加条注释，重新编辑存盘后，准备好提交。不过且慢，再运行git status 看看：

1. $ vim benchmarks.rb

2. $ git status

3. # On branch master

4. # Changes to be committed:

5. # (use "git reset HEAD

6.  
7.  
8.  
9.  
10.  
11.  
12.  
13.  
14.  

15. ..." to unstage)

16. #

17. # new file: README

18. # modified: benchmarks.rb

19. #

20. # Changed but not updated:

21. # (use "git add

22.  
23.  
24.  
25.  
26.  
27.  
28.  
29.  
30.  

31. ..." to update what will be committed)

32. #

33. # modified: benchmarks.rb

34. #

35.  
36.  
37.  
38.  
39.  
40.  
41.  
42.  
43.  

怎么回事？benchmarks.rb 文件出现了两次！一次算未暂存，一次算已暂存，这怎么可能呢？好吧，实际上 Git 只不过暂存了你运行 git add 命令时的版本，如果现在提交，那么提交的是添加注释前的版本，而非当前工作目录中的版本。所以，运行了git add 之后又作了修订的文件，需要重新运行git add 把最新版本重新暂存起来：

1. $ git add benchmarks.rb

2. $ git status

3. # On branch master

4. # Changes to be committed:

5. # (use "git reset HEAD

6.  
7.  
8.  
9.  
10.  
11.  
12.  
13.  
14.  

15. ..." to unstage)

16. #

17. # new file: README

18. # modified: benchmarks.rb

19. #

20.  
21.  
22.  
23.  

回到顶部

忽略某些文件

一般我们总会有些文件无需纳入 Git 的管理，也不希望它们总出现在未跟踪文件列表。通常都是些自动生成的文件，比如日志文件，或者编译过程中创建的临时文件等。我们可以创建一个名为 .gitignore 的文件，列出要忽略的文件模式。来看一个实际的例子：

1. $ cat .gitignore

2. *.[oa]

3. *~

第一行告诉 Git 忽略所有以 .o 或 .a 结尾的文件。一般这类对象文件和存档文件都是编译过程中出现的，我们用不着跟踪它们的版本。第二行告诉 Git 忽略所有以波浪符（~）结尾的文件，许多文本编辑软件（比如 Emacs）都用这样的文件名保存副本。此外，你可能还需要忽略 log，tmp 或者 pid 目录，以及自动生成的文档等等。要养成一开始就设置好 .gitignore 文件的习惯，以免将来误提交这类无用的文件。

文件 .gitignore 的格式规范如下：

• 所有空行或者以注释符号 ＃ 开头的行都会被 Git 忽略。
• 可以使用标准的 glob 模式匹配。 * 匹配模式最后跟反斜杠（/）说明要忽略的是目录。 * 要忽略指定模式以外的文件或目录，可以在模式前加上惊叹号（!）取反。

所谓的 glob 模式是指 shell 所使用的简化了的正则表达式。星号（*）匹配零个或多个任意字符；[abc] 匹配任何一个列在方括号中的字符（这个例子要么匹配一个 a，要么匹配一个 b，要么匹配一个 c）；问号（?）只匹配一个任意字符；如果在方括号中使用短划线分隔两个字符，表示所有在这两个字符范围内的都可以匹配（比如[0-9] 表示匹配所有 0 到 9 的数字）。

我们再看一个 .gitignore 文件的例子：

1. # 此为注释 – 将被 Git 忽略

2. *.a # 忽略所有 .a 结尾的文件

3. !lib.a # 但 lib.a 除外

4. /TODO # 仅仅忽略项目根目录下的 TODO 文件，不包括 subdir/TODO

5. build/ # 忽略 build/ 目录下的所有文件

6. doc/*.txt # 会忽略 doc/notes.txt 但不包括 doc/server/arch.txt

回到顶部

查看已暂存和未暂存的更新

实际上 git status 的显示比较简单，仅仅是列出了修改过的文件，如果要查看具体修改了什么地方，可以用 git diff 命令。稍后我们会详细介绍git diff，不过现在，它已经能回答我们的两个问题了：当前做的哪些更新还没有暂存？有哪些更新已经暂存起来准备好了下次提交？git diff 会使用文件补丁的格式显示具体添加和删除的行。

假如再次修改 README 文件后暂存，然后编辑 benchmarks.rb 文件后先别暂存，运行 status 命令，会看到：

1. $ git status

2. # On branch master

3. # Changes to be committed:

4. # (use "git reset HEAD

5.  
6.  
7.  
8.  
9.  
10.  
11.  
12.  
13.  

14. ..." to unstage)

15. #

16. # new file: README

17. #

18. # Changed but not updated:

19. # (use "git add

20.  
21.  
22.  
23.  
24.  
25.  
26.  
27.  
28.  

29. ..." to update what will be committed)

30. #

31. # modified: benchmarks.rb

32. #

33.  
34.  
35.  
36.  
37.  
38.  
39.  
40.  
41.  

要查看尚未暂存的文件更新了哪些部分，不加参数直接输入 git diff：

1. $ git diff

2. diff --git a/benchmarks.rb b/benchmarks.rb

3. index 3cb747f..da65585 100644

4. --- a/benchmarks.rb

5. +++ b/benchmarks.rb

6. @@ -36,6 +36,10 @@ def main

7. @commit.parents[0].parents[0].parents[0]

8. end

9.  

10. + run_code(x, 'commits 1') do

11. + git.commits.size

12. + end

13. +

14. run_code(x, 'commits 2') do

15. log = git.commits('master', 15)

16. log.size

此命令比较的是工作目录中当前文件和暂存区域快照之间的差异，也就是修改之后还没有暂存起来的变化内容。

若要看已经暂存起来的文件和上次提交时的快照之间的差异，可以用 git diff --cached 命令。（Git 1.6.1 及更高版本还允许使用git diff --staged，效果是相同的，但更好记些。）来看看实际的效果：

1. $ git diff --cached

2. diff --git a/README b/README

3. new file mode 100644

4. index 0000000..03902a1

5. --- /dev/null

6. +++ b/README2

7. @@ -0,0 +1,5 @@

8. +grit

9. + by Tom Preston-Werner, Chris Wanstrath

10. + http://github.com/mojombo/grit

11. +

12. +Grit is a Ruby library for extracting information from a Git repository

请注意，单单 git diff 不过是显示还没有暂存起来的改动，而不是这次工作和上次提交之间的差异。所以有时候你一下子暂存了所有更新过的文件后，运行git diff 后却什么也没有，就是这个原因。

像之前说的，暂存 benchmarks.rb 后再编辑，运行 git status 会看到暂存前后的两个版本：

1. $ git add benchmarks.rb

2. $ echo '# test line' >> benchmarks.rb

3. $ git status

4. # On branch master

5. #

6. # Changes to be committed:

7. #

8. # modified: benchmarks.rb

9. #

10. # Changed but not updated:

11. #

12. # modified: benchmarks.rb

13. #

现在运行 git diff 看暂存前后的变化：

1. $ git diff

2. diff --git a/benchmarks.rb b/benchmarks.rb

3. index e445e28..86b2f7c 100644

4. --- a/benchmarks.rb

5. +++ b/benchmarks.rb

6. @@ -127,3 +127,4 @@ end

7. main()

8.  

9. ##pp Grit::GitRuby.cache_client.stats

10. +# test line

然后用 git diff --cached 查看已经暂存起来的变化：

1. $ git diff --cached

2. diff --git a/benchmarks.rb b/benchmarks.rb

3. index 3cb747f..e445e28 100644

4. --- a/benchmarks.rb

5. +++ b/benchmarks.rb

6. @@ -36,6 +36,10 @@ def main

7. @commit.parents[0].parents[0].parents[0]

8. end

9.  

10. + run_code(x, 'commits 1') do

11. + git.commits.size

12. + end

13. +

14. run_code(x, 'commits 2') do

15. log = git.commits('master', 15)

16. log.size

回到顶部

提交更新

现在的暂存区域已经准备妥当可以提交了。在此之前，请一定要确认还有什么修改过的或新建的文件还没有 git add 过，否则提交的时候不会记录这些还没暂存起来的变化。所以，每次准备提交前，先用git status 看下，是不是都已暂存起来了，然后再运行提交命令git commit：

$ git commit

这种方式会启动文本编辑器以便输入本次提交的说明。（默认会启用 shell 的环境变量 $EDITOR 所指定的软件，一般都是 vim 或 emacs。当然也可以按照第一章介绍的方式，使用git config --global core.editor 命令设定你喜欢的编辑软件。）

编辑器会显示类似下面的文本信息（本例选用 Vim 的屏显方式展示）：

1. # Please enter the commit message for your changes. Lines starting

2. # with '#' will be ignored, and an empty message aborts the commit.

3. # On branch master

4. # Changes to be committed:

5. # (use "git reset HEAD

6.  
7.  
8.  
9.  
10.  
11.  
12.  
13.  
14.  

15. ..." to unstage)

16. #

17. # new file: README

18. # modified: benchmarks.rb

19. ~

20. ~

21. ~

22. ".git/COMMIT_EDITMSG" 10L, 283C

23.  
24.  
25.  
26.  
27.  

可以看到，默认的提交消息包含最后一次运行 git status 的输出，放在注释行里，另外开头还有一空行，供你输入提交说明。你完全可以去掉这些注释行，不过留着也没关系，多少能帮你回想起这次更新的内容有哪些。（如果觉得这还不够，可以用-v 选项将修改差异的每一行都包含到注释中来。）退出编辑器时，Git 会丢掉注释行，将说明内容和本次更新提交到仓库。

另外也可以用 -m 参数后跟提交说明的方式，在一行命令中提交更新：

1. $ git commit -m "Story 182: Fix benchmarks for speed"

2. [master]: created 463dc4f: "Fix benchmarks for speed"

3. 2 files changed, 3 insertions(+), 0 deletions(-)

4. create mode 100644 README

好，现在你已经创建了第一个提交！可以看到，提交后它会告诉你，当前是在哪个分支（master）提交的，本次提交的完整 SHA-1 校验和是什么（463dc4f），以及在本次提交中，有多少文件修订过，多少行添改和删改过。

记住，提交时记录的是放在暂存区域的快照，任何还未暂存的仍然保持已修改状态，可以在下次提交时纳入版本管理。每一次运行提交操作，都是对你项目作一次快照，以后可以回到这个状态，或者进行比较。

回到顶部

跳过使用暂存区域

尽管使用暂存区域的方式可以精心准备要提交的细节，但有时候这么做略显繁琐。Git 提供了一个跳过使用暂存区域的方式，只要在提交的时候，给 git commit 加上-a 选项，Git 就会自动把所有已经跟踪过的文件暂存起来一并提交，从而跳过git add 步骤：

1. $ git status

2. # On branch master

3. #

4. # Changed but not updated:

5. #

6. # modified: benchmarks.rb

7. #

8. $ git commit -a -m 'added new benchmarks'

9. [master 83e38c7] added new benchmarks

10. 1 files changed, 5 insertions(+), 0 deletions(-)

看到了吗？提交之前不再需要 git add 文件 benchmarks.rb 了。

回到顶部

移除文件

要从 Git 中移除某个文件，就必须要从已跟踪文件清单中移除（确切地说，是从暂存区域移除），然后提交。可以用 git rm 命令完成此项工作，并连带从工作目录中删除指定的文件，这样以后就不会出现在未跟踪文件清单中了。

如果只是简单地从工作目录中手工删除文件，运行 git status 时就会在 “Changed but not updated” 部分（也就是_未暂存_清单）看到：

1. $ rm grit.gemspec

2. $ git status

3. # On branch master

4. #

5. # Changed but not updated:

6. # (use "git add/rm

7.  
8.  
9.  
10.  
11.  
12.  
13.  
14.  
15.  

16. ..." to update what will be committed)

17. #

18. # deleted: grit.gemspec

19. #

20.  
21.  
22.  
23.  

然后再运行 git rm 记录此次移除文件的操作：

1. $ git rm grit.gemspec

2. rm 'grit.gemspec'

3. $ git status

4. # On branch master

5. #

6. # Changes to be committed:

7. # (use "git reset HEAD

8.  
9.  
10.  
11.  
12.  
13.  
14.  
15.  
16.  

17. ..." to unstage)

18. #

19. # deleted: grit.gemspec

20. #

21.  
22.  
23.  
24.  
25.  

最后提交的时候，该文件就不再纳入版本管理了。如果删除之前修改过并且已经放到暂存区域的话，则必须要用强制删除选项 -f（译注：即 force 的首字母），以防误删除文件后丢失修改的内容。

另外一种情况是，我们想把文件从 Git 仓库中删除（亦即从暂存区域移除），但仍然希望保留在当前工作目录中。换句话说，仅是从跟踪清单中删除。比如一些大型日志文件或者一堆.a 编译文件，不小心纳入仓库后，要移除跟踪但不删除文件，以便稍后在.gitignore 文件中补上，用--cached 选项即可：

$ git rm --cached readme.txt

后面可以列出文件或者目录的名字，也可以使用 glob 模式。比方说：

$ git rm log/\*.log

注意到星号 * 之前的反斜杠 \，因为 Git 有它自己的文件模式扩展匹配方式，所以我们不用 shell 来帮忙展开（译注：实际上不加反斜杠也可以运行，只不过按照 shell 扩展的话，仅仅删除指定目录下的文件而不会递归匹配。上面的例子本来就指定了目录，所以效果等同，但下面的例子就会用递归方式匹配，所以必须加反斜 杠。）。此命令删除所有log/ 目录下扩展名为.log 的文件。类似的比如：

$ git rm \*~

会递归删除当前目录及其子目录中所有 ~ 结尾的文件。

回到顶部

移动文件

不像其他的 VCS 系统，Git 并不跟踪文件移动操作。如果在 Git 中重命名了某个文件，仓库中存储的元数据并不会体现出这是一次改名操作。不过 Git 非常聪明，它会推断出究竟发生了什么，至于具体是如何做到的，我们稍后再谈。

既然如此，当你看到 Git 的 mv 命令时一定会困惑不已。要在 Git 中对文件改名，可以这么做：

$ git mv file_from file_to

它会恰如预期般正常工作。实际上，即便此时查看状态信息，也会明白无误地看到关于重命名操作的说明：

1. $ git mv README.txt README

2. $ git status

3. # On branch master

4. # Your branch is ahead of 'origin/master' by 1 commit.

5. #

6. # Changes to be committed:

7. # (use "git reset HEAD

8.  
9.  
10.  
11.  
12.  
13.  
14.  
15.  
16.  

17. ..." to unstage)

18. #

19. # renamed: README.txt -> README

20. #

21.  
22.  
23.  
24.  

其实，运行 git mv 就相当于运行了下面三条命令：

1. $ mv README.txt README

2. $ git rm README.txt

3. $ git add README

如此分开操作，Git 也会意识到这是一次改名，所以不管何种方式都一样。当然，直接用 git mv 轻便得多，不过有时候用其他工具批处理改名的话，要记得在提交前删除老的文件名，再添加新的文件名。

 

2.3  查看提交历史

在提交了若干更新之后，又或者克隆了某个项目，想回顾下提交历史，可以使用 git log 命令查看。

接下来的例子会用我专门用于演示的 simplegit 项目，运行下面的命令获取该项目源代码：

git clone git://github.com/schacon/simplegit-progit.git

然后在此项目中运行 git log，应该会看到下面的输出：

1. $ git log

2. commit ca82a6dff817ec66f44342007202690a93763949

3. Author: Scott Chacon

4.  
5.  
6.  
7.  
8.  
9.  
10.  
11.  
12.  
13.  

14. Date: Mon Mar 17 21:52:11 2008 -0700

15.  

16. changed the version number

17.  

18. commit 085bb3bcb608e1e8451d4b2432f8ecbe6306e7e7

19. Author: Scott Chacon

20.  
21.  
22.  
23.  
24.  
25.  
26.  
27.  
28.  
29.  

30. Date: Sat Mar 15 16:40:33 2008 -0700

31.  

32. removed unnecessary test code

33.  

34. commit a11bef06a3f659402fe7563abf99ad00de2209e6

35. Author: Scott Chacon

36.  
37.  
38.  
39.  
40.  
41.  
42.  
43.  
44.  
45.  

46. Date: Sat Mar 15 10:31:28 2008 -0700

47.  

48. first commit

49.  
50.  
51.  
52.  
53.  
54.  
55.  
56.  
57.  
58.  
59.  
60.  
61.  
62.  

默认不用任何参数的话，git log 会按提交时间列出所有的更新，最近的更新排在最上面。看到了吗，每次更新都有一个 SHA-1 校验和、作者的名字和电子邮件地址、提交时间，最后缩进一个段落显示提交说明。

git log 有许多选项可以帮助你搜寻感兴趣的提交，接下来我们介绍些最常用的。

我们常用 -p 选项展开显示每次提交的内容差异，用 -2 则仅显示最近的两次更新：

1. $ git log -p -2

2. commit ca82a6dff817ec66f44342007202690a93763949

3. Author: Scott Chacon

4.  
5.  
6.  
7.  
8.  
9.  
10.  
11.  
12.  
13.  

14. Date: Mon Mar 17 21:52:11 2008 -0700

15.  

16. changed the version number

17.  

18. diff --git a/Rakefile b/Rakefile

19. index a874b73..8f94139 100644

20. --- a/Rakefile

21. +++ b/Rakefile

22. @@ -5,7 +5,7 @@ require 'rake/gempackagetask'

23. spec = Gem::Specification.new do |s|

24. - s.version = "0.1.0"

25. + s.version = "0.1.1"

26. s.author = "Scott Chacon"

27.  

28. commit 085bb3bcb608e1e8451d4b2432f8ecbe6306e7e7

29. Author: Scott Chacon

30.  
31.  
32.  
33.  
34.  
35.  
36.  
37.  
38.  
39.  

40. Date: Sat Mar 15 16:40:33 2008 -0700

41.  

42. removed unnecessary test code

43.  

44. diff --git a/lib/simplegit.rb b/lib/simplegit.rb

45. index a0a60ae..47c6340 100644

46. --- a/lib/simplegit.rb

47. +++ b/lib/simplegit.rb

48. @@ -18,8 +18,3 @@ class SimpleGit

49. end

50.  

51. end

52. -

53. -if $0 == __FILE__

54. - git = SimpleGit.new

55. - puts git.show

56. -end

57. \ No newline at end of file

58.  
59.  
60.  
61.  
62.  
63.  
64.  
65.  
66.  

在做代码审查，或者要快速浏览其他协作者提交的更新都作了哪些改动时，就可以用这个选项。此外，还有许多摘要选项可以用，比如 --stat，仅显示简要的增改行数统计：

1. $ git log --stat

2. commit ca82a6dff817ec66f44342007202690a93763949

3. Author: Scott Chacon

4.  
5.  
6.  
7.  
8.  
9.  
10.  
11.  
12.  
13.  

14. Date: Mon Mar 17 21:52:11 2008 -0700

15.  

16. changed the version number

17.  

18. Rakefile | 2 +-

19. 1 files changed, 1 insertions(+), 1 deletions(-)

20.  

21. commit 085bb3bcb608e1e8451d4b2432f8ecbe6306e7e7

22. Author: Scott Chacon

23.  
24.  
25.  
26.  
27.  
28.  
29.  
30.  
31.  
32.  

33. Date: Sat Mar 15 16:40:33 2008 -0700

34.  

35. removed unnecessary test code

36.  

37. lib/simplegit.rb | 5 -----

38. 1 files changed, 0 insertions(+), 5 deletions(-)

39.  

40. commit a11bef06a3f659402fe7563abf99ad00de2209e6

41. Author: Scott Chacon

42.  
43.  
44.  
45.  
46.  
47.  
48.  
49.  
50.  
51.  

52. Date: Sat Mar 15 10:31:28 2008 -0700

53.  

54. first commit

55.  

56. README | 6 ++++++

57. Rakefile | 23 +++++++++++++++++++++++

58. lib/simplegit.rb | 25 +++++++++++++++++++++++++

59. 3 files changed, 54 insertions(+), 0 deletions(-)

60.  
61.  
62.  
63.  
64.  
65.  
66.  
67.  
68.  
69.  
70.  
71.  
72.  
73.  

每个提交都列出了修改过的文件，以及其中添加和移除的行数，并在最后列出所有增减行数小计。还有个常用的 --pretty 选项，可以指定使用完全不同于默认格式的方式展示提交历史。比如用oneline 将每个提交放在一行显示，这在提交数很大时非常有用。另外还有short，full 和fuller 可以用，展示的信息或多或少有些不同，请自己动手实践一下看看效果如何。

1. $ git log --pretty=oneline

2. ca82a6dff817ec66f44342007202690a93763949 changed the version number

3. 085bb3bcb608e1e8451d4b2432f8ecbe6306e7e7 removed unnecessary test code

4. a11bef06a3f659402fe7563abf99ad00de2209e6 first commit

但最有意思的是 format，可以定制要显示的记录格式，这样的输出便于后期编程提取分析，像这样：

1. $ git log --pretty=format:"%h - %an, %ar : %s"

2. ca82a6d - Scott Chacon, 11 months ago : changed the version number

3. 085bb3b - Scott Chacon, 11 months ago : removed unnecessary test code

4. a11bef0 - Scott Chacon, 11 months ago : first commit

表 2-1 列出了常用的格式占位符写法及其代表的意义。

1. 选项 说明

2. %H 提交对象（commit）的完整哈希字串

3. %h 提交对象的简短哈希字串

4. %T 树对象（tree）的完整哈希字串

5. %t 树对象的简短哈希字串

6. %P 父对象（parent）的完整哈希字串

7. %p 父对象的简短哈希字串

8. %an 作者（author）的名字

9. %ae 作者的电子邮件地址

10. %ad 作者修订日期（可以用 -date= 选项定制格式）

11. %ar 作者修订日期，按多久以前的方式显示

12. %cn 提交者(committer)的名字

13. %ce 提交者的电子邮件地址

14. %cd 提交日期

15. %cr 提交日期，按多久以前的方式显示

16. %s 提交说明

你一定奇怪_作者（author）_和_提交者（committer）_之间究竟有何差别，其实作者指的是实际作出修改的人，提交者指的是最后将此 工作成果提交到仓库的人。所以，当你为某个项目发布补丁，然后某个核心成员将你的补丁并入项目时，你就是作者，而那个核心成员就是提交者。我们会在第五章 再详细介绍两者之间的细微差别。

用 oneline 或 format 时结合 --graph 选项，可以看到开头多出一些 ASCII 字符串表示的简单图形，形象地展示了每个提交所在的分支及其分化衍合情况。在我们之前提到的 Grit 项目仓库中可以看到：

1. $ git log --pretty=format:"%h %s" --graph

2. * 2d3acf9 ignore errors from SIGCHLD on trap

3. * 5e3ee11 Merge branch 'master' of git://github.com/dustin/grit

4. |\

5. | * 420eac9 Added a method for getting the current branch.

6. * | 30e367c timeout code and tests

7. * | 5a09431 add timeout protection to grit

8. * | e1193f8 support for heads with slashes in them

9. |/

10. * d6016bc require time for xmlschema

11. * 11d191e Merge branch 'defunkt' into local

以上只是简单介绍了一些 git log 命令支持的选项。表 2-2 还列出了一些其他常用的选项及其释义。

1. 选项 说明

2. -p 按补丁格式显示每个更新之间的差异。

3. --stat 显示每次更新的文件修改统计信息。

4. --shortstat 只显示 --stat 中最后的行数修改添加移除统计。

5. --name-only 仅在提交信息后显示已修改的文件清单。

6. --name-status 显示新增、修改、删除的文件清单。

7. --abbrev-commit 仅显示 SHA-1 的前几个字符，而非所有的 40 个字符。

8. --relative-date 使用较短的相对时间显示（比如，“2 weeks ago”）。

9. --graph 显示 ASCII 图形表示的分支合并历史。

10. --pretty 使用其他格式显示历史提交信息。可用的选项包括 oneline，short，full，fuller 和 format（后跟指定格式）。

回到顶部

限制输出长度

除了定制输出格式的选项之外，git log 还有许多非常实用的限制输出长度的选项，也就是只输出部分提交信息。之前我们已经看到过 -2 了，它只显示最近的两条提交，实际上，这是 - 选项的写法，其中的 n 可以是任何自然数，表示仅显示最近的若干条提交。不过实践中我们是不太用这个选项的，Git 在输出所有提交时会自动调用分页程序（less），要看更早的更新只需翻到下页即可。

另外还有按照时间作限制的选项，比如 --since 和 --until。下面的命令列出所有最近两周内的提交：

$ git log --since=2.weeks

你可以给出各种时间格式，比如说具体的某一天（“2008-01-15”），或者是多久以前（“2 years 1 day 3 minutes ago”）。

还可以给出若干搜索条件，列出符合的提交。用 --author 选项显示指定作者的提交，用 --grep 选项搜索提交说明中的关键字。（请注意，如果要得到同时满足这两个选项搜索条件的提交，就必须用--all-match 选项。）

如果只关心某些文件或者目录的历史提交，可以在 git log 选项的最后指定它们的路径。因为是放在最后位置上的选项，所以用两个短划线（--）隔开之前的选项和后面限定的路径名。

表 2-3 还列出了其他常用的类似选项。

1. 选项 说明

2. -(n) 仅显示最近的 n 条提交

3. --since, --after 仅显示指定时间之后的提交。

4. --until, --before 仅显示指定时间之前的提交。

5. --author 仅显示指定作者相关的提交。

6. --committer 仅显示指定提交者相关的提交。

来看一个实际的例子，如果要查看 Git 仓库中，2008 年 10 月期间，Junio Hamano 提交的但未合并的测试脚本（位于项目的 t/ 目录下的文件），可以用下面的查询命令：

1. $ git log --pretty="%h - %s" --author=gitster --since="2008-10-01" \

2. --before="2008-11-01" --no-merges -- t/

3. 5610e3b - Fix testcase failure when extended attribute

4. acd3b9e - Enhance hold_lock_file_for_{update,append}()

5. f563754 - demonstrate breakage of detached checkout wi

6. d1a43f2 - reset --hard/read-tree --reset -u: remove un

7. 51a94af - Fix "checkout --track -b newbranch" on detac

8. b0ad11e - pull: allow "git pull origin $something:$cur

Git 项目有 20,000 多条提交，但我们给出搜索选项后，仅列出了其中满足条件的 6 条。

回到顶部

使用图形化工具查阅提交历史

有时候图形化工具更容易展示历史提交的变化，随 Git 一同发布的 gitk 就是这样一种工具。它是用 Tcl/Tk 写成的，基本上相当于 git log 命令的可视化版本，凡是git log 可以用的选项也都能用在 gitk 上。在项目工作目录中输入 gitk 命令后，就会启动图 2-2 所示的界面。

图 2-2. gitk 的图形界面

上半个窗口显示的是历次提交的分支祖先图谱，下半个窗口显示当前点选的提交对应的具体差异。

 

2.4  撤消操作

任何时候，你都有可能需要撤消刚才所做的某些操作。接下来，我们会介绍一些基本的撤消操作相关的命令。请注意，有些操作并不总是可以撤消的，所以请务必谨慎小心，一旦失误，就有可能丢失部分工作成果。

回到顶部

修改最后一次提交

有时候我们提交完了才发现漏掉了几个文件没有加，或者提交信息写错了。想要撤消刚才的提交操作，可以使用 --amend选项重新提交：

$ git commit --amend

此命令将使用当前的暂存区域快照提交。如果刚才提交完没有作任何改动，直接运行此命令的话，相当于有机会重新编辑提交说明，但将要提交的文件快照和之前的一样。

启动文本编辑器后，会看到上次提交时的说明，编辑它确认没问题后保存退出，就会使用新的提交说明覆盖刚才失误的提交。

如果刚才提交时忘了暂存某些修改，可以先补上暂存操作，然后再运行 --amend 提交：

1. $ git commit -m 'initial commit'

2. $ git add forgotten_file

3. $ git commit --amend

上面的三条命令最终只是产生一个提交，第二个提交命令修正了第一个的提交内容。

回到顶部

取消已经暂存的文件

接下来的两个小节将演示如何取消暂存区域中的文件，以及如何取消工作目录中已修改的文件。不用担心，查看文件状态的时候就提示了该如何撤消，所以不需要死记硬背。来看下面的例子，有两个修改过的文件，我们想要分开提交，但不小心用git add . 全加到了暂存区域。该如何撤消暂存其中的一个文件呢？其实，git status 的命令输出已经告诉了我们该怎么做：

1. $ git add .

2. $ git status

3. # On branch master

4. # Changes to be committed:

5. # (use "git reset HEAD

6.  
7.  
8.  
9.  
10.  
11.  
12.  
13.  
14.  

15. ..." to unstage)

16. #

17. # modified: README.txt

18. # modified: benchmarks.rb

19. #

20.  
21.  
22.  
23.  

就在 “Changes to be committed” 下面，括号中有提示，可以使用 git reset HEAD ... 的方式取消暂存。好吧，我们来试试取消暂存 benchmarks.rb 文件：

1. $ git reset HEAD benchmarks.rb

2. benchmarks.rb: locally modified

3. $ git status

4. # On branch master

5. # Changes to be committed:

6. # (use "git reset HEAD

7.  
8.  
9.  
10.  
11.  
12.  
13.  
14.  
15.  

16. ..." to unstage)

17. #

18. # modified: README.txt

19. #

20. # Changed but not updated:

21. # (use "git add

22.  
23.  
24.  
25.  
26.  
27.  
28.  
29.  
30.  

31. ..." to update what will be committed)

32. # (use "git checkout --

33.  
34.  
35.  
36.  
37.  
38.  
39.  
40.  
41.  

42. ..." to discard changes in working directory)

43. #

44. # modified: benchmarks.rb

45. #

46.  
47.  
48.  
49.  
50.  
51.  
52.  
53.  
54.  
55.  
56.  
57.  
58.  
59.  

这条命令看起来有些古怪，先别管，能用就行。现在 benchmarks.rb 文件又回到了之前已修改未暂存的状态。

回到顶部

取消对文件的修改

如果觉得刚才对 benchmarks.rb 的修改完全没有必要，该如何取消修改，回到之前的状态（也就是修改之前的版本）呢？git status 同样提示了具体的撤消方法，接着上面的例子，现在未暂存区域看起来像这样：

1. # Changed but not updated:

2. # (use "git add

3.  
4.  
5.  
6.  
7.  
8.  
9.  
10.  
11.  

12. ..." to update what will be committed)

13. # (use "git checkout --

14.  
15.  
16.  
17.  
18.  
19.  
20.  
21.  
22.  

23. ..." to discard changes in working directory)

24. #

25. # modified: benchmarks.rb

26. #

27.  
28.  
29.  
30.  
31.  
32.  
33.  
34.  
35.  

在第二个括号中，我们看到了抛弃文件修改的命令（至少在 Git 1.6.1 以及更高版本中会这样提示，如果你还在用老版本，我们强烈建议你升级，以获取最佳的用户体验），让我们试试看：

1. $ git checkout -- benchmarks.rb

2. $ git status

3. # On branch master

4. # Changes to be committed:

5. # (use "git reset HEAD

6.  
7.  
8.  
9.  
10.  
11.  
12.  
13.  
14.  

15. ..." to unstage)

16. #

17. # modified: README.txt

18. #

19.  
20.  
21.  
22.  

可以看到，该文件已经恢复到修改前的版本。你可能已经意识到了，这条命令有些危险，所有对文件的修改都没有了，因为我们刚刚把之前版本的文件复制过 来重写了此文件。所以在用这条命令前，请务必确定真的不再需要保留刚才的修改。如果只是想回退版本，同时保留刚才的修改以便将来继续工作，可以用下章介绍 的 stashing 和分支来处理，应该会更好些。

记住，任何已经提交到 Git 的都可以被恢复。即便在已经删除的分支中的提交，或者用 --amend 重新改写的提交，都可以被恢复（关于数据恢复的内容见第九章）。所以，你可能失去的数据，仅限于没有提交过的，对 Git 来说它们就像从未存在过一样。

 

2.5  远程仓库的使用

要参与任何一个 Git 项目的协作，必须要了解该如何管理远程仓库。远程仓库是指托管在网络上的项目仓库，可能会有好多个，其中有些你只能读，另外有些可以写。同他人协作开发某 个项目时，需要管理这些远程仓库，以便推送或拉取数据，分享各自的工作进展。管理远程仓库的工作，包括添加远程库，移除废弃的远程库，管理各式远程库分 支，定义是否跟踪这些分支，等等。本节我们将详细讨论远程库的管理和使用。

回到顶部

查看当前的远程库

要查看当前配置有哪些远程仓库，可以用 git remote 命令，它会列出每个远程库的简短名字。在克隆完某个项目后，至少可以看到一个名为 origin 的远程库，Git 默认使用这个名字来标识你所克隆的原始仓库：

1. $ git clone git://github.com/schacon/ticgit.git

2. Initialized empty Git repository in /private/tmp/ticgit/.git/

3. remote: Counting objects: 595, done.

4. remote: Compressing objects: 100% (269/269), done.

5. remote: Total 595 (delta 255), reused 589 (delta 253)

6. Receiving objects: 100% (595/595), 73.31 KiB | 1 KiB/s, done.

7. Resolving deltas: 100% (255/255), done.

8. $ cd ticgit

9. $ git remote

10. origin

也可以加上 -v 选项（译注：此为 --verbose 的简写，取首字母），显示对应的克隆地址：

1. $ git remote -v

2. origin git://github.com/schacon/ticgit.git

如果有多个远程仓库，此命令将全部列出。比如在我的 Grit 项目中，可以看到：

1. $ cd grit

2. $ git remote -v

3. bakkdoor git://github.com/bakkdoor/grit.git

4. cho45 git://github.com/cho45/grit.git

5. defunkt git://github.com/defunkt/grit.git

6. koke git://github.com/koke/grit.git

7. origin [email protected]:mojombo/grit.git

这样一来，我就可以非常轻松地从这些用户的仓库中，拉取他们的提交到本地。请注意，上面列出的地址只有 origin 用的是 SSH URL 链接，所以也只有这个仓库我能推送数据上去（我们会在第四章解释原因）。

回到顶部

添加远程仓库

要添加一个新的远程仓库，可以指定一个简单的名字，以便将来引用，运行 git remote add [shortname] [url]：

1. $ git remote

2. origin

3. $ git remote add pb git://github.com/paulboone/ticgit.git

4. $ git remote -v

5. origin git://github.com/schacon/ticgit.git

6. pb git://github.com/paulboone/ticgit.git

现在可以用字串 pb 指代对应的仓库地址了。比如说，要抓取所有 Paul 有的，但本地仓库没有的信息，可以运行 git fetch pb：

1. $ git fetch pb

2. remote: Counting objects: 58, done.

3. remote: Compressing objects: 100% (41/41), done.

4. remote: Total 44 (delta 24), reused 1 (delta 0)

5. Unpacking objects: 100% (44/44), done.

6. From git://github.com/paulboone/ticgit

7. * [new branch] master -> pb/master

8. * [new branch] ticgit -> pb/ticgit

现在，Paul 的主干分支（master）已经完全可以在本地访问了，对应的名字是 pb/master，你可以将它合并到自己的某个分支，或者切换到这个分支，看看有些什么有趣的更新。

回到顶部

从远程仓库抓取数据

正如之前所看到的，可以用下面的命令从远程仓库抓取数据到本地：

$ git fetch [remote-name]

此命令会到远程仓库中拉取所有你本地仓库中还没有的数据。运行完成后，你就可以在本地访问该远程仓库中的所有分支，将其中某个分支合并到本地，或者只是取出某个分支，一探究竟。（我们会在第三章详细讨论关于分支的概念和操作。）

如果是克隆了一个仓库，此命令会自动将远程仓库归于 origin 名下。所以，git fetch origin 会抓取从你上次克隆以来别人上传到此远程仓库中的所有更新（或是上次 fetch 以来别人提交的更新）。有一点很重要，需要记住，fetch 命令只是将远端的数据拉到本地仓库，并不自动合并到当前工作分支，只有当你确实准备好了，才能手工合并。

如果设置了某个分支用于跟踪某个远端仓库的分支（参见下节及第三章的内容），可以使用 git pull 命令自动抓取数据下来，然后将远端分支自动合并到本地仓库中当前分支。在日常工作中我们经常这么用，既快且好。实际上，默认情况下git clone 命令本质上就是自动创建了本地的 master 分支用于跟踪远程仓库中的 master 分支（假设远程仓库确实有 master 分支）。所以一般我们运行git pull，目的都是要从原始克隆的远端仓库中抓取数据后，合并到工作目录中的当前分支。

回到顶部

推送数据到远程仓库

项目进行到一个阶段，要同别人分享目前的成果，可以将本地仓库中的数据推送到远程仓库。实现这个任务的命令很简单： git push [remote-name] [branch-name]。如果要把本地的 master 分支推送到origin 服务器上（再次说明下，克隆操作会自动使用默认的 master 和 origin 名字），可以运行下面的命令：

$ git push origin master

只有在所克隆的服务器上有写权限，或者同一时刻没有其他人在推数据，这条命令才会如期完成任务。如果在你推数据前，已经有其他人推送了若干更新，那 你的推送操作就会被驳回。你必须先把他们的更新抓取到本地，合并到自己的项目中，然后才可以再次推送。有关推送数据到远程仓库的详细内容见第三章。

回到顶部

查看远程仓库信息

我们可以通过命令 git remote show [remote-name] 查看某个远程仓库的详细信息，比如要看所克隆的 origin 仓库，可以运行：

1. $ git remote show origin

2. * remote origin

3. URL: git://github.com/schacon/ticgit.git

4. Remote branch merged with 'git pull' while on branch master

5. master

6. Tracked remote branches

7. master

8. ticgit

除了对应的克隆地址外，它还给出了许多额外的信息。它友善地告诉你如果是在 master 分支，就可以用 git pull 命令抓取数据合并到本地。另外还列出了所有处于跟踪状态中的远端分支。

上面的例子非常简单，而随着使用 Git 的深入，git remote show 给出的信息可能会像这样：

1. $ git remote show origin

2. * remote origin

3. URL: [email protected]:defunkt/github.git

4. Remote branch merged with 'git pull' while on branch issues

5. issues

6. Remote branch merged with 'git pull' while on branch master

7. master

8. New remote branches (next fetch will store in remotes/origin)

9. caching

10. Stale tracking branches (use 'git remote prune')

11. libwalker

12. walker2

13. Tracked remote branches

14. acl

15. apiv2

16. dashboard2

17. issues

18. master

19. postgres

20. Local branch pushed with 'git push'

21. master:master

它告诉我们，运行 git push 时缺省推送的分支是什么（译注：最后两行）。它还显示了有哪些远端分支还没有同步到本地（译注：第六行的caching 分支），哪些已同步到本地的远端分支在远端服务器上已被删除（译注：Stale tracking branches 下面的两个分支），以及运行git pull 时将自动合并哪些分支（译注：前四行中列出的issues 和master 分支）。

回到顶部

远程仓库的删除和重命名

在新版 Git 中可以用 git remote rename 命令修改某个远程仓库在本地的简短名称，比如想把 pb 改成paul，可以这么运行：

1. $ git remote rename pb paul

2. $ git remote

3. origin

4. paul

注意，对远程仓库的重命名，也会使对应的分支名称发生变化，原来的 pb/master 分支现在成了 paul/master。

碰到远端仓库服务器迁移，或者原来的克隆镜像不再使用，又或者某个参与者不再贡献代码，那么需要移除对应的远端仓库，可以运行 git remote rm 命令：

1. $ git remote rm paul

2. $ git remote

3. origin

 

 

2.6  打标签

同大多数 VCS 一样，Git 也可以对某一时间点上的版本打上标签。人们在发布某个软件版本（比如 v1.0 等等）的时候，经常这么做。本节我们一起来学习如何列出所有可用的标签，如何新建标签，以及各种不同类型标签之间的差别。

回到顶部

列显已有的标签

列出现有标签的命令非常简单，直接运行 git tag 即可：

1. $ git tag

2. v0.1

3. v1.3

显示的标签按字母顺序排列，所以标签的先后并不表示重要程度的轻重。

我们可以用特定的搜索模式列出符合条件的标签。在 Git 自身项目仓库中，有着超过 240 个标签，如果你只对 1.4.2 系列的版本感兴趣，可以运行下面的命令：

1. $ git tag -l 'v1.4.2.*'

2. v1.4.2.1

3. v1.4.2.2

4. v1.4.2.3

5. v1.4.2.4

回到顶部

新建标签

Git 使用的标签有两种类型：轻量级的（lightweight）和含附注的（annotated）。轻量级标签就像是个不会变化的分支，实际上它就是个指向特 定提交对象的引用。而含附注标签，实际上是存储在仓库中的一个独立对象，它有自身的校验和信息，包含着标签的名字，电子邮件地址和日期，以及标签说明，标 签本身也允许使用 GNU Privacy Guard (GPG) 来签署或验证。一般我们都建议使用含附注型的标签，以便保留相关信息；当然，如果只是临时性加注标签，或者不需要旁注额外信息，用轻量级标签也没问题。

回到顶部

含附注的标签

创建一个含附注类型的标签非常简单，用 -a （译注：取 annotated 的首字母）指定标签名字即可：

1. $ git tag -a v1.4 -m 'my version 1.4'

2. $ git tag

3. v0.1

4. v1.3

5. v1.4

而 -m 选项则指定了对应的标签说明，Git 会将此说明一同保存在标签对象中。如果没有给出该选项，Git 会启动文本编辑软件供你输入标签说明。

可以使用 git show 命令查看相应标签的版本信息，并连同显示打标签时的提交对象。

1. $ git show v1.4

2. tag v1.4

3. Tagger: Scott Chacon

4.  
5.  
6.  
7.  
8.  
9.  
10.  
11.  
12.  
13.  

14. Date: Mon Feb 9 14:45:11 2009 -0800

15.  

16. my version 1.4

17. commit 15027957951b64cf874c3557a0f3547bd83b3ff6

18. Merge: 4a447f7... a6b4c97...

19. Author: Scott Chacon

20.  
21.  
22.  
23.  
24.  
25.  
26.  
27.  
28.  
29.  

30. Date: Sun Feb 8 19:02:46 2009 -0800

31.  

32. Merge branch 'experiment'

33.  
34.  
35.  
36.  
37.  
38.  
39.  
40.  
41.  

我们可以看到在提交对象信息上面，列出了此标签的提交者和提交时间，以及相应的标签说明。

回到顶部

签署标签

如果你有自己的私钥，还可以用 GPG 来签署标签，只需要把之前的 -a 改为 -s （译注： 取 signed 的首字母）即可：

1. $ git tag -s v1.5 -m 'my signed 1.5 tag'

2. You need a passphrase to unlock the secret key for

3. user: "Scott Chacon

4.  
5.  
6.  
7.  
8.  
9.  
10.  
11.  
12.  

13. "

14. 1024-bit DSA key, ID F721C45A, created 2009-02-09

15.  
16.  
17.  
18.  

现在再运行 git show 会看到对应的 GPG 签名也附在其内：

1. $ git show v1.5

2. tag v1.5

3. Tagger: Scott Chacon

4.  
5.  
6.  
7.  
8.  
9.  
10.  
11.  
12.  
13.  

14. Date: Mon Feb 9 15:22:20 2009 -0800

15.  

16. my signed 1.5 tag

17. -----BEGIN PGP SIGNATURE-----

18. Version: GnuPG v1.4.8 (Darwin)

19.  

20. iEYEABECAAYFAkmQurIACgkQON3DxfchxFr5cACeIMN+ZxLKggJQf0QYiQBwgySN

21. Ki0An2JeAVUCAiJ7Ox6ZEtK+NvZAj82/

22. =WryJ

23. -----END PGP SIGNATURE-----

24. commit 15027957951b64cf874c3557a0f3547bd83b3ff6

25. Merge: 4a447f7... a6b4c97...

26. Author: Scott Chacon

27.  
28.  
29.  
30.  
31.  
32.  
33.  
34.  
35.  
36.  

37. Date: Sun Feb 8 19:02:46 2009 -0800

38.  

39. Merge branch 'experiment'

40.  
41.  
42.  
43.  
44.  
45.  
46.  
47.  
48.  

稍后我们再学习如何验证已经签署的标签。

回到顶部

轻量级标签

轻量级标签实际上就是一个保存着对应提交对象的校验和信息的文件。要创建这样的标签，一个 -a，-s 或 -m 选项都不用，直接给出标签名字即可：

1. $ git tag v1.4-lw

2. $ git tag

3. v0.1

4. v1.3

5. v1.4

6. v1.4-lw

7. v1.5

现在运行 git show 查看此标签信息，就只有相应的提交对象摘要：

1. $ git show v1.4-lw

2. commit 15027957951b64cf874c3557a0f3547bd83b3ff6

3. Merge: 4a447f7... a6b4c97...

4. Author: Scott Chacon

5.  
6.  
7.  
8.  
9.  
10.  
11.  
12.  
13.  
14.  

15. Date: Sun Feb 8 19:02:46 2009 -0800

16.  

17. Merge branch 'experiment'

18.  
19.  
20.  
21.  

回到顶部

验证标签

可以使用 git tag -v [tag-name] （译注：取 verify 的首字母）的方式验证已经签署的标签。此命令会调用 GPG 来验证签名，所以你需要有签署者的公钥，存放在 keyring 中，才能验证：

1. $ git tag -v v1.4.2.1

2. object 883653babd8ee7ea23e6a5c392bb739348b1eb61

3. type commit

4. tag v1.4.2.1

5. tagger Junio C Hamano

6.  
7.  
8.  
9.  
10.  
11.  
12.  
13.  
14.  

15. 1158138501 -0700

16.  

17. GIT 1.4.2.1

18.  

19. Minor fixes since 1.4.2, including git-mv and git-http with alternates.

20. gpg: Signature made Wed Sep 13 02:08:25 2006 PDT using DSA key ID F3119B9A

21. gpg: Good signature from "Junio C Hamano

22.  
23.  
24.  
25.  
26.  
27.  
28.  
29.  
30.  

31. "

32. gpg: aka "[jpeg image of size 1513]"

33. Primary key fingerprint: 3565 2A26 2040 E066 C9A7 4A7D C0C6 D9A4 F311 9B9A

34.  
35.  
36.  
37.  
38.  
39.  
40.  
41.  
42.  

若是没有签署者的公钥，会报告类似下面这样的错误：

1. gpg: Signature made Wed Sep 13 02:08:25 2006 PDT using DSA key ID F3119B9A

2. gpg: Can't check signature: public key not found

3. error: could not verify the tag 'v1.4.2.1'

回到顶部

后期加注标签

你甚至可以在后期对早先的某次提交加注标签。比如在下面展示的提交历史中：

1. $ git log --pretty=oneline

2. 15027957951b64cf874c3557a0f3547bd83b3ff6 Merge branch 'experiment'

3. a6b4c97498bd301d84096da251c98a07c7723e65 beginning write support

4. 0d52aaab4479697da7686c15f77a3d64d9165190 one more thing

5. 6d52a271eda8725415634dd79daabbc4d9b6008e Merge branch 'experiment'

6. 0b7434d86859cc7b8c3d5e1dddfed66ff742fcbc added a commit function

7. 4682c3261057305bdd616e23b64b0857d832627b added a todo file

8. 166ae0c4d3f420721acbb115cc33848dfcc2121a started write support

9. 9fceb02d0ae598e95dc970b74767f19372d61af8 updated rakefile

10. 964f16d36dfccde844893cac5b347e7b3d44abbc commit the todo

11. 8a5cbc430f1a9c3d00faaeffd07798508422908a updated readme

我们忘了在提交 “updated rakefile” 后为此项目打上版本号 v1.2，没关系，现在也能做。只要在打标签的时候跟上对应提交对象的校验和（或前几位字符）即可：

$ git tag -a v1.2 9fceb02

可以看到我们已经补上了标签：

1. $ git tag

2. v0.1

3. v1.2

4. v1.3

5. v1.4

6. v1.4-lw

7. v1.5

8.  

9. $ git show v1.2

10. tag v1.2

11. Tagger: Scott Chacon

12.  
13.  
14.  
15.  
16.  
17.  
18.  
19.  
20.  
21.  

22. Date: Mon Feb 9 15:32:16 2009 -0800

23.  

24. version 1.2

25. commit 9fceb02d0ae598e95dc970b74767f19372d61af8

26. Author: Magnus Chacon

27.  
28.  
29.  
30.  
31.  
32.  
33.  
34.  
35.  
36.  

37. Date: Sun Apr 27 20:43:35 2008 -0700

38.  

39. updated rakefile

40. ...

41.  
42.  
43.  
44.  
45.  
46.  
47.  
48.  
49.  

回到顶部

分享标签

默认情况下，git push 并不会把标签传送到远端服务器上，只有通过显式命令才能分享标签到远端仓库。其命令格式如同推送分支，运行git push origin [tagname] 即可：

1. $ git push origin v1.5

2. Counting objects: 50, done.

3. Compressing objects: 100% (38/38), done.

4. Writing objects: 100% (44/44), 4.56 KiB, done.

5. Total 44 (delta 18), reused 8 (delta 1)

6. To [email protected]:schacon/simplegit.git

7. * [new tag] v1.5 -> v1.5

如果要一次推送所有本地新增的标签上去，可以使用 --tags 选项：

1. $ git push origin --tags

2. Counting objects: 50, done.

3. Compressing objects: 100% (38/38), done.

4. Writing objects: 100% (44/44), 4.56 KiB, done.

5. Total 44 (delta 18), reused 8 (delta 1)

6. To [email protected]:schacon/simplegit.git

7. * [new tag] v0.1 -> v0.1

8. * [new tag] v1.2 -> v1.2

9. * [new tag] v1.4 -> v1.4

10. * [new tag] v1.4-lw -> v1.4-lw

11. * [new tag] v1.5 -> v1.5

现在，其他人克隆共享仓库或拉取数据同步后，也会看到这些标签。

 

2.7  技巧和窍门

在结束本章之前，我还想和大家分享一些 Git 使用的技巧和窍门。很多使用 Git 的开发者可能根本就没用过这些技巧，我们也不是说在读过本书后非得用这些技巧不可，但至少应该有所了解吧。说实话，有了这些小窍门，我们的工作可以变得更简单，更轻松，更高效。

回到顶部

自动完成

如果你用的是 Bash shell，可以试试看 Git 提供的自动完成脚本。下载 Git 的源代码，进入 contrib/completion 目录，会看到一个git-completion.bash 文件。将此文件复制到你自己的用户主目录中（译注：按照下面的示例，还应改名加上点：cp git-completion.bash ~/.git-completion.bash），并把下面一行内容添加到你的.bashrc 文件中：

source ~/.git-completion.bash

也可以为系统上所有用户都设置默认使用此脚本。Mac 上将此脚本复制到 /opt/local/etc/bash_completion.d 目录中，Linux 上则复制到/etc/bash_completion.d/ 目录中。这两处目录中的脚本，都会在 Bash 启动时自动加载。

如果在 Windows 上安装了 msysGit，默认使用的 Git Bash 就已经配好了这个自动完成脚本，可以直接使用。

在输入 Git 命令的时候可以敲两次跳格键（Tab），就会看到列出所有匹配的可用命令建议：

1. $ git co

2.  
3.  
4.  
5.  
6.  
7.  
8.  
9.  
10.  
11.  
12.  
13.  
14.  
15.  

16. commit config

17.  
18.  
19.  
20.  
21.  
22.  
23.  
24.  
25.  

此例中，键入 git co 然后连按两次 Tab 键，会看到两个相关的建议（命令） commit 和 config。继而输入 m 会自动完成git commit 命令的输入。

命令的选项也可以用这种方式自动完成，其实这种情况更实用些。比如运行 git log 的时候忘了相关选项的名字，可以输入开头的几个字母，然后敲 Tab 键看看有哪些匹配的：

1. $ git log --s

2.  
3.  
4.  
5.  
6.  
7.  
8.  
9.  
10.  

11. --shortstat --since= --src-prefix= --stat --summary

12.  
13.  
14.  
15.  

这个技巧不错吧，可以节省很多输入和查阅文档的时间。

回到顶部

Git 命令别名

Git 并不会推断你输入的几个字符将会是哪条命令，不过如果想偷懒，少敲几个命令的字符，可以用 git config 为命令设置别名。来看看下面的例子：

1. $ git config --global alias.co checkout

2. $ git config --global alias.br branch

3. $ git config --global alias.ci commit

4. $ git config --global alias.st status

现在，如果要输入 git commit 只需键入 git ci 即可。而随着 Git 使用的深入，会有很多经常要用到的命令，遇到这种情况，不妨建个别名提高效率。

使用这种技术还可以创造出新的命令，比方说取消暂存文件时的输入比较繁琐，可以自己设置一下：

$ git config --global alias.unstage 'reset HEAD --'

这样一来，下面的两条命令完全等同：

1. $ git unstage fileA

2. $ git reset HEAD fileA

显然，使用别名的方式看起来更清楚。另外，我们还经常设置 last 命令：

$ git config --global alias.last 'log -1 HEAD'

然后要看最后一次的提交信息，就变得简单多了：

1. $ git last

2. commit 66938dae3329c7aebe598c2246a8e6af90d04646

3. Author: Josh Goebel

4.  
5.  
6.  
7.  
8.  
9.  
10.  
11.  
12.  
13.  

14. Date: Tue Aug 26 19:48:51 2008 +0800

15.  

16. test for current head

17.  

18. Signed-off-by: Scott Chacon

19.  
20.  
21.  
22.  
23.  
24.  
25.  
26.  
27.  

可以看出，实际上 Git 只是简单地在命令中替换了你设置的别名。不过有时候我们希望运行某个外部命令，而非 Git 的附属工具，这个好办，只需要在命令前加上 ! 就行。如果你自己写了些处理 Git 仓库信息的脚本的话，就可以用这种技术包装起来。作为演示，我们可以设置用 git visual 启动gitk：

$ git config --global alias.visual "!gitk"

 

2.8  小结

到目前为止，你已经学会了最基本的 Git 操作：创建和克隆仓库，做出更新，暂存并提交这些更新，以及查看所有历史更新记录。接下来，我们将学习 Git 的必杀技特性：分支模型。

 

Git命令行配置 
1 安装Github 
2 安装msysgit 
3 要配置用户名和油箱 
  git config --global user.name <用户名> 
 我的命令就是：git config --global user.name mchdbagh 
  git config --global user.email <油箱> 
 我的命令就是：git config --global [email protected] 
4 验证有没有连接上remote远程服务器 
ssh -T [email protected] 

5 要生成ssh key 
$ ssh -keygen 
看到需要输入密码的，直接2个回车键即可回到主窗口。 

去找.ssh里面的id_isa.pub打开，最好用notepad++打开，的里面的内容copy出来，然后放到https://网址里面，加入 
如何生成，请看文档详细介绍。http://www.worldhello.net/gotgithub/index.html#id6 

Git常用命令介绍 
git init --初始化项目，刚开始初始化项目的时候使用 
git clone --从服务器上克隆到本地，如果服务器上面已经有项目了，直接使用这个命令clone到本地进行使用。 
git status --查看版本信息 
git add  --添加本地文件 
git commit --提交更改 
git push --tags --将更改推送到服务器 

(1) git init操作 

1. kyman@SKYMAN-CF7E3587 ~

2. mkdir test_git

3.  

4. kyman@SKYMAN-CF7E3587 ~

5. cd test_git/

6.  

7. kyman@SKYMAN-CF7E3587 ~/test_git

8. ls

9.  

10. kyman@SKYMAN-CF7E3587 ~/test_git

11. $ git init

12. Initialized empty Git repository in c:/Documents and Settings/skyman/test_git/.git/

13. ls -a

14. .. .git

看到有.git文件 

1. $ ls -al

2. total 0

3. drwxr-xr-x 3 skyman Administ 0 Sep 25 23:10 .

4. drwxr-xr-x 41 skyman Administ 0 Sep 25 23:10 ..

5. drwxr-xr-x 1 skyman Administ 0 Sep 25 23:10 .git

6.  

7. $

看到多另一个.git目录，表示项目创建成功了。 

(2) git clone操作 
登陆 https://github.com/，看右下角，如图下图，找到打开库的网址把提示mchdbagh/manual56加到后面，网址就是 https://github.com/mchdbagh/manual56 

 

 

打开后，点击右下角的HTTPS clone URL栏目下方的复制按钮，就得到了库的clone地址 https://github.com/mchdbagh/manual56.git，如图所示

也可以选择ssh方式：[email protected]:mchdbagh/manual56.git 

git clone [email protected]:mchdbagh/manual56.git;

打开 git clone [email protected]:mchdbagh/helloworld.git 
如果需要自定义一个目录名，可以写成 git clone [email protected]:mchdbagh/helloworld.git test_hw 
 

检测是否clone成功，看到有manual56目录是否存在

1. $ ls

2. AppData Favorites NTUSER.DAT SendTo _viminfo manual56 wc

3. Application Data IECompatCache NetHood Templates admovie.jpg ntuser.dat.LOG ??????????????????

4. CMB IETldCache PrintHood UserData client.log ntuser.ini ??????

5. Contacts Local Settings PrivacIE VirtualBox VMs extensions ntuserdirect_MyManager.dat

6. Cookies My Documents Recent WINDOWS helloworld test_git

 

(3) git add 操作实验

1. $ cd manual56/

2. --查看git当前版本库的状态

3. $ git status

4. # On branch master

5. nothing to commit (working directory clean)

6.  

7. --进入我要修改的章节目录

8. $ cd docs/Chapter_17/

9. $ vim 17.5.0.0.0.md --新建一个md文件，里面简单写“only a test”字符串，wq保存退出编辑状态。

10.  

11. -- 查看状态

12. $ git status

13. # On branch master

14. # Untracked files:

15. # (use "git add ..." to include in what will be committed)

16. #

17. # 17.5.0.0.0.md --看到有红颜色的一个新的文件还没有提交上去，这一行的文件名显示为红色。

18. nothing added to commit but untracked files present (use "git add" to track)

添加文件add 

git add 17.5.0.0.0.md添加单个文件，多个文件可以用空格来隔开，比如(git add 17.5.0.0.0.md 17.5.0.0.1.md 17.5.0.0.2.md)，也可以使用git add -A添加所有的文件。

1. --执行添加命令

2. $ git add 17.5.0.0.0.md

3.  

4. --查看单个文件版本状态

5. $ git status 17.5.0.0.0.md

6. # On branch master

7. # Changes to be committed:

8. # (use "git reset HEAD ..." to unstage)

9. #

10. # new file: 17.5.0.0.0.md

11. #

12.  

13. --查看整个库版本状态

14. $ git status

15. # On branch master

16. # Changes to be committed:

17. # (use "git reset HEAD ..." to unstage)

18. #

19. # new file: 17.5.0.0.0.md

20. #

 

手动用MarkdownPad打开C:\Documents and Settings\skyman\manual56\docs\Chapter_17\17.5.0.0.0.md，在里面输入中文字符串，保存退出。然后查看版本库状态，显示绿颜色的表示已经缓存起来了，显示红颜色的是修改过的但是没有缓存起来的。

(4) git commit,修改完之后，进行commit提交 git commit -m "Test change", -m 是指定提交信息，必填项目

1. $ git commit -am "Test chanage"

2. [master 3e96f90] Test chanage

3. 1 file changed, 1 insertion(+), 1 deletion(-)

4.  

5. $ git status

6. # On branch master

7. # Your branch is ahead of 'origin/master' by 2 commits.

8. #

9. nothing to commit (working directory clean)

10. --显示已经提交到本地版本库了

 

(5)把已经修改的文件push到服务器，git push --tags   --push所以缓存到本地服务器的文件。

$ git push origin master  
Counting objects: 13, done.
Delta compression using up to 2 threads.
Compressing objects: 100% (8/8), done.
Writing objects: 100% (10/10), 768 bytes, done.
Total 10 (delta 6), reused 0 (delta 0)
To [email protected]:mchdbagh/manual56.git
   e754e68..3e96f90  master -> master

 

OK成功了，然后打开网址https://github.com/xxxxxx/blob/master/docs/Chapter_17/17.5.0.0.0.md去看提交的新内容，见图片所示，新建立的文件17.5.0.0.0.md已经成功上传到remote文件服务器了。

 

 

这些项目，如果是个人项目，已经足够满足我们的日常使用要求了，但是如果多人协同操作，那还是远远不够的。

 

 

本文暂时不会涉及到团队如何使用Git的内容，而是从个人的角度探讨如何用好Git。

约定

绿色的5位字符表示提交的ID，分别指向父节点。分支用橘色显示，分别指向特定的提交。当前分支由附在其上的标识。 这张图片里显示最后5次提交，是最新提交。分支指向此次提交，另一个分支指向祖父提交节点。

git cat-file

git cat-file -t，查看Git对象的类型，主要的git对象包括tree，commit，parent，和blob等。

git cat-file -p，查看Git对象的内容

git log

git log主要用来显示分支中提交更改的记录。当执行git commit以存储一个快照的时候，文件详单、提交消息和提交者的信息、此次提交所基于的快照都会被保存。

git log --oneline，可以显示更加短小的提交ID.

git log --graph，显示何时出现了分支和合并等信息.

git log --pretty=raw，显示提交对象的parent属性.

git config

git config -e

git config -e --global

git config -e --system

Git的三个配置文件分别是版本库级别的配置文件（/.git/config）、全局配置文件（用户主目录下）和系统级配置文件（/etc目录下）。这个命令的作用是打开相应的配置文件，并且进行编辑。其中版本库级别的配置文件的优先级最高，全局配置文件次之，系统级别配置文件最低。Git配置文件采用的是INI文件格式。

git config

.，读取和更改INI配置文件的内容。

git config

. ，修改INI配置文件中某个配置的键值

在全局空间中添加新的用户

git config --global user.name "harvey liu"

git config --global user.email [email protected]

设置git命令的别名

git config --global alias.ci commit

git config --global alias.co checkout

删除git全局配置文件中的用户名

git config --unset --global user.name

git config --unset --global user.email

git diff

git diff，显示工作区和暂存区的差异

git diff HEAD，显示工作区和HEAD之间的差异

git diff --cached，显示暂存区和HEAD之间的差异

git diff id1 id2，显示两次提交之间的差异

git status

git status，查看你的代码在缓存与当前工作目录的状态

git status -s，将结果以简短的形式输出

git add

git add，在提交你修改的文件之前，你需要把它们添加到暂存区。如果该文件是新创建的，你可以执行将该文件添加到暂存区

git add . ，Git会递归地将你执行命令时所在的目录中的所有文件添加上去，所以如果你将当前的工作目录作为参数，它就会追踪那儿的所有文件

git add -u，使用-u参数调用了git add命令，会将本地有改动（包括删除和修改）的已经追踪的文件标记到暂存区中。

git add -A，使用-A参数会将添加所有改动的已跟踪文件和未跟踪文件。

git add -i，交互式的方式进行添加。

git commit

git commit --amend，修补式提交。

git commit --a，对本地所有变更的文件执行提交操作，包括对本地修改的文件和删除的文件，但是不包括未被版本库跟踪的文件。但是这个命令最好不要使用，这样会丢掉Git暂存区带给用户的最大好处：对提交内容进行控制的能力

git reset

把当前分支指向另一个位置，并且有选择的变动工作目录和索引

git reset --hard ，替换引用的指向，替换暂存区，替换工作区

git reset --soft ，只更改引用的指向，不改变暂存区和工作区

git reset，用HEAD指向的目录树重置暂存区

git reset -- filename，将文件filename的改动撤出暂存区，暂存区其他文件不变

git branch

git branch，显示当前所在的分支

git branch ，创建新的分支branchname

git branch -d ，删除名称为branchname的分支

git checkout

git checkout，检出命令。

git checkout branchname，会改变HEAD头指针，主要用于切换分支

git checkout -b branchname，用于创建一个新的分支，并且切换到创建的新的分支上

git checkout --filename，用暂存区中的filename文件来覆盖工作区中的filename文件

git checkout --filename，用指定提交中的文件覆盖暂存区和工作区中对应的文件

git checkout -- .或者git checkout .，用暂存区的所有文件直接覆盖本地文件，取消所有的本地的修改，是一条危险的操作

git rm

rm命令删除的文件只是在本地进行了删除，尚未添加到暂存区，也就是说，直接在工作区删除，对暂存区和版本库没有任何影响。

git rm命令会将删除动作加入暂存区，这是执行提交动作，就从真正意义上执行了文件删除。

git mv

git mv，移动文件，git中以git rm和git add两条命令取而代之。

git archive

git archive，对任意提交对应的目录树建立归档。

git archive -o latest.zip HEAD，基于最新提交建立归档文件latest.zip

git archive -o partial.tar HEAD src doc，只将目录src和doc建立到归档文件partial.tar中

git archive --format=tar --prefix=1.0/ v1.0 | gzip > foo-1.0.tar.gz，基于里程碑v1.0建立归档，并且为归档中的文件添加目录前缀1.0

git clone

git clone ，将repository指向的版本库创建一个克隆到directory目录中。目录directory相当于克隆版本库的工作区，文件都会检出，版本库位于工作区下得.git目录中。

git clone --bare

git clone --mirror 

上面的两种克隆版本都不包含工作区，直接就是版本库的内容，这样的版本库称为裸版本库。

git push

git push [branch]，就会将你的 [branch] 分支推送成为 [alias] 远端上的 [branch] 分支，要推送的远程版本号的URL地址由remote..pushurl给出，如果没有配置，则使用remote..url配置的URL地址。

git pull

git pull，从远端的服务器上下载数据，从而实现同步更新。要获取的远程版本库的URL地址由remote..url提供。

 

 

 

git checkout 命令详解

时间 2013-05-07 14:21:00 博客园-原创精华区

原文  http://www.cnblogs.com/hutaoer/archive/2013/05/07/git_checkout.html

主题 Git

在日常的git操作中，git checkout——检出，是我们的常用命令。最为常用的两种情形是创建分支和切换分支。

（一）基础——千里之行，始于切糕(checkout)

先熟悉下常用操作，创建分支和切换分支，也可以称为检出分支。

首先我们新建一个仓库gitTest，然后新建文件a，为什么要用a命名呢，这里是故意为之，后面为大家揭晓分支。呵呵。或许下面的介绍会有些枯燥乏味，因为您已经对这些命令烂熟于胸，而且运用得相当熟练，那么您可以直接跳过这一步。

在master分支上，做一次提交c1，然后现在新建一个分支a，并切换到a分支。

这个操作主要会用到两个命令：

创建新分支：git branch branchName

切换到新分支：git checkout branchName

然后 ，上面两个命令也可以合成为一个命令：

git checkout -b branchName

（二）真相——HEAD是checkout的灵魂

其实，我们在切换分支，和新建分支的时候，有没有想过，这些操作操作背后的工作原理是怎样的呢？最大的功臣就是.git目录下的HEAD引用，她宛如一个芭蕾舞者，从一个分支飘逸的跳到另一个分支，虽无声无息，却精准无比。

在我们身处master分支的时候，您一定很好奇，当前的HEAD的内容是什么？不妨来看看吧。

我们看到c1的提交hash值和HEAD对应分支master的当前hash值是一样的。也就是说，HEAD指向的是当前分支名master，而master又对应了当前的最新的一次提交ID.

好，那么我们再做一次提交，看看master对应的hash值有无变化。

从上图，我们可以不难看出，HEAD对应的ref没有变化，还是master，但是master对应的commit ID却变成了c2对应的commit ID，即更新为最后一次提交的ID咯。

现在，提交一次的原理，我们已然了解，那么切换分支的时候呢？？

现在我们身处master分支，然后我们切换到a分支，看看会发生什么样的情况吧。

从上图分析，在master分支上的时候，HEAD指向的是master，对应的是c2的commit ID。而切换到a分支的时候，HEAD也相应的指向了a，同时a对应的是a分支上的最新commit ID。因此，我们可以得出结论，在切换分支的时候，HEAD也会相应的指向对应的分支引用。

但是，使用checkout命令的时候，并不是每次都会改变HEAD指针的指向哦。在什么情况下HEAD一直坚定不移的拥护者他的女神呢？可谓衣带渐宽终不悔，长使英雄泪满襟啊！让我们接着往下看。

（三）进阶——HEAD懂不懂，看你怎么用

checkout命令用法如下：

1. git checkout [-q] [] [--] ...

2. git checkout []

3. git checkout [-m] [ [-b | -- orphan ] ]  [start_point] 

用法2比用法1的区别在于，用法1包含了路径。为了避免路径和引用（或提交ID）同名而发生冲突，可以在前用两个连续的连字符作为分隔。用法1的是可选项，如果省略，则相当于从暂存区进行检出。

来看个例子：

情景1，省略掉

现在我们处于master分支下，然后我们修改了文件a，输入“c3”文本到a中，这时候，暂存区中的内容是没有"c3"的，通过git diff可以比较。现在我们从当前分支暂存区中检出文件a。那么我们可以直接使用git checkout a。

  这时候，提示检出失败，git以为我们想检出仓库a。还记得为什么在第一步中，我们曾新建的文件a吗？这里终于派上用场了，由于仓库中还存在分支a，同时当前分支中又存在文件a，于是git傻傻分不清楚了。这时候怎么办？有两个办法，第一，我们在命名分支的时候要注意语义性，分支名要具有一定的意义，不能使用简单的a,b,c来命名，这样很容易导致分支名和文件名重复；第二，参照用法1，使用两个连字符来分隔。在目前的情形中，我们使用第二种方法吧。

这时候，发现工作区的内容被暂存区的内容覆盖，"c3"文本也没有了，当然HEAD指针也没有什么变化，一切又恢复了平静。

再看一个例子：

情景2，不省略

在不省略的时候，既可以是某一个具体的commit hash值，也可以是某个分支名称，tag名称。不论分支也好，tag也好，它们本质上对应的都是一个commit hash值。

在检出a分支下的a文件的时候，最好把两个连字符加上，不然git也会无法区分。整个过程中，HEAD头指针没有发生改动。

总结：第1种用法（包含的用法）不会改变HEAD头指针，主要使用于指定版本的文件覆盖工作区中对应的文件。如果省略，则会用暂存区的文件覆盖工作区中的文件，否则用指定提交中的文件覆盖暂存区和工作区中的对应文件。

接下来，我们看看用法2，在第一部分中，我们知道切换分支，会改变HEAD的指向，那么如果我们是检出某个commit会怎样呢？同检出分支一样，会用该commit下的内容覆盖当前分支工作区和暂存区的内容，请看例子。

目前我们处于master分支上，且已经有了两次提交，分别是c1和c2，然后我们修改a，给a文件添加内容"c3"，并add到暂存区，随即使用checkout到c1的commit 上。注意，刚开始checkout的时候，git不会允许你直接切换，因为你修改了暂存区的内容， 它会提醒你提交后再切换，这时候，你可以使用-f 强行切换。再查看状态的时候，git提示我们已经不在任何分支上，HEAD指针也是指向具体的c1的commit值，进入了“分离头指针”状态。这个状态下，要回到master上面，只需要git checkout master即可，也可以在这个状态上新建分支。

如果，checkou后面不跟任何参数，则就是对工作区进行检查，请看例子。

我们身处master分支上，并且没有任何改动，这时候git checkout没有任何输出。然后，我们给a文件添加内容“c3”，然后再git checkout一下，git就会提示a文件有修改，是不是很简单？

总结：对于第2种用法，不是检出某个具体文件的的时候，即不指定的时候，单纯的检出某个commit或分支，是会改变HEAD头指针的。而且只有当HEAD切换到某个分支的时候才可以对提交进行跟踪，否则就会进入“分离头指针”的状态。如果省略用法2后面的，则默认对工作区进行状态检查。

（四）熟悉的checkout，陌生的用法，妈妈再也不用担心我的checkout啦！

1. git branch

以某个commit创建新分支。 在通常情况下，我们都会在当前分支的基础上，创建新分支。比如git branch new_branch

也许你不知道，我们还可以基于当前分支的某一次commit来创建分支。请看！

从上图可见，我们想基于master分支的c1 提交ID创建新分支new_branch，创建成功后，切换到new_branch，查看log，只有c1，耶~~成功啦！

当然，也可以使用git checkout -b 这个常用的命令。

 

2.  git checkout --datch

切换到分支的游离状态，默认以该分支下的最后一次提交ID，请看下面的例子。

当前分支为a，然后使用git checkout --detach master，那么HEAD就会切换到master的最后一次commit值的状态下！

 

3. git checkout -B

这个命令，可以强制创建新的分支，为什么加-B呢？如果当前仓库中，已经存在一个跟你新建分支同名的分支，那么使用普通的git checkout -b 这个命令，是会报错的，且同名分支无法创建。如果使用-B参数，那么就可以强制创建新的分支，并会覆盖掉原来的分支。请看具体操作。

当前分支为master，且仓库中已经存在分支a，我们先用git checkout -b a来创建a分支，必然会失败的，并提示我们仓库中已经有了一个a分支咯，仿佛在说“hi，哥们，你已经有了一个老婆了，一夫一妻制你的不懂？你以为这里是印度啊？”。随后，我们使用git checkout -B a，耶~~，it works!

4. git checkout --orphan

是的，假如你的某个分支上，积累了无数次的提交，你也懒得去打理，打印出的log也让你无力吐槽，那么这个命令将是你的神器，它会基于当前所在分支新建一个赤裸裸的分支，没有任何的提交历史，但是当前分支的内容一一俱全。新建的分支，严格意义上说，还不是一个分支，因为HEAD指向的引用中没有commit值，只有在进行一次提交后，它才算得上真正的分支。还等什么呢？赶紧试试！

好了，现在我们终于找到组织了！

5. git checkout --merge

这个命令适用于在切换分支的时候，将当前分支修改的内容一起打包带走，同步到切换的分支下。

有两个需要注意的问题。

第一，如果当前分支和切换分支间的内容不同的话，容易造成冲突。

第二，切换到新分支后，当前分支修改过的内容就丢失了。

所以这个命令，慎用！

6. git checkout -p

这个命令可以用来打补丁。这个命令主要用来比较两个分支间的差异内容，并提供交互式的界面来选择进一步的操作。这个命令不仅可以比较两个分支间的差异，还可以比较单个文件的差异哦！

结束语 ：至此，关于git checkout命令暂告一段落，对于checkout命令，你也有所熟悉了吧。当然，git checkout还有一些其它用法，本文并没有讲到，你可以在git bash或终端中使用git checkout --help去进一步了解！

 

 

 

天在服务器上git pull是出现以下错误：

error: Your local changes to the following files would be overwritten by merge:

        application/config/config.php

        application/controllers/home.php

Please, commit your changes or stash them before you can merge.

Aborting

不知道什么原因造成的代码冲突，处理方法如下：

如果希望保留生产服务器上所做的改动,仅仅并入新配置项:

git stash

git pull

git stash pop

然后可以使用git diff -w +文件名 来确认代码自动合并的情况.

如果希望用代码库中的文件完全覆盖本地工作版本. 方法如下:

git reset --hard

git pull

1、

git push origin  gpio_keys_motor:master   // 提交本地gpio_keys_motor分支到远程的master分支

出错，提示有的ref无法提交。

原因是本地的master分支，和remote上的master有冲突，应该更行到最新的remote master。

问题一：本地分支不是最新的，和remote有冲突，需要更新

问题二：git  pull --rebase 的话，因为较长时间没有更新，此时更新，可能会有比较多冲突

解决：

a: git  checkout gpio_keys_motor

    git log --author=xxxx

commit 75ce33cd41955f70071e95ebed4a699f7657ef54 ----->
Author: xxxx
Date:   Tue Dec 17 10:04:57 2013 +0800
          keyup gpio 
    
    Signed-off-by: xxxx

查找到 需要push 到 remote 的

b: git  checkout -b upstream master               //  创建本地分支 upstream，trace  本地master分支

    git reset --hard HEAD

    git pull origin master:master                       // 从远程获取master最新的版本到本地的master分支上

    git cherry-pick 

    git push origin upstream:master



git merge是用来合并两个分支的。
# 将b分支合并到当前分支
git merge b

git rebase有点类似git merge，但是两者又有不同，打个比方，你有两个抽屉A和B，里面都装了衣服，现在想把B中的衣服放到A中，git merge是那种横冲直撞型的，拿起B就倒入A里面，如果满了（冲突）再一并整理；而git rebase就很持家了，它会一件一件的从B往A中加，会根据一开始放入的时间顺序的来加，如果满了你可以处理这一件，你可以继续加，或者跳过这一件，又或者不加了，把A还原。所以merge适合那种比较琐碎的，简单的合并，系统级的合并还是用rebase吧。

专业的区别请移步到这里合并和衍合
# 合并b
git rebase b

# 处理完冲突继续合并
git rebase --continue

# 跳过
git rebase --skip

# 取消合并
git rebase --abort


git cherry-pick. 如何把已经提交的commit, 从一个分支放到另一个分支

git cherry-pick可以选择某一个分支中的一个或几个commit(s)来进行操作。例如，假设我们有个稳定版本的分支，叫v2.0，另外还有个开发版本的分支v3.0，我们不能直接把两个分支合并，这样会导致稳定版本混乱，但是又想增加一个v3.0中的功能到v2.0中，这里就可以使用cherry-pick了。
# 先在v3.0中查看要合并的commit的commit id
git log
# 假设是 commit f79b0b1ffe445cab6e531260743fa4e08fb4048b
# 切到v2.0中
git check v2.0

# 合并commit
git cherry-pick f79b0b1ffe445cab6e531260743fa4e08fb4048b






注意：当执行完 cherry-pick 以后，将会 生成一个新的提交；这个新的提交的哈希值和原来的不同，但标识名 一样；

实际问题： 
  在本地 master 分支上做了一个commit ( 38361a68138140827b31b72f8bbfd88b3705d77a ) ， 如何把它放到 本地 old_cc 分支上？ 

办法之一： 使用 cherry-pick.  根据git 文档：

    Apply the changes introduced by some existing commits 

就是对已经存在的commit 进行apply (可以理解为再次提交）
简单用法：

    git cherry-pick


例如：
$ git checkout old_cc
$ git cherry-pick 38361a68     # 这个 38361a68 号码，位于：
 

    $ git log 

    commit 38361a68138140827b31b72f8bbfd88b3705d77a 
    Author: Siwei Shen
    Date:   Sat Dec 10 00:09:44 2011 +0800


1. 如果顺利，就会正常提交。结果：

    Finished one cherry-pick.
    # On branch old_cc
    # Your branch is ahead of 'origin/old_cc' by 3 commits.


2. 如果在cherry-pick 的过程中出现了冲突

    Automatic cherry-pick failed.  After resolving the conflicts,
    mark the corrected paths with 'git add ' or 'git rm '
    and commit the result with: 

            git commit -c 15a2b6c61927e5aed6718de89ad9dafba939a90b


就跟普通的冲突一样，手工解决：
2.1 $ git status    # 看哪些文件出现冲突

    both modified:      app/models/user.rb 


2.2 $ vim app/models/user.rb  # 手动解决它。 
2.3 $ git add app/models/user.rb
2.4 git commit -c <新的commit号码>






2、git commit  -s -m "提交的描述信息"
-s
--signoff

    Add Signed-off-by line by the committer at the end of the commit log message.


git commit -a -m "提交的描述信息"
git commit 命令的-a 选项可只将所有被修改或者已删除的且已经被git管理的文档提交倒仓库中。如果只是修改或者删除了已被Git 管理的文档，是没必要使用git add 命令的。


 

Git Stash用法

最近在使用Git管理项目工程的时候，遇到了很多问题，也学习到了很多关于Git常见使用的技巧，下面就其中关于Git Stash的用法和大家分享下。
首先，简单介绍下Git Stash命令的用法，详细的用法在man文档中有相关介绍，下面我来说明常见的使用。
git stash: 备份当前的工作区的内容，从最近的一次提交中读取相关内容，让工作区保证和上次提交的内容一致。同时，将当前的工作区内容保存到Git栈中。
git stash pop: 从Git栈中读取最近一次保存的内容，恢复工作区的相关内容。由于可能存在多个Stash的内容，所以用栈来管理，pop会从最近的一个stash中读取内容并恢复。
git stash list: 显示Git栈内的所有备份，可以利用这个列表来决定从那个地方恢复。
git stash clear: 清空Git栈。此时使用gitg等图形化工具会发现，原来stash的哪些节点都消失了。
关于Git Stash的详细解释，适用场合，这里做一个说明：

使用git的时候，我们往往使用branch解决任务切换问题，例如，我们往往会建一个自己的分支去修改和调试代码, 如果别人或者自己发现原有的分支上有个不得不修改的bug，我们往往会把完成一半的代码 commit提交到本地仓库，然后切换分支去修改bug，改好之后再切换回来。这样的话往往log上会有大量不必要的记录。其实如果我们不想提交完成一半或者不完善的代码，但是却不得不去修改一个紧急Bug，那么使用'git stash'就可以将你当前未提交到本地（和服务器）的代码推入到Git的栈中，这时候你的工作区间和上一次提交的内容是完全一样的，所以你可以放心的修 Bug，等到修完Bug，提交到服务器上后，再使用'git stash apply'将以前一半的工作应用回来。也许有的人会说，那我可不可以多次将未提交的代码压入到栈中？答案是可以的。当你多次使用'git stash'命令后，你的栈里将充满了未提交的代码，这时候你会对将哪个版本应用回来有些困惑，'git stash list'命令可以将当前的Git栈信息打印出来，你只需要将找到对应的版本号，例如使用'git stash apply stash@{1}'就可以将你指定版本号为stash@{1}的工作取出来，当你将所有的栈都应用回来的时候，可以使用'git stash clear'来将栈清空。
在这里顺便提下git format-patch -n , n是具体某个数字， 例如 'git format-patch -1' 这时便会根据log生成一个对应的补丁，如果 'git format-patch -2' 那么便会生成2个补丁，当然前提是你的log上有至少有两个记录。

看过上面的信息，就可以知道使用场合了：当前工作区内容已被修改，但是并未完成。这时Boss来了，说前面的分支上面有一个Bug，需要立即修复。可是我又不想提交目前的修改，因为修改没有完成。但是，不提交的话，又没有办法checkout到前面的分支。此时用Git Stash就相当于备份工作区了。然后在Checkout过去修改，就能够达到保存当前工作区，并及时恢复的作用。

下面，将我使用过程中遇到的一个问题和大家分享：

首先，在Git Stash之后，提交图如下所示：

从图中可以看到，develop和newdevelop是在同一个分支上，因为分支newdevelop是在develop分支的基础上开发的。想加入一个新的特性，所以就开了newdevelop分支，然后就在上面加东西，加特性，该代码。这个时候工作的内容已经变化了，但是develop和newdevelop都是指向同一个提交的，因为newdevelop上面还木有提交。
这个时候，Boss来了，说develop上面有个Bug，赶快改一下，手头的工作先放放，稳定版本不能有缺陷。没办法，当前正在newdevelop上搞的high呢，就Git Stash一下。所以会看到上面有两个节点，红色以及上面一个。就是stash之后的结果，注意是在newdevelop上面进行的stash。

正如前面所说，stash会暂存当前的工作区内容，然后将工作区内容保持和上次提交相同，此时内容都是上面8a32那个提交的内容。从终端中查看相应的信息内容，如下：

印证了签名的说法，newdevelop是有修改，modified，然后stash之后，工作区是最近一次提交，此时newdevelop和develop都是相同的，所以再git status查看发现，都一样，nothing to commit.

然后Stash完成之后，就要Fix Bug了。为此，回到develop分支上进行修复，然后提交，完成后的提交图如下所示：

从途中可以看到，newdevelop还是在下面，因为指向的是老的那个8a32的commit。新的develop由于修复了Bug，所以产生一个新提交。


然后在develop上面修复了Bug之后，在回到newdevelop上面进行一个新的特性的继续编码，此时checkout回去的时候，没有神马内容可以提交，因为都存在Stash中了，没有任何修改。如上图。

那么，恢复工作区内容吧。于是git stash pop（注意这里由于只Stash了一次所以使用pop，具体你存放了多少，要恢复哪一个要自己清楚，否则会出错！）

恢复之后，从上图中可以看到，此时再git status就会发现文件有修改，说明恢复过来了。然后就继续编码，提交一个稳定的新特性版本，如下图，产生的新提交为0906.
然后再查看提交图，会发现，stash pop之后，对应的存放的stash被清空掉了，提交图中，newdevelop上面对应一个新的提交。并且在develop上面。分支的develop那个红色，即为前面修复Bug的那个提交。


总结起来：
操作很简单，但是头脑要清楚。要在哪个分支上修复Bug，要暂存哪个地方的内容，之后修复完了在那个地方提交，然后要到哪个分支上面恢复工作区，都是需要注意的，否则，很容易造成提交图混乱。只有弄清楚了工作流程，才不容易出错，才能保证很高的工作效率。
最后一句：Git是神器，就要看你如何驾驭它了。