Git学习笔记(总)

第一章 概述

1、Git 历史

同生活中的许多伟大事件一样，Git 诞生于一个极富纷争大举创新的年代。Linux 内核开源项目有着为数众广的参与者。绝大多数的 Linux 内核维护工作都花在了提交补丁和保存归档的繁琐事务上（1991－2002年间）。到 2002 年，整个项目组开始启用分布式版本控制系统 BitKeeper 来管理和维护代码。

到 2005 年的时候，开发 BitKeeper 的商业公司同 Linux 内核开源社区的合作关系结束，他们收回了免费使用 BitKeeper 的权力。这就迫使 Linux 开源社区（特别是 Linux的缔造者 Linus Torvalds ）不得不吸取教训，只有开发一套属于自己的版本控制系统才不至于重蹈覆辙。他们对新的系统订了若干目标：

• 速度

• 简单的设计

• 对非线性开发模式的强力支持（允许上千个并行开发的分支）

• 完全分布式

• 有能力高效管理类似 Linux 内核一样的超大规模项目（速度和数据量）

2、Git 定义

Git 是一个开源的分布式版本控制系统（Distributed Version Control System，简称 DVCS），仓库类型分为：本地仓库和远程仓库：

**本地仓库：**开发人员自己电脑上的 Git 仓库

**远程仓库：**是在远程服务器上的 Git 仓库

/*
Git 是目前世界上最先进、最流行的版本控制系统，可以快速高效地处理从很小到非常大的项目版本管理。

它没有中央服务器的概念，每个人的电脑就是一个完整的版本库，这样，工作的时候就不需要联网了，因为版本都是在自己的电脑上。

既然每个人的电脑都有一个完整的版本库，那多个人如何协作呢？比如说自己在电脑上改了文件A，其他人也在电脑上改了文件A，这时，你们两之间只需把各自的修改推送给对方，就可以互相看到对方的修改了，

下图就是分布式版本控制工具管理方式：

Clone：克隆，就是将远程仓库复制到本地

Push：推送，就是将本地仓库代码上传到远程仓库

Pull：拉取，就是将远程仓库代码下载到本地仓库

特点：项目越大越复杂，协同开发者越多，越能体现出 Git 的高性能和高可用性

3、Git 特性和优势

Git 之所以快速和高效，主要依赖于它的如下两个特性：

1. 直接记录快照，而非差异比较
2. 近乎所有操作都是本地执行，不需要联网

特性一：git的记录快照

Git 快照是在原有文件版本的基础上重新生成一份新的文件，类似于备份。为了效率，如果文件没有修改，Git 不再重新存储该文件，而是只保留一个链接指向之前存储的文件。

/*
解析：
version1：文件A、B、C
version2：A 和 C 更新为 A1 C1，  B 没有更新，不备份
version3：C1 更新为 C2，  A1 和 B 没有更新，不备份
version4：A1 B 更新为 A2 B1，  C2 没有更新，不备份
...

优缺点：

缺点：占用磁盘空间较大

优点：版本切换时非常快，因为每个版本都是完整的文件快照，切换版本时直接恢复目标版本的快照即可。

特点：空间换时间

特性二：在 Git 中的绝大多数操作都只需要访问本地文件和资源，一般不需要来自网络上其它计算机的信息。

特性：

1. 断网后依旧可以在本地对项目进行版本管理
2. 联网后，把本地修改的记录同步到云端服务器即可

Git的优势还有：

1. 尽可能添加数据而不是删除或修改数据
2. 分支操作非常快捷流畅
3. 与 Linux 命令全面兼容

Git 应用场景

1. 写作（作家、演说家、编剧）
2. 程序开发
3. 起草法律条款
4. 写学术论文

4、Git 与 SVN 比较

SVN是集中式版本控制系统，版本库是集中放在中央服务器的，而干活的时候，用的都是自己的电脑，所以首先要从中央服务器哪里得到最新的版本，然后干活，干完后，需要把自己做完的活推送到中央服务器。集中式版本控制系统是必须联网才能工作，如果在局域网还可以，带宽够大，速度够快，如果在互联网下，如果网速慢的话，就郁闷了。

下图就是标准的集中式版本控制工具管理方式：

集中管理方式在一定程度上看到其他开发人员在干什么，而管理员也可以很轻松掌握每个人的开发权限。

svn：传统的版本控制系统是基于差异的版本控制（每次记录的是变化的内容），它们存储的是一组基本文件和每个文件随时间逐步累积的差异。

/*
解析：
初始版本1 中有三个文件 A B C
升级到版本2：在版本2中记录的是文件A变化的内容 🔺1  和 文件C变化的内容 🔺1
升级到版本3：在版本3中记录文件c的变化内容 🔺2
...
切换到版本3，需要在初始文件 A 应用一次差异，在初始文件 C 上应用2次差异
如果是切换版本5，需要在初始文件 A 上应用2次差异，在初始文件 B 上应用2次差异，在初始文件 C 上应用2次差异

优缺点：

好处：节省磁盘空间

缺点：耗时、效率低 在每次切换版本的时候，都需要在基本文件的基础上，应用每个差异，从而生成目标版本对应的文件。

集中式和分布式版本控制系统的区别？

集中式SVN，分布式git，区别如下：

集中式的缺点：

1. 必须联网才能工作

2. 中央服务器出问题了，就没法工作

3. 分支速度慢

分布式的优点：

1. 不需要联网，也可以工作。
2. 没有中央服务，每台自己就是服务器。
3. 没有全局分支，自己的服务器可以创建n个分支，速度极快。

git和svn的区别

• 1.Git 是分布式的，SVN集中式
  2.Git 把内容按元数据方式存储，而 SVN 是按文件
  3.Git 分支和 SVN 的分支不同
  4.Git 没有一个全局的版本号，而 SVN 有
  5.Git 的内容完整性要优于 SVN

5、Git 中的三个区域

使用 Git 管理的项目，拥有三个区域，分别是：

1. 工作区：本地处理工作的区域（写代码，修改代码）
2. 暂存区：已完成的工作临时存放区域， 等待被提交
3. Git 仓库：最终的存放区域

解析：

工作区就是电脑里能看到的目录，存放项目或者文件的目录；

在这个工作目录中的 .git 隐藏文件夹才是版本库；

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

当我们创建Git版本库时，Git自动为我们创建了唯一一个master分支，git commit就是往master分支上提交更改。

可以简单理解为，需要提交的文件修改后通通放到暂存区，然后，一次性将暂存区的所有修改提交到分支。

6、Git 中的三种状态

使用 Git 管理的项目，拥有三个状态，分别是：

1. modified（已修改）：表示修改了文件，但还没 将修改的结果放到暂存区
2. staged（已暂存）：表示对已修改文件的当前版本做了标记，让它包含在下次提交的列表中
3. committed（已提交）：表示文件已经安全地保存 在本地的 Git 仓库中

注意：

工作区的文件被修改了，但还没有放到暂存区，就是已修改状态。

如果文件已修改并放入暂存区，就属于已暂存状态。

如果 Git 仓库中保存着特定版本的文件，就属于已提交状态。

7、Git 和代码托管中心

代码托管中心的作用是：维护远程库

局域网环境下：gitlab 服务器（可以自己搭建的服务器）

联网环境下：github 和 码云(gitee)

注意：

git 和 github 是两个完全没有关系的概念，

• git 是版本控制工具，管理本地仓库
• GitHub 是远程仓库托管中心

Git 与 GitHub 区别？

git是一个版本控制系统，而github是一个在线开源托管网站。你可以使用git上传源码到github开源网站上去。

8、Git 工作流程

一般工作流程如下：

1. 从远程仓库中克隆 Git 资源作为本地仓库；

2. 从本地仓库中 checkout 代码到工作区，然后进行代码修改；

3. 在提交前先将代码提交到暂存区；

4. 提交到本地仓库，本地仓库中保存修改的各个历史版本；

5. 在修改完成后，需要和团队成员共享代码时，可以将代码 push 到远程仓库（git仓库）。

下图展示了 Git 的工作流程：

9、本地库和远程库

作用是协作开发

9.1 团队内部协作

9.2 跨团队协作

第二章 环境准备

最早Git是在Linux上开发的，很长一段时间内，Git也只能在Linux和Unix系统上跑。不过，慢慢地有人把它移植到了Windows上。现在，Git可以在Linux、Unix、Mac和Windows这几大平台上正常运行了。由于开发机大多数情况都是windows，所以这里讲解windows下的git的安装及使用

1、Git

1.1 软件下载

下载地址：https://git-scm.com/download

淘宝镜像下载安装

• https://npm.taobao.org/mirrors/git-for-windows/

安装方式

• 因为git是命令行工具，默认安装再C盘，不要装作含中文的目录下，建议一路下一步安装

1.2 软件安装

git的安装一路点击“下一步”，使用默认的选项即可

安装详解：

1. 安装 git for windows

2. 选择安装路径：使用非中文没有空格的目录

3. 选择组件：默认

选项解析：

Additional icons ： 否创建图标

• On the Desktop ：在桌面

Windows Explorer integration：集成右键功能

• Git Bash Here
• Git GUI Here

Git LFS (Large File Support)：git大文件支持

Associate .git* configuration files with the default text editorAssociate .sh files to be run with Bash：打开 git 配置文件的默认文本编辑器

4. 选择开始目录文件：默认

5. 选择默认文本编辑器：使用默认的 vim 编辑器

6. 初始化分支名称：默认

解析：

Let Git decide：让 git 决定

• .Let Git use its default branch name (currently: “master”) for the initial branchin newly created repositories. The Git project intends to change this default toa more inclusive name in the near future.

让 git 使用初始化生成的分支，默认名称为 master…

7. 调整环境变量：可以选择第一项，也可以使用默认的推荐选项（第二项）

解析：

Use Git from Git Bash only:

• 这是最多的选择，将不会改变你的环境，但是只能在 git bash 中执行 git 命令

Git from the command line and also from 3rd-party software

• 推荐，这个选项只给你的path添加了一些最小的git包装器，可以从 git bash 中使用git，也可以从命令提示符等以及任何第三方软件中寻找 git

use Git and optional Unix tools from the Command Prompt

• 警告：这个选项会修改 path，覆盖 windows的一些命令，如“查找” 和 “排序”… 不推荐

8. 选择可知行文件：默认自带的 ssh.exe

解析：

Use bundled OpenSSH：使用自带的 ssh.exe（可执行文件）

• This uses ssh.exe that comes with Git.)

Use external OpenSSH：使用外部的可执行文件

• NEW!This uses an external ssh.exe.Git will not install its own OpenSSH(and related) binaries but use them as found on the PATH.

9. 选择传输协议：默认

解析：

Use the openSSL library

• 使用通用的 openSSL 库建立连接，推荐

Use the native Windows Secure Channel library

• 本地windows安全通道连接有一定的局限性，不推荐使用

10. 配置文本结束符：默认

解析：

checkout Windows-style, commit Unix-style line endings

• Git will convert LF to CRLF when checking out text files. When committingtext files,CRLF will be converted to LF. For cross-platform projects,
  this is the recommended setting on Windows (“core.autocrIf” is set to “true”).

检出文件时将 LF 转换为 CRLF, 提交时将 CRLF 转换为 LF（windows 和 Unix 系统换行符不一样，这个选项会帮我们做转换）

Checkout as-is, commit Unix-style line endings

• Git will not perform any conversion when checking out text files. When committing text files,CRLF will be converted to LF.For cross-platform projects,this is the recommended setting on Unix (“core.autocrlf” is set to “input”).

Checkout as-is, commit as-is

• Git will not perform any conversions when checking out or committingtext files. Choosing this option is not recommended for cross-platformprojects (“core.autocrlf” is set to “false”).

11. 配置 git 终端：默认

解析：

Use MinTTY (the default terminal of MSYS2)

• Git Bash will use MinTTY as terminal emulator, which sports a resizable window,non-rectangular selections and a Unicode font. Windows console programs(suchas interactive Python) must be launched via ‘winpty` to work in MinTTY.

使用 git 自带的默认终端（推荐，命令和 linux 命令兼容）

use Windows’ default console window

• Git will use the default console window of Windows (“cmd.exe”), which works wellwith Win32 console programs such as interactive Python or node.js, but has avery limited default scroll-back, needs to be configured to use a Unicode font inorder to display non-ASCII characters correctly, and prior to Windows 10 itswindow was not freely resizable and it only allowed rectangular text selections.

使用 windows 默认的的命令提示符（可能会有命令冲突，不推荐）

12. 选择 git pull 默认行为：默认

13. 启用授权管理器：默认

14. 启用文件缓存：默认

15. 最后是一些新的功能，可以不勾选，直接 Install 安装

16. 安装成功

最后取消勾选”View Release Notes（视图版本说明，不需要）” → finish

17. 检测是否安装成功

任意位置右键，有 Git GUI Here 和 Git Bash Here 表示安装成功

验证安装成功

• 1. win菜单 打开运行命令
• 2. 打开 CMD 命名窗口
• 3. 在命令行中输入 git –version 然后会打印出版本号
• 4. 安装成功

2、TortoiseGit

2.1 软件介绍

TortoiseGit 其实是一款开源的git的版本控制系统，也叫海龟git。TortoiseGit提供了人性化的图形化界面，不用像Git一样输入许多语句，像git init、git add、git commit这些语句就通通不用记了。轻松使用鼠标，就可以完成代码的提交和上传。对于使用本地Git的新手来说，TortoiseGit更加简便，更加容易上手。

2.2 软件下载

地址：https://tortoisegit.org/download/

2.3 软件安装

TortoiseGit 安装一路点击“下一步”，使用默认的选项即可

安装详解：

1. 下一步

2. 下一步

3. 客户端选择推荐的 “基于Putty…, 更好的与 windows 集成”，下一步：

4. 自定义安装路径，下一步：

5. install，安装

6. 取消勾选，完成

2.4 安装中文语言包

中文语言包并不是必选项。可以根据个人情况来选择安装。

点击中文语言语言安装包，直接下一步完成即可

在 TortoiseGit 的设置中可以选择语言：

3、代码托管服务

3.1 概述

前面我们已经知道了Git中存在两种类型的仓库，即本地仓库和远程仓库。那么我们如何搭建Git远程仓库呢？我们可以借助互联网上提供的一些代码托管服务来实现，其中比较常用的有GitHub、码云、GitLab等。

知名远程仓库网站

gitHub（ 地址：https://github.com/ ）是一个面向开源及私有软件项目的托管平台，因为只支持Git 作为唯一的版本库格式进行托管，故名gitHub

码云（地址： https://gitee.com/ ）是国内的一个代码托管平台，由于服务器在国内，所以相比于GitHub，码云速度会更快

GitLab （地址： https://about.gitlab.com/ ）是一个用于仓库管理系统的开源项目，使用Git作为代码管理工具，并在此基础上搭建起来的web服务

内网仓库
gitlab是使用java开发的一个内网仓库

3.2 创建 GitHub账号

访问 github 官方网站https://github.com/，注册账号

第一步：Sign up

第二步：填入注册信息

账号：24932***8@qq.com

密码：p***

用户名：pan0506

第三步：注册成功

选择免费版本，忽略兴趣选项，注册成功后自动登入githhub

注册成功后点击 Create Repository 就可以创建远程仓库了

3.3 创建gitee账号

推荐使用：由于服务器在国内，所以相比于GitHub，码云速度会更快

访问码云官方网站https://gitee.com/，选择注册：

填入注册信息

用户名：pan0506

邮箱：343268***@qq.com

密码：p***

3.4 创建Git远程仓库

登录成功后即可创建 “我的仓库”

填写仓库名称（其他选项默认即可），点击创建

初始化 readme 文件（可以不需要）：

设置仓库开源：

完成：

每个Git远程仓库都会对应一个网络地址，可以点击克隆/下载按钮弹出窗口并点击复制按钮获得这个网络地址：

当前创建的远程仓库对应的地址为：

https://gitee.com/pan0506/my-repo1.git

3.5 设置其他仓库成员

前面已经在码云上创建了自己的远程仓库，目前仓库成员只有自己一个人（身份为管理员）。在企业实际开发中，一个项目往往是由多个人共同开发完成的，为了使多个参与者都有权限操作远程仓库，就需要邀请其他项目参与者成为当前仓库的成员。

在 【管理】选项

→ 仓库成员管理

→ 开发者（当前仓库除了创建的人是管理员，其他用户一般都是开发人员）

→ 添加仓库成员

→ 邀请用户：

邀请的方式有多种，可以通过链接邀请，也可以直接添加：

注意：

直接添加可以输入其他用户的个性邮箱或者注册时的用户名（必须是存在的用户）：

点击添加后提交，会将邀请信息发送到对方的用户邮箱，对方同意后，即可参与项目开发，即：代码的下载、修改、推送等操纵

第三章 GitBash管理文件版本

1、 本地仓库操作

1.1 初始化本地仓库

1.1.1 获取方式

获取（初始化）git 仓库的方式有两种：

• 将尚未进行版本控制的本地目录转换为 Git 仓库
• 从其它服务器克隆一个已存在的 Git 仓库（后面演示）

以上两种方式都能够在自己的电脑上得到一个可用的 Git 仓

1.1.2 命令

# 在当前目录新建一个Git代码库
$ git init

# 新建一个目录，将其初始化为Git代码库
$ git init [project-name]

# 下载一个项目和它的整个代码历史
$ git clone [url]

Linux 常用命令

清屏命令：clear

快捷键：Ctrl + L

重启终端：reset

1.1.3 步骤

如果自己有一个尚未进行版本控制的项目目录，想要用 Git 来控制它，需要执行如下两个步骤：

1. 在项目目录中，通过鼠标右键打开“Git Bash”
2. 执行 git init 命令将当前的目录转化为 Git 仓库

在工作空间新建一个 gitRepository 目录，测试 git 操作：

在当前 gitRepository 目录中新建仓库1：repo1

在当前目录 repo1 中右键 → Git Bash Here，打开 git 命令行窗口

输入 git init 命令初始化本地仓库

注意：

git init 命令会创建一个名为 .git 的隐藏目录，这个 .git 目录就是当前项目的 Git 仓库，

里面包含了初始的必要 文件，这些文件是 Git 仓库的必要组成部分。

.git 目录中存放的是本地库相关的子目录和文件，不要删除，也不要轻易修改

概念：

版本库：“.git”目录就是版本库，将来文件都需要保存到版本库中。

工作目录：包含 “.git”目录的目录，也就是.git目录的上一级目录就是工作目录。

只有工作目录中的文件才能保存到版本库中。

1.2 配置用户信息

1.2.1 签名形式

设置自己的用户名和邮件地址（设置签名）。通过 Git 对项目进行版本管理的时候，Git 需要使用这些基本信息，来记录是谁对项目进行了操作，

例如：

用户名：pan

Email 地址：pan0506@cc.com

注意：

用户名可以和邮箱名称不一致，邮箱也可以是不存在的

这个签名（用户名和邮箱）的作用：是区分开发人员的身份

这里的设置的签名和登录远程仓库（GitHub 或 码云）的账号密码没有任何关系，可以是不存在的用户名和邮箱

1.2.2 查看配置项

查看配置信息： git config --list

解析：

我们发现这里面并没有用户信息，所以需要我们去配置用户信息

1.2.3 命令

用户的信息可以设置为两个级别

1. 仓库级别（也叫项目级别）：仅在当前本地仓库范围有效

命令：

git config user.name "pan_pro" 命令设置仓库级别用户名（pro表示项目级别）

git config user.email "pan0506@cc.com" 命令设置邮箱

使用 git config --list 或者 cat .git/config 命令查看 配置的信息

2. 全局范围（也叫系统用户级别）：登录当前操作系统的用户范围

命令：

git config --global user.name "pan_glb" 设置全局范围用户名（gib表示全局配置）

git config --global user.email "pan0506@cc.com" 设置全范围别邮箱

使用 git config --list 或者 cat ~/.gitconfig：查看当前系统用户家目录（c/users/cc/.gitconfig）中保存的信息。

（~ 表示当前系统用户的家目录：c/user/cc）

1.2.4 签名的优先级

就近原则：

项目级别优先于系统用户级别，二者都有时采用项目级别的签名

如果只有系统用户级别的签名，就以系统用户级别的签名为准

注意：

仓库级别和全局级别，必须存在一个，不允许二者都没有

1.2.5 小结

在 linux 系统中，git 的命令都是以 git 开头（主命令），后面跟其他的命令，

例如：git config，表示配置命令

还可以在命令后面使用 --添加一些参数，

例如：git config --golbal，表示全局配置

1.3 查看状态（status）

1.3.1 准备测试文件

在当前目录中新建一个 test.txt 文件用于测试基本操作

1.3.2 命令

可以使用 git status 命令查看文件处于什么状态

解析：

没有未追踪文件：

on branch master：表示当前在 master 分支上

no commits yet：没有任何提交

nothing to commit ：没有可以提交的东西

(create/copy files and use “git add” to track)：使用 git add 命令追踪创建或者复制的文件（即使用 git 管理文件）

有未追踪文件：

Untracked files: 未追踪文件
(use “git add …” to include in what will be committed)：使用git add包含到将要提交的文件（保存到暂存区）
test.txt ：文件名称

nothing added to commit but untracked files present (use “git add” to track)：没有添加提交但是有未追踪的文件

使用 git status 输出的状态报告很详细，但有些繁琐。

如果希望以精简的方式显示文件的状态，可以使用 git status -s 或者 git status --short命令，

其中 -s 是 --short 的简写形式，

如果有未跟踪文件，前面有红色的 ?? 标记

1.4 跟踪文件

1.4.1 添加到暂存区（add）

使用命令 git add 开始跟踪文件（即：将文件添加到暂存区），然后查看状态

解析：

Changes to be committed: 改变成将要提交的文件（保存到暂存区的文件）
(use “git rm –cached …” to unstage)：可以使用 git rm --cached 取消文件跟踪
new file: test.txt

1.4.1 取消跟踪（rm）

使用命令 git rm --cached 文件名 命令取消跟踪文件（从暂存区删除文件，本地工作区文件还在，不是删除本地文件）

1.5 提交更新（commit）

使用 git commit 命令提交文件

提交的方式有两种

• git commit 文件，进入 vim 编辑器，编辑日志信息
• git commit -m "message" 文件，在命令中添加日志message，直接提交

1.5.1 第一种方式

git commit 文件，进入 vim 编辑器，编辑日志信息

环境准备：将 test.txt 文件添加到暂存区（跟踪文件）

操作步骤：

1. 输入 git commit test.txt 命令， 进入 vim 编辑器

2. 进入 vim 编辑器

3. 在 vim 编辑器中输入提交日志内容

步骤：

:set nu 命令可以显示行号

a 或者 i 命令切换为编辑模式，编辑日志内容

Esc 退出编辑模式

:wq + 回车，保存退出

4. 提交成功信息

解析：

[master (root-commit) e549da4]：表示在master主干根提交

first commit, new file test.txt：提交的日志信息

1 file changed, 1 insertion(+)：1个文件变化，1行内容（文本中的内容）

5. 查询状态

解析：

nothing to commit, working tree clean: 没有可以提交的，工作树很干净

1.5.2 第二种方式

git commit -m "message" 文件，在命令中添加日志message，直接提交

环境准备：

1. 修改文件内容（可以手动修改，也可以使用命令修改）

命令修改步骤：

vim test.txt 命令进入文件

:set nu 命令显示行号

a 命令切换为编辑模式，修改内容

Esc 退出编辑

:wq + 回车 保存并退出文件

2. 修改后查看状态

解析

Changes not staged for commit: 没有暂存到可以提交的区域

(use “git add …” to update what will be committed) ： 使用git add 命令 更新 到准备提交的区域

(use “git restore …” to discard changes in working directory) ： 使用git restore 命令取消修改文件

modified: test.txt 修改的文件

no changes added to commit (use “git add” and/or “git commit -a”) ：可以先add 再commit，也可以直接commit

3. 先执行 git add

出现了两行警告，解析：

warning: LF will be replaced by CRLF in test.txt. 行末（换行符）LF 将会被转换为 CRLF
The file will have its original line endings in your working directory 不会修改工作空间的文件行末

4. 查看状态

解析：

Changes to be committed: 变为可提交的文件
(use “git restore –staged …” to unstage)：可以使用 git restore 命令取消跟踪
modified: test.txt 修改的文件

在命令中添加日志信息，直接提交：

输入命令： git commit -m "second commit,modify test.txt" test.txt

1.6 综合练习：将java工程提交到版本库

1.6.0 需求

将 springbootShiro 项目提交到本地仓库，忽略不需要提交的文件

1.6.1 初始化本地仓库

新建 repo2 目录，复制需要版本控制的 springbootShiro 到当前目录，

执行git init 命令，初始化本地仓库：

1.6.2 忽略文件或目录

在此工程中，并不是所有文件都需要保存到版本库中的，

例如 target 目录是编译后的目录，这个目录及目录下的文件就可以忽略。

Git解决这个问题很简单，在Git工作区的根目录下创建一个特殊的 .gitignore 文件，然后把要忽略的文件名填进去，Git就会自动忽略这些文件。

步骤：

工作区间的根目录中创建 .gitignore 文件

编辑内容，填写忽略的文件名称（springbootShiro目录下的target目录）

注意文件中的内容：

springbootShiro/target 表示忽略 springbootShiro 目录下的 taget 文件和 target 目录

springbootShiro/target/ 表示忽略 springbootShiro 目录下的 target 目录（不包括 target 文件）

拓展：

忽略文件语法规范：

• 空行或是以 # 开头的行，即注释行将被忽略。

• 可以在前面添加正斜杠 / 来避免递归,下面的例子中可以很明白的看出来与下一条的区别。

• 可以在后面添加正斜杠 / 来忽略文件夹，例如 build/c 即忽略 build文件夹。

• 可以使用 ! 来否定忽略，即比如在前面用了 *.apk ，然后使用 !a.apk ，则这个 a.apk 不会被忽略。

• * 用来匹配零个或多个字符，如 *.[oa] 忽略所有以 .o或 .a 结尾

• *~ 忽略所有以 ~ 结尾的文件（这种文件通常被许多编辑器标记为临时文件）；

• [] 用来匹配括号内的任一字符，如 [abc] ，也可以在括号内加连接符，如 [0-9] 匹配0至9的数；

• ? 用来匹配单个字符。

看个例子：

*.a      		// 表示忽略 .a 文件

!lib.a   		// 但否定忽略 lib.a, 尽管已经在前面忽略了 .a 文件

/TODO    		// 仅在当前目录下忽略 TODO 文件， 但不包括子目录下的 subdir/TODO

build/			// 忽略 build/ 文件夹下的所有文件

doc/*.txt		// 忽略 doc/notes.txt, 不包括 doc/server/arch.txt

doc/**/*.pdf    // 忽略在 doc/  directory 下的所有的 .pdf 文件 

1.6.3 添加到暂存区

执行 git add . 命令，添加当前目录下的所有文件（夹）

git add . 命令 表示添加当前目录下的所有文件（夹）添加到暂存区

注意：也可以进入到指定目录（cd springbootShiro）执行 git add . 命令

查看 springbootShiro 目录发现，target 目录已经被忽略，没有添加到暂存区

1.6.4 提交到本地仓库

执行git commit -m "日志信息" 命令提交

提交命令不使用文件名称，默认提交当前所有暂存区的文件

查看 springbootShiro 目录，发现此时 target 目录是被忽略的，没有提交到本地仓库：

2、远程仓库操作

回顾Git工作流程

前面通过命令或者 TortoiseGit 操作的都是本地仓库是，接下来我们要操作远程仓库，示意图：

一般工作流程如下：

1. 从远程仓库中克隆 Git 资源作为本地仓库。

2. 从本地仓库中 checkout 代码到工作区，然后进行代码修改

3. 在提交前先将代码提交到暂存区。

4. 提交到本地仓库，本地仓库中保存修改的各个历史版本。

5. 在修改完成后，需要和团队成员共享代码时，可以将代码 push 到远程仓库（git仓库）。

下图展示了 Git 的工作流程：

2.1 克隆远程仓库

克隆远程仓库也就是从远程把仓库复制一份到本地，克隆后会创建一个新的本地仓库。选择一个任意部署仓库的目录，然后克隆远程仓库。

可以通过 Git 提供的命令从远程仓库进行克隆，将远程仓库克隆到本地

在存放的目录中打开 GitBash 窗口，输入命令：git clone 远程仓库地址：

2.2 查看远程仓库

如果想查看已经配置的远程仓库服务器，可以运行 git remote 命令。 它会列出指定的每一个远程服务器的简写。 如果已经克隆了远程仓库，那么至少应该能看到 origin ，这是 Git 克隆的仓库服务器的默认名字

git remote 命令：在克隆的仓库中查看远程仓库服务器名称：

解析：

前面，我们克隆了远程仓库 myRepo1 到本地，其实这个远程仓库和本地仓库已经建立起关联关系，

在这个克隆的远程仓库中执行 git remote 命令就能查询当前本地仓库和哪个远程仓库服务器（默认名称origin）建立了关联

git remote -v 命令可以列出远程仓库地址信息：

解析：

通过这个命令列出了远程仓库的地址信息

fetch：表示获取远程仓库链接的地址，即：可以从远程仓库获取代码

push：表示推送本地仓库代码到远程仓库的地址，即：可以将本地仓库的代码推送到远程仓库

如果我们想要查看更详细的信息，可以使用 git remote show origin

**注意：**如果是本地仓库没有和远程仓库建立关联，那么输入查看命令是没有信息显示的，例如在前面我们自己创建的本地仓库 repo1 中查看：

2.3 添加远程仓库

对于我们本地创建的Git仓库 repo1，是没有和远程仓库建立联系的，我们可以添加到指定的远程服务器上

git remote add <shortname> <url> 命令：添加一个新的远程 Git 仓库，同时指定一个可以引用的简写，

示例：将本地仓库 repo1 添加到远程仓库（即：将本地仓库关联到远程仓库）

在码云上新建一个远程仓库repo1（远程仓库和本地仓库名称可以不一致，但是建议保持一致）：

创建后，初始化 readme 文件和 设置为开源仓库

在本地仓库 repo1 中打开 GitBash，执行git remote add <remote-name> <url> 命令:

shortname：通常使用默认的 origin，也可以自定义名称

url：远程仓库的地址

添加成功后，就能查询到远程仓库的信息了

练习：创建远程仓库 repo2，并将本地仓库 repo2 添加到该远程仓库

2.4 拉取远程仓库代码：git pull

从远程仓库拉取代码的命令有两个：get pull 和 get fetch

git pull <remote-name> <branch-name> 命令：是从远程仓库的指定分支获取最新版本并 merge（合并）到本地仓库

注意：

如果，当前本地仓库有文件，那么从原仓库拉取文件会报错：

fatal: refusing to merge unrelated histories

解析：

因为本地仓库有文件，从远程仓库拉取文件下来，可能会覆盖当前的文件，所以拉取失败

解决方式：

在拉取的命令后面添加参数选项：–allow-unrelated-histories

表示强制拉取，并合并到本地仓库

执行强制拉取并合并到本地的命令后会进入到日志界面，不需要填写日志的话直接:wq! 保存推出即可

拉取成功：

2.5 拉取远程仓库代码：git fetch

环境准备：将本地仓库 repo1 删除，重新初始化，并关联远程仓库repo1

git fetch 或者 git fetch origin master 命令：从远程仓库抓取文件

执行完命令抓取命令后，远程仓库的的文件已经以二进制的文件形式抓取到本地仓库（.git 目录下的 objects 目录中）

但是不会 merge 到本地工作空间（即：没有合并到工作空间中，不会显示）

上面抓取的结果我们可以看到抓取到的分支是 origin/master，

需要执行 git merge origin/master 命令 ，将同步到本地仓库的文件 merge（合并）到本地工作空间

pull 和 fetch 的区别：

1. git pull 命令相当于 git fetch + git merge 两个命令的结合

2. 建议使用 git fetch 命令获取远程仓库文件，因为：

git fetch是将远程主机的最新内容拉到本地，用户检查后决定是否合并到分支中，而git pull则是将远程主机的最新内容拉下来直接合并即：git pull = git fetch + git merge，可能产生冲突需要手动解决

3. 当本地仓库存在文件时，从远程仓库拉取数据会报错，解决方式：

添加：–allow-unrelated-histories 参数

2.6 移除远程仓库

日常工作中：可能会因为一些原因想要移除一个远程仓库

注意：移除远程仓库只是从本地移除远程仓库的记录，并不会真正影响到远程仓库

可以使用 git remote rm <remote-name> 命令移除远程仓库

2.7 推送到远程仓库

前面我们将本地仓库 repo2 关联到远程仓库后，本地仓库中的文件并没有推送到远程仓库中

推送本地仓库的文件到远程仓库之前要先拉取远程仓库的代码，这里我们的本地仓库有文件，所以需要先强制拉取文件：

强制拉取命令：git pull origin master --allow-unrelated-histories

通过git push <remmote-name> <branch-name> 命令将本地仓库的文件推送到远程仓库：

第一次推送的时候需要输入码云的用户名和密码

推送成功，本地仓库的文件和目录已经同步到了远程仓库中：

小结：

修改本地文件后，可以通过git push <remmote-name> <branch-name> 命令来同步到远程仓库

3、Git 分支

几乎所有的版本控制系统都以某种形式支持分支。 使用分支意味着你可以把你的工作从开发主线上分离开来，以免影响开发主线。Git 的master分支并不是一个特殊分支。 它跟其它分支没有区别。 之所以几乎每一个仓库都有 master 分支，是因为git init 命令默认创建它，并且大多数人都懒得去改动它。

3.1 查看分支

分支有两种，一种是本地仓库分支，另一种是远程仓库的分支

接下来操作 repo2 仓库，来查看分支：

查看分支的命令：

git branch 命令：列出所有本地分支

git branch -r 命令：列出所有远程分支

git branch -a 命令：列出所有本地分支和远程分支

效果如下：

3.2 创建分支

创建本地仓库分支，后面可以推送到远程仓库：

命令：

git branch <branch-name> 命令：在本地仓库创建一个分支

解析：

上面的命令创建了两个分支：a1、a2，加上默认创建的 master 分支，查询结果有三个分支

3.3 切换分支

命令：

git checkout <branch-name> 命令：切换到指定的分支

解析：

上面的命令将当前的分支从 master 切换到 a1 分支

查看分支：标 * 号的分支表示当前分支，或者通过行末括号中的名称也能分辨当前属于哪个分支

3.4 推送至远程仓库分支

命令

git push <remote-name> <branch-name> 命令：将本地分支推送至远程仓库分支

练习：将 a2 分支推送到远程仓库分支

解析：

查看远程仓库中的 a1、a2分支，我们发现，a1、a2分支中的内容和 master 分支中的内容一样，

原因： a1、a2 分支是在 master 分支的基础上创建出来的，随着我们在不同的分支上开发，修改内容，不同分支的代码会产生差异

3.5 合并分支

命令：

git merge <branch-name> 命令：将指定分支的内容合并到当前分支

例如我们当前在 a1 分支下新增了一个文件 user.txt

当我们切换到 master 分支后发现，master 分支下并没有 User.txt

在当前 master 分支下，执行 git merge a1 命令即可将 a1 分支的文件合并到当前 master 分支下：

注意：

有时候合并操作不会如此顺利。 如果你在两个不同的分支中，对同一个文件的同一个部分进行了不同的修改，Git 在合并的时候就会提示会提示文件冲突，合并失败；

此时需要我们打开冲突的文件并修复冲突内容，最后执行git add命令来标识冲突已解决

示例：

在 master 分支下修改 User.txt 文件 → 添加缓存区 → 提交到本地仓库：

切换到 a1 分支，修改 User.txt 文件 → 添加缓存区 → 提交到本地仓库：

切换回 master 分支，将 a1 分支合并到 master 分支：

解析：

CONFLICT (content): Merge conflict in User.txt 【表示合并内容发生冲突】
Automatic merge failed; fix conflicts and then commit the result. 【自动合并失败】

行末的分支 (master|MERGING) 表示 master 分支在合并时发生错误

打开 User.txt 查看内容发现，在合并时这里面多了很多多余的内容

需要我们手动解决冲突内容（删除不需要的内容，保留需要内容），然后添加暂存区，提交到本地仓库即可：

3.6 推送到远程

将我们在本地仓库分支修改或者添加的文件推送到远程分支中：

命令：

git push <remote-name> <branch-name> 命令：将本地分支的内容推送到指定远程分支

查看远程仓库的分支，验证推送成功

3.7 删除分支

删除本地分支命令：

git branch -d <branch-name> 命令：删除指定的分支

如果要删除的分支中进行了一些开发动作（比如修改了文件没有推送到远程仓库中），此时执行上面的删除命令并不会删除分支，如果坚持要删除此分支，可以将命令中的-d参数改为-D

示例：

此时：本地仓库 a1 分支修改的内容没有推送到远程仓库，不能直接通过 git branch -d <branch-name> 命令直接删除 a1 分支，可以将命令中的-d参数改为-D 强制删除；

切换到 master 分支删除 a1：

如果要删除远程仓库中的分支，可以使用命令

git push <remote-name> –d <branch-name> 命令：可以删除指定的远程仓库：

执行命令后查看远程仓库分支，验证删除成功

4、Git 标签

像其他版本控制系统（vcs）一样，GIt可以给历史中某一个提交打上标签，以示重要；比较有代表的就是使用这个功能来标记发布节点（v1.0，v2.0 等）；

标签指的是某个分支某个特定时间点的状态，通过标签，可以很方便的切换到标记时的状态

4.1 列出已有标签

命令：

git tag 命令：列出当前标签

示例（当前本地仓库还没有标签）：

4.2 创建标签

命令：

git tag <tag-name> 命令：用来创建一个标签

示例：创建两个标签

标签的作用是用来记录状态（版本）的，所以通常使用 v 开头来标签

也可以通过

git show <tag-name> 命令：来显示标签的详细信息

解析：

详细信息中列出了：提交的标识字符串、作者（用户）信息、提交的日期信息等等

4.3 推送到远程仓库

和前面的推送分支命令类似：

git push <remote-name> <tag-name> 命令：将指定本地标签推送到远程仓库

注意：

当前 v1.0 和 v1.1 两个标签标记的内容是一样的

4.4 检出标签

通常情况下会新建一个分支，指向某个标签：

git checkout -b <branch-name> <tag-name> 命令：用于创建一个新的分支，并检出指定标签到这个分支

执行完命令后会切换到创建的 a3 分支，这个分支的内容就是前面 v1.0 版本的内容，在这个版本中我们可以继续开发，例如：添加 login.txt 文件：

开发完成后，可以再创建一个标签，标记为 v2.0 版本，提交到远程仓库

小结：

标签通常再一些重要的节点使用，例如发布的时候，下次更新或者升级完成后发布的时候…

4.5 删除标签

删除标签分为删除本地标签和远程标签：

git tag -d <tag-name> 命令：用于删除指定的本地标签；

git push <remote-name> :refs/tags/<tag-name> 命令：用户伤处指定的远程标签，

注意：语法中 :refs/tags/ 是固定写法

第四章 TortoiseGit管理文件版本

1、本地仓库操作

1.1 初始化本地仓库

新建仓库3：repo3，在目录中右键选择：”Git create repository here…” (在这里创建版本库)

默认不勾选：”Make it Bare(No working directories)” （表示：制作纯版本库）

初始化本地仓库成功：

1.2 添加文件

当前工作目录中新增一个 aaa.txt 文件

选中文件，右键 → TortoiseGit → Add

添加成功：

添加（到缓存区）成功后，文件会有一个蓝色 + 号：

1.3 提交文件

选中已追踪（添加到缓存区）的文件，右键选择 Git commit → "master"... 将文件提交到版本库中：

填写提交日志信息，点击 commit 按钮提交：

提交成功后，文件的状态为绿色√号

1.4 修改文件

被版本库管理的文件不可避免的发生修改，此时只需要直接对文件修改即可，修改完毕后需要将修改的文件提交到版本库。

修改文件（修改后文件会变为红色感叹号）：

选中修改后的文件，右键提交：

添加提交日志信息，提交：

提交成功成功后，文件状态由红色 ! 号变为绿色 √ 号。

1.5 查看修改历史

在开发过程中可能会经常查看代码的修改历史，或者叫做修改日志。来查看某个版本是谁修改的，什么时间修改的，修改了哪些内容。

可以选中文件，右键选择 “show log（显示日志）” ：

查看修改历史：

1.6 差异比较

当文件内容修改后，需要和修改之前对比一下修改了哪些内容，此时可以使用“比较差异功能”

修改文件内容：

选择” Diff（比较差异）”

对比修改后的内容：

1.7 还原修改

当文件修改后不想把修改的内容提交，还想还原到未修改之前的状态。

此时可以使用 “Revert（还原）” 功能

点击 “Ok” 还原

还原成功！

注意：

此操作会撤销所有未提交的修改，所以做还原操作是需要慎重慎重！！！

1.8 删除文件

需要删除无用的文件时可以使用git提供的删除功能直接将文件从版本库中删除。

1.9 综合练习：将java工程提交到版本库

将 springbootShiro 工程复制到工作区中，提交到版本库中，并且忽略 target 目录

1.9.1 忽略文件或目录

选中要忽略的文件/目录，右键 → TortoiseGit → add to ignore list （添加到忽略列表）

选择 忽略的类型和 .gitignore 文件存放的位置（默认即可）：

完成后在工作空间的根目录多出一个.gitignore文件，这个文件就是文件忽略文件，当然也可以手工编辑。其中的内容就是把 springbootShiro 中的 target 目录忽略掉。

1.9.2 添加暂存区

将工程和忽略文件添加到暂存区：

勾选需要添加的文件（这里默认全选），点击ok

点击ok，完成暂存区添加

1.9.3 提交代码

先将 选中项目 和 .gitignore 文件

右键然后提交代码：

提交成功后查看工程里面的文件，发现 target 目录没有提交到版本库

输入提交日志，点击 commit 提交按钮

查看 springbootShiro 目录，验证 target 目录是否被忽略

2、远程仓库操作

2.1 克隆远程仓库

克隆远程仓库也就是从远程把仓库复制一份到本地，克隆后会创建一个新的本地仓库。选择一个任意部署仓库的目录，然后克隆远程仓库。

在码云上创建一个远程仓库 myRepo2（readme初始化，开源仓库）：

在存放目录中右键 → Git clone…，复制远程仓库的地址到 URL 选项中 → Ok:

克隆成功：

2.2 查看远程仓库

在克隆的仓库中右键 → TortoiseGit → settings

然后，在设置的 Remote 中可以看到远程仓库服务器名称，点击名称，显示远程仓库地址：

2.3 添加远程仓库

同样我们，也可以通过 TortoiseGit 将本地仓库添加到远程仓库：

在码云新建远程仓库： repo3

在本地仓库 repo3 中右键 → settings

然后在 Remote 中填入名称和 URL → 确定即可：

名称自定义，通常使用 Origin

url：远程仓库地址

Push Url：远程仓库地址（暂时可以不填写）

Putty Key：这里使用 https 协议传输，不需要填

“是否从新添加的远程服务器获取分支” ，选 “是”

默认ok

成功后 close

完成后可以使用 GitBash 命令查看，验证是否添加成功

2.4 推送到远程仓库

将本地仓库的文件推送到远程仓库

→ 在工作区间中右键 TortoiseGit → push 推送

→ 填写要推送到哪个分支 → ok

出现异常：

异常原因解析：

在推送的之前要先拉取远程仓库的代码，以防止覆盖，我们的本地仓库有文件，所有要强制拉取，可以使用 git 命令强制拉取（快速简单）

然后重新推送：

到远程仓库查看，验证是否推送成功

2.5 TortoiseGit拉取

右键 TortoiseGit → pull → Ok

注意：

如果本地仓库有文件，在使用 TortoiseGit 拉取文件时，同样可会报错

可以使用 GitBash 的命令强制拉取后，再使用 TortoiseGit 操作（使用 git 命令的方式解决方便快速）

2.6 移除远程仓库

在本地仓库的工作空间右键 → TortoiseGit → Settings

Remote → 选中远程服务器名称（origin） → remove → 确定：

移除之后，可以只用 GitBash 的查看命令，验证是否移除

3、分支操作

上面如果将本地仓库repo3 的远程仓库移除了，这里需要重新添加上，演示本地仓库和远程仓库的分支操作

3.1 创建分支

右键 → TortoiseGit → Create Branch… （创建分支）

填写分支名称，选择分支状态：Base on（默认基于 master 分支，创建出来的分支和 master 分支状态一致）

3.2 切换分支

右键 → TortoiseGit → Switch/Checkout… （切换分支）

选择分支 → Ok 即可切换

切换后的操作和之前命令操作是一样的

3.3 合并分支

在房前 master 分支下右键 → TortoiseGit → merge… （合并分支）

选择要合并的分支 → Ok 即可

3.4 推送到远程仓库

选择 push 选项：

选择要推送的分支，定义远程分支的名称（一般和本地分支名称保持一致）

推送成功后可以在远程仓库查看

4、标签操作

略

第五章 在 idea 中使用 Git

在实际开发中，我们都是在开发工具 idea 中开发的，在开发完成之后可以直接在 idea 中完成 git 的相关操作，比如提交代码、推送到远程仓库等等。

1、配置Git

老版本的 IntelliJ IDEA 如果Git安装在默认路径下，那么idea会自动找到git的位置，如果更改了Git的安装位置则需要手动配置下Git的路径；

最新版本会帮我们自动找到 Git 的安装路径；

点击Test 按钮 测试是否正确配置，如果是正确的则会提示安装的 Git 的版本信息

2、创建工程并添加至Git

环境准备：

创建一个新的 Module：gitTest（maven版的普通Java项目即可）：

添加一些开发的内容：

将当前项目添加到 Git 其实就是在项目的根目录下添加 git 仓库：

在 Idea 上方的 VSC 选项中选择： VCS Operations（VCS 操作）

→ Create Git Repository…

→ 选择当前项目的根目录（注意是在src 同级目录，即：在 gitTest 目录创建git仓库）：

在目录中查看，验证成功创建 git 仓库：

此时，项目根目录下的文件还没有交给 git 版本控制管理

将项目添加至Git管理后，可以从IDEA的工具栏上看到Git操作的按钮：

3、忽略文件和目录

在当前项目的根目录下创建 .gitignore 文件，把需要忽略的文件和目录编辑进去：

我们可以使用 maven 编译一下当前项目，就会出现 target 目录，可以更好的看到后面添加和提交等效果：

4、添加到暂存区

其实 IDEA 可以不需要添加到暂存区直接提交的（简化了步骤），

如果我们需要添加到暂存区可以右键当前项目 → GIt 选项 → Add ：

在目录中可以看到允许被提交的文件状态变为 + 号了，即添加到了暂存区：

5、提交文件

提交的方式地方有很多：

可以右键项目 → Git 选项 → Commit…

也可以使用 Git 按钮提交：

还可以在 VCS 中选择 Commit…

这些提交的效果是一样的，在弹出的对话框中添加提交日志信息 → commit：

如果需要看到目录，可以在提交界面的 Group by 按钮中勾选 Model 和 Directory：

现在项目中添加一个 配置文件 jdbc.properties，再次提交，勾选 Model 和 Directory 后可以看到要提交的文件在哪个目录中：

6、推送到远程仓库

在码云创建一个新的远程仓库 gitTest：

这里不初始化 readme 文件，不然后面需要解决第一此推送或拉取，本地仓库有文件冲突，需要强制拉取解决冲突

在idea 中右键项目 → Git → Push

或者 VCS 中 push

或者 找到 Push 按钮：

选择定义 Define remote（远程仓库），添加远程仓库地址：

点击 push 推送本地仓库到远程仓库：

推送成功后查看远程仓库：

7、从远程仓库克隆工程到本地

选择从VCS 克隆工程：

填写远程仓库地址，选择保存路径：

Trust Project：

克隆成功：

8、从远程拉取代码

我们可以打开前面 gitTest 项目

因为这两个本地仓库都是关联的同一个远程仓库，所以可以模拟两个用户操作同一个项目：

注意区分两个本地仓库，前面我们自己创建的叫 gitTest， 后面克隆下来的叫 git-test

在 gitTest 项目中：

添加 UserService 接口：

→ 提交到本地仓库：

→ 推送到远程仓库：

查看远程仓库，推送成功：

在 git-test 项目中：

点击 Update Project 选项拉取代码到本地，或者点击选择 Pull 选项也可以将远程仓库的代码拉取到本地：

练习：

在 gitTest 项目中修改 jdbc.properties 文件的内容，并推送到远程仓库

在 git-test 项目中拉取远程仓库中修该的内容

9、版本对比

每一次提交都都会产生新的版本，我们可以使用 idea 来比较不同的版本文件的区别：

例如我们想要查看 jdbc.properties 文件不同版本的区别：

打开 jdbc.properties 文件，在文件中右键 → Git 选项 → Compare with Revision…（比较版本信息）：

选择一个版本比较差异：

为了看到效果，我提交了两次，

第一次提交 jdbc.username

第二次提交 jdbc.userpassword

左边是选择的版本内容，右边是最新的内容：

10、创建分支

可以在 VCS 中 选择 New Branch… 选项来创建分支：

填写要创建的分支名称：

勾选 Checkout branch 表示创建 a1 分支，并且切换到 a1 分支:

创建并切换成功：

切换成功以后代码没有变化，是因为当前 a1 分支和 master 分支的状态是一样的

11、切换分支

可以在底部 Git 选项中，右键想要切换的分支，选择 Checkout 切换分支

也可以在顶部 VCS 中选中 Branchs… 选项，找到想要切换的分支，然后 Checkout 即可：

12、分支合并

我们可以在 b1 分支上开发，提交并推送到远程仓库，然后在 master 分支上操作，将 b1 分支合并到 master 分支：

在 b1 分支中的 User 类中添加 username 属性：

提交并推送到远程仓库（可以同时操作）：

推送到远程仓库：

切换到 master 分支，此时的 User 用户是没有 username 属性的：

在顶部 VCS 中选中 Merge… 选项:

选择合并本地的 a1 分支即可（origin/a1 是远程的分支）：

合并成功：

第六章 使用 SSH 协议传输数据

1、Git 支持的传输协议

由于 Git 的远程仓库不在本地，当我们在使用远程仓库时（例如克隆、拉取、推送）就会涉及到数据的网络传输，Git 支持多种数据传输协议：

• 本地协议（Local）
• HTTPS 协议
• SSH（Secure Shell）协议
• Git 协议

我们前面的操作都是基于 HTTPS 协议传输的，而码云支持两种传输协议：

2、什么是 SSH 协议

SSH 是 Sercure Shell（安全外壳协议）的缩写，由 IETE 的网络小组（Network Working Group）制定；

SSH 是目前较可靠，专为远程登陆会话和其他网络服务提供安全性的协议；利用 SSH 协议可以有效防止远程管理过程中的信息泄露问题

由于本地 Git 仓库和远程仓库之间的传输是通过 SSH 加密的，所以必须要让远程仓库服务器认证你的 SSH key，在此之前，必须要先生成 SSH key；

使用 SSH 协议通信时，推荐使用基于密钥的验证方式，我们需要先为自己创建一对密钥（公钥和私钥），并将公钥放在需要访问的服务器上。

解析：

其实前面我们使用 https 协议传输的时候，它是基于我们码云的账户和密码验证的，我们后面的操作之所以不需要每次输入用户名和密码，是因为第一次操作时验证了用户名和密码，然后将用户名和密码凭证保存在了我们的计算机上，我们可以查看到：

控制面板 → 用户账户 → 管理 Windows 凭据

普通凭据中就可以看到，我们的 码云账户和密码永久保存在了计算机上：

3、生成密钥

在使用密钥之前我们可以尝试复制一个 SSH 协议的远程仓库地址克隆远程仓库，结果肯定是不行的

前面我们了解了 Https 协议是基于用户名和密码验证的，而 SSH 协议传输数据是基于一对密钥验证的，所以我们要给自己生成一对密钥

可以使用 GitBash 工具生成公钥和私钥：

任位置打开 GitBash，执行命令：

ssh-keygen -t rsa 命令：生成公钥和私钥

一路回车，执行完成后后 windows 本地用户 .ssh 目录中生成如下名称的公钥和私钥

4、服务器配置公钥

私钥就保存在当前用户的 .ssh 目录中即可，我们需要将公钥的内容复制下来，在远程仓库中配置公钥：

复制公钥内容：

码云配置公钥：

右边账户信息下拉框，选择 设置：

在安全设置中，选择 SSH公钥，粘贴公钥 → 确定：

验证账户密码后，添加成功：

5、使用 SSH 协议

当我们在服务器添加好公钥之后，就可以使用 SSH 协议传输数据了：

复制远程仓库的 SSH 地址：

使用 SSH 协议克隆远程仓库到本地：

第七章 常用命令查询

1、新建代码库 git init

• 创建（初始化）空仓库，由git接管，文件的改动（修改、删除）都能监测到
• 例外情况：doc等办公文档可以监测到文件大小改变，无非监测到具体内容改变
  无法监测到二进制文件内部内容信息的改变，只能监测文件大小改变
  所以说git比较适合纯文本类文件版本控制（txt,md）

常见的二进制文件：

图片、视频、音频、办公文档（doc、xls）

# 在当前目录新建一个Git代码库
$ git init

# 新建一个目录，将其初始化为Git代码库
$ git init [project-name]

# 下载一个项目和它的整个代码历史
$ git clone [url]

• 什么是本地仓库？

  • 在你的电脑通过git init就是初始化了一个本地仓库

• 什么是远程仓库？

  • 就是你在gitee或者github等在线开源网站里面创建一个仓库称为远程仓库

• 什么是工作区？

  • 就是你写作的文件目录，这里面我们称为工作区

• 什么是暂存盘？

• 什么是版本库？

2、配置 git config

Git的设置文件为.gitconfig，它可以在用户主目录下（全局配置），也可以在项目目录下（项目配置）。

# 显示当前的Git配置
$ git config --list

# 编辑Git配置文件
$ git config -e [--global]

# 设置提交代码时的用户信息
$ git config [--global] user.name "[name]"
$ git config [--global] user.email "[email address]"

3、增加/删除文件 git add/git rm

# 添加指定文件到暂存区
$ git add [file1] [file2] ...

# 添加指定目录到暂存区，包括子目录
$ git add [dir]

# 添加当前目录的所有文件到暂存区
$ git add .
$ git add -A 
# 添加每个变化前，都会要求确认
# 对于同一个文件的多处变化，可以实现分次提交
$ git add -p

# 删除工作区文件，并且将这次删除放入暂存区
$ git rm [file1] [file2] ...

# 停止追踪指定文件，但该文件会保留在工作区
$ git rm --cached [file]

# 改名文件，并且将这个改名放入暂存区
$ git mv [file-original] [file-renamed]

4、代码提交 git commit

# 提交暂存区到仓库区
$ git commit -m [message]

# 提交暂存区的指定文件到仓库区
$ git commit [file1] [file2] ... -m [message]

# 提交工作区自上次commit之后的变化，直接到仓库区
$ git commit -a

# 提交时显示所有diff信息
$ git commit -v

# 使用一次新的commit，替代上一次提交
# 如果代码没有任何新变化，则用来改写上一次commit的提交信息
$ git commit --amend -m [message]

# 重做上一次commit，并包括指定文件的新变化
$ git commit --amend [file1] [file2] ...

提交一个版本的步骤

• 先看是否存在仓库，没有使用git init 创建仓库

• git add 添加到暂存盘

• git commit 提交一个版本

git commit –amend 的作用

用于修改最近一次的提交，包括：

• 修改提交信息（commit message）
• 添加遗漏的文件到上一次提交中
• 修改提交的内容（比如你刚提交完，发现漏改了一行代码）

⚠️ 注意：只能修改尚未推送到远程仓库的最新提交。如果已经推送，修改后需要强制推送（git push --force），这可能影响协作，需谨慎！

5、分支

#修改主分支名为main
 git config --global init.defaultBranch main

# 列出所有本地分支
$ git branch

# 列出所有远程分支
$ git branch -r

# 列出所有本地分支和远程分支
$ git branch -a

# 新建一个分支，但依然停留在当前分支
$ git branch [branch-name]

# 新建一个分支，并切换到该分支
$ git checkout -b [branch]

# 新建一个分支，指向指定commit
$ git branch [branch] [commit]

# 新建一个分支，与指定的远程分支建立追踪关系
$ git branch --track [branch] [remote-branch]

# 切换到指定分支，并更新工作区
$ git checkout [branch-name]

# 切换到上一个分支
$ git checkout -

# 建立追踪关系，在现有分支与指定的远程分支之间
$ git branch --set-upstream [branch] [remote-branch]

# 合并指定分支到当前分支
$ git merge [branch]

# 选择一个commit，合并进当前分支
$ git cherry-pick [commit]

# 删除分支
$ git branch -d [branch-name]

# 删除远程分支
$ git push origin --delete [branch-name]
$ git branch -dr [remote/branch]

6、标签

# 列出所有tag
$ git tag

# 新建一个tag在当前commit
$ git tag [tag]

# 新建一个tag在指定commit
$ git tag [tag] [commit]

# 删除本地tag
$ git tag -d [tag]

# 删除远程tag
$ git push origin :refs/tags/[tagName]

# 查看tag信息
$ git show [tag]

# 提交指定tag
$ git push [remote] [tag]

# 提交所有tag
$ git push [remote] --tags

# 新建一个分支，指向某个tag
$ git checkout -b [branch] [tag]

git show

7、查看信息 status,log,reflog,blame,show,diff

git status

• 查看状态

可以查看

1. 那些文件被修改了？
2. 增加了那些文件？
3. 删除了那些文件？
4. 是否有修改？（提交了版本之后）

• 对于二进制类型文件，只能监测文件是否被修改，或者被删除，具体改了什么不清楚

比如doc文件、git只能知道它被修改了，不知道改了什么内容

除了doc还有mp4、jpg、gif等等非文本文件。

git diff

• git diff [file]
  显示暂存区和工作区的差异

• git diff –cached [file]
  或者
  git diff –staged [file]

显示暂存区和上一次提交(commit)的差异

git show

• git show命令是Git的一个强大命令，它用于显示Git仓库中的各种对象的详细信息。这些对象可以是提交、分支、标签、或者具体的文件。

git blame

• git blame 是Git 命令，用于显示文件中每行代码的最后修改版本及作者信息，帮助追踪代码变更历史。

• 运行 git blame <文件路径> 可显示指定文件的每行代码最后一次修改的提交信息（作者、时间、代码内容）。

• 例如：git blame app.js

git stash

• git stash是git中用于临时保存工作目录和暂存区未提交的修改的命令，允许用户切换到干净的工作区处理其他的任务，后续可以恢复这些修改

• 保存修改，将所有未提交的更改存入栈，恢复工作区至最新状态。

• 查看条目 git stash list 列出所有储藏条目（如stash@{0}为最新）

• 恢复修改：git stash pop：应用并删除最新的储藏条目

git stash apply ：应用指定条目但不删除

• 删除条目：git stash drop 移除指定条目

• 测试步骤

  • 1. git clone 远程仓库hello9-15
  • 2. 再本地工作区随便修改一下（注意不要添加暂存和保存版本）
  • 3. 然后再远程仓库手动修改一下1.txt文件，并提交一个版本
  • 4. 然后执行git pull拉起远程仓库的数据，发现报错了，拒绝拉起
  • 5. 此时使用git stash将工作区存储起来
  • 6. 然后再使用git pull拉去，这个时候允许拉去了
  • 7. 然后想起恢复刚才的内容，使用git stash list 查看，使用git stash pop恢复
  • 8. 手动解决冲突，git add -A
  • 9. 完成

# 显示有变更的文件
$ git status	#查看状态

# 显示当前分支的版本历史(看历史版本到当前版本的日志)
$ git log

# 显示commit历史，以及每次commit发生变更的文件
$ git log --stat

# 搜索提交历史，根据关键词
$ git log -S [keyword]

# 显示某个commit之后的所有变动，每个commit占据一行
$ git log [tag] HEAD --pretty=format:%s

# 显示某个commit之后的所有变动，其"提交说明"必须符合搜索条件
$ git log [tag] HEAD --grep feature

# 显示某个文件的版本历史，包括文件改名
$ git log --follow [file]
$ git whatchanged [file]

# 显示指定文件相关的每一次diff
$ git log -p [file]

# 显示过去5次提交
$ git log -5 --pretty --oneline

# 显示所有提交过的用户，按提交次数排序
$ git shortlog -sn

# 显示指定文件是什么人在什么时间修改过
$ git blame [file]

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

# 显示暂存区和上一个commit的差异
$ git diff --cached [file]

# 显示工作区与当前分支最新commit之间的差异
$ git diff HEAD

# 显示两次提交之间的差异
$ git diff [first-branch]...[second-branch]

# 显示今天你写了多少行代码
$ git diff --shortstat "@{0 day ago}"

# 显示某次提交的元数据和内容变化
$ git show [commit]

# 显示某次提交发生变化的文件
$ git show --name-only [commit]

# 显示某次提交时，某个文件的内容
$ git show [commit]:[filename]

# 显示当前分支的最近几次提交(查看所有历史版本信息)
#注意这里查看的是一个短的版本号，例如 da213db
$ git reflog

git blame

8、远程同步

# 下载远程仓库的所有变动
$ git fetch [remote]

# 显示所有远程仓库
$ git remote -v

# 显示某个远程仓库的信息
$ git remote show [remote]

# 增加一个新的远程仓库，并命名
$ git remote add [shortname] [url]

# 取回远程仓库的变化，并与本地分支合并
$ git pull [remote] [branch]

# 上传本地指定分支到远程仓库
$ git push [remote] [branch]

# 强行推送当前分支到远程仓库，即使有冲突
$ git push [remote] --force

# 推送所有分支到远程仓库
$ git push [remote] --all

git pull
# -u选项安全模式
git push -u origin main

git pull 和 git fetch 的区别：

git fetch 和 git pull 都用于从远程仓库获取最新数据，但它们的行为有本质区别：