Linux Git新手入门 git常用命令 Git全面指南：基础概念、操作与远程仓库、标签、分支全解析 MIT第六课

标签：文件 git 第六课 -- Git 提交 分支

一、GIT基础概念介绍

        请记住下面这些关于 Git 的概念。 Git 有三种状态，你的文件可能处于其中之一： 已提交（committed）、已修改（modified） 和 已暂存（staged）。

• 已修改表示修改了文件，但还没保存到数据库中。

• 已暂存表示对一个已修改文件的当前版本做了标记，使之包含在下次提交的快照中。

• 已提交表示数据已经安全地保存在本地数据库中

这会让我们的 Git 项目拥有三个阶段：工作区、暂存区以及 Git 目录。

        工作区是对项目的某个版本独立提取出来的内容。 这些从 Git 仓库的压缩数据库中提取出来的文件，放在磁盘上供你使用或修改。

        暂存区是一个文件，保存了下次将要提交的文件列表信息，一般在 Git 仓库目录中。 按照 Git 的术语叫做“索引”，不过一般说法还是叫“暂存区”。

        Git 仓库目录是 Git 用来保存项目的元数据和对象数据库的地方。 这是 Git 中最重要的部分，从其它计算机克隆仓库时，复制的就是这里的数据。

基本的 Git 工作流程如下：

1. 在工作区中修改文件。

2. 将你想要下次提交的更改选择性地暂存，这样只会将更改的部分添加到暂存区。

3. 提交更新，找到暂存区的文件，将快照永久性存储到 Git 目录。

如果 Git 目录中保存着特定版本的文件，就属于 已提交 状态。 如果文件已修改并放入暂存区，就属于 已暂存 状态。 如果自上次检出后，作了修改但还没有放到暂存区域，就是 已修改 状态。 
 

二、git基础使用操作

2.1 获取git仓库

通常有两种获取 Git 项目仓库的方式：

1. 将尚未进行版本控制的本地目录转换为 Git 仓库；

2. 从其它服务器 克隆 一个已存在的 Git 仓库。

两种方式都会在你的本地机器上得到一个工作就绪的 Git 仓库
在已存在目录中初始化仓库

cd /home/user/my_project
git init

进入任意个目录执行git init就会在当前目录下创建一个名为.git的子隐藏目录，这个子目录含有你初始化的 Git 仓库中所有的必须文件。 但是，在这个时候，我们仅仅是做了一个初始化的操作，你的项目里的文件还没有被跟踪。

2.1.1 在已存在目录中初始化仓库  

        接下来可以在一个已存在文件的文件夹（而非空文件夹）中进行版本控制，你应该开始追踪这些文件并进行初始提交。 可以通过 git add 命令来指定所需的文件来进行追踪，然后执行git commit ：

git add *.c
git commit -m 'initial project version'

        假设你的文件下有一个hello.c文件，git add根据hello.c是否是新文件有俩个不同的作用：

1. 将文件添加到暂存区
        当你在本地修改了 hello.c这个文件后（此时文件处于工作区），执行 git add hello.c 命令，它的作用就是将 hello.c 这个文件从工作区添加到暂存区。相当于告诉 Git，你希望接下来把这个文件包含的更改内容记录到一个新的版本提交中，把它标记为 “准备好提交” 的状态，后续再执行 git commit 命令就能将暂存区里的这些更改（包括 hello.c 文件此次的更改情况）正式提交到本地仓库，形成一个新的版本记录了。
例如，你在 hello.c 文件里新写了一些代码或者修改了原有的代码内容，先通过 git add hello.c 把它添加到暂存区，然后使用 git commit -m "对hello.c进行功能扩展" （这里 -m 选项用于添加提交信息）这样的命令，就可以把这次对 hello.c 文件的更改以 “对 hello.c 进行功能扩展” 为说明记录到本地仓库中，完成一次代码版本更新操作。
2. 开始跟踪新文件
        如果 hello.c 是一个新建的文件（在执行 git add 之前，该文件不在 Git 的版本控制范围内，也就是 Git 还没有 “认识” 这个文件），那么 git add hello.c 还有一个重要作用就是让 Git 开始跟踪这个文件。
        此后，Git 就会关注这个文件的状态变化，无论是后续再对它进行修改、重命名还是删除等操作，都可以通过 Git 的相关命令（如 git status 查看文件状态、git diff 查看文件更改内容等）来进行监控和管理了，并且后续再次提交代码版本更新时，只要这个文件有变化，就同样可以通过 git add 操作把它的更改添加到暂存区，进而提交到本地仓库中持续记录项目的版本演进情况。

2.1.2 克隆现有的仓库

克隆仓库的命令是：

git clone <url> # url是任意参考连接
# 例如：git clone https://github.com/libgit2/libgit2

        这会在当前目录下创建一个名为 “libgit2” 的目录，并在这个目录下初始化一个 .git 文件夹， 从远程仓库拉取下所有数据放入 .git 文件夹，然后从中读取最新版本的文件的拷贝。 如果你进入到这个新建的 libgit2 文件夹，你会发现所有的项目文件已经在里面了，准备就绪等待后续的开发和使用

        如果你想在克隆远程仓库的时候，自定义本地仓库的名字，你可以通过额外的参数指定新的目录名：

$ git clone https://github.com/libgit2/libgit2 mylibgit

这会执行与上一条命令相同的操作，但目标目录名变为了 mylibgit。

2.2 记录每次更新到仓库

        你工作目录下的每一个文件都不外乎这两种状态：已跟踪 或 未跟踪。 已跟踪的文件是指那些被纳入了版本控制的文件，在上一次快照中有它们的记录，在工作一段时间后， 它们的状态可能是未修改，已修改或已放入暂存区。简而言之，已跟踪的文件就是 Git 已经知道的文件。
        初次克隆某个仓库的时候，工作目录中的所有文件都属于已跟踪文件，并处于未修改状态，因为 Git 刚刚检出了它们， 而你尚未编辑过它们。
        编辑过某些文件之后，由于自上次提交后你对它们做了修改，Git 将它们标记为已修改文件。 在工作时，你可以选择性地将这些修改过的文件放入暂存区，然后提交所有已暂存的修改，如此反复。

git commit -m 'initial project version'

         git commit 命令的关键作用之一就是将暂存区（staging area）中的文件更改内容（这些更改是通过之前执行 git add 命令添加到暂存区的）打包记录下来，形成项目在某个特定时刻的一个 “快照”，也就是一个版本状态记录。这个快照包含了当时所有被添加到暂存区的文件及其具体的修改情况，相当于给项目的当前进展做了一次存档，方便后续随时回溯查看或者基于此继续开发。

       

2.3 检查当前文件状态

        可以用 git status 命令查看哪些文件处于什么状态，如果在刚刚克隆的仓库中效果如下：

$ git status
位于分支 master

尚无提交

无文件要提交（创建/拷贝文件并使用 "git add" 建立跟踪）

        这说明你现在的工作目录相当干净。换句话说，所有已跟踪文件在上次提交后都未被更改过。 此外，上面的信息还表明，当前目录下没有出现任何处于未跟踪状态的新文件，否则 Git 会在这里列出来。 最后，该命令还显示了当前所在分支，并告诉你这个分支同远程服务器上对应的分支没有偏离。 现在，分支名是“master”，这是默认的分支名。 我们在 Git 分支 中会详细讨论分支和引用。

        现在，让我们在项目下创建一个新的hello.py 文件。 如果之前并不存在这个文件，使用 git status 命令，你将看到一个新的未跟踪文件：

$ git status
位于分支 master

尚无提交

未跟踪的文件:
  （使用 "git add <文件>..." 以包含要提交的内容）
        hello.py

提交为空，但是存在尚未跟踪的文件（使用 "git add" 建立跟踪）

2.4 跟踪新文件

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

git add hello.py

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

$ git status
位于分支 master

尚无提交

要提交的变更：
  （使用 "git rm --cached <文件>..." 以取消暂存）
        新文件：   hello.py

        只要在 (Changes to be committed)要提交的变更这行下面的，就说明是已暂存状态。 如果此时提交，那么该文件在你运行 git add 时的版本将被留存在后续的历史记录中。 你可能会想起之前我们使用 git init 后就运行了 git add <files> 命令，开始跟踪当前目录下的文件。 git add 命令使用文件或目录的路径作为参数；如果参数是目录的路径，该命令将递归地跟踪该目录下的所有文件。

        我们先提交hello.py一下：

$ git commit -m "initial project version"
[master （根提交） 922c3f4] initial project version
 1 file changed, 1 insertion(+)
 create mode 100644 hello.py

2.5 暂存已修改的文件

        现在我们来修改一个已被跟踪且在之前快照提交过的文件。 修改 hello.py 这个已被跟踪的文件，然后运行 git status 命令，会看到下面内容：

$ git status
位于分支 master
尚未暂存以备提交的变更：
  （使用 "git add <文件>..." 更新要提交的内容）
  （使用 "git restore <文件>..." 丢弃工作区的改动）
        修改：     hello.py

修改尚未加入提交（使用 "git add" 和/或 "git commit -a"）

        文件  hello.py 出现在 （Changes not staged for commit)尚未暂存以备提交的变更 这行下面，说明已跟踪文件的内容发生了变化，但还没有放到暂存区。 要暂存这次更新，需要运行 git add 命令。 这是个多功能命令：可以用它开始跟踪新文件，或者把已跟踪的文件放到暂存区，还能用于合并时把有冲突的文件标记为已解决状态等。 将这个命令理解为“精确地将内容添加到下一次提交中”而不是“将一个文件添加到项目中”要更加合适。 现在让我们运行 git add 将hello.py放到暂存区，然后再看看 git status 的输出：

$ git status
位于分支 master
要提交的变更：
  （使用 "git restore --staged <文件>..." 以取消暂存）
        修改：     hello.py

取消暂存的文件

  git reset 是一个功能强大的 Git 命令，用于将当前的 HEAD（版本库中当前分支顶端的提交指针）重置到指定状态，根据所使用的选项不同，它可以修改暂存区（索引）以及工作目录。该命令可用于撤销更改以及移动当前分支指针。

# 不更改工作目录，取消暂存任何已暂存的更改（即重置暂存区）。
git reset

# 将 HEAD 和分支指针移动到指定的提交位置，即回溯提交版本（之前版本的更改会丢失）。
git reset --hard commit <哈希值>

# 回退到某个历史提交并保留工作目录和暂存区的更改。
git reset --soft commit <哈希值>

# 将文件从暂存区移除（也就是 “取消暂存” 它们），而不会影响工作目录。
git reset HEAD <filename>

适用场景：
        git reset:错误地将一个文件暂存，但尚未提交。希望在不修改工作目录的情况下将其“取消暂存”
        git reset --hard commit <哈希值>：提交了几次更改，但它们引入了错误。你想丢弃所有内容并恢复到某个特定的稳定提交。
        git reset --soft commit <哈希值>：过早地提交了更改并希望修正它们，但您希望保留所有已暂存的更改
        git reset HEAD <filename>：暂存了多个文件，但其中有一个不应包含在下次提交中。

撤消对文件的修改

git checkout -- <filename>

        撤销对文件的修改，但请务必记得 git checkout — <file> 是一个危险的命令。 你对那个文件在本地的任何修改都会消失——Git 会用最近提交的版本覆盖掉它。 除非你确实清楚不想要对那个文件的本地修改了，否则请不要使用这个命令。

        如果你仍然想保留对那个文件做出的修改，但是现在仍然需要撤消，将会在Git分支介绍保存进度与分支，这通常是更好的做法。

        记住，在 Git 中任何 已提交 的东西几乎总是可以恢复的。 甚至那些被删除的分支中的提交或使用 --amend 选项覆盖的提交也可以恢复 （阅读 数据恢复 了解数据恢复）。 然而，任何你未提交的东西丢失后很可能再也找不到了。

2.6 状态简览

  git status 命令的输出十分详细，但其用语有些繁琐。 Git 有一个选项可以帮你缩短状态命令的输出，这样可以以简洁的方式查看更改。 如果你使用 git status -s 命令或 git status --short 命令，你将得到一种格式更为紧凑的输出。

$ git status -s
M  hello.py

所有可能的前缀含义：
未暂存的更改（红色）
M：已修改 —— 文件已被修改，但尚未添加到暂存区。
D：已删除 —— 文件已被删除，但尚未添加到暂存区。
已暂存的更改（绿色）
M：已修改 —— 文件已被修改且已添加到暂存区，准备提交。
A：已添加 —— 文件已被添加到暂存区。
D：已删除 —— 文件已被删除且已添加到暂存区，准备移除。
R：已重命名 —— 文件已被重命名且已添加到暂存区。
C：已复制 —— 文件已被复制且已添加到暂存区。
其他前缀
??：未跟踪 —— 该文件未被 Git 跟踪（它既未被添加到暂存区，也不属于版本库的一部分）。
UU：未合并 —— 该文件存在需要解决的冲突（例如，在合并过程中）。
组合前缀示例
有时，一个文件在暂存区和工作目录中可能都有更改。在这种情况下，你会看到前缀的组合：
AM：一个文件已被添加到暂存区（A），然后在提交前又被修改（M）了。
MM：一个文件在暂存区和工作目录中都被修改了。

2.7 忽略文件

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

# 忽略所有的 .a 文件
*.a

# 但跟踪所有的 lib.a，即便你在前面忽略了 .a 文件
!lib.a

# 只忽略当前目录下的 TODO 文件，而不忽略 subdir/TODO
/TODO

# 忽略任何目录下名为 build 的文件夹
build/

# 忽略 doc/notes.txt，但不忽略 doc/server/arch.txt
doc/*.txt

# 忽略 doc/ 目录及其所有子目录下的 .pdf 文件
doc/**/*.pdf

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

• 所有空行或者以 # 开头的行都会被 Git 忽略。

• 可以使用标准的 glob 模式匹配，它会递归地应用在整个工作区中。

• 匹配模式可以以（/）开头防止递归。

• 匹配模式可以以（/）结尾指定目录。

• 要忽略指定模式以外的文件或目录，可以在模式前加上叹号（!）取反。

        所谓的 glob 模式是指 shell 所使用的简化了的正则表达式。 但特别的是：使用两个星号（**）表示匹配任意中间目录，比如 a/**/z 可以匹配 a/z 、 a/b/z 或 a/b/c/z 等。

2.8 查看已暂存和未暂存的修改

        你想知道具体修改了什么地方，可以用 git diff 命令。 稍后我们会详细介绍 git diff，你通常可能会用它来回答这两个问题：当前做的哪些更新尚未暂存？ 有哪些更新已暂存并准备好下次提交？ 虽然 git status 已经通过在相应栏下列出文件名的方式回答了这个问题，但 git diff 能通过文件补丁的格式更加具体地显示哪些行发生了改变。

        例如：我在hello.py文件将第一行1111111111111111111改成了112111111111111并且在第二行添加了ajiwjfa。这些变化在输出内容中都有体现。

$ git diff
diff --git a/hello.py b/hello.py
index bea3e9c..f1c0053 100644
--- a/hello.py
+++ b/hello.py
@@ -1 +1,2 @@
-1111111111111111111
+112111111111111
+ajiwjfa

要查看尚未暂存的文件更新了哪些部分，不加参数直接输入 git diff。
若要查看已暂存的将要添加到下次提交里的内容，可以用 git diff --staged 命令。这条命令将比对已暂存文件与最后一次提交的文件差异。

        请注意，git diff 本身只显示尚未暂存的改动，而不是自上次提交以来所做的所有改动。 所以有时候你一下子暂存了所有更新过的文件，运行 git diff 后却什么也没有，就是这个原因。

2.9 提交更新

        现在的暂存区已经准备就绪，可以提交了。 在此之前，请务必确认还有什么已修改或新建的文件还没有 git add 过， 否则提交的时候不会记录这些尚未暂存的变化。 这些已修改但未暂存的文件只会保留在本地磁盘。 所以，每次准备提交前，先用 git status 看下，你所需要的文件是不是都已暂存起来了， 然后再运行提交命令 git commit：

$ git commit

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

# 请为您的变更输入提交说明。以 '#' 开始的行将被忽略，而一个空的提交
# 说明将会终止提交。
#
# 位于分支 master
# 要提交的变更：
#	删除：     4.txt
#	修改：     hello.py
#
# 未跟踪的文件:
#	1.txt
#	6.txt
#

        可以看到，默认的提交消息包含最后一次运行 git status 的输出，放在注释行里，另外开头还有一个空行，供你输入提交说明。 退出编辑器时，Git 会忽略处理注释行内容，用你输入的提交说明生成一次提交。若没有处理任何要提交的变更，也就是没有删除要提交变更前的注释符号，就是提交为空，那么git会自动终止这次工作。如：

# 不做任何处理
$ git commit
终止提交因为提交说明为空。
# 删除 #	修改：     hello.py 这一行前的#符号
$ git commit
[master a9e7059]        修改：     hello.py
 2 files changed, 2 insertions(+), 2 deletions(-)
 delete mode 100644 4.txt

        另外，你也可以在 commit 命令后添加 -m 选项，快速默认提交全部变更信息并且加入版本更新说明，如：

$ git commit -m "add 1.txt file"
[master 6c33f57] add 1.txt file
 1 file changed, 1 insertion(+)
 create mode 100644 1.txt

        可以看到，提交后它会告诉你，当前是在哪个分支（master）提交的，本次提交的完整 SHA-1 校验和是什么（463dc4f），以及在本次提交中，有多少文件修订过，多少行添加和删改过。 每一次运行提交操作，都是对你项目作一次快照，以后可以回到这个状态，或者进行比较。

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

撤消操作

        在任何一个阶段，你都有可能想要撤消某些操作。 这里，我们将会学习几个撤消你所做修改的基本工具。 注意，有些撤消操作是不可逆的。 这是在使用 Git 的过程中，会因为操作失误而导致之前的工作丢失的少有的几个地方之一。

        有时候我们提交完了才发现漏掉了几个文件没有添加，或者提交信息写错了。 此时，可以运行带有 --amend 选项的提交命令来重新提交：

$ git commit --amend

        这个命令会将修改最近一次的提交，可以修改提交信息或添加新的更改文件(新提交替代上一次的提交)。 如果自上次提交以来你还未做任何修改（例如，在上次提交后马上执行了此命令）， 那么快照会保持不变，而你所修改的只是提交信息。

若你提交后发现忘记了暂存某些需要的修改，可以像下面这样操作：

$ git commit -m 'initial commit'
$ git add forgotten_file
$ git commit --amend

最终你只会有一个提交——第二次提交将代替第一次提交的结果。

2.10 移除文件（停止跟踪文件）

        要从 Git 中移除某个文件，就必须要移除该文件之后进行对该移除文件的提交。但可以用 git rm 命令完成此项工作，并连带从工作目录中删除指定的文件，这样以后就不会出现在未跟踪文件清单中了。也就是说运行git rm file相当于运行了下面两条命令：

$ rm file
$ git add file

        如，对1.txt仅执行了rm 1.txt，而对2.txt文件执行了git rm 2.txt。

       如果你仅想删除将指定文件从暂存区移除，但会保留该文件在工作区的副本，也就是文件依然存在于工作区中，你可以执行git rm --cached命令。这样该文件会从暂存区中消失，当查看 git status 时，会发现该文件显示为已修改（因为暂存区和工作区状态不一致了，暂存区里没它了但工作区还有），如果后续还想把这个文件再次添加到暂存区，可以重新执行 git add操作。即git rm --cached file不会删除file，只是停止git对file的跟踪。
例如：

2.11 重命名文件

        如果在 Git 中重命名了某个文件，仓库中存储的元数据并不会体现出这是一次改名操作。 不过 Git 非常聪明，它会推断出究竟发生了什么。

        要在 Git 中对文件改名，可以这么做：

$ git mv hello.py hell.c

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

$ git mv hello.py hello.c
$ git status
位于分支 master
要提交的变更：
  （使用 "git restore --staged <文件>..." 以取消暂存）
        重命名：   hello.py -> hello.c

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

$ mv README.md README
$ git rm README.md
$ git add README

2.12 查看提交历史

        在提交了若干更新，又或者克隆了某个项目之后，你也许想回顾下提交历史。 完成这个任务最简单而又有效的工具是 git log 命令，但git log只会显示当前分支上的历史。

$ git log
commit 1d9eba1977ae2111c41ede839c675e8f4aa9f586 (HEAD -> master)
Author: Lin <2106639605@qq.com>
Date:   Sun Dec 1 12:22:35 2024 +0800

    add hello.py

commit b9f7f02e03d5f5096becbf5cf4fdde13a84c7a45
Author: Lin <2106639605@qq.com>
Date:   Sun Dec 1 12:05:42 2024 +0800

    untrack hello.py

commit db6c089740980bc3832848ea3b0e2cecc01f1685
Author: Lin <2106639605@qq.com>
Date:   Sun Dec 1 11:47:34 2024 +0800

Date:   Sun Dec 1 11:47:34 2024 +0800

    delete 2.txt

commit 6c33f574da17e731b40f1d4544b3c2f3568380a3
Author: Lin <2106639605@qq.com>
Date:   Sun Dec 1 11:29:55 2024 +0800

    add 1.txt file

commit a9e7059d9ab8ae596a892ff7272cb444512363a1
Author: Lin <2106639605@qq.com>
Date:   Sun Dec 1 11:20:23 2024 +0800

            修改：     hello.py

commit 0e08f91fc13ee45b23d4e2ad4be68a6e2326cfcf
Author: Lin <2106639605@qq.com>
Date:   Sat Nov 30 20:06:05 2024 +0800

    new

commit 4d6c179bed6721e0a5b20b05a6beca8322a67721
Author: Lin <2106639605@qq.com>
Date:   Sat Nov 30 19:41:58 2024 +0800

    new

commit 922c3f41f2a9d1dff882294b6146d3d2389c05b2
Author: Lin <2106639605@qq.com>
Date:   Sat Nov 30 17:31:46 2024 +0800

    initial project version

        不传入任何参数的默认情况下，git log 会按时间先后顺序列出所有的提交，最近的更新排在最上面。 正如你所看到的，这个命令会列出每个提交的 SHA-1 校验和、作者的名字和电子邮件地址、提交时间以及提交说明。

        git log 有许多选项可以帮助你搜寻你所要找的提交， 下面我们会介绍几个最常用的选项。
 1、-p 或 --patch：显示每次提交所引入的差异（按 diff的格式输出）。 你也可以限制显示的日志条目数量，例如使用 -2 选项来只显示最近的两次提交。

2、--stat：显示每次提交的简略统计信息，列出所有被修改过的文件、有多少文件被修改了以及被修改过的文件的哪些行被移除或是添加了。 在每次提交的最后还有提交说明。

3、--pretty：这个选项可以使用不同于默认格式的方式展示提交历史。 这个选项有一些内建的子选项供你使用。比如 oneline 会将每个提交记录显示在单独的一行上，每行内容由提交的哈希值和提交信息两部分组成，在浏览大量的提交时非常有用。 另外还有 short，full 和 fuller 选项，它们展示信息的格式基本一致，但是详尽程度不一。 format 可以定制记录的显示格式。 这样的输出对后期提取分析格外有用。

例如：

$ git log --pretty=format:"%h - %an, %ar : %s"
ca82a6d - Scott Chacon, 6 years ago : changed the version number
085bb3b - Scott Chacon, 6 years ago : removed unnecessary test
a11bef0 - Scott Chacon, 6 years ago : first commit

% H 提交的完整哈希值。
% h 提交的简短哈希值。
% T 树对象的完整哈希值。
% t 树对象的简短哈希值。
% P 父提交的完整哈希值（对于合并提交，以空格分隔）。
% p 父提交的简短哈希值。
% an 作者的姓名。
% ae 作者的电子邮件地址。
% ad 作者日期（使用由 “--date” 指定的日期格式）。
% ar 作者日期，相对于当前时间（例如，“两周前”）。
% cn 提交者的姓名。
% ce 提交者的电子邮件地址。
% cd 提交者的日期。
% cr 提交者的日期，相对于当前时间。
% s 提交信息。
% b 提交信息的正文内容。
% N 与提交相关联的引用（例如，标签、分支）。
%n git中使用 %n 作为统一的换行符占位符，以兼容不同平台

当 oneline 或 format 与另一个 log 选项 --graph 结合使用时尤其有用。 这个选项添加了一些 ASCII 字符串来形象地展示你的分支、合并历史：

$ git log --pretty=format:"%h %s" --graph
* 2d3acf9 ignore errors from SIGCHLD on trap
*  5e3ee11 Merge branch 'master' of git://github.com/dustin/grit
|\
| * 420eac9 Added a method for getting the current branch.
* | 30e367c timeout code and tests
* | 5a09431 add timeout protection to grit
* | e1193f8 support for heads with slashes in them
|/
* d6016bc require time for xmlschema
*  11d191e Merge branch 'defunkt' into local

限制log记录条数（限制log时间）

        除了定制输出格式的选项之外，git log 还有许多非常实用的限制输出长度的选项，也就是只输出一部分的提交。比如git log -2 选项了，它只会显示最近的两条提交， 实际上，你可以使用类似 -n的选项，其中的 n 可以是任何整数，表示仅显示最近的 n 条提交。还可以按照时间做限制的选项--since 和 --until 。 例如，下面的命令会列出最近两周的所有提交：

$ git log --since=2.weeks

该命令可用的格式十分丰富——可以是类似 "2008-01-15" 的具体的某一天，也可以是类似 "2 years 1 day 3 minutes ago" 的相对日期。还可以过滤出匹配指定条件的提交。 用 --author 选项显示指定作者的提交，用 --grep 选项搜索提交说明中的关键字。

        --since，--after=<日期>：显示在指定日期或之后发生的提交，--until,before=<日期>：显示在指定日期或之前发生的提交，这两个选项可以一起使用来指定一个日期范围。Git 在日期格式方面很灵活。你可以通过以下几种方式指定日期：
绝对日期：2024-01-01，Jan 1 2024
相对日期：2周前，昨天，3天前
特定时间：2024-01-01 14:30，3小时前

# 特定日期之后的提交
git log --since="2024-01-01"

# 截至特定日期的提交
git log --until="昨天"

# 在某个日期范围内的提交
git log --since="2周前" --until="昨天"

# 在分支上使用 --since 和 --until 并且搭配format结合使用
git log --since="2024-01-01" --until="2024-02-01" --pretty=format:"%h - %an, %ar : %s" main
# 筛选出 main 分支在 2024 年 1 月期间所做的提交。

# 仅查看合并提交
git log --since="2024-01-01" --merges

# 回顾特定作者进展
git log --since="7天前" --author="名字"

滤出匹配条件的提交

        如用 --author 选项显示指定作者的提交，用 --grep 选项搜索提交说明中的关键字。另一个非常有用的过滤器是 -S， 它接受一个字符串参数，并且只会显示那些添加或删除了该字符串的提交。 假设你想找出添加或删除了对某一个特定函数的引用的提交，可以调用：

$ git log -S function_name

三、远程仓库的使用

3.1 配置github远程仓库

        生成SSH密钥：

ssh-keygen -t ed25519 -C "your_email@example.com"

 这里邮箱地址替换成自己的邮箱地址，再直接敲3次回车

$ ssh-keygen -t ed25519 -C "2106639605@qq.com"
Generating public/private ed25519 key pair.
Enter file in which to save the key (/home/Lin/.ssh/id_ed25519):
Enter passphrase (empty for no passphrase):
Enter same passphrase again:
Your identification has been saved in /home/Lin/.ssh/id_ed25519
Your public key has been saved in /home/Lin/.ssh/id_ed25519.pub
The key fingerprint is:
SHA256:4DRTEfxnbZ5ZlEZZhHEWDGEuCroytAJG5lVMPf5of60 2106639605@qq.com
The key's randomart image is:
+--[ED25519 256]--+
|    oo..+o   +**X|
|    .. +.   o .B.|
| o .  *... . o.. |
|+ .  o.=. o + o .|
|.o . .. S. o o + |
|o . . .o .    +  |
| . + .. .   .    |
|  . o    . . .   |
|          .E.    |
+----[SHA256]-----+

        可以看出ssh密钥的公匙部分被生成放在了/home/Lin/.ssh/id_ed25519.pub路径下，执cat /home/Lin/.ssh/id_ed25519.pub，复制密钥至github上.参考来至：生成新的 SSH 密钥并将其添加到 ssh-agent - GitHub 文档

        在github上添加ssh密钥，cat /root/.ssh/id_rsa.pub //复制到github上（Settings-->SSH andGPG keys-->New SSH key）,title随意设置,就此就完成了远程仓库的配置，可以通过ssh链接抓取git上的仓库.

3.2 查看远程仓库

        如果想查看你已经配置的远程仓库服务器，可以运行 git remote 命令。 它会列出你指定的每一个远程服务器的简写。 如果你已经克隆了自己的仓库，那么至少应该能看到 origin ——这是 Git 给你克隆的仓库服务器的默认名字，也可以指定选项 -v，会显示需要读写远程仓库使用的 Git 保存的简写与其对应的 URL

Lin:~/ysyx/mit_class/miss_class6/dotfile$ git remote
origin
Lin:~/ysyx/mit_class/miss_class6/dotfile$ git remote -v
origin  git@github.com:attackedrookie/dotfile.git (fetch)
origin  git@github.com:attackedrookie/dotfile.git (push)

3.3 添加远程仓库

        运行 git remote add <shortname> <url> 添加一个新的远程 Git 仓库，同时指定一个方便使用的简写。git remote rename重命名远程仓库，git remote remove/rm删除远程仓库。可以在命令行中使用仓库名 来代替整个 URL，git remote show查看远程仓库的更多信息。

3.4 从远程仓库中抓取与拉取

就如刚才所见，从远程仓库中获得数据，可以执行：

$ git fetch remote

这个命令会访问远程仓库，从中拉取所有你还没有的数据。 执行完成后，你将会拥有那个远程仓库中所有分支的引用，可以随时合并或查看。

如果你使用 clone 命令克隆了一个仓库，命令会自动将其添加为远程仓库并默认以 “origin” 为简写。 所以，git fetch origin 会抓取克隆（或上一次抓取）后新推送的所有工作。 必须注意 git fetch 命令只会将数据下载到你的本地仓库——它并不会自动合并或修改你当前的工作。 当准备好时你必须手动将其合并入你的工作。

如果你的当前分支设置了跟踪远程分支（阅读下一节和 Git 分支 了解更多信息）， 那么可以用 git pull 命令来自动抓取后合并该远程分支到当前分支。 这或许是个更加简单舒服的工作流程。默认情况下，git clone 命令会自动设置本地 master 分支跟踪克隆的远程仓库的 master 分支（或其它名字的默认分支）。 运行 git pull 通常会从最初克隆的服务器上抓取数据并自动尝试合并到当前所在的分支。

3.5 推送到远程仓库

        当你想分享你的项目时，必须将其推送到上游。 这个命令很简单：git push <remote> <branch>。 当你想要将 master 分支推送到 origin 服务器时（再次说明，克隆时通常会自动帮你设置好那两个名字）， 那么运行这个命令就可以将你所做的备份到服务器：

$ git push origin master

        只有当你有所克隆服务器的写入权限，并且之前没有人推送过时，这条命令才能生效。 当你和其他人在同一时间克隆，他们先推送到上游然后你再推送到上游，你的推送就会毫无疑问地被拒绝。 你必须先抓取他们的工作并将其合并进你的工作后才能推送。 阅读 Git 分支 了解如何推送到远程仓库服务器的详细信息

四、打标签

4.1 创建标签

Git 支持两种标签：轻量标签（lightweight）与附注标签（annotated）。

轻量标签很像一个不会改变的分支——它只是某个特定提交的引用。

而附注标签是存储在 Git 数据库中的一个完整对象， 它们是可以被校验的，其中包含打标签者的名字、电子邮件地址、日期时间， 此外还有一个标签信息，并且可以使用 GNU Privacy Guard （GPG）签名并验证。 通常会建议创建附注标签，这样你可以拥有以上所有信息。但是如果你只是想用一个临时的标签， 或者因为某些原因不想要保存这些信息，那么也可以用轻量标签。

附注标签

在 Git 中创建附注标签十分简单。 最简单的方式是当你在运行 tag 命令时指定 -a 选项：

$ git tag -a v1.4 -m "my version 1.4"
$ git tag
v0.1
v1.3
v1.4

-m 选项指定了一条将会存储在标签中的信息。 如果没有为附注标签指定一条信息，Git 会启动编辑器要求你输入信息。

通过使用 git show 命令可以看到标签信息和与之对应的提交信息：

$ git show v1.4
tag v1.4
Tagger: Ben Straub <ben@straub.cc>
Date:   Sat May 3 20:19:12 2014 -0700

my version 1.4

commit ca82a6dff817ec66f44342007202690a93763949
Author: Scott Chacon <schacon@gee-mail.com>
Date:   Mon Mar 17 21:52:11 2008 -0700

    changed the version number

输出显示了打标签者的信息、打标签的日期时间、附注信息，然后显示具体的提交信息。

轻量标签

另一种给提交打标签的方式是使用轻量标签。 轻量标签本质上是将提交校验和存储到一个文件中——没有保存任何其他信息。 创建轻量标签，不需要使用 -a、-s 或 -m 选项，只需要提供标签名字：

$ git tag v1.4-lw
$ git tag
v0.1
v1.3
v1.4
v1.4-lw
v1.5

这时，如果在标签上运行 git show，你不会看到额外的标签信息。 命令只会显示出提交信息：

$ git show v1.4-lw
commit ca82a6dff817ec66f44342007202690a93763949
Author: Scott Chacon <schacon@gee-mail.com>
Date:   Mon Mar 17 21:52:11 2008 -0700

    changed the version number

后期打标签

你也可以对过去的提交打标签。 假设提交历史是这样的：

$ git log --pretty=oneline
15027957951b64cf874c3557a0f3547bd83b3ff6 Merge branch 'experiment'
a6b4c97498bd301d84096da251c98a07c7723e65 beginning write support
0d52aaab4479697da7686c15f77a3d64d9165190 one more thing
6d52a271eda8725415634dd79daabbc4d9b6008e Merge branch 'experiment'
0b7434d86859cc7b8c3d5e1dddfed66ff742fcbc added a commit function
4682c3261057305bdd616e23b64b0857d832627b added a todo file
166ae0c4d3f420721acbb115cc33848dfcc2121a started write support
9fceb02d0ae598e95dc970b74767f19372d61af8 updated rakefile
964f16d36dfccde844893cac5b347e7b3d44abbc commit the todo
8a5cbc430f1a9c3d00faaeffd07798508422908a updated readme

现在，假设在 v1.2 时你忘记给项目打标签，也就是在 “updated rakefile” 提交。 你可以在之后补上标签。 要在那个提交上打标签，你需要在命令的末尾指定提交的校验和（或部分校验和）：

$ git tag -a v1.2 9fceb02

可以看到你已经在那次提交上打上标签了：

$ git tag
v0.1
v1.2
v1.3
v1.4
v1.4-lw
v1.5

$ git show v1.2
tag v1.2
Tagger: Scott Chacon <schacon@gee-mail.com>
Date:   Mon Feb 9 15:32:16 2009 -0800

version 1.2
commit 9fceb02d0ae598e95dc970b74767f19372d61af8
Author: Magnus Chacon <mchacon@gee-mail.com>
Date:   Sun Apr 27 20:43:35 2008 -0700

    updated rakefile
...

4.2 列出标签

在 Git 中列出已有的标签非常简单，只需要输入 git tag （可带上可选的 -l 选项 --list，匹配标签名的通配模式）：

$ git tag
v1.0
v2.0

这个命令以字母顺序列出标签，但是它们显示的顺序并不重要。

你也可以按照特定的模式查找标签。 例如，Git 自身的源代码仓库包含标签的数量超过 500 个。 如果只对 1.8.5 系列感兴趣，可以运行：

$ git tag -l "v1.8.5*"
v1.8.5
v1.8.5-rc0
v1.8.5-rc1
v1.8.5-rc2
v1.8.5-rc3
v1.8.5.1
v1.8.5.2
v1.8.5.3
v1.8.5.4
v1.8.5.5

4.3 共享标签

默认情况下，git push 命令并不会传送标签到远程仓库服务器上。 在创建完标签后你必须显式地推送标签到共享服务器上。 这个过程就像共享远程分支一样——你可以运行 git push origin <tagname>。

$ git push origin v1.5
Counting objects: 14, done.
Delta compression using up to 8 threads.
Compressing objects: 100% (12/12), done.
Writing objects: 100% (14/14), 2.05 KiB | 0 bytes/s, done.
Total 14 (delta 3), reused 0 (delta 0)
To git@github.com:schacon/simplegit.git
 * [new tag]         v1.5 -> v1.5

如果想要一次性推送很多标签，也可以使用带有 --tags 选项的 git push 命令。 这将会把所有不在远程仓库服务器上的标签全部传送到那里。

$ git push origin --tags
Counting objects: 1, done.
Writing objects: 100% (1/1), 160 bytes | 0 bytes/s, done.
Total 1 (delta 0), reused 0 (delta 0)
To git@github.com:schacon/simplegit.git
 * [new tag]         v1.4 -> v1.4
 * [new tag]         v1.4-lw -> v1.4-lw

现在，当其他人从仓库中克隆或拉取，他们也能得到你的那些标签。

4.4 删除标签

要删除掉你本地仓库上的标签，可以使用命令 git tag -d <tagname>。 例如，可以使用以下命令删除一个轻量标签：

$ git tag -d v1.4-lw
Deleted tag 'v1.4-lw' (was e7d5add)

注意上述命令并不会从任何远程仓库中移除这个标签，你必须用 git push <remote> :refs/tags/<tagname> 来更新你的远程仓库：

第一种变体是 git push <remote> :refs/tags/<tagname> ：

$ git push origin :refs/tags/v1.4-lw
To /git@github.com:schacon/simplegit.git
 - [deleted]         v1.4-lw

上面这种操作的含义是，将冒号前面的空值推送到远程标签名，从而高效地删除它。

第二种更直观的删除远程标签的方式是：

$ git push origin --delete <tagname>

4.5 检出标签

如果你想查看某个标签所指向的文件版本，可以使用 git checkout 命令， 虽然这会使你的仓库处于“分离头指针（detached HEAD）”的状态——这个状态有些不好的副作用：

$ git checkout 2.0.0
Note: checking out '2.0.0'.

You are in 'detached HEAD' state. You can look around, make experimental
changes and commit them, and you can discard any commits you make in this
state without impacting any branches by performing another checkout.

If you want to create a new branch to retain commits you create, you may
do so (now or later) by using -b with the checkout command again. Example:

  git checkout -b <new-branch>

HEAD is now at 99ada87... Merge pull request #89 from schacon/appendix-final

$ git checkout 2.0-beta-0.1
Previous HEAD position was 99ada87... Merge pull request #89 from schacon/appendix-final
HEAD is now at df3f601... add atlas.json and cover image

        在“分离头指针”状态下，如果你做了某些更改然后提交它们，标签不会发生变化， 但你的新提交将不属于任何分支，并且将无法访问，除非通过确切的提交哈希才能访问。 因此，如果你需要进行更改，比如你要修复旧版本中的错误，那么通常需要创建一个新分支：

$ git checkout -b version2 v2.0.0
Switched to a new branch 'version2'

        如果在这之后又进行了一次提交，version2 分支就会因为这个改动向前移动， 此时它就会和 v2.0.0 标签稍微有些不同，这时就要当心了。

五、分支

5.1 创建分支

        Git 是怎么创建新分支的呢？ 很简单，它只是为你创建了一个可以移动的新的指针。 比如，创建一个 test 分支， 你需要使用 git branch 命令(-b 创建一个新分支后立即切换过去)：

$ git branch test

这会在当前所在的提交对象上创建一个指针。

        那么，Git 又是怎么知道当前在哪一个分支上呢？ 也很简单，它有一个名为 HEAD 的特殊指针。 请注意它和许多其它版本控制系统（如 Subversion 或 CVS）里的 HEAD 概念完全不同。 在 Git 中，它是一个指针，指向当前所在的本地分支（译注：将 HEAD 想象为当前分支的别名）。 在本例中，你仍然在 master 分支上。 因为 git branch 命令仅仅 创建 一个新分支，并不会自动切换到新分支中去。

        可以用git log命令可以查看查看各个分支当前所指的对象

        如上图所示当前所在分支为maser，master分支指向7a55b93的提交对象;而test分支指向0e06396的提交对象.

5.2 分支切换

        要切换到一个已存在的分支，你需要使用 git checkout 命令。 我们现在切换到新创建的 test 分支去：

$ git checkout test

这样 HEAD 就指向 test 分支了。

        如果在进行一次提交，我的 test 分支向前移动了，但是 master 分支却没有，它仍然指向运行 git checkout 时所指的对象。也就是说，你现在切回master做修改的话，项目将始于一个较旧的版本。 本质上来讲，这就是忽略 test分支所做的修改，以便于向另一个方向进行开发。

        现在如果我们对master和test俩个分支都进行一次修改并提交，那么这个项目的提交历史已经产生了分叉。你可以在不同分支间不断地来回切换和工作，并在时机成熟时将它们合并起来。

查看项目分叉历史

        你可以简单地使用 git log 命令查看分叉历史。 运行 git log --oneline --graph --all ，它会输出你的提交历史、各个分支的指向以及项目的分支分叉情况。

5.3 合并分支

        假设你的分支情况如下，你想将test分支合并至master，你要确保切换至master分支，然后执行git merge test.

$ git checkout master
$ git merge test

但如果你文件内有冲突内容那么会导致合并失败。合并分支成功之后，master和test分支指向同一个对象，如果你不需要test分支可以使用git branch -d来删除这个分支。

遇到冲突时的分支合并

        有时候合并操作不会如此顺利。 如果你在两个不同的分支中，对同一个文件的同一个部分进行了不同的修改，Git 就没法干净的合并它们。
         此时 Git 做了合并，但是没有自动地创建一个新的合并提交。 Git 会暂停下来，等待你去解决合并产生的冲突。 你可以在合并冲突后的任意时刻使用 git status 命令来查看那些因包含合并冲突而处于未合并（unmerged）状态的文件。
        任何因包含合并冲突而有待解决的文件，都会以未合并状态标识出来。 Git 会在有冲突的文件中加入标准的冲突解决标记，这样你可以打开这些包含冲突的文件然后手动解决冲突。 出现冲突的文件会包含一些特殊区段，看起来像下面这个样子：

<<<<<<< HEAD


2024/12/4
16:11
=======
2024/12/4
16:09
>>>>>>> test

这表示 HEAD 所指示的版本（也就是你的 master 分支所在的位置，因为你在运行 merge 命令的时候已经检出到了这个分支）在这个区段的上半部分（======= 的上半部分），而test 分支所指示的版本在 ======= 的下半部分。 为了解决冲突，你必须选择使用由 ======= 分割的两部分中的一个，或者你也可以自行合并这些内容:

2024/12/4
16:09
2024/12/4
16:11

上述的冲突解决方案仅保留了其中一个分支的修改，并且 <<<<<<< , ======= , 和 >>>>>>> 这些行被完全删除了。 在你解决了所有文件里的冲突之后，对每个文件使用 git add 命令来将其标记为冲突已解决。 一旦暂存这些原本有冲突的文件，Git 就会将它们标记为冲突已解决。当冲突已经解决可以使用git branch --continue选项或git commit继续完成合并，也可以使用--abort选项终止此次合并。

5.4 分支管理

        当执行 `git branch` 且不添加任何参数时，它能够展示出当前仓库中所有的分支信息，并且会在当前检出的分支名称前以 `*` 号作为标识，该分支即为 `HEAD` 指针当前所指向的分支，这意味着后续的提交操作将使此分支随着新的工作进展而向前推进。
        若要查看各个分支的最后一次提交详情，则可使用 `git branch -v` 命令，它会在分支列表中同时显示每个分支对应的最后一次提交的哈希值以及提交信息，从而让使用者清晰地了解每个分支的最新进展状态。
        在分支管理过程中，`--merged` 和 `--no-merged` 是两个极为有用的选项。其中，`git branch --merged` 可用于筛选出那些已经合并到当前分支的其他分支，这些已合并分支在某些情况下可能不再需要独立存在，例如当它们的工作成果已经完全整合进当前分支后，就可以考虑使用 `git branch -d` 命令进行删除，因为这样做不会导致任何工作成果的丢失。
        而 `git branch --no-merged` 则用于查看那些尚未合并到当前分支的分支。对于这类包含未合并工作的分支，如果尝试使用 `git branch -d` 命令进行删除，操作将会失败，因为这可能会导致未合并的工作成果丢失。不过，如果确实确定要删除此类分支并舍弃其中未合并的工作，正如命令执行失败时所给出的提示信息那样，可以使用 `git branch -D` 选项来强制删除分支，但这种操作需要谨慎使用，以免误删重要的工作内容。
        分支开发工作流详见Git - 分支开发工作流

5.5 跟踪远程分支

        远程引用是对远程仓库的引用（指针），包括分支、标签等等。 你可以通过 git ls-remote <remote> 来显式地获得远程引用的完整列表， 或者通过 git remote show <remote> 获得远程分支的更多信息。 然而，一个更常见的做法是利用远程跟踪分支。

        一个远程跟踪分支是一个本地引用，它们以 <remote>/<branch> 的形式命名，它指向远程仓库中一个分支的状态。在 Git 中，远程分支跟踪指的是将本地分支与远程分支相关联的机制。这本质上是建立一个 “跟踪分支”，它能让你的本地分支 “跟踪” 远程仓库中某个分支的变更情况。当一个本地分支被设置为跟踪一个远程分支时，Git 就会知道要向哪个远程分支推送以及从哪个远程分支拉取内容，这简化了与远程仓库的交互操作。
        当克隆一个仓库时，它通常会自动地创建一个跟踪 origin/master 的 master 分支。 然而，如果你愿意的话可以设置其他的跟踪分支，或是一个在其他远程仓库上的跟踪分支，又或者不跟踪 master 分支。 最简单的实例就是像之前看到的那样，运行 git checkout -b <branch> <remote>/<branch>。 这是一个十分常用的操作所以 Git 提供了 --track 快捷方式。

        远程跟踪的好处在于：它能够简化协作，无论是克隆仓库还是创建新分支，Git 都能精准确定本地分支与对应的远程分支同步关系，使本地分支自动追踪变更，极大方便开发者间的协同工作；可实现自动推送与拉取，在执行相关命令且未指定分支时，Git 能依据跟踪设定自动与相应远程分支交互；有助于高效的分支管理，明确本地与远程分支对应联系，确保功能开发或漏洞修复时的更改与远程分支始终保持一致；支持自动合并，设置跟踪分支后，git pull 能自动获取并合并远程分支的更改且无需每次指定远程仓库和分支，利于及时知晓其他开发者的改动；还能在创建新分支时，基于远程分支自动设置跟踪，新分支创建完毕即可马上与远程仓库进行推送和拉取操作，提升开发效率与便捷性。

创建远程分支跟踪

  git branch --track <local-branch-name> <remote-name>/<remote-branch-name>命令用于创建一个新的本地分支，并将其设置为跟踪一个特定的远程分支。通过跟踪，本地分支与远程分支相链接，使得拉取更新或推送更改更加容易。或用git checkout --track <remote-name>/<remote-branch-name>自动在本地创建名为 <remote-branch-name>的分支，并且将其与远程的 <remote-name>分支建立跟踪关系。

获取远程跟踪信息

确立跟踪远程分支关系之后，可以使用git branch -vv命令来获取远程跟踪信息。

$ git branch -vv
  iss53     7e424c3 [origin/iss53: ahead 2] forgot the brackets
  master    1ae2a45 [origin/master] deploying index fix
* serverfix f8674d9 [teamone/server-fix-good: ahead 3, behind 1] this should do it
  testing   5ea463a trying something new

        这里可以看到 iss53 分支正在跟踪 origin/iss53 并且 “ahead” 是 2，意味着本地有两个提交还没有推送到服务器上。 也能看到 master 分支正在跟踪 origin/master 分支并且是最新的。 接下来可以看到 serverfix 分支正在跟踪 teamone 服务器上的 server-fix-good 分支并且领先 3 落后 1， 意味着服务器上有一次提交还没有合并入同时本地有三次提交还没有推送。 最后看到 testing 分支并没有跟踪任何远程分支。

删除远程跟踪信息

git branch --unset-upstream

设置本地分支跟踪远程分支

git branch --set-upstream-to=<remote>/<branch> <local-branch>

 

 以上就是全部Git的基础操作内容了，更多详细的解读可以参照PRO_Git中文版

 

附录:配置GIT

用户信息

         安装完 Git 之后，要做的第一件事就是设置你的用户名和邮件地址。 这一点很重要，因为每一个 Git 提交都会使用这些信息（方便代码管理、协作以及与代码托管平台等的交互操作），它们会写入到你的每一次提交中，不可更改：

git config --global user.name "Lin"
git config --global user.email 2106639xxx@qq.com

        如果使用了 --global 选项，那么该命令只需要运行一次，因为之后无论你在该系统上做任何事情， Git 都会使用那些信息。 当你想针对特定项目使用不同的用户名称与邮件地址时，可以在那个项目目录下运行没有 --global 选项的命令来配置。
        以上配置信息将写入~/Lin/.gitconfig文件中，Lin是我的用户名，可以通过以下命令查看所有的git配置以及所在的文件：

git config --list --show-origin
# output:
# file:/home/Lin/.gitconfig       user.name=Lin
# file:/home/Lin/.gitconfig       user.email=2106639605@qq.com

以上信息可以随便填写，只是为了其他项目协作者方便知道每次项目操作的人和联系方式

 

常用Git命令总结大全

标签：文件,git,第六课,--,Git,提交,分支
From： https://blog.csdn.net/weixin_52342399/article/details/144156014