入门知识——Git

灰太狼 2022-04-15 03:48 259阅读 0赞

1.Git定义：

Git是分布式版本控制系统

工作原理 / 流程：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ppamVycnk_size_16_color_FFFFFF_t_70][]

Workspace：工作区

Index / Stage：暂存区

Repository：仓库区（或本地仓库）

Remote：远程仓库

因为Git是分布式版本控制系统，所以需要填写用户名和邮箱作为一个标识。

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

2.操作

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

通过命令 git init 把这个目录变成git可以管理的仓库，如下：

![史上最全Git教程（一）][Git]

这时候你当前testgit目录下会多了一个.git的目录，这个目录是Git来跟踪管理版本的，没事千万不要手动乱改这个目录里面的文件，否则，会把git仓库给破坏了

第一步：使用命令 git add readme.txt添加到暂存区里面去

第二步：用命令 git commit告诉Git，把文件提交到仓库。通过命令git status来查看是否还有文件

接下来我想看下readme.txt文件到底改了什么内容，如何查看呢？可以使用如下命令：

git diff readme.txt 如下：

![史上最全Git教程（一）][Git 1]

那么我现在想查看下历史记录，如何查呢？我们现在可以使用命令 git log ，如果嫌上面显示的信息太多的话，我们可以使用命令 git log –pretty=oneline

我想把当前的版本回退到上一个版本，要使用什么命令呢？可以使用如下2种命令，第一种是：git reset --hard HEAD^ 那么如果要回退到上上个版本只需把HEAD^ 改成 HEAD^^ 以此类推。那如果要回退到前100个版本的话，使用上面的方法肯定不方便，我们可以使用下面的简便命令操作：git reset --hard HEAD~100 即可

通过版本号回退，使用命令方法如下：

git reset --hard 版本号

3.工作区和暂存区区别

工作区：就是你在电脑上看到的目录，比如目录下testgit里的文件(.git隐藏目录版本库除外)。或者以后需要再新建的目录文件等等都属于工作区范畴。

版本库(Repository)：工作区有一个隐藏目录.git,这个不属于工作区，这是版本库。其中版本库里面存了很多东西，其中最重要的就是stage(暂存区)，还有Git为我们自动创建了第一个分支master,以及指向master的一个指针HEAD

命令 git checkout --readme.txt 意思就是，把readme.txt文件在工作区做的修改全部撤销，注意：命令git checkout -- readme.txt 中的 -- 很重要，如果没有 -- 的话，那么命令变成创建分支了

二、git的初始化  
在使用git进行代码管理之前，我们首先要对git进行初始化。

2.1 Git 配置  
使用Git的第一件事就是设置你的名字和email,这些就是你在提交commit时的签名，每次提交记录里都会包含这些信息。使用git config命令进行配置：

$ git config --global user.name "Scott Chacon"  
$ git config --global user.email "schacon@gmail.com"  
执行了上面的命令后,会在家目录(/home/shiyanlou)下建立一个叫.gitconfig 的文件（该文件为隐藏文件，需要使用ls -al查看到）. 内容一般像下面这样，可以使用vim或cat查看文件内容:

$ cat ~/.gitconfig  
\[user\]  
email = schacon@gmail.com  
name = Scott Chacon  
上面的配置文件就是Git全局配置的文件，一般配置方法是git config --global <配置名称> <配置的值>。

如果你想使项目里的某个值与前面的全局设置有区别(例如把私人邮箱地址改为工作邮箱)，你可以在项目中使用git config 命令不带 --global 选项来设置. 这会在你当前的项目目录下创建 .git/config，从而使用针对当前项目的配置。

三、获得一个Git仓库  
既然我们现在把一切都设置好了，那么我们需要一个Git仓库。有两种方法可以得到它：一种是从已有的Git仓库中clone (克隆，复制)；还有一种是新建一个仓库，把未进行版本控制的文件进行版本控制。

3.1 Clone一个仓库  
为了得到一个项目的拷贝(copy),我们需要知道这个项目仓库的地址(Git URL). Git能在许多协议下使用，所以Git URL可能以ssh://, http(s)://, git://. 有些仓库可以通过不只一种协议来访问。

我们在github.com上提供了一个名字为gitproject的供大家测试的公有仓库，这个仓库可以使用下面方式进行clone：

$ git clone https://github.com/shiyanlou/gitproject  
clone 操作完成后，会发现当前目录下多了一个gitproject文件夹，这个文件夹里的内容就是我们刚刚clone下来的代码。由于当前\`gitproject仅是测试项目，里面仅有一个README.md文件。

$ cd gitproject/  
(master)$ ls  
README.md  
细心的同学可以发现在命令提示符$前面多了个(master)。这是由于实验楼的Linux使用的是zsh Shell，zsh会判断当前的目录是否有Git仓库，如果是的话则自动把目前所在的git分支显示在提示符中。Git 分支的概念我们会在稍后介绍。

3.2 初始化一个新的仓库  
可以对一个已存在的文件夹用下面的命令让它置于Git的版本控制管理之下。

创建代码目录project：

$ cd /home/shiyanlou/  
$ mkdir project  
进入到代码目录，创建并初始化Git仓库：

$ cd project  
$ git init  
Git会输出:

Initialized empty Git repository in /home/shiyanlou/project/.git/  
通过ls -la命令会发现project目录下会有一个名叫.git 的目录被创建，这意味着一个仓库被初始化了。可以进入到.git目录查看下有哪些内容。

四、正常的工作流程  
git的基本流程如下：

创建或修改文件  
使用git add命令添加新创建或修改的文件到本地的缓存区（Index）  
使用git commit命令提交到本地代码库  
（可选，有的时候并没有可以同步的远端代码库）使用git push命令将本地代码库同步到远端代码库  
4.1 创建或修改文件  
进入我们刚才建立的project目录，分别创建文件file1，file2，file3：

$ cd project  
$ touch file1 file2 file3  
修改文件，可以使用vim编辑内容，也可以直接echo添加测试内容。

$ echo "test" >> file1  
$ echo "test" >> file2  
$ echo "test" >> file3  
此时可以使用git status命令查看当前git仓库的状态：

$ git status  
On branch master

Initial commit

Untracked files:  
(use "git add <file>...") to include in what will be committed)

file1  
file2  
file3  
nothing added to commit but untracked files present (use "git add" to track)  
可以发现，有三个文件处于untracked状态，下一步我们就需要用git add命令将他们加入到缓存区（Index）。

4.2 使用 git add 加入缓存区  
使用git add命令将新建的文件添加到：

$ git add file1 file2 file3  
然后再次执行git status就会发现新的变化：

$ git status  
On branch master

Initial commit

Changes to be committed:  
(use "git rm --cached <file>..." to unstage)

new file: file1  
new file: file2  
new file: file3  
你现在为commit做好了准备，你可以使用 git diff 命令再加上 --cached 参数，看看缓存区中哪些文件被修改了。进入到git diff --cached界面后需要输入q才可以退出：

$ git diff --cached  
如果没有--cached参数，git diff 会显示当前你所有已做的但没有加入到索引里的修改。

如果你要做进一步的修改, 那就继续做, 做完后就把新修改的文件加入到缓存区中。

4.3 使用 git commit 提交修改  
当所有新建，修改的文件都被添加到了缓存区，我们就要使用git commit提交到本地仓库：

$ git commit -m "add 3 files"  
需要使用-m添加本次修改的注释，完成后就会记录一个新的项目版本。除了用git add 命令，我们还可以用下面的命令将所有没有加到缓存区的修改也一起提交，但-a命令不会添加新建的文件。

$ git commit -a -m "add 3 files"  
再次输入git status查看状态，会发现当前的代码库已经没有待提交的文件了，缓存区已经被清空。

至此，我们完成了第一次代码提交，这次提交的代码中我们创建了三个新文件。需要注意的是如果是修改文件，也需要使用git add命令添加到缓存区才可以提交。如果是删除文件，则直接使用git rm命令删除后会自动将已删除文件的信息添加到缓存区，git commit提交后就会将本地仓库中的对应文件删除。

这时如果我们希望将本地仓库关联到远端服务器，我们可以使用 git remote 命令，不同于刚刚的 git clone 命令，直接将远端的仓库克隆下来。 我们当前的仓库是使用 git init 初始化的本地仓库，所以我们需要将本地仓库与远程仓库关联，使用如下命令（需要修改下面的远程仓库地址为自己的仓库地址）：

git remote add origin https://github.com/kinglion580/shiyanlou.git  
对于上述命令而言，git remote add 命令用于添加远程主机，origin 是主机名，此处我们可以自定义，不一定非要使用 origin，而 https://github.com/kinglion580/shiyanlou.git，是我自己的远程仓库，此处 需要替换为自己的远程仓库地址

这个时候如果本地的仓库连接到了远程Git服务器，可以使用下面的命令将本地仓库同步到远端服务器：

\# 需要输入仓库对应的用户名和密码  
$ git push origin master  
五、分支与合并  
Git 的分支可以让你在主线（master分支）之外进行代码提交，同时又不会影响代码库主线。分支的作用体现在多人协作开发中，比如一个团队开发软件，你负责独立的一个功能需要一个月的时间来完成，你就可以创建一个分支，只把该功能的代码提交到这个分支，而其他同事仍然可以继续使用主线开发，你每天的提交不会对他们造成任何影响。当你完成功能后，测试通过再把你的功能分支合并到主线。

5.1 创建分支  
一个Git仓库可以维护很多开发分支。现在我们来创建一个新的叫 experimental的分支：

$ git branch experimental  
运行git branch命令可以查看当前的分支列表，以及目前的开发环境处在哪个分支上：

$ git branch  
experimental  
\* master  
5.2 切换分支  
experimental 分支是你刚才创建的，master分支是Git系统默认创建的主分支。星号标识了你当工作在哪个分支下，输入git checkout 分支名可以切换到其他分支：

$ git checkout experimental  
Switched to branch 'experimental'  
切换到experimental分支，切换完成后，先编辑里面的一个文件，再提交(commit)改动，最后切换回 “master”分支：

\# 修改文件file1  
$ echo "update" >> file1  
\# 查看当前状态  
$ git status  
\# 添加并提交file1的修改  
$ git add file1  
$ git commit -m "update file1"  
\# 查看file1的内容  
$ cat file1  
test  
update  
\# 切换到master分支  
$ git checkout master  
查看下file1中的内容会发现刚才做的修改已经看不到了。因为刚才的修改时在experimental分支下，现在切换回了master分支，目录下的文件都是master分支上的文件了。

5.3 合并分支  
现在可以在master分支下再作一些不同的修改:

\# 修改文件file2  
$ echo "update again" >> file2  
\# 查看当前状态  
$ git status  
\# 添加并提交file2的修改  
$ git add file2  
$ git commit -m "update file2 on master"  
\# 查看file2的内容  
$ cat file2  
test  
update again  
这时，两个分支就有了各自不同的修改，分支的内容都已经不同，如何将多个分支进行合并呢？

可以通过下面的git merge命令来合并experimental到主线分支master:

\# 切换到master分支  
$ git checkout master  
\# 将experimental分支合并到master  
$ git merge -m 'merge experimental branch' experimental  
\-m参数仍然是需要填写合并的注释信息。

由于两个 branch 修改了两个不同的文件，所以合并时不会有冲突，执行上面的命令后合并就完成了。

如果有冲突，比如两个分支都改了一个文件 file3，则合并时会失败。首先我们在master分支上修改file3文件并提交：

\# 切换到master分支  
$ git checkout master  
\# 修改file3文件  
$ echo "master: update file3" >> file3  
\# 提交到master分支  
$ git commit -a -m 'update file3 on master'  
然后切换到experimental，修改file3并提交：

\# 切换到experimental分支  
$ git checkout experimental  
\# 修改file3文件  
$ echo "experimental: update file3" >> file3  
\# 提交到experimental分支  
$ git commit -a -m 'update file3 on experimental'  
切换到master进行合并：

$ git checkout master  
$ git merge experimental  
Auto-merging file3  
CONFLICT (content): Merge conflict in file3  
Automatic merge failed; fix conflicts and then commit the result.  
合并失败后先用git status查看状态，会发现file3显示为both modified，查看file3内容会发现：

$ cat file3  
test  
<<<<<<< HEAD  
master: update file3  
=======  
experimental: update file3  
>>>>>>> experimental  
上面的内容也可以使用git diff查看，先前已经提到git diff不加参数可以显示未提交到缓存区中的修改内容。

可以看到冲突的内容都被添加到了file3中，我们使用vim编辑这个文件，去掉git自动产生标志冲突的<<<<<<等符号后，根据需要只保留我们需要的内容后保存，然后使用git add file3和git commit命令来提交合并后的file3内容，这个过程是手动解决冲突的流程。

\# 编辑冲突文件  
$ vim file3  
\# 提交修改后的文件  
$ git add file3  
$ git commit -m 'merge file3'  
5.4 删除分支  
当我们完成合并后，不再需要experimental时，可以使用下面的命令删除：

$ git branch -d experimental  
git branch -d只能删除那些已经被当前分支的合并的分支. 如果你要强制删除某个分支的话就用git branch –D

5.5 撤销一个合并  
如果你觉得你合并后的状态是一团乱麻，想把当前的修改都放弃，你可以用下面的命令回到合并之前的状态：

$ git reset --hard HEAD^  
\# 查看file3的内容，已经恢复到合并前的master上的文件内容  
$ cat file3  
5.6 快速向前合并  
还有一种需要特殊对待的情况，在前面没有提到。通常，一个合并会产生一个合并提交(commit), 把两个父分支里的每一行内容都合并进来。

但是，如果当前的分支和另一个分支没有内容上的差异，就是说当前分支的每一个提交(commit)都已经存在另一个分支里了，git 就会执行一个“快速向前"(fast forward)操作；git 不创建任何新的提交(commit),只是将当前分支指向合并进来的分支。

六、Git日志  
下面我们来学习有关 git 日志的内容。

6.1 查看日志  
git log命令可以显示所有的提交(commit)：

$ git log  
如果提交的历史纪录很长，回车会逐步显示，输入q可以退出。

git log有很多选项，可以使用git help log查看，例如下面的命令就是找出所有从"v2.5“开始在 fs 目录下的所有 Makefile 的修改（这个只是举例，不用操作）：

$ git log v2.5.. Makefile fs/  
Git会根据git log命令的参数，按时间顺序显示相关的提交(commit)。

6.2 日志统计  
如果用--stat 选项使用 git log',它会显示在每个提交(commit)中哪些文件被修改了, 这些文件分别添加或删除了多少行内容，这个命令相当于打印详细的提交记录：

$ git log --stat  
6.3 格式化日志  
你可以按你的要求来格式化日志输出。--pretty 参数可以使用若干表现格式，如oneline:

$ git log --pretty=oneline  
或者你也可以使用 short 格式:

$ git log --pretty=short  
你也可用medium,full,fuller,email 或raw。 如果这些格式不完全符合你的需求， 你也可以用--pretty=format参数定义格式。

\--graph 选项可以可视化你的提交图(commit graph)，会用ASCII字符来画出一个很漂亮的提交历史(commit history)线：

$ git log --graph --pretty=oneline  
6.4 日志排序  
日志记录可以按不同的顺序来显示。如果你要指定一个特定的顺序，可以为git log命令添加顺序参数。

按默认情况，提交会按逆时间顺序显示，可以指定--topo-order参数，让提交按拓扑顺序来显示(就是子提交在它们的父提交前显示):

$ git log --pretty=format:'%h : %s' --topo-order --graph  
你也可以用 --reverse参数来逆向显示所有提交日志。

七、小结  
本节讲解了几个基本命令：

git config：配置相关信息  
git clone：复制仓库  
git init：初始化仓库  
git add：添加更新内容到索引中  
git diff：比较内容  
git status：获取当前项目状况  
git commit：提交  
git branch：分支相关  
git checkout：切换分支  
git merge：合并分支  
git reset：恢复版本  
git log：查看日志

2.1 比较提交 - Git Diff  
现在我们对项目做些修改：

$ cd gitproject  
\# 向README文件添加一行  
$ echo "new line" >> README.md  
\# 添加新的文件file1  
$ echo "new file" >> file1  
使用git status查看当前修改的状态：

$ git status  
On branch master  
Your branch is up-to-date with 'origin/master'.

Changes not staged for commit:  
(use "git add <file>..." to update what will be committed)  
(use "git checkout -- <file>..." to discard changes in working directory)

modified: README.md

Untracked files:  
(use "git add <file>..." to include in what will be committed)

file1

no changes added to commit (use "git add" and/or "git commit -a")  
可以看到一个文件修改了，另外一个文件添加了。如何查看修改的文件内容呢，那就需要使用git diff命令。git diff命令的作用是比较修改的或提交的文件内容。

$ git diff  
diff --git a/README.md b/README.md  
index 21781dd..410e719 100644  
\--- a/README.md  
\+++ b/README.md  
@@ -1,2 +1,3 @@  
gitproject  
==========  
\+new line  
上面的命令执行后需要使用q退出。命令输出当前工作目录中修改的内容，并不包含新加文件，请注意这些内容还没有添加到本地缓存区。

将修改内容添加到本地缓存区，通配符可以把当前目录下所有修改的新增的文件都自动添加：

$ git add \*  
再执行git diff会发现没有任何内容输出，说明当前目录的修改都被添加到了缓存区，如何查看缓存区内与上次提交之间的差别呢？需要使用--cached参数：

$ git diff --cached  
diff --git a/README.md b/README.md  
index 21781dd..410e719 100644  
\--- a/README.md  
\+++ b/README.md  
@@ -1,2 +1,3 @@  
gitproject  
==========  
\+new line  
diff --git a/file1 b/file1  
new file mode 100644  
index 0000000..fa49b07  
\--- /dev/null  
\+++ b/file1  
@@ -0,0 +1 @@  
\+new file  
可以看到输出中已经包含了新加文件的内容，因为file1已经添加到了缓存区。

最后我们提交代码：

$ git commit -m 'update code'  
提交后git diff与git diff --cached都不会有任何输出了。

2.2 比较分支  
可以用 git diff 来比较项目中任意两个分支的差异。

我们首先创建一个新的分支test，并在该分支上提交一些修改：

\# 创建test分支并切换到该分支  
$ git branch test  
$ git checkout test  
\# 添加新的一行到file1  
$ echo "branch test" >> file1  
\# 创建新的文件file2  
$ echo "new file2" >> file2  
\# 提交所有修改  
$ git add \*  
$ git commit -m 'update test branch'  
然后，我们查看test分支和master之间的差别：

$ git diff master test  
diff --git a/file1 b/file1  
index fa49b07..17059cd 100644  
\--- a/file1  
\+++ b/file1  
@@ -1 +1,2 @@  
new file  
\+branch test  
diff --git a/file2 b/file2  
new file mode 100644  
index 0000000..80e7991  
\--- /dev/null  
\+++ b/file2  
@@ -0,0 +1 @@  
\+new file2  
git diff 是一个难以置信的有用的工具，可以找出你项目上任意两个提交点间的差异。可以使用git help diff详细查看其他参数和功能。

2.3 更多的比较选项  
如果你要查看当前的工作目录与另外一个分支的差别，你可以用下面的命令执行:

\# 切换到master  
$ git checkout master

\# 查看与test分支的区别  
$ git diff test  
diff --git a/file1 b/file1  
index 17059cd..fa49b07 100644  
\--- a/file1  
\+++ b/file1  
@@ -1,2 +1 @@  
new file  
\-branch test  
diff --git a/file2 b/file2  
deleted file mode 100644  
index 80e7991..0000000  
\--- a/file2  
\+++ /dev/null  
@@ -1 +0,0 @@  
\-new file2  
你也以加上路径限定符，来只比较某一个文件或目录：

$ git diff test file1  
diff --git a/file1 b/file1  
index 17059cd..fa49b07 100644  
\--- a/file1  
\+++ b/file1  
@@ -1,2 +1 @@  
new file  
\-branch test  
上面这条命令会显示你当前工作目录下的file1与test分支之间的差别。

\--stat 参数可以统计一下有哪些文件被改动，有多少行被改动：

$ git diff test --stat  
file1 | 1 -  
file2 | 1 -  
2 files changed, 2 deletions(-)  
三、分布式的工作流程  
下面我们学习 git 的分布式工作流程。

3.1 分布式的工作流程  
你目前的项目在/home/shiyanlou/gitproject目录下，这是我们的git 仓库(repository)，另一个用户也想与你协作开发。他的工作目录在这台机器上，如何让他提交代码到你的 git 仓库呢？

首先，我们假设另一个用户也用shiyanlou用户登录，只是工作在不同的目录下开发代码，实际工作中不太可能发生，大部分情况都是多个用户，这个假设只是为了让实验简化。

该用户需要从 git 仓库进行克隆：

\# 进入到临时目录  
$ cd /tmp  
\# 克隆git仓库  
$ git clone /home/shiyanlou/gitproject myrepo  
$ ls -l myrepo  
\-rw-rw-r-- 1 shiyanlou shiyanlou 31 Dec 22 08:24 README.md  
\-rw-rw-r-- 1 shiyanlou shiyanlou 9 Dec 22 08:24 file1  
这就建了一个新的叫"myrepo"的目录，这个目录里包含了一份gitproject仓库的克隆。这份克隆和原始的项目一模一样，并且拥有原始项目的历史记录。

在 myrepo 做了一些修改并且提交:

$ cd myrepo

\# 添加新的文件newfile  
$ echo "newcontent" > newfile

\# 提交修改  
$ git add newfile  
$ git commit -m "add newfile"  
myrepo修改完成后，如果我们想合并这份修改到gitproject的git仓库该如何做呢？

可以在仓库/home/shiyanlou/gitproject中把myrepo的修改给拉 (pull)下来。执行下面几条命令:

$ cd /home/shiyanlou/gitproject  
$ git pull /tmp/myrepo master  
remote: Counting objects: 5, done.  
remote: Compressing objects: 100% (2/2), done.  
remote: Total 3 (delta 0), reused 0 (delta 0)  
Unpacking objects: 100% (3/3), done.  
From /tmp/myrepo  
\* branch master -> FETCH\_HEAD  
Updating 8bb57aa..866c452  
Fast-forward  
newfile | 1 +  
1 file changed, 1 insertion(+)  
create mode 100644 newfile

\# 查看当前目录文件  
$ ls  
README.md file1 newfile  
这就把myrepo的主分支合并到了gitproject的当前分支里了。

如果gitproject在myrepo修改文件内容的同时也做了修改的话，可能需要手工去修复冲突。

如果你要经常操作远程分支(remote branch),你可以定义它们的缩写:

$ git remote add myrepo /tmp/myrepo  
git pull命令执行两个操作: 它从远程分支(remote branch)抓取修改git fetch的内容，然后把它合并git merge进当前的分支。

gitproject里可以用git fetch 来执行git pull前半部分的工作， 但是这条命令并不会把抓下来的修改合并到当前分支里：

$ git fetch myrepo  
From /tmp/myrepo  
\* \[new branch\] master -> myrepo/master  
获取后，我们可以通过git log查看远程分支做的所有修改，由于我们已经合并了所有修改，所以不会有任何输出：

$ git log -p master..myrepo/master  
当检查完修改后，gitproject可以把修改合并到它的主分支中：

$ git merge myrepo/master  
Already up-to-date.  
如果我们在myrepo目录下执行git pull会发生什么呢？

myrepo会从克隆的位置拉取代码并更新本地仓库，就是把gitproject上的修改同步到本地:

\# 进入到gitproject  
$ cd /home/shiyanlou/gitproject

\# 添加一行内容到newfile  
$ echo "gitproject: new line" >> newfile

\# 提交修改  
$ git commit -a -m 'add newline to newfile'  
\[master 8c31532\] add newline to newfile  
1 file changed, 1 insertion(+)

\# 进入myrepo目录  
$ cd /tmp/myrepo

\# 同步gitproject的所有修改  
$ git pull  
remote: Counting objects: 6, done.  
remote: Compressing objects: 100% (2/2), done.  
remote: Total 3 (delta 1), reused 0 (delta 0)  
Unpacking objects: 100% (3/3), done.  
From /home/shiyanlou/gitproject  
8bb57aa..8c31532 master -> origin/master  
Updating 866c452..8c31532  
Fast-forward  
newfile | 1 +  
1 file changed, 1 insertion(+)  
因为myrepo是从gitproject仓库克隆的，那么他就不需要指定gitproject仓库的地 址。因为Git把gitproject仓库的地址存储到myrepo的配置文件中，这个地址就是在git pull时默认使用的远程仓库：

$ git config --get remote.origin.url  
/home/shiyanlou/gitproject  
如果myrepo和gitproject在不同的主机上，可以通过ssh协议来执行clone 和pull操作：

$ git clone localhost:/home/shiyanlou/gitproject test  
这个命令会提示你输入shiyanlou用户的密码，用户密码随机，可以点击实验操作界面右侧工具栏的SSH直连按钮查看。

3.2 公共Git仓库  
开发过程中，通常大家都会使用一个公共的仓库，并clone到自己的开发环境中，完成一个阶段的代码后可以告诉目标仓库的维护者来pull自己的代码。

如果你和维护者都在同一台机器上有帐号，那么你们可以互相从对 方的仓库目录里直接拉所作的修改，git命令里的仓库地址也可以是本地的某个目录名：

$ git clone /path/to/repository  
$ git pull /path/to/other/repository  
也可以是一个ssh地址：

$ git clone ssh://yourhost/~you/repository  
3.3 将修改推到一个公共仓库  
通过http或是git协议，其它维护者可以通过远程访问的方式抓取(fetch)你最近的修改，但是他们 没有写权限。如何将本地私有仓库的最近修改主动上传到公共仓库中呢？

最简单的办法就是用git push命令，推送本地的修改到远程Git仓库，执行下面的命令:

$ git push ssh://yourserver.com/~you/proj.git master:master  
或者

$ git push ssh://yourserver.com/~you/proj.git master  
git push命令的目地仓库可以是ssh或http/https协议访问。

3.4 当推送代码失败时要怎么办  
如果推送(push)结果不是快速向前fast forward，可能会报像下面一样的错误：

error: remote 'refs/heads/master' is not an ancestor of  
local 'refs/heads/master'.  
Maybe you are not up-to-date and need to pull first?  
error: failed to push to 'ssh://yourserver.com/~you/proj.git'  
这种情况通常是因为没有使用git pull获取远端仓库的最新更新，在本地修改的同时，远端仓库已经变化了（其他协作者提交了代码），此时应该先使用git pull合并最新的修改后再执行git push：

$ git pull  
$ git push ssh://yourserver.com/~you/proj.git master  
四、Git标签  
下面学习 git 标签相关内容。

4.1 轻量级标签  
我们可以用 git tag不带任何参数创建一个标签(tag)指定某个提交(commit):

\# 进入到gitproject目录  
$ cd /home/shiyanlou/gitproject

\# 查看git提交记录  
$ git log

\# 选择其中一个记录标志位stable-1的标签，注意需要将后面的8c315325替换成仓库下的真实提交内，commit的名称很长，通常我们只需要写前面8位即可  
$ git tag stable-1 8c315325

\# 查看当前所有tag  
$ git tag  
stable-1  
这样，我们可以用stable-1 作为提交 8c315325 的代称。

前面这样创建的是一个“轻量级标签”。

如果你想为一个tag添加注释，或是为它添加一个签名, 那么我们就需要创建一个 "标签对象"。

标签对象  
git tag中使用-a， -s 或是 -u三个参数中任意一个，都会创建一个标签对象，并且需要一个标签消息(tag message)来为tag添加注释。 如果没有-m 或是 -F 这些参数，命令执行时会启动一个编辑器来让用户输入标签消息。

当这样的一条命令执行后，一个新的对象被添加到Git对象库中，并且标签引用就指向了一个标签对象，而不是指向一个提交，这就是与轻量级标签的区别。

下面是一个创建标签对象的例子:

$ git tag -a stable-2 8c315325 -m "stable 2"  
$ git tag  
stable-1  
stable-2  
4.2 签名的标签  
签名标签可以让提交和标签更加完整可信。如果你配有GPG key，那么你就很容易创建签名的标签。首先你要在你的 .git/config 或 ~/.gitconfig 里配好key。

下面是示例:

\[user\]  
signingkey = <gpg-key-id>  
你也可以用命令行来配置:

$ git config (--global) user.signingkey <gpg-key-id>  
现在你可以在创建标签的时候使用-s 参数来创建“签名的标签”：

$ git tag -s stable-1 1b2e1d63ff  
如果没有在配置文件中配GPG key,你可以用-u参数直接指定。

$ git tag -u <gpg-key-id> stable-1 1b2e1d63ff

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ppamVycnk_size_16_color_FFFFFF_t_70]: /images/20220415/153b1fc191a74b94a979ef64edce9b76.png
[Git]: http://p3.pstatp.com/large/pgc-image/153718858399043dee2351e
[Git 1]: /images/20220415/d7cff0e2760c4c5091b8cedabd8ed5f9.png