Git 简明教程

Git - Quick Guide

Git - Basic Concepts

Version Control System

Version Control System (VCS) 是一款软件，用于帮助软件开发人员共同协作并维护其工作完整记录。

以下列出了 VCS 的功能 −

允许开发人员同时工作。
不允许相互覆盖更改。
维护每个版本的记录。

以下为 VCS 的类型 −

集中式版本控制系统 (CVCS)。
分布式/分散式版本控制系统 (DVCS)。

在本章中，我们将仅集中讨论分布式版本控制系统，特别是 Git。Git 属于分布式版本控制系统。

Distributed Version Control System

集中式版本控制系统 (CVCS) 使用中央服务器存储所有文件，并实现团队协作。但 CVCS 的主要缺点在于它的单点故障，即中央服务器发生故障。不幸的是，如果中央服务器中断一个小时，那么在这个小时内，根本没有人可以协作。在最坏的情况下，如果中央服务器的磁盘损坏且未进行适当的备份，那么您将丢失项目的整个历史记录。此处，分布式版本控制系统 (DVCS) 发挥了作用。

DVCS 客户端不仅可以签出目录的最新快照，还完全镜像仓库。如果服务器发生故障，那么可以从任何客户端将仓库复制回服务器，以便恢复它。每次签出都是仓库的完整备份。Git 不依赖于中央服务器，这就是为什么您在离线时可以执行许多操作的原因。您可以在离线时提交更改、创建分支、查看日志并执行其他操作。您仅需要网络连接即可发布更改并获取最新更改。

Advantages of Git

Free and open source

Git 在 GPL 开源许可下发布。它可免费在网上获得。您无需支付一分钱即可使用 Git 来管理房地产项目。由于它是开源的，您可以下载其源代码，并根据您的要求执行更改。

Fast and small

由于大多数操作都将在本地执行，因此它在速度方面具有巨大的优势。Git 不依赖于中央服务器；这就是为什么无需为每个操作与远程服务器进行交互的原因。Git 的核心部分是用 C 语言编写的，这避免了与其他高级语言相关的运行时开销。尽管 Git 镜像整个仓库，但在客户端上的数据大小却很小。这说明了 Git 在客户端压缩和存储数据方面的效率。

Implicit backup

当存在多个副本时，丢失数据的机会非常罕见。客户机侧上的数据镜像仓库，因此可以在发生崩溃或磁盘损坏时使用它。

Security

Git 使用一种称为安全散列函数 (SHA1) 的常见加密散列函数，在数据库中对对象命名和标识。每次签出时，都会对每个文件和提交进行校验和，并通过其校验和进行检索。这意味着，在不知道 Git 的情况下，无法从 Git 数据库更改文件、日期和提交消息以及任何其他数据。

No need of powerful hardware

对于 CVCS，中央服务器需要足够强大，才能为整个团队提供请求。对于较小的团队而言，这并不是问题，但随着团队规模的扩大，服务器的硬件限制可能会成为性能瓶颈。对于 DVCS，开发人员无需与服务器进行交互，除非他们需要推送或拉取更改。所有繁重的任务都在客户端上进行，因此服务器硬件确实可以非常简单。

Easier branching

CVCS 使用廉价复制机制，如果我们创建一个新分支，它将所有代码复制到新分支，因此非常耗时且效率低下。此外，在 CVCS 中删除和合并分支很复杂且耗时。但使用 Git 进行分支管理非常简单。创建、删除和合并分支只需几秒钟即可完成。

DVCS Terminologies

Local Repository

每个 VCS 工具都提供一个私有工作区作为工作副本。开发人员在其私有工作区中进行更改，而在提交后，这些更改将成为仓库的一部分。Git 将其更进一步，为他们提供了整个仓库的私有副本。用户可以使用此仓库执行许多操作，例如添加文件、移除文件、重命名文件、移动文件、提交更改等许多操作。

Working Directory and Staging Area or Index

工作目录是签出文件的位置。在其他 CVCS 中，开发人员通常进行修改并直接提交其更改到仓库。但是 Git 使用了一种不同的策略。Git 不会跟踪每个修改过的文件。每当您执行提交操作时，Git 都会查找暂存区中存在的文件。只有暂存区中存在的文件才会提交，而并非所有修改过的文件。

让我们看看 Git 的基本工作流。

Step 1 − 你修改了工作目录中的一个文件。

Step 2 − 你将这些文件添加到暂存区。

Step 3 − 你执行提交操作，该操作将文件从暂存区移动。在执行推送操作后，它会将这些更改永久地存储到 Git 存储库中。

假设你修改了两个文件，即“sort.c”和“search.c”，并且你希望对每个操作进行两次不同的提交。你可以将一个文件添加到暂存区并进行提交。在第一次提交后，对另一个文件重复相同的过程。

# First commit
[bash]$ git add sort.c

# adds file to the staging area
[bash]$ git commit –m “Added sort operation”

# Second commit
[bash]$ git add search.c

# adds file to the staging area
[bash]$ git commit –m “Added search operation”

Blobs

Blob 表示 二进制 大对象。文件的每个版本都由 blob 表示。blob 保存着文件数据，但不包含任何关于该文件元数据。它是一个二进制文件，在 Git 数据库中，它被命名为该文件 SHA1 哈希值。在 Git 中，文件并非通过名称来寻址。每种文件都是根据其内容进行寻址的。

Trees

Tree 是一个对象，表示一个目录。它保存着 blob 和其他子目录。tree 是一个二进制文件，它存储着对 blob 和 tree 的引用，它们也被命名为树对象的 SHA1 哈希值。

Commits

Commit 存储着存储库的当前状态。commit 也被 SHA1 哈希值命名。你可以将 commit 对象视作一个链表的节点。每个 commit 对象都有一个父级 commit 对象指针。从给定的 commit 开始，你可以通过查看父级指针来追溯历史提交。如果一个 commit 有多个父级 commit，那么该特定 commit 是通过合并两个分支创建的。

Branches

Branch 用来创建另一个开发线路。默认情况下，Git 有一个 master 分支，它与 Subversion 的 trunk 相同。一般来说，一个分支被创建来开发一个新功能。一旦该功能完成，它就会被合并回 master 分支，然后我们删除这个分支。每个分支都通过 HEAD 引用，该引用指向分支中的最新 commit。每当你进行一次 commit，HEAD 就会被更新为最新 commit。

Clone

Clone 操作创建存储库的实例。Clone 操作不仅会检出工作副本，还会镜像整个存储库。用户可以使用此本地存储库执行许多操作。进行网络交互的唯一时间是存储库实例正在同步的时候。

Pull

Pull 操作将更改从一个远程存储库实例复制到一个本地存储库实例。pull 操作用于在两个存储库实例之间执行同步。这与 Subversion 中的更新操作相同。

Push

Push 操作将更改从一个本地存储库实例复制到一个远程存储库实例。这用于将更改永久地存储到 Git 存储库中。这与 Subversion 中的 commit 操作相同。

HEAD

HEAD 是一个指针，它总是指向分支中的最新 commit。每当你进行一次 commit，HEAD 就会被更新为最新 commit。分支的头部存储在 .git/refs/heads/ 目录中。

[CentOS]$ ls -1 .git/refs/heads/
master

[CentOS]$ cat .git/refs/heads/master
570837e7d58fa4bccd86cb575d884502188b0c49

Revision

Revision 表示源代码的版本。Git 中的 Revision 由 commit 表示。这些 commit 通过 SHA1 安全哈希值来识别。

URL

URL 表示 Git 存储库的位置。Git URL 存储在配置文件中。

[tom@CentOS tom_repo]$ pwd
/home/tom/tom_repo

[tom@CentOS tom_repo]$ cat .git/config
[core]
repositoryformatversion = 0
filemode = true
bare = false
logallrefupdates = true
[remote "origin"]
url = gituser@git.server.com:project.git
fetch = +refs/heads/*:refs/remotes/origin/*

Git - Environment Setup

在使用 Git 之前，您必须安装并执行一些基本配置更改。以下是有关在 Ubuntu 和 Centos Linux 上安装 Git 客户端的步骤。

Installation of Git Client

如果您使用 Debian 基础 GNU/Linux 发行版，则 apt-get 命令将完成必要的操作。

[ubuntu ~]$ sudo apt-get install git-core
[sudo] password for ubuntu:

[ubuntu ~]$ git --version
git version 1.8.1.2

如果您使用基于 RPM 的 GNU/Linux 发行版，请按照给定的使用 yum 命令。

[CentOS ~]$
su -
Password:

[CentOS ~]# yum -y install git-core

[CentOS ~]# git --version
git version 1.7.1

Customize Git Environment

Git 提供了 git config 工具，允许您设置配置变量。Git 将所有全局配置存储在 .gitconfig 文件中，该文件位于您的主目录中。要将这些配置值设置为全局，请添加 --global 选项，如果您省略 --global 选项，则您的配置特定于当前 Git 存储库。

您还可以设置系统范围内的配置。Git 将这些值存储在 /etc/gitconfig 文件中，其中包含系统上每个用户和存储库的配置。要设置这些值，您必须拥有 root 权限并使用 --system 选项。

编译并执行上述代码后，将产生以下结果 −

Setting username

Git 在每次提交时都会使用这些信息。

[jerry@CentOS project]$ git config --global user.name "Jerry Mouse"

Setting email id

Git 在每次提交时都会使用这些信息。

[jerry@CentOS project]$ git config --global user.email "jerry@tutorialspoint.com"

Avoid merge commits for pulling

您从远程存储库拉取最新的更改，如果这些更改是不同的，那么默认情况下 Git 会创建合并提交。我们可以通过以下设置避免这种情况。

jerry@CentOS project]$ git config --global branch.autosetuprebase always

Color highlighting

以下命令为控制台中的 Git 启用颜色高亮显示。

[jerry@CentOS project]$ git config --global color.ui true

[jerry@CentOS project]$ git config --global color.status auto

[jerry@CentOS project]$ git config --global color.branch auto

Setting default editor

默认情况下，Git 使用从 VISUAL 或 EDITOR 环境变量中获取的系统默认编辑器。我们可以使用 git config 配置不同的编辑器。

[jerry@CentOS project]$ git config --global core.editor vim

Setting default merge tool

Git 不提供用于将冲突更改集成到您的工作树中的默认合并工具。我们可以通过启用以下设置来设置默认合并工具。

[jerry@CentOS project]$ git config --global merge.tool vimdiff

Listing Git settings

若要验证本地存储库的 Git 设置，请按照给出下文所示使用 git config –list 命令。

[jerry@CentOS ~]$ git config --list

上述命令将产生以下结果。

user.name=Jerry Mouse
user.email=jerry@tutorialspoint.com
push.default=nothing
branch.autosetuprebase=always
color.ui=true
color.status=auto
color.branch=auto
core.editor=vim
merge.tool=vimdiff

Git - Life Cycle

在本章中，我们将讨论 Git 的生命周期。在后面的章节中，我们将介绍每个操作的 Git 命令。

一般工作流程如下 −

将 Git 存储库克隆为工作副本。
通过添加/编辑文件修改工作副本。
如有必要，通过接受其他开发人员的更改来更新工作副本。
在提交前查看更改。
提交更改。如果一切正常，则将更改推送到存储库。
提交后，如果你意识到有什么问题，则更正上次提交并将更改推送到存储库。

以下是工作流程的图片表示。

Git - Create Operation

在本教程中，我们将看到如何创建远程 Git 存储库；从现在起，我们将称之为 Git 服务器。我们需要 Git 服务器才能实现团队协作。

Create New User

# add new group
[root@CentOS ~]# groupadd dev

# add new user
[root@CentOS ~]# useradd -G devs -d /home/gituser -m -s /bin/bash gituser

# change password
[root@CentOS ~]# passwd gituser

上述命令将产生以下结果。

Changing password for user gituser.
New password:
Retype new password:
passwd: all authentication token updated successfully.

Create a Bare Repository

让我们使用 init 命令，后面跟 --bare 选项，来初始化一个新存储库。它初始化存储库，而没有工作目录。按照惯例，裸存储库必须命名为 .git 。

[gituser@CentOS ~]$ pwd
/home/gituser

[gituser@CentOS ~]$ mkdir project.git

[gituser@CentOS ~]$ cd project.git/

[gituser@CentOS project.git]$ ls

[gituser@CentOS project.git]$ git --bare init
Initialized empty Git repository in /home/gituser-m/project.git/

[gituser@CentOS project.git]$ ls
branches config description HEAD hooks info objects refs

Generate Public/Private RSA Key Pair

让我们逐步完成配置 Git 服务器的过程， ssh-keygen 实用程序生成公钥/私钥 RSA 密钥对，我们将使用该密钥对进行用户身份验证。

打开终端，输入以下命令，并在每个输入后面按 Enter。成功完成后，它会在主目录中创建一个 .ssh 目录。

tom@CentOS ~]$ pwd
/home/tom

[tom@CentOS ~]$ ssh-keygen

上述命令将产生以下结果。

Generating public/private rsa key pair.
Enter file in which to save the key (/home/tom/.ssh/id_rsa): Press Enter Only
Created directory '/home/tom/.ssh'.
Enter passphrase (empty for no passphrase): ---------------> Press Enter Only
Enter same passphrase again: ------------------------------> Press Enter Only
Your identification has been saved in /home/tom/.ssh/id_rsa.
Your public key has been saved in /home/tom/.ssh/id_rsa.pub.
The key fingerprint is:
df:93:8c:a1:b8:b7:67:69:3a:1f:65:e8:0e:e9:25:a1 tom@CentOS
The key's randomart image is:
+--[ RSA 2048]----+
| |
| |
| |
|
.
|
| Soo |
| o*B. |
| E = *.= |
| oo==. . |
| ..+Oo
|
+-----------------+

ssh-keygen 生成了两个密钥，第一个是私钥（即 id_rsa），第二个是公钥（即 id_rsa.pub）。

Note: 绝不要与其他人共享您的私人密钥。

Adding Keys to authorized_keys

假设有两位开发人员正在处理某个项目，他们分别是 Tom 和 Jerry。两个用户都生成了公钥。让我们了解如何使用这些密钥进行验证。

Tom 使用 ssh-copy-id 命令将他的公钥添加到服务器，如下所示：

[tom@CentOS ~]$ pwd
/home/tom

[tom@CentOS ~]$ ssh-copy-id -i ~/.ssh/id_rsa.pub gituser@git.server.com

上述命令将产生以下结果。

gituser@git.server.com's password:
Now try logging into the machine, with "ssh 'gituser@git.server.com'", and check in:
.ssh/authorized_keys
to make sure we haven't added extra keys that you weren't expecting.

同样，Jerry 使用 ssh-copy-id 命令将他的公钥添加到服务器。

[jerry@CentOS ~]$ pwd
/home/jerry

[jerry@CentOS ~]$ ssh-copy-id -i ~/.ssh/id_rsa gituser@git.server.com

上述命令将产生以下结果。

gituser@git.server.com's password:
Now try logging into the machine, with "ssh 'gituser@git.server.com'", and check in:
.ssh/authorized_keys
to make sure we haven't added extra keys that you weren't expecting.

Push Changes to the Repository

我们在服务器上创建了一个裸存储库，并允许两位用户访问。从现在起，Tom 和 Jerry 可以通过将其作为远程存储库添加的方式向存储库推送他们的更改。

Git init 命令创建一个 .git 目录，以便每次从 .git/config 文件读取配置时存储有关存储库的元数据。

Tom 创建一个新目录，添加 README 文件，并将他的更改提交作为初始提交。提交后，他通过运行 git log 命令验证提交消息。

[tom@CentOS ~]$ pwd
/home/tom

[tom@CentOS ~]$ mkdir tom_repo

[tom@CentOS ~]$ cd tom_repo/

[tom@CentOS tom_repo]$ git init
Initialized empty Git repository in /home/tom/tom_repo/.git/

[tom@CentOS tom_repo]$ echo 'TODO: Add contents for README' > README

[tom@CentOS tom_repo]$ git status -s
?? README

[tom@CentOS tom_repo]$ git add .

[tom@CentOS tom_repo]$ git status -s
A README

[tom@CentOS tom_repo]$ git commit -m 'Initial commit'

上述命令将产生以下结果。

[master (root-commit) 19ae206] Initial commit
1 files changed, 1 insertions(+), 0 deletions(-)
create mode 100644 README

Tom 通过执行 git log 命令检查日志消息。

[tom@CentOS tom_repo]$ git log

上述命令将产生以下结果。

commit 19ae20683fc460db7d127cf201a1429523b0e319
Author: Tom Cat <tom@tutorialspoint.com>
Date: Wed Sep 11 07:32:56 2013 +0530

Initial commit

Tom 将他的更改提交到本地存储库。现在，是时候将更改推送到远程存储库了。但在那之前，我们必须将存储库添加为远程存储库，这是一次性操作。在此之后，他可以安全地将更改推送到远程存储库。

Note - 默认情况下，Git 只推送至匹配的分支：对于本地侧存在的每个分支，如果那里已经存在具有相同名称的分支，则会更新远程侧。在我们的教程中，每次我们向 origin master 分支推送更改时，请根据您的要求使用适当的分支名称。

[tom@CentOS tom_repo]$ git remote add origin gituser@git.server.com:project.git

[tom@CentOS tom_repo]$ git push origin master

上述命令将产生以下结果。

Counting objects: 3, done.
Writing objects: 100% (3/3), 242 bytes, done.
Total 3 (delta 0), reused 0 (delta 0)
To gituser@git.server.com:project.git
* [new branch]
master −> master

现在，更改已成功提交到远程存储库。

Git - Clone Operation

我们在 Git 服务器上有一个裸存储库，Tom 也推送了他的第一个版本。现在，Jerry 可以查看他的更改。Clone 操作创建远程存储库的实例。

Jerry 在自己的主目录中创建一个新目录并执行 clone 操作。

[jerry@CentOS ~]$ mkdir jerry_repo

[jerry@CentOS ~]$ cd jerry_repo/

[jerry@CentOS jerry_repo]$ git clone gituser@git.server.com:project.git

上述命令将产生以下结果。

Initialized empty Git repository in /home/jerry/jerry_repo/project/.git/
remote: Counting objects: 3, done.
Receiving objects: 100% (3/3), 241 bytes, done.
remote: Total 3 (delta 0), reused 0 (delta 0)

Jerry 更改为新本地存储库的目录并列出其目录内容。

[jerry@CentOS jerry_repo]$ cd project/

[jerry@CentOS jerry_repo]$ ls
README

Git - Perform Changes

Jerry 克隆了存储库并决定实现基本字符串操作。因此，他创建了 string.c 文件。添加内容后，string.c 将如下所示 −

#include <stdio.h>

int my_strlen(char *s)
{
   char *p = s;

   while (*p)
      ++p;

   return (p - s);
}

int main(void)
{
   int i;
   char *s[] =
   {
      "Git tutorials",
      "Tutorials Point"
   };

   for (i = 0; i < 2; ++i)

   printf("string lenght of %s = %d\n", s[i], my_strlen(s[i]));

   return 0;
}

他编译并测试了代码，一切都运行良好。现在，他可以安全地将这些更改添加到仓库中。

Git add 操作将文件添加到暂存区。

[jerry@CentOS project]$ git status -s
?? string
?? string.c

[jerry@CentOS project]$ git add string.c

Git在文件名之前显示一个问号。显然，这些文件不属于 Git，这就是为什么 Git 不知道如何处理这些文件。因此，Git 在文件名之前显示一个问号。

Jerry 已将文件添加到暂存区，git status 命令将显示暂存区中的文件。

[jerry@CentOS project]$ git status -s
A string.c
?? string

为了提交这些更改，他使用了 git commit 命令，后跟 -m 选项。如果我们省略 -m 选项。Git 将打开一个文本编辑器，我们可以在其中编写多行提交消息。

[jerry@CentOS project]$ git commit -m 'Implemented my_strlen function'

以上命令将生成以下结果 −

[master cbe1249] Implemented my_strlen function
1 files changed, 24 insertions(+), 0 deletions(-)
create mode 100644 string.c

提交后，为了查看日志详情，他运行 git log 命令。它将显示所有提交的信息，包括提交 ID、提交作者、提交日期和提交的 SHA-1 哈希。

[jerry@CentOS project]$ git log

以上命令将生成以下结果 −

commit cbe1249b140dad24b2c35b15cc7e26a6f02d2277
Author: Jerry Mouse <jerry@tutorialspoint.com>
Date: Wed Sep 11 08:05:26 2013 +0530

Implemented my_strlen function


commit 19ae20683fc460db7d127cf201a1429523b0e319
Author: Tom Cat <tom@tutorialspoint.com>
Date: Wed Sep 11 07:32:56 2013 +0530

Initial commit

Git - Review Changes

在查看提交详细信息后，杰瑞意识到字符串长度不能为负，因此他决定更改 my_strlen 函数的返回类型。

杰瑞使用 git log 命令查看日志详细信息。

[jerry@CentOS project]$ git log

上述命令将产生以下结果。

commit cbe1249b140dad24b2c35b15cc7e26a6f02d2277
Author: Jerry Mouse <jerry@tutorialspoint.com>
Date: Wed Sep 11 08:05:26 2013 +0530

Implemented my_strlen function

杰瑞使用 git show 命令查看提交详细信息。git show 命令采用 SHA-1 提交 ID 作为参数。

[jerry@CentOS project]$ git show cbe1249b140dad24b2c35b15cc7e26a6f02d2277

以上命令将生成以下结果 −

commit cbe1249b140dad24b2c35b15cc7e26a6f02d2277
Author: Jerry Mouse <jerry@tutorialspoint.com>
Date: Wed Sep 11 08:05:26 2013 +0530

Implemented my_strlen function


diff --git a/string.c b/string.c
new file mode 100644
index 0000000..187afb9
--- /dev/null
+++ b/string.c
@@ -0,0 +1,24 @@
+#include <stdio.h>
+
+int my_strlen(char *s)
+{
   +
   char *p = s;
   +
   +
   while (*p)
   + ++p;
   + return (p -s );
   +
}
+

他将函数的返回类型从 int 更改为 size_t。在测试代码后，他通过运行 git diff 命令审查自己的更改。

[jerry@CentOS project]$ git diff

以上命令将生成以下结果 −

diff --git a/string.c b/string.c
index 187afb9..7da2992 100644
--- a/string.c
+++ b/string.c
@@ -1,6 +1,6 @@
#include <stdio.h>

-int my_strlen(char *s)
+size_t my_strlen(char *s)
{
   char *p = s;
   @@ -18,7 +18,7 @@ int main(void)
};
for (i = 0; i < 2; ++i)
{
   - printf("string lenght of %s = %d\n", s[i], my_strlen(s[i]));
   + printf("string lenght of %s = %lu\n", s[i], my_strlen(s[i]));
   return 0;
}

Git diff 会在新增行前显示 '+' 符号，在已删除行前显示 '−' 。

Git - Commit Changes

Jerry 已经提交了更改，并且想要纠正他最近的提交。在这种情况下， git amend 操作将有所帮助。amend 操作会更改最后的提交，包括您的提交信息；它会创建一个新的提交 ID。

在 amend 操作之前，他检查提交日志。

[jerry@CentOS project]$ git log

上述命令将产生以下结果。

commit cbe1249b140dad24b2c35b15cc7e26a6f02d2277
Author: Jerry Mouse <jerry@tutorialspoint.com>
Date: Wed Sep 11 08:05:26 2013 +0530

Implemented my_strlen function


commit 19ae20683fc460db7d127cf201a1429523b0e319
Author: Tom Cat <tom@tutorialspoint.com>
Date: Wed Sep 11 07:32:56 2013 +0530

Initial commit

Jerry 使用 –amend 操作提交新更改并查看提交日志。

[jerry@CentOS project]$ git status -s
M string.c
?? string

[jerry@CentOS project]$ git add string.c

[jerry@CentOS project]$ git status -s
M string.c
?? string

[jerry@CentOS project]$ git commit --amend -m 'Changed return type of my_strlen to size_t'
[master d1e19d3] Changed return type of my_strlen to size_t
1 files changed, 24 insertions(+), 0 deletions(-)
create mode 100644 string.c

现在，git log 将显示带有新提交 ID 的新提交信息 −

[jerry@CentOS project]$ git log

上述命令将产生以下结果。

commit d1e19d316224cddc437e3ed34ec3c931ad803958
Author: Jerry Mouse <jerry@tutorialspoint.com>
Date: Wed Sep 11 08:05:26 2013 +0530

Changed return type of my_strlen to size_t


commit 19ae20683fc460db7d127cf201a1429523b0e319
Author: Tom Cat <tom@tutorialspoint.com>
Date: Wed Sep 11 07:32:56 2013 +0530

Initial commit

Git - Push Operation

Jerry 使用 amend 操作修改了他的最后提交，并且他准备推送更改。推送操作将数据永久存储到 Git 存储库中。在推送操作成功后，其他开发人员可以看到 Jerry 的更改。

他执行 git log 命令以查看提交详细信息。

[jerry@CentOS project]$ git log

上述命令将生成以下结果：

commit d1e19d316224cddc437e3ed34ec3c931ad803958
Author: Jerry Mouse <jerry@tutorialspoint.com>
Date: Wed Sep 11 08:05:26 2013 +0530

Changed return type of my_strlen to size_t

在推送操作之前，他想要查看他的更改，因此他使用 git show 命令来查看他的更改。

[jerry@CentOS project]$ git show d1e19d316224cddc437e3ed34ec3c931ad803958

上述命令将生成以下结果：

commit d1e19d316224cddc437e3ed34ec3c931ad803958
Author: Jerry Mouse <jerry@tutorialspoint.com>
Date: Wed Sep 11 08:05:26 2013 +0530

Changed return type of my_strlen to size_t

diff --git a/string.c b/string.c
new file mode 100644
index 0000000..7da2992
--- /dev/null
+++ b/string.c
@@ -0,0 +1,24 @@
+#include <stdio.h>
+
+size_t my_strlen(char *s)
+
{
   +
   char *p = s;
   +
   +
   while (*p)
   + ++p;
   + return (p -s );
   +
}
+
+int main(void)
+
{
   + int i;
   + char *s[] =
   {
      + "Git tutorials",
      + "Tutorials Point"
      +
   };
   +
   +
   +
   for (i = 0; i < 2; ++i)
   printf("string lenght of %s = %lu\n", s[i], my_strlen(s[i]));
   +
   +
   return 0;
   +
}

Jerry 对他的更改很满意，并且他准备推送他的更改。

[jerry@CentOS project]$ git push origin master

上述命令将生成以下结果：

Counting objects: 4, done.
Compressing objects: 100% (3/3), done.
Writing objects: 100% (3/3), 517 bytes, done.
Total 3 (delta 0), reused 0 (delta 0)
To gituser@git.server.com:project.git
19ae206..d1e19d3 master −> master

Jerry 的更改已被成功推送到存储库；现在其他开发人员可以通过执行克隆或更新操作查看他的更改。

Git - Update Operation

Modify Existing Function

Tom 执行克隆操作并找到了一个新文件 string.c。他想了解是谁将此文件添加到仓库的以及出于什么目的，因此他执行了 git log 命令。

[tom@CentOS ~]$ git clone gituser@git.server.com:project.git

以上命令将生成以下结果 −

Initialized empty Git repository in /home/tom/project/.git/
remote: Counting objects: 6, done.
remote: Compressing objects: 100% (4/4), done.
Receiving objects: 100% (6/6), 726 bytes, done.
remote: Total 6 (delta 0), reused 0 (delta 0)

克隆操作将在当前工作目录中创建一个新目录。他将目录更改为新创建的目录并执行 git log 命令。

[tom@CentOS ~]$ cd project/

[tom@CentOS project]$ git log

以上命令将生成以下结果 −

commit d1e19d316224cddc437e3ed34ec3c931ad803958
Author: Jerry Mouse <jerry@tutorialspoint.com>
Date: Wed Sep 11 08:05:26 2013 +0530

Changed return type of my_strlen to size_t


commit 19ae20683fc460db7d127cf201a1429523b0e319
Author: Tom Cat <tom@tutorialspoint.com>
Date: Wed Sep 11 07:32:56 2013 +0530

Initial commit

在观察日志后，他意识到文件 string.c 是由 Jerry 添加的，以实现基本字符串操作。他对 Jerry 的代码感到好奇。因此，他在文本编辑器中打开了 string.c，并立即发现了错误。在 my_strlen 函数中，Jerry 没有使用常量指针。所以，他决定修改 Jerry 的代码。修改后，代码如下 −

[tom@CentOS project]$ git diff

以上命令将生成以下结果 −

diff --git a/string.c b/string.c
index 7da2992..32489eb 100644
--- a/string.c
+++ b/string.c
@@ -1,8 +1,8 @@
#include <stdio.h>
-size_t my_strlen(char *s)
+size_t my_strlen(const char *s)
{
   - char *p = s;
   + const char *p = s;
   while (*p)
   ++p;
}

在测试后，他提交了他的更改。

[tom@CentOS project]$ git status -s
M string.c
?? string

[tom@CentOS project]$ git add string.c

[tom@CentOS project]$ git commit -m 'Changed char pointer to const char pointer'
[master cea2c00] Changed char pointer to const char pointer
1 files changed, 2 insertions(+), 2 deletions(-)

[tom@CentOS project]$ git log

以上命令将生成以下结果 −

commit cea2c000f53ba99508c5959e3e12fff493b
Author: Tom Cat <tom@tutorialspoint.com>
Date: Wed Sep 11 08:32:07 2013 +0530

Changed char pointer to const char pointer


commit d1e19d316224cddc437e3ed34ec3c931ad803958
Author: Jerry Mouse <jerry@tutorialspoint.com>
Date: Wed Sep 11 08:05:26 2013 +0530

Changed return type of my_strlen to size_t


commit 19ae20683fc460db7d127cf201a1429523b0e319
Author: Tom Cat <tom@tutorialspoint.com>
Date: Wed Sep 11 07:32:56 2013 +0530
Initial commit

Tom 使用 git push 命令去推送他的更改。

[tom@CentOS project]$ git push origin master

以上命令将生成以下结果 −

Counting objects: 5, done.
Compressing objects: 100% (3/3), done.
Writing objects: 100% (3/3), 336 bytes, done.
Total 3 (delta 1), reused 0 (delta 0)
To gituser@git.server.com:project.git
d1e19d3..cea2c00 master −> master

Add New Function

与此同时，Jerry 决定实现 string compare 功能。因此，他修改了 string.c。修改后，该文件如下所示 −

[jerry@CentOS project]$ git diff

以上命令将生成以下结果 −

index 7da2992..bc864ed 100644
--- a/string.c
+++ b/string.c
30Git Tutorials
@@ -9,9 +9,20 @@ size_t my_strlen(char *s)
return (p -s );
}
+char *my_strcpy(char *t, char *s)
+
{
   +
   char *p = t;
   +
   + while (*t++ = *s++)
   + ;
   +
   +
   return p;
   +
}
+
int main(void)
{
   int i;
   +
   char p1[32];
   char *s[] =
   {
      "Git tutorials",
      "Tutorials Point"
      @@ -20,5 +31,7 @@ int main(void)
      for (i = 0; i < 2; ++i)
      printf("string lenght of %s = %lu\n", s[i], my_strlen(s[i]));
      +
      printf("%s\n", my_strcpy(p1, "Hello, World !!!"));
      +
      return 0;
   }
}

经过测试，他准备推送自己的变更。

[jerry@CentOS project]$ git status -s
M string.c
?? string

[jerry@CentOS project]$ git add string.c

[jerry@CentOS project]$ git commit -m "Added my_strcpy function"
[master e944e5a] Added my_strcpy function
1 files changed, 13 insertions(+), 0 deletions(-)

在推送操作之前，他通过查看日志消息验证提交。

[jerry@CentOS project]$ git log

以上命令将生成以下结果 −

commit e944e5aab74b26e7447d3281b225309e4e59efcd
Author: Jerry Mouse <jerry@tutorialspoint.com>
Date: Wed Sep 11 08:41:42 2013 +0530

Added my_strcpy function


commit d1e19d316224cddc437e3ed34ec3c931ad803958
Author: Jerry Mouse <jerry@tutorialspoint.com>
Date: Wed Sep 11 08:05:26 2013 +0530

Changed return type of my_strlen to size_t


commit 19ae20683fc460db7d127cf201a1429523b0e319
Author: Tom Cat <tom@tutorialspoint.com>
Date: Wed Sep 11 07:32:56 2013 +0530

Initial commit

Jerry 对更改感到满意，他想推送他的更改。

[jerry@CentOS project]$ git push origin master

以上命令将生成以下结果 −

To gituser@git.server.com:project.git
! [rejected]
master −> master (non-fast-forward)
error: failed to push some refs to 'gituser@git.server.com:project.git'
To prevent you from losing history, non-fast-forward updates were rejected
Merge the remote changes before pushing again. See the 'Note about
fast-forwards' section of 'git push --help' for details.

但是，Git 不允许 Jerry 推送他的更改。因为 Git 识别出远程仓库和 Jerry 的本地仓库不同步。因此，他可能会丢失项目的历史记录。为了避免出现混乱，Git 失败了此操作。现在，Jerry 必须首先更新本地仓库，然后才能推送自己的更改。

Fetch Latest Changes

Jerry 执行 git pull 命令将他的本地仓库与远程仓库同步。

[jerry@CentOS project]$ git pull

以上命令将生成以下结果 −

remote: Counting objects: 5, done.
remote: Compressing objects: 100% (3/3), done.
remote: Total 3 (delta 1), reused 0 (delta 0)
Unpacking objects: 100% (3/3), done.
From git.server.com:project
d1e19d3..cea2c00 master −> origin/master
First, rewinding head to replay your work on top of it...
Applying: Added my_strcpy function

在 pull 操作之后，Jerry 检查日志消息并查找 Tom 的提交的详细信息，提交 ID 为 cea2c000f53ba99508c5959e3e12fff493ba6f69

[jerry@CentOS project]$ git log

以上命令将生成以下结果 −

commit e86f0621c2a3f68190bba633a9fe6c57c94f8e4f
Author: Jerry Mouse <jerry@tutorialspoint.com>
Date: Wed Sep 11 08:41:42 2013 +0530

Added my_strcpy function


commit cea2c000f53ba99508c5959e3e12fff493ba6f69
Author: Tom Cat <tom@tutorialspoint.com>
Date: Wed Sep 11 08:32:07 2013 +0530

Changed char pointer to const char pointer


commit d1e19d316224cddc437e3ed34ec3c931ad803958
Author: Jerry Mouse <jerry@tutorialspoint.com>
Date: Wed Sep 11 08:05:26 2013 +0530

Changed return type of my_strlen to size_t


commit 19ae20683fc460db7d127cf201a1429523b0e319
Author: Tom Cat <tom@tutorialspoint.com>
Date: Wed Sep 11 07:32:56 2013 +0530
Initial commit

现在，Jerry 的本地仓库已与远程仓库完全同步。因此，他可以安全地推送自己的更改。

[jerry@CentOS project]$ git push origin master

以上命令将生成以下结果 −

Counting objects: 5, done.
Compressing objects: 100% (3/3), done.
Writing objects: 100% (3/3), 455 bytes, done.
Total 3 (delta 1), reused 0 (delta 0)
To gituser@git.server.com:project.git
cea2c00..e86f062 master −> master

Git - Stash Operation

假设你正在为你的产品实现一种新功能。你的代码正在进行中，突然收到客户升级。由于这一点，你不得不搁置你的新功能工作几个小时。你无法提交你的部分代码，也不能抛弃你的更改。所以，你需要一些临时空间，在那里你可以存储你的部分更改并在以后提交它们。

在 Git 中，存储操作需要你的已修改的跟踪文件、阶段更改，并将它们保存到一个未完成的更改堆栈中，你可以在任何时候重新应用这些更改。

[jerry@CentOS project]$ git status -s
M string.c
?? string

现在，你想切换分支进行客户升级，但你不想提交你尚未完成的工作，因此你将存储这些更改。要将一个新存储推送到你的堆栈中，请运行 git stash 命令。

[jerry@CentOS project]$ git stash
Saved working directory and index state WIP on master: e86f062 Added my_strcpy function
HEAD is now at e86f062 Added my_strcpy function

现在，你的工作目录已清除，所有更改都已保存在堆栈中。让我们使用 git status 命令对其进行验证。

[jerry@CentOS project]$ git status -s
?? string

现在，你可以安全切换分支并在其他地方工作。我们可以使用 git stash list 命令查看存储的更改的列表。

[jerry@CentOS project]$ git stash list
stash@{0}: WIP on master: e86f062 Added my_strcpy function

假设你已解决了客户升级，并且你回到新功能正在寻找你一半完成的代码，只需执行 git stash pop 命令，即可从堆栈中删除更改并将它们放置在当前工作目录中。

[jerry@CentOS project]$ git status -s
?? string

[jerry@CentOS project]$ git stash pop

上述命令将生成以下结果：

# On branch master
# Changed but not updated:
# (use "git add ..." to update what will be committed)
# (use "git checkout -- ..." to discard changes in working directory)
#
#
modified: string.c
#
# Untracked files:
# (use "git add ..." to include in what will be committed)
#
#
string
no changes added to commit (use "git add" and/or "git commit -a")
Dropped refs/stash@{0} (36f79dfedae4ac20e2e8558830154bd6315e72d4)

[jerry@CentOS project]$ git status -s
M string.c
?? string

Git - Move Operation

顾名思义，移动操作会将目录或文件从一个位置移动到另一个位置。汤姆决定将源代码移动到 src 目录。修改后的目录结构将如下所示：

[tom@CentOS project]$ pwd
/home/tom/project

[tom@CentOS project]$ ls
README string string.c

[tom@CentOS project]$ mkdir src

[tom@CentOS project]$ git mv string.c src/

[tom@CentOS project]$ git status -s
R string.c −> src/string.c
?? string

要使这些更改成为永久更改，我们必须将修改的目录结构推送到远程仓库中，以便其他开发人员可以查看。

[tom@CentOS project]$ git commit -m "Modified directory structure"

[master 7d9ea97] Modified directory structure
1 files changed, 0 insertions(+), 0 deletions(-)
rename string.c => src/string.c (100%)

[tom@CentOS project]$ git push origin master
Counting objects: 4, done.
Compressing objects: 100% (2/2), done.
Writing objects: 100% (3/3), 320 bytes, done.
Total 3 (delta 0), reused 0 (delta 0)
To gituser@git.server.com:project.git
e86f062..7d9ea97 master −> master

在 Jerry 的本地仓库中，在拉取操作之前，将显示旧的目录结构。

[jerry@CentOS project]$ pwd
/home/jerry/jerry_repo/project

[jerry@CentOS project]$ ls
README string string.c

但在拉取操作之后，目录结构将更新。现在，Jerry 可以看到 src 目录以及该目录中存在的文件。

[jerry@CentOS project]$ git pull
remote: Counting objects: 4, done.
remote: Compressing objects: 100% (2/2), done.
remote: Total 3 (delta 0), reused 0 (delta 0)
Unpacking objects: 100% (3/3), done.
From git.server.com:project
e86f062..7d9ea97 master −> origin/master
First, rewinding head to replay your work on top of it...
Fast-forwarded master to 7d9ea97683da90bcdb87c28ec9b4f64160673c8a.

[jerry@CentOS project]$ ls
README src string

[jerry@CentOS project]$ ls src/
string.c

Git - Rename Operation

到目前为止，Tom 和 Jerry 都在使用手动命令编译他们的项目。现在，Jerry 决定为他们的项目创建 Makefile，并且还要为文件“string.c”提供一个恰当的名称。

[jerry@CentOS project]$ pwd
/home/jerry/jerry_repo/project

[jerry@CentOS project]$ ls
README src

[jerry@CentOS project]$ cd src/

[jerry@CentOS src]$ git add Makefile

[jerry@CentOS src]$ git mv string.c string_operations.c

[jerry@CentOS src]$ git status -s
A Makefile
R string.c −> string_operations.c

Git 在文件名之前显示 R 以指示该文件已重命名。

对于提交操作，Jerry 使用 -a 标志，这使得 git 提交自动检测已修改的文件。

[jerry@CentOS src]$ git commit -a -m 'Added Makefile and renamed strings.c to
string_operations.c '

[master 94f7b26] Added Makefile and renamed strings.c to string_operations.c
1 files changed, 0 insertions(+), 0 deletions(-)
create mode 100644 src/Makefile
rename src/{string.c => string_operations.c} (100%)

在提交之后，他将更改推送到仓库。

[jerry@CentOS src]$ git push origin master

以上命令将生成以下结果 −

Counting objects: 6, done.
Compressing objects: 100% (3/3), done.
Writing objects: 100% (4/4), 396 bytes, done.
Total 4 (delta 0), reused 0 (delta 0)
To gituser@git.server.com:project.git
7d9ea97..94f7b26 master −> master

现在，其他开发人员可以通过更新其本地存储库来查看这些修改。

Git - Delete Operation

Tom 更新他的本地仓库，并在 src 目录中找到已编译的二进制文件。在查看提交消息后，他意识到此编译的二进制文件是由 Jerry 添加的。

[tom@CentOS src]$ pwd
/home/tom/project/src

[tom@CentOS src]$ ls
Makefile string_operations string_operations.c

[tom@CentOS src]$ file string_operations
string_operations: ELF 64-bit LSB executable, x86-64, version 1 (SYSV), dynamically linked (uses
shared libs), for GNU/Linux 2.6.18, not stripped

[tom@CentOS src]$ git log
commit 29af9d45947dc044e33d69b9141d8d2dad37cc62
Author: Jerry Mouse <jerry@tutorialspoint.com>
Date: Wed Sep 11 10:16:25 2013 +0530

Added compiled binary

VCS 仅用于存储源代码，不存储可执行二进制文件。因此，Tom 决定从此存储库中删除此文件。对于进一步的操作，他使用了 git rm 命令。

[tom@CentOS src]$ ls
Makefile string_operations string_operations.c

[tom@CentOS src]$ git rm string_operations
rm 'src/string_operations'

[tom@CentOS src]$ git commit -a -m "Removed executable binary"

[master 5776472] Removed executable binary
1 files changed, 0 insertions(+), 0 deletions(-)
delete mode 100755 src/string_operations

在提交之后，他将更改推送到仓库。

[tom@CentOS src]$ git push origin master

上述命令将产生以下结果。

Counting objects: 5, done.
Compressing objects: 100% (3/3), done.
Writing objects: 100% (3/3), 310 bytes, done.
Total 3 (delta 1), reused 0 (delta 0)
To gituser@git.server.com:project.git
29af9d4..5776472 master −> master

Git - Fix Mistakes

人非圣贤，孰能无过。因此，每个 VCS 都提供了在一定范围内修复错误的功能。Git 提供了一个功能，我们可以使用该功能撤销对本地存储库所做的修改。

假设用户错误地对他的本地存储库进行了一些更改，然后想要撤销这些更改。在这种情况下， revert 操作将发挥重要作用。

Revert Uncommitted Changes

让我们假设 Jerry 错误地修改了他本地存储库中的一个文件。但是，他想要撤销他的修改。为了处理这种情况，我们可以使用 git checkout 命令。我们可以使用这个命令来还原文件的内容。

[jerry@CentOS src]$ pwd
/home/jerry/jerry_repo/project/src

[jerry@CentOS src]$ git status -s
M string_operations.c

[jerry@CentOS src]$ git checkout string_operations.c

[jerry@CentOS src]$ git status –s

此外，我们可以使用 git checkout 命令从本地存储库中获取已删除的文件。让我们假设 Tom 从本地存储库中删除了一个文件，并且我们想要恢复这个文件。我们可以使用相同的命令来实现这一点。

[tom@CentOS src]$ pwd
/home/tom/top_repo/project/src

[tom@CentOS src]$ ls -1
Makefile
string_operations.c

[tom@CentOS src]$ rm string_operations.c

[tom@CentOS src]$ ls -1
Makefile

[tom@CentOS src]$ git status -s
D string_operations.c

Git 在文件名之前显示了字母 D 。这表示该文件已从本地存储库中删除。

[tom@CentOS src]$ git checkout string_operations.c

[tom@CentOS src]$ ls -1
Makefile
string_operations.c

[tom@CentOS src]$ git status -s

Note − 我们可以在提交前执行所有这些操作。

Remove Changes from Staging Area

我们已经看到当我们执行一个添加操作时，文件从本地仓库移动到暂存区域。如果一个用户意外地修改了一个文件并将其添加到暂存区域中，他可以使用 git checkout 命令撤销他的修改。

在 Git 中，有一个 HEAD 指针始终指向最新的提交。如果你想要撤销一个来自暂存区域的修改，你可以使用 git checkout 命令，使用 checkout 命令的时候，你必须提供一个额外的参数，即 HEAD 指针。额外的提交指针参数指示 git checkout 命令重置工作树并移除暂存修改。

假设 Tom 从他的本地仓库中修改了一个文件。如果我们查看这个文件的状态，它将会显示文件已经修改但是尚未添加到暂存区域中。

tom@CentOS src]$ pwd
/home/tom/top_repo/project/src
# Unmodified file

[tom@CentOS src]$ git status -s

# Modify file and view it’s status.
[tom@CentOS src]$ git status -s
M string_operations.c

[tom@CentOS src]$ git add string_operations.c

Git status 显示文件出现在暂存区域中，现在使用 git checkout 命令撤销它并查看撤销的文件的状态。

[tom@CentOS src]$ git checkout HEAD -- string_operations.c

[tom@CentOS src]$ git status -s

Move HEAD Pointer with Git Reset

完成了一些修改之后，你可能决定移除这些修改。Git reset 命令用于重置或撤销修改。我们可以执行三种不同类型的重置操作。

下图展示了 Git reset 命令的图片表示。

Soft

每个分支都有一个 HEAD 指针，指向最新的提交。如果我们使用带有 --soft 选项的 Git reset 命令，后面跟着提交 ID，那么它仅仅会在不销毁任何东西的情况下重置 HEAD 指针。

.git/refs/heads/master 文件储存了 HEAD 指针的提交 ID。我们可以使用 git log -1 命令验证它。

[jerry@CentOS project]$ cat .git/refs/heads/master
577647211ed44fe2ae479427a0668a4f12ed71a1

现在，查看最新的提交 ID，它将会与上面的提交 ID 相匹配。

[jerry@CentOS project]$ git log -2

上述命令将产生以下结果。

commit 577647211ed44fe2ae479427a0668a4f12ed71a1
Author: Tom Cat <tom@tutorialspoint.com>
Date: Wed Sep 11 10:21:20 2013 +0530

Removed executable binary


commit 29af9d45947dc044e33d69b9141d8d2dad37cc62
Author: Jerry Mouse <jerry@tutorialspoint.com>
Date: Wed Sep 11 10:16:25 2013 +0530

Added compiled binary

让我们重置 HEAD 指针。

[jerry@CentOS project]$ git reset --soft HEAD~

现在，我们简单地将 HEAD 指针回退一个位置。让我们检查 .git/refs/heads/master file 的内容。

[jerry@CentOS project]$ cat .git/refs/heads/master
29af9d45947dc044e33d69b9141d8d2dad37cc62

文件中的提交 ID 已经改变，现在通过查看提交信息来验证它。

jerry@CentOS project]$ git log -2

上述命令将产生以下结果。

commit 29af9d45947dc044e33d69b9141d8d2dad37cc62
Author: Jerry Mouse <jerry@tutorialspoint.com>
Date: Wed Sep 11 10:16:25 2013 +0530

Added compiled binary


commit 94f7b26005f856f1a1b733ad438e97a0cd509c1a
Author: Jerry Mouse <jerry@tutorialspoint.com>
Date: Wed Sep 11 10:08:01 2013 +0530

Added Makefile and renamed strings.c to string_operations.c

mixed

Git reset 带有 --mixed 选项会撤销那些尚未提交的来自暂存区域的修改。它仅仅会撤销来自暂存区域的修改。对文件工作副本所做的实际修改不会受到影响。默认的 Git reset 等同于 git reset — mixed。

hard

如果你对 Git reset 命令使用 --hard 选项，它将会清空暂存区域；它将会将 HEAD 指针重置为特定提交 ID 的最新提交，也会删除本地文件修改。

让我们检查提交 ID。

[jerry@CentOS src]$ pwd
/home/jerry/jerry_repo/project/src

[jerry@CentOS src]$ git log -1

上述命令将产生以下结果。

commit 577647211ed44fe2ae479427a0668a4f12ed71a1
Author: Tom Cat <tom@tutorialspoint.com>
Date: Wed Sep 11 10:21:20 2013 +0530

Removed executable binary

Jerry 通过在文件开头添加单行注释来修改了文件。

[jerry@CentOS src]$ head -2 string_operations.c
/* This line be removed by git reset operation */
#include <stdio.h>

他使用 git status 命令验证了它。

[jerry@CentOS src]$ git status -s
M string_operations.c

Jerry 将修改的文件添加到暂存区域，并使用 git status 命令验证了它。

[jerry@CentOS src]$ git add string_operations.c
[jerry@CentOS src]$ git status

上述命令将产生以下结果。

# On branch master
# Changes to be committed:
# (use "git reset HEAD <file>..." to unstage)
#
#
modified: string_operations.c
#

Git 状态显示文件出现在暂存区域中。现在，使用重置命令——硬选项重置 HEAD。

[jerry@CentOS src]$ git reset --hard 577647211ed44fe2ae479427a0668a4f12ed71a1

HEAD is now at 5776472 Removed executable binary

Git 重置命令成功，它将从暂存区撤消文件并删除对该文件进行的所有本地更改。

[jerry@CentOS src]$ git status -s

Git 状态显示文件已从暂存区域撤消。

[jerry@CentOS src]$ head -2 string_operations.c
#include <stdio.h>

head 命令还显示了重置操作也移除了本地更改。

Git - Tag Operation

标记操作允许为存储库中的特定版本指定有意义的名称。假设汤姆和杰瑞决定标记他们的项目代码，以便他们以后可以轻松访问它。

Create Tags

让我们使用 git tag 命令标记当前 HEAD。汤姆使用 -a 选项提供标记名称，并使用 –m 选项提供标记消息。

tom@CentOS project]$ pwd
/home/tom/top_repo/project

[tom@CentOS project]$ git tag -a 'Release_1_0' -m 'Tagged basic string operation code' HEAD

如果你想标记特定提交，那么使用适当的 COMMIT ID 代替 HEAD 指针。汤姆使用以下命令将标记推送到远程存储库。

[tom@CentOS project]$ git push origin tag Release_1_0

以上命令将生成以下结果 −

Counting objects: 1, done.
Writing objects: 100% (1/1), 183 bytes, done.
Total 1 (delta 0), reused 0 (delta 0)
To gituser@git.server.com:project.git
* [new tag]
Release_1_0 −> Release_1_0

View Tags

汤姆创建了标记。现在，杰瑞可以使用 Git 标记命令和 –l 选项查看所有可用标记。

[jerry@CentOS src]$ pwd
/home/jerry/jerry_repo/project/src

[jerry@CentOS src]$ git pull
remote: Counting objects: 1, done.
remote: Total 1 (delta 0), reused 0 (delta 0)
Unpacking objects: 100% (1/1), done.
From git.server.com:project
* [new tag]
Release_1_0 −> Release_1_0
Current branch master is up to date.

[jerry@CentOS src]$ git tag -l
Release_1_0

杰瑞使用 Git show 命令，后跟其标记名称来查看标记的更多详细信息。

[jerry@CentOS src]$ git show Release_1_0

以上命令将生成以下结果 −

tag Release_1_0
Tagger: Tom Cat <tom@tutorialspoint.com>
Date: Wed Sep 11 13:45:54 2013 +0530

Tagged basic string operation code


commit 577647211ed44fe2ae479427a0668a4f12ed71a1
Author: Tom Cat <tom@tutorialspoint.com>
Date: Wed Sep 11 10:21:20 2013 +0530

Removed executable binary

diff --git a/src/string_operations b/src/string_operations
deleted file mode 100755
index 654004b..0000000
Binary files a/src/string_operations and /dev/null differ

Delete Tags

汤姆使用以下命令从本地和远程存储库中删除标记。

[tom@CentOS project]$ git tag
Release_1_0

[tom@CentOS project]$ git tag -d Release_1_0
Deleted tag 'Release_1_0' (was 0f81ff4)
# Remove tag from remote repository.

[tom@CentOS project]$ git push origin :Release_1_0
To gituser@git.server.com:project.git
- [deleted]
Release_1_0

Git - Patch Operation

补丁是一个文本文件，其内容类似于 Git diff，但在代码的同时，还包含有关提交的元数据；例如，提交 ID、日期、提交消息等。我们能够从提交中创建一个补丁，其他人能够将其应用到自己的存储库中。

杰瑞为自己的项目实现了 strcat 函数。杰瑞能够创建他的代码的路径并将它发送给汤姆。然后，他能够将收到的补丁应用到自己的代码中。

杰瑞使用 Git format-patch 命令为最新的提交创建了一个补丁。如果你想要为某个特定的提交创建补丁，那么请与格式化补丁命令一起使用 COMMIT_ID 。

[jerry@CentOS project]$ pwd
/home/jerry/jerry_repo/project/src

[jerry@CentOS src]$ git status -s
M string_operations.c
?? string_operations

[jerry@CentOS src]$ git add string_operations.c

[jerry@CentOS src]$ git commit -m "Added my_strcat function"

[master b4c7f09] Added my_strcat function
1 files changed, 13 insertions(+), 0 deletions(-)

[jerry@CentOS src]$ git format-patch -1
0001-Added-my_strcat-function.patch

上述命令在当前工作目录中创建 .patch 文件。汤姆能够使用此补丁修改他的文件。Git 提供了两个命令应用补丁 git am*and *git apply 。 Git apply 修改本地文件而不会创建提交，而 git am 修改文件并创建提交。

要应用补丁并创建提交，请使用以下命令：

[tom@CentOS src]$ pwd
/home/tom/top_repo/project/src

[tom@CentOS src]$ git diff

[tom@CentOS src]$ git status –s

[tom@CentOS src]$ git apply 0001-Added-my_strcat-function.patch

[tom@CentOS src]$ git status -s
M string_operations.c
?? 0001-Added-my_strcat-function.patch

该补丁已成功应用，现在我们可以使用 git diff 命令查看修改。

[tom@CentOS src]$ git diff

以上命令将生成以下结果 −

diff --git a/src/string_operations.c b/src/string_operations.c
index 8ab7f42..f282fcf 100644
--- a/src/string_operations.c
+++ b/src/string_operations.c
@@ -1,5 +1,16 @@
#include <stdio.h>
+char *my_strcat(char *t, char *s)
diff --git a/src/string_operations.c b/src/string_operations.c
index 8ab7f42..f282fcf 100644
--- a/src/string_operations.c
+++ b/src/string_operations.c
@@ -1,5 +1,16 @@
#include <stdio.h>
+char *my_strcat(char *t, char *s)
+
{
   +
   char *p = t;
   +
   +
   +
   while (*p)
   ++p;
   +
   while (*p++ = *s++)
   + ;
   + return t;
   +
}
+
size_t my_strlen(const char *s)
{
   const char *p = s;
   @@ -23,6 +34,7 @@ int main(void)
   {

Git - Managing Branches

分支操作允许创建另一行开发内容。我们可以使用此操作将开发进程分叉到两个不同的方向。例如，我们为 6.0 版本发布了一个产品，我们可能希望创建一个分支，以便使 7.0 功能的开发与 6.0 的 bug 修复保持分离。

Create Branch

Tom 使用 git branch <branch name> 命令创建一个新分支。我们可以从现有分支创建一个新分支。我们可以使用特定的提交或标签作为起点。如果没有提供任何特定提交 ID，那么将以 HEAD 为起点创建分支。

[jerry@CentOS src]$ git branch new_branch

[jerry@CentOS src]$ git branch
* master
new_branch

新分支已创建；Tom 使用 git branch 命令列出可用分支。Git 在当前签出的分支前显示星号标记。

下面显示创建分支操作的图片表示形式 −

Switch between Branches

Jerry 使用 git checkout 命令在分支之间切换。

[jerry@CentOS src]$ git checkout new_branch
Switched to branch 'new_branch'
[jerry@CentOS src]$ git branch
master
* new_branch

Shortcut to Create and Switch Branch

在上面的示例中，我们分别使用了两个命令创建并切换分支。Git 为 checkout 命令提供 –b 选项；此操作创建一个新分支，然后立即切换到新分支。

[jerry@CentOS src]$ git checkout -b test_branch
Switched to a new branch 'test_branch'

[jerry@CentOS src]$ git branch
master
new_branch
* test_branch

Delete a Branch

可以通过使用 –D 选项和 git 分支命令删除分支。但在删除现有分支之前，请切换到另一个分支。

Jerry 目前在 test_branch ，他希望删除该分支。因此，他切换分支并删除分支，如下所示。

[jerry@CentOS src]$ git branch
master
new_branch
* test_branch

[jerry@CentOS src]$ git checkout master
Switched to branch 'master'

[jerry@CentOS src]$ git branch -D test_branch
Deleted branch test_branch (was 5776472).

现在，Git 只会显示两个分支。

[jerry@CentOS src]$ git branch
* master
new_branch

Rename a Branch

Jerry 决定在他的字符串操作项目中添加对宽字符的支持。他已经创建了一个新分支，但分支名称不恰当。因此，他使用 –m 选项，后跟 old branch name 和 new branch name ，更改分支名称。

[jerry@CentOS src]$ git branch
* master
new_branch

[jerry@CentOS src]$ git branch -m new_branch wchar_support

现在，git branch 命令将显示新的分支名称。

[jerry@CentOS src]$ git branch
* master
wchar_support

Merge Two Branches

杰瑞实现了一个返回宽字符长度的字符串长度的函数。现在代码将显示如下所示：

[jerry@CentOS src]$ git branch
master
* wchar_support

[jerry@CentOS src]$ pwd
/home/jerry/jerry_repo/project/src

[jerry@CentOS src]$ git diff

上述命令会产生以下结果 −

t a/src/string_operations.c b/src/string_operations.c
index 8ab7f42..8fb4b00 100644
--- a/src/string_operations.c
+++ b/src/string_operations.c
@@ -1,4 +1,14 @@
#include <stdio.h>
+#include <wchar.h>
+
+size_t w_strlen(const wchar_t *s)
+
{
   +
   const wchar_t *p = s;
   +
   +
   while (*p)
   + ++p;
   + return (p - s);
   +
}

在测试后，他提交并推送下代码更改到新的分支。

[jerry@CentOS src]$ git status -s
M string_operations.c
?? string_operations

[jerry@CentOS src]$ git add string_operations.c

[jerry@CentOS src]$ git commit -m 'Added w_strlen function to return string lenght of wchar_t
string'

[wchar_support 64192f9] Added w_strlen function to return string lenght of wchar_t string
1 files changed, 10 insertions(+), 0 deletions(-)

请注意，杰瑞将这些更改推送到新的分支，这才使他使用分支名称 wchar_support ，而不是 master 分支。

[jerry@CentOS src]$ git push origin wchar_support   <−−− Observer branch_name

上述命令将产生以下结果。

Counting objects: 7, done.
Compressing objects: 100% (4/4), done.
Writing objects: 100% (4/4), 507 bytes, done.
Total 4 (delta 1), reused 0 (delta 0)
To gituser@git.server.com:project.git
* [new branch]
wchar_support -> wchar_support

在提交更改后，新分支将显示如下所示：

汤姆很想知道杰瑞在他的私有分支中做了什么，并从 wchar_support 分支中查看了日志。

[tom@CentOS src]$ pwd
/home/tom/top_repo/project/src

[tom@CentOS src]$ git log origin/wchar_support -2

上述命令将产生以下结果。

commit 64192f91d7cc2bcdf3bf946dd33ece63b74184a3
Author: Jerry Mouse <jerry@tutorialspoint.com>
Date: Wed Sep 11 16:10:06 2013 +0530

Added w_strlen function to return string lenght of wchar_t string


commit 577647211ed44fe2ae479427a0668a4f12ed71a1
Author: Tom Cat <tom@tutorialspoint.com>
Date: Wed Sep 11 10:21:20 2013 +0530

Removed executable binary

通过查看提交消息，汤姆得知杰瑞实现了一个宽字符的 strlen 函数，他还希望在主分支中实现相同的功能。他决定不重新实现，而是通过将自己的分支与主分支合并来采用杰瑞的代码。

[tom@CentOS project]$ git branch
* master

[tom@CentOS project]$ pwd
/home/tom/top_repo/project

[tom@CentOS project]$ git merge origin/wchar_support
Updating 5776472..64192f9
Fast-forward
src/string_operations.c | 10 ++++++++++
1 files changed, 10 insertions(+), 0 deletions(-)

在合并操作后，主分支将显示如下所示：

现在，分支 wchar_support 已与主分支合并。我们可以通过查看提交消息或通过查看对 string_operation.c 文件所做的修改来验证这一点。

[tom@CentOS project]$ cd src/

[tom@CentOS src]$ git log -1

commit 64192f91d7cc2bcdf3bf946dd33ece63b74184a3
Author: Jerry Mouse
Date: Wed Sep 11 16:10:06 2013 +0530

Added w_strlen function to return string lenght of wchar_t string

[tom@CentOS src]$ head -12 string_operations.c