Git入门指南

一、Git简介

Git 是一种分布式版本控制系统。它最初由 Linus Torvalds 开发，用于管理 Linux 内核的源代码。Git 可以追踪文件的变化，记录每个版本的修改，以便于文件的恢复和合并。Git 的主要特点包括：

1. 分布式：每个开发者都拥有一份完整的代码库，可以在本地进行代码修改和版本控制，而不需要集中式服务器的支持。
2. 强大的分支和合并支持：Git 提供了灵活的分支和合并策略，使得开发者可以轻松创建和管理多个并行开发的分支，合并不同的代码版本。
3. 高效性：Git采用了一些优化策略，如快照存储，增量传输等，使得它在处理大型代码库时表现出色。
4. 安全性：Git 采用了 SHA-1算法对每个版本的文件和目录进行哈希校验，以确保文件的完整性和安全性。
5. 开放源代码：Git是一款自由和开源的软件，可以在各种操作系统平台上使用。

Git 是开发者和团队进行版本管理和协作的重要工具，已经成为开源社区和企业中最流行的版本控制系统之一。

二、Git实战

2.1 安装Git

最早Git是在Linux上开发的，很长一段时间内，Git也只能在Linux和Unix系统上跑。不过，慢慢地有人把它移植到了Windows上。现在，Git可以在Linux、Unix、Mac和Windows这几大平台上正常运行了。

在Windows上使用Git，可以从Git官网直接下载安装程序，（网速慢的同学请移步国内镜像），然后按默认选项安装即可。

安装完成后，在开始菜单里找到“Git”->“Git Bash”，蹦出一个类似命令行窗口的东西，就说明Git安装成功！

安装完成后，还需要最后一步设置，在命令行输入：

$ git config --global user.name "Your Name"
$ git config --global user.email "email@example.com"
$ git config --global --get user.name #得到user.name的值
$ git config --global -l #列表参数

因为Git是分布式版本控制系统，所以，每个机器都必须自报家门：你的名字和Email地址。

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

2.2 创建版本库

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

2.2.1 创建版本库

cd /e/ #window的git bash中进入e盘
$ mkdir learngit #创建一个learngit目录
$ cd learngit 
$ pwd
/Users/michael/learngit
$ git init
Initialized empty Git repository in /Users/michael/learngit/.git/

如果你使用Windows系统，为了避免遇到各种莫名其妙的问题，请确保目录名（包括父目录）不包含中文。通过 git init命令把这个目录变成Git可以管理的仓库：

瞬间Git就把仓库建好了，而且告诉你是一个空的仓库（empty Git repository），细心的读者可以发现当前目录下多了一个 .git的目录，这个目录是Git来跟踪管理版本库的，没事千万不要手动修改这个目录里面的文件，不然改乱了，就把Git仓库给破坏了。

如果你没有看到 .git目录，那是因为这个目录默认是隐藏的，用 ls -ah命令就可以看见。

所有的版本控制系统，其实只能跟踪文本文件的改动

2.2.2 添加文件到版本库

现在我们编写一个 readme.txt文件，内容如下：

 Git is a version control system.
 Git is free software.

一定要放到 learngit 目录下（子目录也行），因为这是一个Git仓库，放到其他地方Git找不到这个文件。

把一个文件放到Git仓库只需要两步。
（1）用命令 git add 告诉Git，把文件添加到仓库：

 $ git add readme.txt

（2）用命令 git commit 告诉Git，把文件提交到仓库：

$ git commit -m "wrote a readme file"
[master (root-commit) eaadf4e] wrote a readme file
1 file changed, 2 insertions(+)
create mode 100644 readme.txt

git commit 是一个 Git 命令，用于将暂存区的更改提交为一个新的版本。

运行 git commit 命令时，将会打开一个文本编辑器，让您输入本次提交的消息。提交消息应该清晰、简明地描述本次提交所做的更改或修复。在编辑器中输入提交消息后，保存并关闭编辑器，Git 将完成提交操作，并为该提交生成一个唯一的提交哈希值。

通常，您需要先通过 git add 命令将要提交的更改添加到暂存区，然后再运行 git commit 来提交这些更改。

此外，还有许多选项可以与 git commit 命令一起使用，以满足特定的需求，如：

• -m "<message>"：直接在命令中指定提交消息，而无需打开编辑器。
• -a：自动将已跟踪文件的修改一并提交，跳过 git add 步骤。
• -am "<message>"：结合了 -a 和 -m 的选项，可一次性提交所有已跟踪文件的修改并指定提交消息。

请注意，在提交之前，建议先使用 git status 命令查看当前的状态，并确保要提交的更改正确无误。

$ git log
commit 6e4de12122b22ee3145dfa87af974d284f832dd2 (HEAD -> master)
Author: lxsong <lxsong77@163.com>
Date: Tue Jul 11 09:57:08 2023 +0800
wrote a readme file

git log 是一个 Git 命令，用于显示当前分支的提交历史。

运行 git log 命令将按照提交时间的倒序显示提交历史，最新的提交将显示在最顶部。每个提交记录都包含以下信息：

• 提交哈希值（commit hash）：代表每个提交的唯一标识符。
• 作者（Author）：提交的作者。
• 日期和时间：提交的日期和时间。
• 提交消息（Commit message）：作者为提交添加的描述信息。

默认情况下，git log 会显示所有的提交记录，并按时间倒序排列。可以通过输入命令 q 来退出 git log 视图。

你还可以使用一些选项来自定义 git log 的输出。以下是常用的一些选项：

• --oneline：以紧凑的单行格式显示提交历史。
• --graph：以 ASCII 图形的形式显示分支和合并历史。
• --author=<author>：只显示指定作者的提交历史。
• --since=<date>：只显示从指定日期开始的提交历史。

还可以多次 add 不同的文件，比如：

$ touch file1.txt,file2.txt,file3.txt
$ git add file1.txt
$ git add file2.txt file3.txt 或者 git add . #添加所有untrack文件到stage

使用git status查看git状态

$ git status
On branch master
Changes to be committed:
(use "git restore --staged <file>..." to unstage)
new file: file1.txt
new file: file2.txt
new file: file3.txt

提交

 $ git commit -m "add 3 files."

总结:

• git add . 把工作区文件添加到暂存区

• git commit -m “xxxx”：把暂存区(stage)文件提交到分支

• git status：查看git版本库状态

• git log：查看版本提交

2.3 版本控制

2.3.1 修改readme.txt

修改readme.txt文件，改成如下内容：

Git is a distributed version control system.
Git is free software.

运行 git status命令看看结果：

 $ git status
2 On branch master
3 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.txt

 no changes added to commit (use "git add" and/or "git commit -a")

git status命令可以让我们时刻掌握仓库当前的状态，上面的命令输出告诉我们， readme.txt被修改过了，但还没有准备提交的修改。

虽然Git告诉我们 readme.txt被修改了，但如果能看看具体修改了什么内容，自然是很好的。
需要用git diff这个命令看看：

$ git diff readme.txt
diff --git a/readme.txt b/readme.txt
index 46d49bf..9247db6 100644
--- a/readme.txt
+++ b/readme.txt
@@ -1,2 +1,2 @@
-Git is a version control system.
+Git is a distributed version control system.
Git is free software.

git diff 顾名思义就是查看difference，显示的格式正是Unix通用的diff格式，可以从上面的命令输出看到，我们在第一行添加了一个 distributed 单词。

2.3.2 版本回退

2.3.2.1 准备几个版本

现在，你已经学会了修改文件，然后把修改提交到Git版本库，现在，再练习一次，修readme.txt
文件如下：

1 Git is a distributed version control system.
2 Git is free software distributed under the GPL.

然后提交：

$ git add readme.txt
$ git commit -m "append GPL"
[master 1094adb] append GPL
file changed, 1 insertion(+), 1 deletion(-)

现在，我们回顾一下 readme.txt文件一共有几个版本被提交到Git仓库里了：

版本1：wrote a readme file

 Git is a version control system.

 Git is free software.

版本2：add three file

1 file1, file2, file3

版本3：add distributed

 Git is a distributed version control system.

 Git is free software.

版本4：append GPL

 Git is a distributed version control system.

 Git is free software distributed under the GPL.

git log 命令查看版本：

$ git log
commit 1094adb7b9b3807259d8cb349e7df1d4d6477073 (HEAD -> master)
Author: Michael Liao <askxuefeng@gmail.com>
Date: Fri May 18 21:06:15 2018 +0800
	append GPL
commit e475afc93c209a690c39c13a46716e8fa000c366
Author: Michael Liao <askxuefeng@gmail.com>
Date: Fri May 18 21:03:36 2018 +0800
	add distributed
commit eaadf4e385e865d25c48e7ca9c8395c3f7dfaef0
Author: Michael Liao <askxuefeng@gmail.com>
Date: Fri May 18 20:59:18 2018 +0800
	wrote a readme file

git log命令显示从最近到最远的提交日志，我们可以看到3次提交，最近的一次是 append GPL，上一次是 add distributed，最早的一次是 wrote a readme file。

如果嫌输出信息太多，看得眼花缭乱的，可以试试加上 –pretty=oneline参数：

$ git log --pretty=oneline
1094adb7b9b3807259d8cb349e7df1d4d6477073 (HEAD -> master) append GPL
e475afc93c209a690c39c13a46716e8fa000c366 add distributed
eaadf4e385e865d25c48e7ca9c8395c3f7dfaef0 wrote a readme file

2.3.2.2 版本回退

好了，现在我们准备把 readme.txt 回退到上一个版本，也就是 add distributed 的那个版本

首先，Git必须知道当前版本是哪个版本，在Git中，用 HEAD 表示当前版本，也就是最新的提交
1094adb… （注意我的提交ID和你的肯定不一样），上一个版本就是 HEAD^ ，上上一个版本就是
HEAD^^ ，当然往上100个版本写100个 ^ 比较容易数不过来，所以写成 HEAD~100 。

现在，我们要把当前版本 append GPL 回退到上一个版本 add distributed ，就可以使用 git
reset 命令：

$ git reset --hard HEAD^
HEAD is now at e475afc add distributed

看看 readme.txt 的内容是不是版本 add distributed ：

$ cat readme.txt
Git is a distributed version control system.
Git is free software.

果然被还原了。
还可以继续回退到上一个版本 wrote a readme file ，我们用 git log 看看现在版本库的状态：

$ git log
commit e475afc93c209a690c39c13a46716e8fa000c366 (HEAD -> master)
Author: Michael Liao <askxuefeng@gmail.com>
Date: Fri May 18 21:03:36 2018 +0800
	add distributed
commit eaadf4e385e865d25c48e7ca9c8395c3f7dfaef0
Author: Michael Liao <askxuefeng@gmail.com>
Date: Fri May 18 20:59:18 2018 +0800
	wrote a readme file

最新的那个版本 append GPL 已经看不到了！
办法其实还是有的，只要上面的命令行窗口还没有被关掉，你就可以顺着往上找，找到那个append GPL 的 commit id 是 1094adb… ，于是就可以指定回到的某个版本：

$ git reset --hard 1094a
HEAD is now at 83b0afe append GPL

版本号没必要写全，前几位就可以了，Git会自动去找。

git reset 命令既可以回退版本，也可以把暂存区的修改回退到工作区。当我们用 HEAD`时，表示最新的
版本。

• –soft ：仅仅移动本地库 HEAD 指针
• –mixed: 移动本地库 HEAD 指针，重置暂存区
• –hard：移动HEAD指针，重置暂存区，工作区，省略git checkout – file

Git的版本回退速度非常快，因为Git在内部有个指向当前版本的 HEAD 指针，当你回退版本的时候，Git仅仅是把HEAD从指向 append GPL ：

┌────┐
│HEAD│
└────┘
│
└──> ○ append GPL
│
○ add distributed
│
○ wrote a readme file

改为指向 add distributed ：

┌────┐
│HEAD│
└────┘
│
│ ○ append GPL
│ │
└──> ○ add distributed
│
○ wrote a readme file

然后顺便把工作区的文件更新了。所以你让 HEAD 指向哪个版本号，你就把当前版本定位在哪。
现在，你回退到了某个版本，关掉了电脑，第二天早上就后悔了，想恢复到新版本怎么办？找不到
新版本的 commit id 怎么办？
在Git中，当你用 $ git reset --hard HEAD^ 回退到 add distributed版本时，再想恢复到 append GPL ，就必须找到 append GPL 的commit id。

Git提供了一个命令 git reflog 用来记录你的每一次命令：

$ git reflog
e475afc HEAD@{1}: reset: moving to HEAD^
1094adb (HEAD -> master) HEAD@{2}: commit: append GPL
e475afc HEAD@{3}: commit: add distributed
eaadf4e HEAD@{4}: commit (initial): wrote a readme file

2.3.3 工作区和暂存区

Git和其他版本控制系统如SVN的一个不同之处就是有暂存区的概念。先来看名词解释。

1. 工作区（Working Directory）
   就是你在电脑里能看到的目录，比如我的 learngit 文件夹就是一个工作区：
   
2. 版本库（Repository）
   工作区有一个隐藏目录 .git ，这个不算工作区，而是Git的版本库。
   （1）版本库基本状态
   Git的版本库里存了很多东西，其中最重要的就是称为stage（或者叫index）的暂存区，还有Git为
   我们自动创建的第一个分支 master ，以及指向 master 的一个指针叫 HEAD 。
   

对 readme.txt 做个修改，比如加上一行内容

Git is a distributed version control system.
Git is free software distributed under the GPL.
Git has a mutable index called stage.

然后，在工作区新增一个 LICENSE 文本文件（内容随便写）。
先用 git status 查看一下状态：

$ git status
On branch 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.txt
Untracked files:
(use "git add <file>..." to include in what will be committed)
LICENSE
no changes added to commit (use "git add" and/or "git commit -a")

Git非常清楚地告诉我们， readme.txt 被修改了，而 LICENSE 还从来没有被添加过，所以它的状态是 Untracked 。
现在，使用两次命令 git add ，把 readme.txt 和 LICENSE 都添加后，用 git status 再查看一
下：

$ git status
On branch master
Changes to be committed:
(use "git reset HEAD <file>..." to unstage)
new file: LICENSE
modified: readme.txt

（2） add两次后的版本库状态

git add .

执行后git版本库状态如下：

所以， git add 命令实际上就是把要提交的所有修改放到暂存区（Stage），然后，执行 git
commit 就可以一次性把暂存区的所有修改提交到分支。

$ git commit -m "understand how stage works"
[master e43a48b] understand how stage works
2 files changed, 2 insertions(+)
create mode 100644 LICENSE

一旦提交后，如果你又没有对工作区做任何修改，那么工作区就是“干净”的：

$ git status
On branch master
nothing to commit, working tree clean

（3）commit后的版本库状态

2.3.4 撤销修改

上一个小节使用的

git reset --hard HEAD^ #
#等价于
git reset --mixed HEAD^
git checkout -- readme.txt

• –hard：重置工作区和暂存区，修改HEAD指针
• –mixed：重置暂存区，修改HEAD指针
• –soft：只修改HEAD指针

git checkout：重置工作区到版本库
你正在赶一份工作报告，你在 readme.txt 中添加了一行：

$ cat readme.txt
Git is a distributed version control system.
Git is free software distributed under the GPL.
Git has a mutable index called stage.
Git tracks changes of files.
My stupid boss still prefers SVN.

在你准备提交前，发现了 stupid boss 可能会让你丢掉这个月的奖金！
你可以删掉最后一行，手动把文件恢复到上一个版本的状态。
如果用 git status 查看一下：

$ git status
On branch 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.txt
no changes added to commit (use "git add" and/or "git commit -a")

你可以发现，Git会告诉你， git checkout – file 可以丢弃工作区的修改：

$ git checkout -- readme.txt

命令 git checkout - - readme.txt 意思就是，把 readme.txt 文件在工作区的修改全部撤销，这里有
两种情况：
一种是 readme.txt 自修改后还没有被放到暂存区，现在，撤销修改就回到和版本库一模一样的状态；
一种是 readme.txt 已经添加到暂存区后，又作了修改，现在，撤销修改就回到添加到暂存区后的状态。
总之，就是让这个文件回到最近一次 git commit 或 git add 时的状态。
现在，看看 readme.txt 的文件内容：

$ cat readme.txt
Git is a distributed version control system.
Git is free software distributed under the GPL.
Git has a mutable index called stage.
Git tracks changes of files.

文件内容复原了。
git checkout - - file 命令中的 - - 很重要，没有 - - ，就变成了“切换到另一个分支”的命令，我们
在后面的分支管理中会再次遇到 git checkout 命令。

现在假定是凌晨3点，你不但写了一些胡话，还 git add 到暂存区了：

$ cat readme.txt
Git is a distributed version control system.
Git is free software distributed under the GPL.
Git has a mutable index called stage.
Git tracks changes of files.
My stupid boss still prefers SVN.
$ git add readme.txt

庆幸的是，在 commit 之前，你发现了这个问题。用 git status 查看一下，修改只是添加到了暂
存区，还没有提交：

$ git status
On branch master
Changes to be committed:
(use "git reset HEAD <file>..." to unstage)
modified: readme.txt

Git同样告诉我们，用命令 git reset HEAD 可以把暂存区的修改撤销掉（unstage），重新放
回工作区：

$ git reset HEAD readme.txt
Unstaged changes after reset:
M readme.txt

git reset 命令既可以回退版本，也可以把暂存区的修改回退到工作区。当我们用 HEAD 时，表示最新
的版本。

• –soft ：仅仅移动本地库 HEAD 指针
• –mixed: 移动本地库 HEAD 指针，重置暂存区
• –hard：移动HEAD指针，重置暂存区，工作区，省略git checkout – file

再用 git status 查看一下，现在暂存区是干净的，工作区有修改：

$ git status
On branch 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.txt

还记得如何丢弃工作区的修改吗？

$ git checkout -- readme.txt
$ git status
On branch master
nothing to commit, working tree clean

总结：

#撤销修改
1：
git reset --hard HEAD^ readme.txt
--hard
--soft
--mixed
2：
git reset --mixed HEAD readme.txt #重置缓存区
git checkout -- readme.txt
git reset HEAD readme.txt

2.3.5 删除文件

在Git中，删除也是一个修改操作，我们实战一下，先添加一个新文件 test.txt 到Git并且提交：

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

一般情况下，你通常直接在文件管理器中把没用的文件删了，或者用 rm 命令删了：

$ rm test.txt

这个时候，Git知道你删除了文件，因此，工作区和版本库就不一致了， git status 命令会立刻告诉你哪些文件被删除了：

$ git status
On branch master
Changes not staged for commit:
(use "git add/rm <file>..." to update what will be committed)
(use "git checkout -- <file>..." to discard changes in working directory)
deleted: test.txt
no changes added to commit (use "git add" and/or "git commit -a")

现在你有两个选择，一是确实要从版本库中删除该文件，那就用命令 git rm 删掉，并且 git commit

$ git rm test.txt
rm 'test.txt'
$ git commit -m "remove test.txt"
[master d46f35e] remove test.txt
1 file changed, 1 deletion(-)
delete mode 100644 test.txt

现在，文件就从版本库中被删除了。

先手动删除文件，然后使用git rm 和git add效果是一样的。

另一种情况是删错了，因为版本库里还有呢，所以可以很轻松地把误删的文件恢复到最新版本：

$ git checkout -- test.txt

git checkout 其实是用版本库里的版本替换工作区的版本，无论工作区是修改还是删除，都可以“一键还原”。

三、远程仓库

3.1 使用远程库

完全可以自己搭建一台运行Git的服务器，不过也可以使用现有的Git远程库，应用比较广泛的如
下：

• github
• gitee
  1. 使用SSH协议：
  ssh基于非对称加密的免密登录原理
  
  对称加密：密码本是一个
• MD5
  非对称加密，秘钥是一对(公钥/私钥)
• rsa

第1步: 创建SSH Key。在用户主目录下，看看有没有.ssh目录，如果有，再看看这个目录下有没有
id_rsa 和 id_rsa.pub 这两个文件，如果已经有了，可直接跳到下一步。如果没有，打开Shell
（Windows下打开Git Bash），创建SSH Key：

$ ssh-keygen -t rsa -C "2935179254@qq.com"
#用户宿主目录下.ssh c:\Users\Administrator\.ssh\

你需要把邮件地址换成你自己的邮件地址，然后一路回车，使用默认值即可，由于这个Key也不是用于军事目的，所以也无需设置密码。
如果一切顺利的话，可以在用户主目录里找到 .ssh 目录，里面有 id_rsa 和 id_rsa.pub 两个文件，这两个就是SSH Key的秘钥对， id_rsa 是私钥，不能泄露出去， id_rsa.pub 是公钥，可以放心地告诉任何人。

第2步： 登陆Gitee，打开“Account settings”，“SSH Keys”页面：
然后，点“Add SSH Key”，填上任意Title，在Key文本框里粘贴 id_rsa.pub 文件的内容：


2. HTTS协议
不配置公钥也可以使用HTTS协议，在使用HTTPS协议时输入用户名/密码

3. 克隆
使用https协议

git clone https://gitee.com/halo-dev/halo.git
#第一次访问需要输入gitee的用户名密码

halo：开源博客系统，基于spring boot和vue使用ssh协议

3.2 添加远程库

首先，登陆Gitee，然后，在右上角找到“新建仓库”按钮，创建一个新的仓库：

注意不要选择初始化仓库和模板，要创建一个空的仓库

在Repository name填入 learngit ，其他保持默认设置，点击“创建仓库”按钮，就成功地创建了一个新的Git仓库：

下面是gitee的提示步骤

• Git 全局设置:

#先查看自己的设置
git config --global -l

#如果没有设置
git config --global user.name "你的名字"
git config --global user.email "你的邮箱"

• 创建 git 仓库:
  

mkdir learngit
cd learngit
git init
touch README.md
git add README.md
git commit -m "first commit"
git remote add origin 远程仓库地址
git push -u origin "master"

• 已有仓库

cd learngit
git remote add origin 远程仓库地址
git push -u origin "master"

现在，我们根据Gitee的提示，在本地的 learngit 仓库下运行命令：

git remote add origin 远程仓库地址

添加后，远程库的名字就是 origin ，这是Git默认的叫法，也可以改成别的名字

下一步，就可以把本地库的所有内容推送到远程库上：

$ git push -u origin master
Counting objects: 20, done.
Delta compression using up to 4 threads.
Compressing objects: 100% (15/15), done.
Writing objects: 100% (20/20), 1.64 KiB | 560.00 KiB/s, done.
Total 20 (delta 5), reused 0 (delta 0)
remote: Resolving deltas: 100% (5/5), done.
To github.com:michaelliao/learngit.git
* [new branch] master -> master
Branch 'master' set up to track remote branch 'master' from 'origin'.

把本地库的内容推送到远程，用 git push 命令，实际上是把当前分支 master 推送到远程。
由于远程库是空的，我们第一次推送 master 分支时，加上了 -u 参数，Git不但会把本地的 master
分支内容推送的远程新的 master 分支，还会把本地的 master 分支和远程的 master 分支关联起来，在以后的推送或者拉取时就可以简化命令。

提交 git push -u origin master ->省略 git push

拉取代码 git pull

git pull 的作用:
当你在一个本地分支上使用 git pull 命令时，Git会自动从与该分支关联的远程仓库获取最新的代码并合并到当前分支。

举个例子，假设你有一个本地分支叫做 feature，它与远程仓库的 origin/feature 分支关联。当你执行 git pull 命令时，以下是可能发生的情况：

1. 如果你在本地分支上没有进行任何修改，并且远程分支没有新的提交，那么 Git 会给出一个提示，表示当前已经是 “up to date”，即已经是最新的代码了。

2. 如果有新的提交在远程仓库的 origin/feature 分支上，并且与当前分支没有冲突，Git 将会自动下载最新的提交，并将其合并进你的本地 feature 分支。这将导致你的本地分支与远程仓库保持同步。

3. 如果有新的提交在远程仓库的 origin/feature 分支上，但是与你的本地分支有冲突，Git 将会报告冲突，并中止合并过程。你需要手动解决冲突，然后进行提交（commit）。

注意： 在执行 git pull 命令之前，最好先确保你的本地分支没有未提交的修改。要么提交这些修改，要么使用 git stash 命令将其保存起来，以避免执行 git pull 时的冲突和问题。

推送成功后，可以立刻在gitee页面中看到远程库的内容已经和本地一模一样：

从现在起，只要本地作了提交，就可以通过命令：

$ git push origin master

把本地 master 分支的最新修改推送至Gitee，现在，你就拥有了真正的分布式版本库！

3.3 从远程库克隆

打开另一个窗口模拟其他小伙伴下载远程库

cd f:\tmp
git clone git@gitee.com:lxsong77/learngit.git #克隆远程库到本地库
$ git log --pretty=oneline
64eb3d86d3b46095c006edd91dcf5f2f97ba4b7b (HEAD -> master, origin/master,
origin/HEAD) remove test.txt
18a4e330ee23f4df88e1cb2de7c3bf42fcd60d57 add test.txt
fc99176b6e2d3b2159b6503429611127b090ade0 understand how stage works
64800dbc350bdb87529df4a1efb5203028086926 append GPL
6793214fbc09a35878b9366a4bc3a62b4ab504dd add distributed
bd875ec1f86c22f203741414a238526bfca26279 add 3 files.
6e4de12122b22ee3145dfa87af974d284f832dd2 wrote a readme file

3.4 分支管理

分支就是git世界的平行宇宙，当你正在电脑前努力学习Git的时候，另一个你正在另一个平行宇宙里努力学习SVN。
如果两个平行宇宙互不干扰，那对现在的你也没啥影响。不过，在某个时间点，两个平行宇宙合并
了，结果，你既学会了Git又学会了SVN！

分支在实际中有什么用呢？假设你准备开发一个新功能，但是需要两周才能完成，第一周你写了
50%的代码，如果立刻提交，由于代码还没写完，不完整的代码库会导致别人不能干活了。如果等代码全部写完再一次提交，又存在丢失每天进度的巨大风险。
现在有了分支，就不用怕了。你创建了一个属于你自己的分支，别人看不到，还继续在原来的分支
上正常工作，而你在自己的分支上干活，想提交就提交，直到开发完毕后，再一次性合并到原来的分支上，这样，既安全，又不影响别人工作。
git相对于其他版本控制工具，分支功能非常快

3.4.1 创建与合并分支

在版本回退里，你已经知道，每次提交，Git都把它们串成一条时间线，这条时间线就是一个分支。截止到目前，只有一条时间线，在Git里，这个分支叫主分支，即 master 分支。 HEAD 严格来说不是指向提交，而是指向 master ， master 才是指向提交的，所以， HEAD 指向的就是当前分支。
一开始的时候， master 分支是一条线，Git用 master 指向最新的提交，再用 HEAD 指向master，就能确定当前分支，以及当前分支的提交点：

每次提交， master 分支都会向前移动一步，这样，随着你不断提交， master 分支的线也越来越
长。
当我们创建新的分支，例如 dev 时，Git新建了一个指针叫 dev ，指向 master 相同的提交，再把
HEAD 指向 dev ，就表示当前分支在 dev 上：

从现在开始，对工作区的修改和提交就是针对 dev 分支了，比如新提交一次后， dev 指针往前移动一步，而 master 指针不变：

假如我们在 dev 上的工作完成了，就可以把 dev 合并到 master 上。Git怎么合并呢？最简单的方
法，就是直接把 master 指向 dev 的当前提交，就完成了合并：

所以Git合并分支也很快！就改改指针，工作区内容也不变！
合并完分支后，甚至可以删除 dev 分支。删除 dev 分支就是把 dev 指针给删掉，删掉后，我们就剩下了一条 master 分支

下面开始实战。首先，我们创建 dev 分支，然后切换到 dev 分支：

$ git checkout -b dev
Switched to a new branch 'dev'
git log --oneline
git log --pretty=oneline --abbrev-commit #和上面的命令等价

• –pretty=oneline：显示单行
• –abbrev-commit：缩写commit id
  git checkout 命令加上 -b 参数表示创建并切换，相当于以下两条命令：

$ git branch dev
$ git checkout dev
Switched to branch 'dev'

然后，用 git branch 命令查看当前分支：

$ git branch
* dev
master

git branch 命令会列出所有分支，当前分支前面会标一个*号。
然后，我们就可以在 dev 分支上正常提交，比如对 readme.txt 做个修改，加上一行：

Creating a new branch is quick.

然后提交：

$ git add readme.txt
$ git commit -m "branch test"
[dev b17d20e] branch test
1 file changed, 1 insertion(+)

现在， dev 分支的工作完成，我们就可以切换回 master 分支：

$ git checkout master
Switched to branch 'master'

切换回 master 分支后，再查看一个 readme.txt 文件，刚才添加的内容不见了！因为那个提交是
在 dev 分支上，而 master 分支此刻的提交点并没有变：

现在，我们把 dev 分支的工作成果合并到 master 分支上：

$ git merge dev
Updating d46f35e..b17d20e
Fast-forward
readme.txt | 1 +
1 file changed, 1 insertion(+)

git merge 命令用于合并指定分支到当前分支。合并后，再查看 readme.txt 的内容，就可以看
到，和 dev 分支的最新提交是完全一样的。

合并完成后，就可以放心地删除 dev 分支了：

$ git branch -d dev
Deleted branch dev (was b17d20e).

删除后，查看 branch ，就只剩下 master 分支了：

$ git branch
* master

总结：

• git checkout
  • git checkout - - file：把版本课的文件重置到工作区（撤销工作区的修改）
  • git checkout master：切换到master分支
  • git checkout -b dev：创建dev分支，并且切换到dev分支
• git branch
  • git branch：列表分支分支，有*当前的分支
  • git branch dev：创建dev分支，如果切换需要git checkout dev
  • git branch -d dev：删除分支
• git merge：合并分支

#master合并dev分支
git checkout master
git merge dev #使master分支合并dev分支

3.4.2 版本冲突

准备新的 feature1 分支，继续我们的新分支开发：

$ git checkout -b feature1
Switched to a new branch 'feature1'
git branch feature1 #创建分支
git checkout feature1 #切换分支
git branch #查看分支

修改 readme.txt 最后一行，改为：

Creating a new branch is quick AND simple.

在 feature1 分支上提交：

$ git add readme.txt
$ git commit -m "AND simple"
[feature1 14096d0] AND simple
1 file changed, 1 insertion(+), 1 deletion(-)

切换到 master 分支：

$ git checkout master
Switched to branch 'master'
Your branch is ahead of 'origin/master' by 1 commit.
(use "git push" to publish your local commits)

Git还会自动提示我们当前 master 分支比远程的 master分支要超前1个提交。
在 master 分支上把 readme.txt 文件的最后一行改为：

Creating a new branch is quick & simple.

提交：

$ git add readme.txt
$ git commit -m "& simple"
[master 5dc6824] & simple
1 file changed, 1 insertion(+), 1 deletion(-)

现在， master 分支和 feature1 分支各自都分别有新的提交，变成了这样：

这种情况下，Git无法执行“快速合并”，只能试图把各自的修改合并起来，但这种合并就可能会有冲
突，我们试试看：

$ git merge feature1
Auto-merging readme.txt
CONFLICT (content): Merge conflict in readme.txt
Automatic merge failed; fix conflicts and then commit the result.

Git告诉我们， readme.txt文件存在冲突，必须手动解决冲突后再提交。 git status 也可以告诉我们冲突的文件：

$ git status
On branch master
Your branch is ahead of 'origin/master' by 2 commits.
(use "git push" to publish your local commits)
You have unmerged paths.
(fix conflicts and run "git commit")
(use "git merge --abort" to abort the merge)
Unmerged paths:
(use "git add <file>..." to mark resolution)
both modified: readme.txt
no changes added to commit (use "git add" and/or "git commit -a")

我们可以直接查看readme.txt的内容：

Git is a distributed version control system.
Git is free software distributed under the GPL.
Git has a mutable index called stage.
Git tracks changes of files.
<<<<<<< HEAD
Creating a new branch is quick & simple.
=======
Creating a new branch is quick AND simple.
>>>>>>> feature1

Git用 <<<<<<< ， ======= ， >>>>>>> 标记出不同分支的内容，我们修改如下后保存：

Creating a new branch is quick and simple.

再提交：

$ git add readme.txt
$ git commit -m "conflict fixed"
[master cf810e4] conflict fixed

用 git log 也可以看到分支的合并情况：

$ git log --graph --pretty=oneline --abbrev-commit
* cf810e4 (HEAD -> master) conflict fixed
|\
| * 14096d0 (feature1) AND simple
* | 5dc6824 & simple
|/
* b17d20e branch test
* d46f35e (origin/master) remove test.txt
* b84166e add test.txt
* 519219b git tracks changes
* e43a48b understand how stage works
* 1094adb append GPL
* e475afc add distributed
* eaadf4e wrote a readme file

最后，删除 feature1 分支：

$ git branch -d feature1
Deleted branch feature1 (was 14096d0).

工作完成。

3.4.3 分支管理策略

1.fast forward模式
通常，合并分支时，如果可能，Git会用 Fast forward 模式，但这种模式下，删除分支后，会丢掉分支信息。

如果要强制禁用 Fast forward 模式，Git就会在merge时生成一个新的commit，这样，从分支历
史上就可以看出分支信息。

下面我们实战一下 --no-ff 方式的 git merge ：

首先，仍然创建并切换 dev 分支：

$ git checkout -b dev
Switched to a new branch 'dev'

修改readme.txt文件，并提交一个新的commit：

$ git add readme.txt
$ git commit -m "add merge"
[dev f52c633] add merge
1 file changed, 1 insertion(+)

现在，我们切换回 master ：

$ git checkout master
Switched to branch 'master'

准备合并 dev 分支，请注意 --no-ff 参数，表示禁用 Fast forward ：

$ git merge --no-ff -m "merge with no-ff" dev
Merge made by the 'recursive' strategy.
readme.txt | 1 +
1 file changed, 1 insertion(+)

因为本次合并要创建一个新的commit，所以加上 -m 参数，把commit描述写进去。

合并后，我们用 git log 看看分支历史：

$ git log --graph --pretty=oneline --abbrev-commit
* e1e9c68 (HEAD -> master) merge with no-ff
|\
| * f52c633 (dev) add merge
|/
* cf810e4 conflict fixed
...

可以看到，不使用 Fast forward 模式，merge后就像这样：

2. 分支策略
在实际开发中，我们应该按照几个基本原则进行分支管理：

• master 分支应该是非常稳定的，也就是仅用来发布新版本，平时不能在上面干活；
• 那在哪干活呢？干活都在 dev 分支上，也就是说， dev 分支是不稳定的，到某个时候，比如1.0版本发布时，再把 dev 分支合并到 master 上，在 master 分支发布1.0版本；
• 你和你的小伙伴们每个人都在 dev 分支上干活，每个人都有自己的分支，时不时地往 dev 分支上合并就可以了。
  所以，团队合作的分支看起来就像这样：
  
  

#创建本地dev分支
git checkout -b
#提交dev给服务器
git push origin dev
#创建bob的本地分支
git checkout -b bob
#创建env.txt
touch env.txt
#提交
git add .
git commit -m "add env bob"
#回到dev，合并bob分支
git checkout dev
git merge bob
#上传dev到远程
git push origin dev

cd f:\mickey
git clone git@gitee.com:lxsong77/learngit.git
#注意，只下载master分支，其他分支不会被clone
git checkout -b dev
git branch --set-upstream-to=origin/dev dev
#等价于
git checkout -b dev origin/dev
#拉取dev分支
git pull origin dev
#创建mickey分支
git checkout -b mickey
#修改env.txt增加内容"mickey env"
vim env.txt
#提交
git add .
git commit -m "update env by mickey"
#合并到dev
git checkout dev
git merge mickey
#上传
git push origin dev

合并到master分支

#拉取最新代码
git pull origin master
git pull origin dev
git checkout master
git merge dev
#上传
git push origin master

3.4.4 分支实战

1. Bug分支

软件开发中，bug就像家常便饭一样。有了bug就需要修复，在Git中，由于分支是如此的强大，所
以，每个bug都可以通过一个新的临时分支来修复，修复后，合并分支，然后将临时分支删除。

当你接到一个修复一个代号101的bug的任务时，你想创建一个分支 issue-101 来修复它，但是，当前正在 dev 上进行的工作还没有提交：

$ git status
On branch dev
Changes to be committed:
(use "git reset HEAD <file>..." to unstage)
new file: hello.py
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.txt

工作只进行到一半，还没法提交，预计完成还需1天时间。但是，必须在两个小时内修复该bug，怎么办？
Git还提供了一个 stash 功能，可以把当前工作现场“储藏”起来，等以后恢复现场后继续工作：

$ git stash
Saved working directory and index state WIP on dev: f52c633 add merge

现在，用 git status 查看工作区，就是干净的（除非有没有被Git管理的文件），因此可以放心地
创建分支来修复bug。

首先确定要在哪个分支上修复bug，假定需要在 master 分支上修复，就从 master 创建临时分支：

$ git checkout master
Switched to branch 'master'
Your branch is ahead of 'origin/master' by 6 commits.
(use "git push" to publish your local commits)
$ git checkout -b issue-101
Switched to a new branch 'issue-101'

现在修复bug，需要把“Git is free software ...”改为“Git is a free software ...”，然后提交：

$ git add readme.txt 
$ git commit -m "fix bug 101"
[issue-101 4c805e2] fix bug 101
 1 file changed, 1 insertion(+), 1 deletion(-)

​ 修复完成后，切换到master分支，并完成合并，最后删除issue-101分支：

$ git checkout master
Switched to branch 'master'
Your branch is ahead of 'origin/master' by 6 commits.
  (use "git push" to publish your local commits)

$ git merge --no-ff -m "merged bug fix 101" issue-101
Merge made by the 'recursive' strategy.
 readme.txt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

​ 现在，接着回到dev分支干活了！

$ git checkout dev
Switched to branch 'dev'

$ git status
On branch dev
nothing to commit, working tree clean

​ 工作区是干净的，刚才的工作现场存到哪去了？用git stash list命令看看：

$ git stash list
stash@{0}: WIP on dev: f52c633 add merge

​ 工作现场还在，Git把stash内容存在某个地方了，但是需要恢复一下，有两个办法：

​ 一是用git stash apply恢复，但是恢复后，stash内容并不删除，你需要用git stash drop来删除；

​ 另一种方式是用git stash pop，恢复的同时把stash内容也删了：

$ git stash pop
On branch dev
Changes to be committed:
  (use "git reset HEAD <file>..." to unstage)

	new file:   hello.py

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.txt

Dropped refs/stash@{0} (5d677e2ee266f39ea296182fb2354265b91b3b2a)

​ 再用git stash list查看，就看不到任何stash内容了：

$ git stash list

​ 你可以多次stash，恢复的时候，先用git stash list查看，然后恢复指定的stash，用命令：

$ git stash apply stash@{0}

​ 在master分支上修复了bug后，我们要想一想，dev分支是早期从master分支分出来的，所以，这个bug其实在当前dev分支上也存在。

​ 同样的bug，要在dev上修复，我们只需要把4c805e2 fix bug 101这个提交所做的修改“复制”到dev分支。注意：我们只想复制4c805e2 fix bug 101这个提交所做的修改，并不是把整个master分支merge过来。

​ 为了方便操作，Git专门提供了一个cherry-pick命令，让我们能复制一个特定的提交到当前分支：

$ git branch
* dev
  master
$ git cherry-pick 4c805e2
[master 1d4b803] fix bug 101
 1 file changed, 1 insertion(+), 1 deletion(-)

​ Git自动给dev分支做了一次提交，注意这次提交的commit是1d4b803，它并不同于master的4c805e2，因为这两个commit只是改动相同，但确实是两个不同的commit。用git cherry-pick，我们就不需要在dev分支上手动再把修bug的过程重复一遍。

​ 有些聪明的童鞋会想了，既然可以在master分支上修复bug后，在dev分支上可以“重放”这个修复过程，那么直接在dev分支上修复bug，然后在master分支上“重放”行不行？当然可以，不过你仍然需要git stash命令保存现场，才能从dev分支切换到master分支。

完整的过程命令

#dev分支工作
git checkout dev
echo 'working on stage..' >> readme.txt
git add .
echo 'working on work space' >> readme.txt

#以上是现有工作
#接到一个改正bug101的任务
#现有工作，存储起来
git stash
#列表stash
git stash list

#切换回到master分支修改bug101
git checkout master
#创建修改bug101的分支
git checkout -b issue-101
echo 'fixed issue-101 bug' >> readme.txt
git add .
git commit -m "fixed bug 101"
#合并101分支
git checkout master
git merge issue-101

#bug改完了，回来继续工作
git checkout dev
git stash pop #把之前存储的工作，弹出
。。。。

2. Feature分支

​ 软件开发中，总有无穷无尽的新的功能要不断添加进来。

​ 添加一个新功能时，你肯定不希望因为一些实验性质的代码，把主分支搞乱了，所以，每添加一个新功能，最好新建一个feature分支，在上面开发，完成后，合并，最后，删除该feature分支。

​ 现在，你终于接到了一个新任务：开发代号为Vulcan的新功能，该功能计划用于下一代星际飞船。

​ 于是准备开发：

$ git checkout -b feature-vulcan
Switched to a new branch 'feature-vulcan'

​ 5分钟后，开发完毕：

$ git add vulcan.py

$ git status
On branch feature-vulcan
Changes to be committed:
  (use "git reset HEAD <file>..." to unstage)

	new file:   vulcan.py

$ git commit -m "add feature vulcan"
[feature-vulcan 287773e] add feature vulcan
 1 file changed, 2 insertions(+)
 create mode 100644 vulcan.py

​ 切回dev，准备合并：

$ git checkout dev

​ 一切顺利的话，feature分支和bug分支是类似的，合并，然后删除。

​ 就在此时，接到上级命令，因经费不足，新功能必须取消！

​ 虽然白干了，但是这个包含机密资料的分支还是必须就地销毁：

$ git branch -d feature-vulcan
error: The branch 'feature-vulcan' is not fully merged.
If you are sure you want to delete it, run 'git branch -D feature-vulcan'.

​ 销毁失败。Git友情提醒，feature-vulcan分支还没有被合并，如果删除，将丢失掉修改，如果要强行删除，需要使用大写的-D参数。。

​ 现在我们强行删除：

$ git branch -D feature-vulcan
Deleted branch feature-vulcan (was 287773e).

​ 终于删除成功！

​ 总结： 开发一个新feature，最好新建一个分支；如果要丢弃一个没有被合并过的分支，可以通过git branch -D <name>强行删除。

3.5 标签管理

1. 创建标签

​ 在Git中打标签非常简单，首先，切换到需要打标签的分支上：

$ git branch
* dev
  master
$ git checkout master
Switched to branch 'master'

​ 然后，敲命令git tag <name>就可以打一个新标签：

$ git tag v1.0

​ 可以用命令git tag查看所有标签：

$ git tag
v1.0

$ git log --pretty=oneline --abbrev-commit
12a631b (HEAD -> master, tag: v1.0, origin/master) merged bug fix 101
4c805e2 fix bug 101
e1e9c68 merge with no-ff
f52c633 add merge
cf810e4 conflict fixed
5dc6824 & simple
14096d0 AND simple
b17d20e branch test
d46f35e remove test.txt
b84166e add test.txt
519219b git tracks changes
e43a48b understand how stage works
1094adb append GPL
e475afc add distributed
eaadf4e wrote a readme file

​ 比方说要对add merge这次提交打标签，它对应的commit id是f52c633，敲入命令：

$ git tag v0.9 f52c633

​ 再用命令git tag查看标签：

$ git tag
v0.9
v1.0

注意: 标签不是按时间顺序列出，而是按字母排序的。可以用git show <tagname>查看标签信息：

$ git show v0.9
commit f52c63349bc3c1593499807e5c8e972b82c8f286 (tag: v0.9)
Author: Michael Liao <askxuefeng@gmail.com>
Date:   Fri May 18 21:56:54 2018 +0800

    add merge

diff --git a/readme.txt b/readme.txt
...

​ 可以看到，v0.9确实打在add merge这次提交上。

​ 还可以创建带有说明的标签，用-a指定标签名，-m指定说明文字：

$ git tag -a v0.1 -m "version 0.1 released" b0fbe25

​ 用命令git show <tagname>可以看到说明文字：

$ git show v0.1
tag v0.1
Tagger: Michael Liao <askxuefeng@gmail.com>
Date:   Fri May 18 22:48:43 2018 +0800

version 0.1 released

commit 1094adb7b9b3807259d8cb349e7df1d4d6477073 (tag: v0.1)
Author: Michael Liao <askxuefeng@gmail.com>
Date:   Fri May 18 21:06:15 2018 +0800

    append GPL

diff --git a/readme.txt b/readme.txt
...

注意：标签总是和某个commit挂钩。如果这个commit既出现在master分支，又出现在dev分支，那么在这两个分支上都可以看到这个标签。

总结：

• 命令git tag <tagname>用于新建一个标签，默认为HEAD，也可以指定一个commit id；
• 命令git tag -a <tagname> -m "blablabla..."可以指定标签信息；
• 命令git tag可以查看所有标签。

2. 操作标签

​ 如果标签打错了，也可以删除：

$ git tag -d v0.1
Deleted tag 'v0.1' (was f15b0dd)

​ 因为创建的标签都只存储在本地，不会自动推送到远程。所以，打错的标签可以在本地安全删除。

​ 如果要推送某个标签到远程，使用命令git push origin <tagname>：

$ git push origin v1.0
Total 0 (delta 0), reused 0 (delta 0)
To github.com:michaelliao/learngit.git
 * [new tag]         v1.0 -> v1.0

​ 或者，一次性推送全部尚未推送到远程的本地标签：

$ git push origin --tags
Total 0 (delta 0), reused 0 (delta 0)
To github.com:michaelliao/learngit.git
 * [new tag]         v0.9 -> v0.9

​ 如果标签已经推送到远程，要删除远程标签就麻烦一点，先从本地删除：

$ git tag -d v0.9
Deleted tag 'v0.9' (was f52c633)

​ 然后，从远程删除。删除命令也是push，但是格式如下：

$ git push origin :refs/tags/v0.9
To github.com:michaelliao/learngit.git
 - [deleted]         v0.9

总结：

• 命令git push origin <tagname>可以推送一个本地标签；
• 命令git push origin --tags可以推送全部未推送过的本地标签；
• 命令git tag -d <tagname>可以删除一个本地标签；
• 命令git push origin :refs/tags/<tagname>可以删除一个远程标签。

四、自定义git

4.1 git config自定义配置

在安装Git一节中，我们已经配置了user.name和user.email，实际上，Git还有很多可配置项。

比如，让Git显示颜色，会让命令输出看起来更醒目：

$ git config --global color.ui true

4.2 忽略特殊文件

​ 有些时候，你必须把某些文件放到Git工作目录中，但又不能提交它们，比如保存了数据库密码的配置文件啦，等等，每次git status都会显示Untracked files ...，有强迫症的童鞋心里肯定不爽。

​ 好在Git考虑到了大家的感受，这个问题解决起来也很简单，在Git工作区的根目录下创建一个特殊的.gitignore文件，然后把要忽略的文件名填进去，Git就会自动忽略这些文件。

​ 不需要从头写.gitignore文件，GitHub已经为我们准备了各种配置文件，只需要组合一下就可以使用了。所有配置文件可以直接在线浏览：https://github.com/github/gitignore

忽略文件的原则是：

1. 忽略操作系统自动生成的文件，比如缩略图等；
2. 忽略编译生成的中间文件、可执行文件等，也就是如果一个文件是通过另一个文件自动生成的，那自动生成的文件就没必要放进版本库，比如Java编译产生的.class文件；
3. 忽略你自己的带有敏感信息的配置文件，比如存放口令的配置文件。

举个例子：

​ 假设你在Windows下进行Python开发，Windows会自动在有图片的目录下生成隐藏的缩略图文件，如果有自定义目录，目录下就会有Desktop.ini文件，因此你需要忽略Windows自动生成的垃圾文件：

# Windows:
Thumbs.db
ehthumbs.db
Desktop.ini

然后，继续忽略Python编译产生的.pyc、.pyo、dist等文件或目录：

# Python:
*.py[cod]
*.so
*.egg
*.egg-info
dist
build

加上你自己定义的文件，最终得到一个完整的.gitignore文件，内容如下：

# Windows:
Thumbs.db
ehthumbs.db
Desktop.ini

# Python:
*.py[cod]
*.so
*.egg
*.egg-info
dist
build

# My configurations:
db.ini
deploy_key_rsa

​ 最后一步就是把.gitignore也提交到Git，就完成了！当然检验.gitignore的标准是git status命令是不是说working directory clean。

​ 有些时候，你想添加一个文件到Git，但发现添加不了，原因是这个文件被.gitignore忽略了：

$ git add App.class
The following paths are ignored by one of your .gitignore files:
App.class
Use -f if you really want to add them.

​ 如果你确实想添加该文件，可以用-f强制添加到Git：

$ git add -f App.class

​ 或者你发现，可能是.gitignore写得有问题，需要找出来到底哪个规则写错了，可以用git check-ignore命令检查：

$ git check-ignore -v App.class
.gitignore:3:*.class	App.class

​ Git会告诉我们，.gitignore的第3行规则忽略了该文件，于是我们就可以知道应该修订哪个规则。

总结：

• 忽略某些文件时，需要编写.gitignore；
• .gitignore文件本身要放到Git仓库根目录下，并且可以对.gitignore做版本管理！

4.3 配置别名

​ 有没有经常敲错命令？比如git status？status这个单词真心不好记。

如果敲git st就表示git status那就简单多了，当然这种偷懒的办法我们是极力赞成的。

我们只需要敲一行命令，告诉Git，以后st就表示status：

$ git config --global alias.st status

好了，现在敲git st看看效果。

当然还有别的命令可以简写，很多人都用co表示checkout，ci表示commit，br表示branch：

$ git config --global alias.co checkout
$ git config --global alias.ci commit
$ git config --global alias.br branch

以后提交就可以简写成：

$ git ci -m "bala bala bala..."

--global参数是全局参数，也就是这些命令在这台电脑的所有Git仓库下都有用。

配置一个git last，让其显示最后一次提交信息：

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

这样，用git last就能显示最近一次的提交：

$ git last
commit adca45d317e6d8a4b23f9811c3d7b7f0f180bfe2
Merge: bd6ae48 291bea8
Author: Michael Liao <askxuefeng@gmail.com>
Date:   Thu Aug 22 22:49:22 2013 +0800

    merge & fix hello.py

甚至还有人丧心病狂地把lg配置成了：

git config --global alias.lg "log --color --graph --pretty=format:'%Cred%h%Creset -%C(yellow)%d%Creset %s %Cgreen(%cr) %C(bold blue)<%an>%Creset' --abbrev-commit"

配置Git的时候，加上--global是针对当前用户起作用的，如果不加，那只针对当前的仓库起作用。

配置文件放哪了？每个仓库的Git配置文件都放在.git/config文件中：

$ cat .git/config 
[core]
    repositoryformatversion = 0
    filemode = true
    bare = false
    logallrefupdates = true
    ignorecase = true
    precomposeunicode = true
[remote "origin"]
    url = git@github.com:michaelliao/learngit.git
    fetch = +refs/heads/*:refs/remotes/origin/*
[branch "master"]
    remote = origin
    merge = refs/heads/master
[alias]
    last = log -1

别名就在[alias]后面，要删除别名，直接把对应的行删掉即可。

而当前用户的Git配置文件放在用户主目录下的一个隐藏文件.gitconfig中：

$ cat .gitconfig
[alias]
    co = checkout
    ci = commit
    br = branch
    st = status
[user]
    name = Your Name
    email = your@email.com

配置别名也可以直接修改这个文件，如果改错了，可以删掉文件重新通过命令配置。