Loading...

Git入门

Git入门
　　iwehdio的博客园：https://www.cnblogs.com/iwehdio/

0、总结

  • 把目录变成Git可以管理的仓库：git init。
  • 把文件添加到仓库（暂存区）：git add <file>。
  • 添加目录下的所有变化：git add -A。
  • 把文件提交到仓库（版本库）：git commit -m <message>。
  • 查看仓库状态：git status。
  • 查看具体的修改内容：git diff。
  • 查看工作区和版本库里面最新版本的区别：git diff HEAD -- <file>。
  • 查看历史记录：git log。
  • 回退到上一版本：git reset --hard HEAD^。
  • 回退到某一版本号：git reset --hard <版本号>。
  • 获取操作后的版本号：git reflog。
  • 丢弃工作区的修改：git checkout -- <file>。
  • 撤销暂存区的修改：git reset HEAD <file> 。
  • 从版本库中删除文件：git rm。
  • 添加远程库：git remote add origin git@github.com:用户名/库名.git。
  • 把本地库的内容推送到远程库上：git push origin master。
  • 抓取远程的新提交：git pull。
  • 在本地创建和远程分支对应的分支：git checkout -b branch-name origin/branch-name。
  • 建立本地分支和远程分支的关联：git branch --set-upstream branch-name origin/branch-name。
  • 创建分支：git branch <分支名>。
  • 切换分支：git checkout <分支名>或git switch <分支名>。
  • 查看当前分支：git branch。
  • 合并分支：git merge <分支名>。
  • 删除分支：git branch -d <分支名> 。
  • 强行删除分支：git branch -D <分支名> 。
  • 禁用Fast forward的合并分支：git merge --no-ff -m <message> <分支名>。
  • 储存工作现场：git stash。
  • 恢复工作现场：git stash apply。
  • 恢复（并删除）工作现场：git stash pop。
  • 查看工作现场储存列表：git stash list。
  • 复制一个特定的提交到当前分支：git cherry-pick <版本号>。
  • 把分叉的提交历史“整理”成一条直线：git rebase。
  • 打一个新标签：git tag <标签> <版本号>，没有版本号默认为当前。
  • 查看所有标签：git tag 。
  • 查看标签信息：git show 。
  • 推送某个标签到远程：git push origin <标签>。
  • 删除一个本地标签：git tag -d <标签>。
  • 删除一个远程标签：git push origin :refs/tags/<标签>。

1、Git基础

  • 在 Windows系统上安装 Git：

    • 安装 Git 和 Node.js 。

    • 进入 Git -> Git Bash 。

    • 命令行输入，设置用户名和邮箱：

      $ git config --global user.name "Your Name"
$ git config --global user.email "email@example.com"

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

  • 创建版本库（repository）：

    • 创建空目录。

      $ mkdir learngit
$ cd learngit
$ pwd
/Users/michael/learngit

    • 在次目录下，通过git init命令把这个目录变成Git可以管理的仓库。

      $ git init
Initialized empty Git repository in /Users/michael/learngit/.git/
      • 当前目录下会创建一个.git的目录，用来跟踪管理版本库。

  • 把一个文件添加到仓库：

    • 在之前创建的仓库目录下，创建 readme.md 文件。内容为：

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

    • 用命令git add <file>告诉Git，把文件添加到仓库。

      $ git add readme.md

    • 用命令git commit -m <message>告诉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.md
      • -m后面输入的是本次提交的说明，可以输入任意内容，最好是有意义的。
      • 返回的信息，1 file changed：1个文件被改动（我们新添加的readme.txt文件）；2 insertions：插入了两行内容（readme.txt有两行内容）。
      • 为什么要分add，commit两步呢？因为commit可以一次提交很多文件，所以你可以多次add不同的文件，再一起commit。

2、版本控制

（1）版本回退

  • 假如对 readme.md 进行了修改，需要查看修改并更新提交：

    • 修改后的内容为：

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

    • 用命令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.md

no changes added to commit (use "git add" and/or "git commit -a")
      • 上面的命令输出告诉我们，readme.md 被修改过了，但还没有准备提交的修改。

    • 用命令git diff来查看修改的具体内容。

      $ git diff readme.md
diff --git a/readme.md b/readme.md
index 46d49bf..9247db6 100644
--- a/readme.md
+++ b/readme.md
@@ -1,2 +1,2 @@
-Git is a version control system.
+Git is a distributed version control system.
 Git is free software.
      • 从上面的命令输出看到，修改是在第一行添加了一个 distributed 单词。

    • 然后使用git add命令将文件添加到仓库，再用命令git status查看状态。

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

	modified:   readme.md

      • 从上面的命令输出看到，将要被提交的修改包括 readme.md 。

      • git add还有以下使用：

        git add -A  # 添加所有变化
git add -u  # 添加被修改(modified)和被删除(deleted)文件，不包括新文件(new)
git add .   # 添加新文件(new)和被修改(modified)文件，不包括被删除(deleted)文件

    • 最后，就可以用git commit命令将修改提交到仓库，再用命令git status查看状态。

      $ git commit -m "add distributed"
[master e475afc] add distributed
 1 file changed, 1 insertion(+), 1 deletion(-)
$ git status
On branch master
nothing to commit, working tree clean
      • Git告诉我们当前没有需要提交的修改，而且，工作目录是干净（working tree clean）的。

  • 假如需要返回原来的提交，即版本回退：

    • 首先用git log命令查看历史记录。

      $ git log
commit b28a339917922c499ff52fbbb76d0a46bfa9bf2e (HEAD -> master)
Author: iwehdio <iwehdio@qq.com>
Date:   Tue Apr 14 16:16:40 2020 +0800

    add distruibuted

commit dfc9d4ef464a20ba59d493677d312ae3edd3c6a4
Author: iwehdio <iwehdio@qq.com>
Date:   Tue Apr 14 16:13:06 2020 +0800

    wrote a readme file
      • commit 后跟的一串十六进制数为 commit id（即版本号），指向了提交的一个版本。
      • 如果要精简输出，后边加--pretty=oneline参数。

    • 其次用git reset命令进行版本回退。

      $ git reset --hard HEAD^
HEAD is now at dfc9d4e wrote a readme file
      • 完成了回退到版本号以 dfc9d4e 开头的提交版本。
      • Git 中使用HEAD指针指向当前的版本，HEAD^表示上一个版本，HEAD^^表示上上一个版本，HEAD~100表示上100个版本。

    • 如果要在回退后，再返回到新版本。需要借助版本号。如之前新版本的版本号以 b28a339 开头。

      $ git reset --hard b28a339
HEAD is now at b28a339 add distruibuted

      • 版本号不一定要写全，只需写前几位进行区分即可。

      • 如果忘记了新版本的版本号，可以用git reflog获取之前输入的对文件进行操作的命令。

        $ git reflog
b28a339 (HEAD -> master) HEAD@{0}: reset: moving to b28a339
dfc9d4e HEAD@{1}: reset: moving to HEAD^
b28a339 (HEAD -> master) HEAD@{2}: commit: add distruibuted
dfc9d4e HEAD@{3}: commit (initial): wrote a readme file

      • 可以知道执行commit: add distruibuted命令后的版本号为 b28a339。

（2）工作区和暂存区

  • Git 中的区域：

    • 工作区（Working Directory），在电脑里能看到的目录，就是之前创建的空目录。

    • 版本库（Repository），工作区有一个隐藏目录 .git，这个不算工作区，而是Git的版本库。包括：

      • 称为stage（或者叫index）的暂存区。

  • 还有Git为我们自动创建的第一个分支master，以及指向master的一个指针叫HEAD。

  • Git 添加文件到版本库的流程。

    • 第一步是用git add把文件添加进去，实际上就是把文件修改从工作区添加到暂存区。

    • 第二步是用git commit提交更改，实际上就是把暂存区的所有内容提交到当前分支。

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

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

    • 例如，对readme.md 进行修改并创建一个新的LICENSE文件：

      • 查看状态：

        $ git status
On branch master
Changes not staged for commit:
  (use "git add <file>..." to update what will be committed)
  (use "git restore <file>..." to discard changes in working directory)
        modified:   readme.md

Untracked files:
  (use "git add <file>..." to include in what will be committed)
        LICENSE
        • 状态显示，readme.md 被修改了而 LICENSE 从未被提交过。这时二者的新版本都只在工作区。

      • 添加到暂存区。

        $ git add LICENSE
$ git add readme.md
$ git status
On branch master
Changes to be committed:
  (use "git restore --staged <file>..." to unstage)
        new file:   LICENSE
        modified:   readme.md
        • 通过两次 add，两个文件被添加到了暂存区。

      • 提交到分支。

        $ git commit -m "add LICENSE"
[master c4490ac] add LICENSE
 2 files changed, 3 insertions(+), 1 deletion(-)
 create mode 100644 LICENSE
$ git status
On branch master
nothing to commit, working tree clean
        • 通过 commit ，两个文件被提交到了分支，暂存区中没有任何内容。

（3）管理修改

  • Git跟踪并管理的是修改，而非文件。

  • 再在 readme.md 中添加一行 Git tracks changes. 并进行添加：

    $ cat readme.md
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.
$ git add readme.md
$ git status
On branch master
Changes to be committed:
  (use "git restore --staged <file>..." to unstage)
        modified:   readme.md

  • 然后，将最后一行 Git tracks changes. 改为 Git tracks changes of files. ，并进行提交：

    $ cat readme.md
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 commit -m "git tracks changes"
[master 2140aed] git tracks changes
 1 file changed, 2 insertions(+), 1 deletion(-)

  • 然后查看状态：

    $ git status
On branch master
Changes not staged for commit:
  (use "git add <file>..." to update what will be committed)
  (use "git restore <file>..." to discard changes in working directory)
        modified:   readme.md

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

    第二次的修改没有被提交，因为我们的操作过程是：第一次修改 > git add > 第二次修改 > git commit。第二次的修改没有放入暂存区，但是 git commit 只会提交暂存区的修改：

  • 用git diff HEAD -- readme.txt命令可以查看工作区和版本库里面最新版本的区别。

  • 每次修改，如果不用git add到暂存区，那就不会加入到commit中。

（3）撤销修改

  • 如果你在 readme.md 中不小心加了一句：My stupid boss still prefers SVN. ，你可以使用git checkout -- file丢弃工作区的修改。

    $ cat readme.md
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 status
On branch master
Changes not staged for commit:
  (use "git add <file>..." to update what will be committed)
  (use "git restore <file>..." to discard changes in working directory)
        modified:   readme.md

no changes added to commit (use "git add" and/or "git commit -a")
$ git checkout -- readme.md
$ cat readme.md
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.

    命令git checkout -- readme.md意思就是，把readme.md文件在工作区的修改全部撤销，这里有两种情况：

    • 一种是readme.md自修改后还没有被放到暂存区，现在，撤销修改就回到和版本库一模一样的状态；
    • 一种是readme.md已经添加到暂存区后，又作了修改，现在，撤销修改就回到添加到暂存区后的状态。
    • 总之，就是让这个文件回到最近一次git commit或git add时的状态。
    • git checkout -- file命令中的--很重要，没有--，就变成了“切换到另一个分支”的命令，

  • 如果在进行了错误的修改后，还add进了暂存区，但是还没有commit。可以用命令git reset HEAD <file> 可以把暂存区的修改撤销掉（unstage），重新放回工作区

    $ cat readme.md
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.
My stupid boss still prefers SVN.
$ git add readme.md
$ git status
On branch master
Changes to be committed:
  (use "git restore --staged <file>..." to unstage)
        modified:   readme.md
$ git reset HEAD readme.md
Unstaged changes after reset:
M       readme.md
$ git status
On branch master
Changes not staged for commit:
  (use "git add <file>..." to update what will be committed)
  (use "git restore <file>..." to discard changes in working directory)
        modified:   readme.md

no changes added to commit (use "git add" and/or "git commit -a")
$ git checkout -- readme.md
$ git status
On branch master
nothing to commit, working tree clean
    • git reset命令既可以回退版本，也可以把暂存区的修改回退到工作区。当我们用HEAD时，表示最新的版本。
    • 再用git status查看一下，现在暂存区是干净的，工作区有修改。也就是说，git reset HEAD <file> 会将暂存区中的文件回撤到工作区，暂存区此时就没有文件了。
    • 最后再用git checkout -- readme.md丢弃工作区的修改。直到这里才撤销了所有的修改。此时暂存区没有文件，工作区回退到版本库中的提交。

  • 小结：

    1. 当你改乱了工作区某个文件的内容，想直接丢弃工作区的修改时，用命令git checkout -- file。
    2. 当你不但改乱了工作区某个文件的内容，还添加到了暂存区时，想丢弃修改，分两步，第一步用命令git reset HEAD <file> ，第二步按情况1操作。
    3. 已经提交了不合适的修改到版本库时，想要撤销本次提交，参考版本回退的方法，不过前提是没有推送到远程库。

（4）删除文件

  • 先添加一个新文件test.txt，添加并提交后在工作区删除它。

    $ git add test.txt
$ git commit -m "add test.txt"
[master e2bf2cb] add test.txt
 1 file changed, 0 insertions(+), 0 deletions(-)
 create mode 100644 test.txt
$ rm test.txt
$ git status
On branch master
Changes not staged for commit:
  (use "git add/rm <file>..." to update what will be committed)
  (use "git restore <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 146fc06] remove test.txt
 1 file changed, 0 insertions(+), 0 deletions(-)
 delete mode 100644 test.txt

  • 如果是误删，则可以从版本库中恢复：

    $ git checkout -- test.txt

3、远程仓库（使用GitHub）

  • 链接到GitHub：

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

      $ ssh-keygen -t rsa -C "youremail@example.com"
      • 你需要把邮件地址换成你自己的邮件地址，然后一路回车，使用默认值即可。
      • 如果一切顺利的话，可以在用户主目录里找到.ssh目录，里面有id_rsa和id_rsa.pub两个文件，这两个就是SSH Key的秘钥对，id_rsa是私钥，不能泄露出去，id_rsa.pub是公钥，可以放心地告诉任何人。

    2. 登陆GitHub，打开“Account settings”，“SSH Keys”页面。然后，点“Add SSH Key”，填上任意Title，在Key文本框里粘贴id_rsa.pub文件的内容。点“Add Key”，你就应该看到已经添加的Key。

      • 为什么GitHub需要SSH Key呢？因为GitHub需要识别出你推送的提交确实是你推送的，而不是别人冒充的，而Git支持SSH协议，所以，GitHub只要知道了你的公钥，就可以确认只有你自己才能推送。
      • GitHub允许你添加多个Key。假定你有若干电脑，你一会儿在公司提交，一会儿在家里提交，只要把每台电脑的Key都添加到GitHub，就可以在每台电脑上往GitHub推送了。

  • 已经在本地创建了一个Git仓库后，又想在GitHub创建一个Git仓库，并且让这两个仓库进行远程同步，这样，GitHub上的仓库既可以作为备份，又可以让其他人通过该仓库来协作。

    1. 首先，登陆GitHub，然后，在右上角找到“Create a new repo”按钮，创建一个新的仓库。

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

    3. 根据GitHub的提示，在本地的仓库下运行命令：

      $ git remote add origin git@github.com:michaelliao/learngit.git
      • 把上面的michaelliao替换成你自己的GitHub账户名，learngit改为你自己的仓库名。
      • 添加后，远程库的名字就是origin，这是Git默认的叫法，也可以改成别的，但是origin这个名字一看就知道是远程库。

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

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

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

      $ git push origin master

      把本地master分支的最新修改推送至GitHub。

  • 如果是从零开发，那么最好的方式是先创建远程库，然后，从远程库克隆。

    1. 首先创建一个新的仓库，名字叫gitskills。

    2. 在，远程库已经准备好了，下一步是用命令git clone克隆一个本地库。

      $ git clone git@github.com:michaelliao/gitskills.git

      注意把Git库的地址换成自己的。

    3. 如果有多个人协作开发，那么每个人各自从远程克隆一份就可以了。

4、分支管理

（1）创建与合并分支

  • 分支管理的目的是，为了在多人协作中互不影响，每个人可以现在自己的分支上进行开发， 等到开发完成后在进行分支合并。

  • 一开始的时候，master分支是一条线，Git用master指向最新的提交，再用HEAD指向master，就能确定当前分支，以及当前分支的提交点。每次提交，master分支都会向前移动一步。

  • 当我们创建新的分支，例如dev时，Git新建了一个指针叫dev，指向master相同的提交，再把HEAD指向dev，就表示当前分支在dev上。

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

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

  • 合并完分支后，甚至可以删除dev分支。删除dev分支就是把dev指针给删掉，删掉后，我们就剩下了一条master分支。

  • 首先，创建dev分支，然后切换到dev分支：

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

    git checkout命令加上-b参数表示创建并切换，相当于以下两条命令：

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

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

    $ git branch
* dev
  master

    git branch命令会列出所有分支，当前分支前面会标一个*号。

  • 然后，我们就可以在dev分支上正常提交，比如对readme.md做个修改，加上一行并提交：

    $ cat readme.md
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.
Creating a new branch is quick.
$ git add readme.md
$ git commit -m "branch test"
[dev dba7ae6] branch test
 1 file changed, 2 insertions(+), 1 deletion(-)

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

    $ git checkout master
Switched to branch 'master'

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

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

    $ git merge dev
Updating 146fc06..dba7ae6
Fast-forward
 readme.md | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

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

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

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

  • 最新版本的Git提供了新的git switch命令来切换分支：

    # 创建并切换到新的dev分支，可以使用
$ git switch -c dev
# 直接切换到已有的master分支，可以使用：
$ git switch master

  • 小结：

    • 查看分支：git branch。
    • 创建分支：git branch 。
    • 切换分支：git checkout 或者git switch 。
    • 创建+切换分支：git checkout -b 或者git switch -c 。
    • 合并某分支到当前分支：git merge 。
    • 删除分支：git branch -d 。

（2）分支中的冲突

  • 分支有时会产生冲突，例如：

  • 准备新的feature1分支，继续我们的新分支开发，并在该分支上提交，最后切换到master分支：

    $ git switch -c feature1
Switched to a new branch 'feature1'
# 修改readme.md最后一行，改为：
Creating a new branch is quick AND simple.
$ git add readme.md
$ git commit -m "AND simple"
[feature1 c31f599] AND simple
 1 file changed, 2 insertions(+), 1 deletion(-)
 $ git switch master
Switched to branch 'master'

  • 在master分支上进行修改并提交：

    # 在master分支上把readme.txt文件的最后一行改为：
Creating a new branch is quick & simple.
$ git add readme.md
$ git commit -m "& simple"
[master 737f4c7] & simple
 1 file changed, 1 insertion(+), 1 deletion(-)

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

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

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

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

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

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

  • 可以直接查看``readme.md`的内容：

    $ cat readme.md
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.
<<<<<<< HEAD
Creating a new branch is quick & simple.
=======
Creating a new branch is quick AND simple.
>>>>>>> feature1

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

    # 在master分支上把readme.txt文件的最后一行改为
Creating a new branch is quick and simple.
$ git add readme.md
$ git commit -m "conflict fixed"
[master 250b0e9] conflict fixed

  • 现在，master分支和feature1分支变成了下图所示：

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

    $ git log --graph --pretty=oneline --abbrev-commit
*   250b0e9 (HEAD -> master) conflict fixed
|\
| * e3ce034 (feature1) AND simple
* | 737f4c7 & simple
|/
* dba7ae6 branch test
* 146fc06 remove test.txt
* e2bf2cb add test.txt
* 2140aed git tracks changes
* 5f08cd6 back
* 5ff87e2 git tracks changes
* c4490ac add LICENSE
* b28a339 add distruibuted
* dfc9d4e wrote a readme file

  • 最后，删除feature1分支：

    $ git branch -d feature1
Deleted branch feature1 (was e3ce034).

（3）分支管理

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

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

  • 禁用Fast forward的合并分支，因为本次合并要创建一个新的commit，所以加上-m参数，把commit描述写进去。：

    $ git merge --no-ff -m "merge with no-ff" dev

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

    • 首先，master分支应该是非常稳定的，也就是仅用来发布新版本，平时不能在上面干活；
    • 那在哪干活呢？干活都在dev分支上，也就是说，dev分支是不稳定的，到某个时候，比如1.0版本发布时，再把dev分支合并到master上，在master分支发布1.0版本。

  • BUG分支：当你接到一个修复一个代号101的bug的任务时，很自然地，你想创建一个分支issue-101来修复它。

    • 但是，当前正在dev上进行的工作还没有提交。Git还提供了一个stash功能，可以把当前工作现场“储藏”起来，等以后恢复现场后继续工作：

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

      现在，用git status查看工作区，就是干净的，因此可以放心地创建分支来修复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.md
$ git commit -m "fix bug 101"
[issue-101 4c805e2] fix bug 101
 1 file changed, 1 insertion(+), 1 deletion(-)

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

      $ git switch 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(-)

    • 工作区是干净的，刚才的工作现场存到哪去了？用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查看，然后用命令$ git stash apply stash@{0}恢复指定的stash。

  • 同样的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的过程重复一遍。

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

    • 现在，你终于接到了一个新任务：开发代号为Vulcan的新功能。于是准备开发：

      $ git switch -c feature-vulcan
Switched to a new branch 'feature-vulcan'

    • 开发完毕并添加提交：

      $ 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 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).

  • 小结：

    • 修复bug时，我们会通过创建新的bug分支进行修复，然后合并，最后删除；
    • 当手头工作没有完成时，先把工作现场git stash一下，然后去修复bug，修复后，再git stash pop，回到工作现场；
    • 在master分支上修复的bug，想要合并到当前dev分支，可以用git cherry-pick 命令，把bug提交的修改“复制”到当前分支，避免重复劳动。
    • 如果要丢弃一个没有被合并过的分支，可以通过git branch -D 强行删除。

（4）多人协作

  • 当你从远程仓库克隆时，实际上Git自动把本地的master分支和远程的master分支对应起来了，并且，远程仓库的默认名称是origin。要查看远程库的信息，用git remote：

    $ git remote
origin

    或者，用git remote -v显示更详细的信息：

    $ git remote -v
origin  git@github.com:michaelliao/learngit.git (fetch)
origin  git@github.com:michaelliao/learngit.git (push)

    上面显示了可以抓取和推送的origin的地址。如果没有推送权限，就看不到push的地址。

  • 推送分支：就是把该分支上的所有本地提交推送到远程库。推送时，要指定本地分支，这样，Git就会把该分支推送到远程库对应的远程分支上：

    $ git push origin master

    如果要推送其他分支，比如dev，就改成：

    $ git push origin dev

  • 哪些分支需要推送，哪些不需要呢？

    • master分支是主分支，因此要时刻与远程同步；
    • dev分支是开发分支，团队所有成员都需要在上面工作，所以也需要与远程同步；
    • bug分支只用于在本地修复bug，就没必要推到远程了，除非老板要看看你每周到底修复了几个bug；
    • feature分支是否推到远程，取决于你是否和你的小伙伴合作在上面开发。

  • 抓取分支：多人协作时，大家都会往master和dev分支上推送各自的修改。现在，模拟一个你的小伙伴，可以在另一台电脑（注意要把SSH Key添加到GitHub）或者同一台电脑的另一个目录下克隆：

    $ git clone git@github.com:michaelliao/learngit.git
Cloning into 'learngit'...
remote: Counting objects: 40, done.
remote: Compressing objects: 100% (21/21), done.
remote: Total 40 (delta 14), reused 40 (delta 14), pack-reused 0
Receiving objects: 100% (40/40), done.
Resolving deltas: 100% (14/14), done.

  • 当你的小伙伴从远程库clone时，默认情况下，你的小伙伴只能看到本地的master分支。不信可以用git branch命令看看：

    $ git branch
* master

  • 现在，你的小伙伴要在dev分支上开发，就必须创建远程origin的dev分支到本地，于是他用这个命令创建本地dev分支：

    $ git checkout -b dev origin/dev

  • 现在，他就可以在dev上继续修改，然后，时不时地把dev分支push到远程：

    $ git add env.txt

$ git commit -m "add env"
[dev 7a5e5dd] add env
 1 file changed, 1 insertion(+)
 create mode 100644 env.txt

$ git push origin dev
Counting objects: 3, done.
Delta compression using up to 4 threads.
Compressing objects: 100% (2/2), done.
Writing objects: 100% (3/3), 308 bytes | 308.00 KiB/s, done.
Total 3 (delta 0), reused 0 (delta 0)
To github.com:michaelliao/learngit.git
   f52c633..7a5e5dd  dev -> dev

  • 你的小伙伴已经向origin/dev分支推送了他的提交，而碰巧你也对同样的文件作了修改，并试图推送：

    $ cat env.txt
env

$ git add env.txt

$ git commit -m "add new env"
[dev 7bd91f1] add new env
 1 file changed, 1 insertion(+)
 create mode 100644 env.txt

$ git push origin dev
To github.com:michaelliao/learngit.git
 ! [rejected]        dev -> dev (non-fast-forward)
error: failed to push some refs to 'git@github.com:michaelliao/learngit.git'
hint: Updates were rejected because the tip of your current branch is behind
hint: its remote counterpart. Integrate the remote changes (e.g.
hint: 'git pull ...') before pushing again.
hint: See the 'Note about fast-forwards' in 'git push --help' for details.

    • 推送失败，因为你的小伙伴的最新提交和你试图推送的提交有冲突，解决办法也很简单，Git已经提示我们，先用git pull把最新的提交从origin/dev抓下来，然后，在本地合并，解决冲突，再推送：

      $ git pull
There is no tracking information for the current branch.
Please specify which branch you want to merge with.
See git-pull(1) for details.

    git pull <remote> <branch>

If you wish to set tracking information for this branch you can do so with:

    git branch --set-upstream-to=origin/<branch> dev

    • git pull也失败了，原因是没有指定本地dev分支与远程origin/dev分支的链接，根据提示，设置dev和origin/dev的链接：

      $ git branch --set-upstream-to=origin/dev dev
Branch 'dev' set up to track remote branch 'dev' from 'origin'.

    • 再pull。这回git pull成功，但是合并有冲突，需要手动解决，解决的方法和分支管理中的解决冲突完全一样。解决后，提交，再push：

      $ git pull
Auto-merging env.txt
CONFLICT (add/add): Merge conflict in env.txt
Automatic merge failed; fix conflicts and then commit the result.
$ git commit -m "fix env conflict"
[dev 57c53ab] fix env conflict

$ git push origin dev
Counting objects: 6, done.
Delta compression using up to 4 threads.
Compressing objects: 100% (4/4), done.
Writing objects: 100% (6/6), 621 bytes | 621.00 KiB/s, done.
Total 6 (delta 0), reused 0 (delta 0)
To github.com:michaelliao/learngit.git
   7a5e5dd..57c53ab  dev -> dev

  • 因此，多人协作的工作模式通常是这样：

    1. 首先，可以试图用git push origin 推送自己的修改；
    2. 如果推送失败，则因为远程分支比你的本地更新，需要先用git pull试图合并；
    3. 如果合并有冲突，则解决冲突，并在本地提交；
    4. 没有冲突或者解决掉冲突后，再用git push origin 推送就能成功。
    5. 如果git pull提示no tracking information，则说明本地分支和远程分支的链接关系没有创建，用命令git branch --set-upstream-to <branch-name> origin/<branch-name>。

  • 小结：

    • 查看远程库信息，使用git remote -v；
    • 本地新建的分支如果不推送到远程，对其他人就是不可见的；
    • 从本地推送分支，使用git push origin branch-name，如果推送失败，先用git pull抓取远程的新提交；
    • 在本地创建和远程分支对应的分支，使用git checkout -b branch-name origin/branch-name，本地和远程分支的名称最好一致；
    • 建立本地分支和远程分支的关联，使用git branch --set-upstream branch-name origin/branch-name；
    • 从远程抓取分支，使用git pull，如果有冲突，要先处理冲突。

（5）Rebase

  • 多人在同一个分支上协作时，很容易出现冲突。即使没有冲突，后push的人不得不先pull，在本地合并，然后才能push成功。每次合并再push后，分支变成了这样：

    $ git log --graph --pretty=oneline --abbrev-commit
* d1be385 (HEAD -> master, origin/master) init hello
*   e5e69f1 Merge branch 'dev'
|\  
| *   57c53ab (origin/dev, dev) fix env conflict
| |\  
| | * 7a5e5dd add env
| * | 7bd91f1 add new env
| |/  
* |   12a631b merged bug fix 101
|\ \  
| * | 4c805e2 fix bug 101
|/ /  
* |   e1e9c68 merge with no-ff
|\ \  
| |/  
| * f52c633 add merge
|/  
*   cf810e4 conflict fixed

    总之看上去很乱，为了让Git的提交历史变成一条干净的直线。Git有一种称为rebase的操作，有人把它翻译成“变基”。

  • 在和远程分支同步后，我们对hello.py这个文件做了两次提交。用git log命令看看：

    $ git log --graph --pretty=oneline --abbrev-commit
* 582d922 (HEAD -> master) add author
* 8875536 add comment
* d1be385 (origin/master) init hello
*   e5e69f1 Merge branch 'dev'
|\  
| *   57c53ab (origin/dev, dev) fix env conflict
| |\  
| | * 7a5e5dd add env
| * | 7bd91f1 add new env
...

    注意到Git用(HEAD -> master)和(origin/master)标识出当前分支的HEAD和远程origin的位置分别是582d922 add author和d1be385 init hello，本地分支比远程分支快两个提交。

  • 现在我们尝试推送本地分支：

    $ git push origin master
To github.com:michaelliao/learngit.git
 ! [rejected]        master -> master (fetch first)
error: failed to push some refs to 'git@github.com:michaelliao/learngit.git'
hint: Updates were rejected because the remote contains work that you do
hint: not have locally. This is usually caused by another repository pushing
hint: to the same ref. You may want to first integrate the remote changes
hint: (e.g., 'git pull ...') before pushing again.
hint: See the 'Note about fast-forwards' in 'git push --help' for details.

    很不幸，失败了，这说明有人先于我们推送了远程分支。按照经验，先pull一下：

    $ git pull
remote: Counting objects: 3, done.
remote: Compressing objects: 100% (1/1), done.
remote: Total 3 (delta 1), reused 3 (delta 1), pack-reused 0
Unpacking objects: 100% (3/3), done.
From github.com:michaelliao/learngit
   d1be385..f005ed4  master     -> origin/master
 * [new tag]         v1.0       -> v1.0
Auto-merging hello.py
Merge made by the 'recursive' strategy.
 hello.py | 1 +
 1 file changed, 1 insertion(+)

    再用git status看看状态：

    $ git status
On branch master
Your branch is ahead of 'origin/master' by 3 commits.
  (use "git push" to publish your local commits)

nothing to commit, working tree clean

    加上刚才合并的提交，现在我们本地分支比远程分支超前3个提交。用git log看看：

    $ git log --graph --pretty=oneline --abbrev-commit
*   e0ea545 (HEAD -> master) Merge branch 'master' of github.com:michaelliao/learngit
|\  
| * f005ed4 (origin/master) set exit=1
* | 582d922 add author
* | 8875536 add comment
|/  
* d1be385 init hello
...

  • 提交历史分叉了。这个时候，rebase就派上了用场。我们输入命令git rebase试试：

    $ git rebase
First, rewinding head to replay your work on top of it...
Applying: add comment
Using index info to reconstruct a base tree...
M	hello.py
Falling back to patching base and 3-way merge...
Auto-merging hello.py
Applying: add author
Using index info to reconstruct a base tree...
M	hello.py
Falling back to patching base and 3-way merge...
Auto-merging hello.py

    再用git log看看：

    $ git log --graph --pretty=oneline --abbrev-commit
* 7e61ed4 (HEAD -> master) add author
* 3611cfe add comment
* f005ed4 (origin/master) set exit=1
* d1be385 init hello
...

  • 原本分叉的提交现在变成一条直线了！这种神奇的操作是怎么实现的？其实原理非常简单。我们注意观察，发现Git把我们本地的提交“挪动”了位置，放到了f005ed4 (origin/master) set exit=1之后，这样，整个提交历史就成了一条直线。rebase操作前后，最终的提交内容是一致的，但是，我们本地的commit修改内容已经变化了，它们的修改不再基于d1be385 init hello，而是基于f005ed4 (origin/master) set exit=1，但最后的提交7e61ed4内容是一致的。

  • 这就是rebase操作的特点：把分叉的提交历史“整理”成一条直线，看上去更直观。缺点是本地的分叉提交已经被修改过了。

  • 最后，通过push操作把本地分支推送到远程。再用git log看看效果：

    Mac:~/learngit michael$ git push origin master
Counting objects: 6, done.
Delta compression using up to 4 threads.
Compressing objects: 100% (5/5), done.
Writing objects: 100% (6/6), 576 bytes | 576.00 KiB/s, done.
Total 6 (delta 2), reused 0 (delta 0)
remote: Resolving deltas: 100% (2/2), completed with 1 local object.
To github.com:michaelliao/learngit.git
   f005ed4..7e61ed4  master -> master
   
$ git log --graph --pretty=oneline --abbrev-commit
* 7e61ed4 (HEAD -> master, origin/master) add author
* 3611cfe add comment
* f005ed4 set exit=1
* d1be385 init hello
...

    远程分支的提交历史也是一条直线。

5、标签管理

  • 发布一个版本时，我们通常先在版本库中打一个标签（tag），这样，就唯一确定了打标签时刻的版本。将来无论什么时候，取某个标签的版本，就是把那个打标签的时刻的历史版本取出来。所以，标签也是版本库的一个快照。

  • Git的标签虽然是版本库的快照，但其实它就是指向某个commit的指针（跟分支很像，但是分支可以移动，标签不能移动）。

  • tag就是一个让人容易记住的有意义的名字，它跟某个commit绑在一起。

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

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

  • 然后，敲命令git tag 就可以打一个新标签：

    $ git tag v1.0

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

    $ git tag
v1.0

  • 如果忘了打标签，也可以找到历史提交的commit id，然后打上就可以了：

    $ 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 show 查看标签信息：

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

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

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

  • 用命令git show 可以看到说明文字：

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

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

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

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

    $ 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 tag 用于新建一个标签，默认为HEAD，也可以指定一个commit id；
    • 命令git tag -a -m "blablabla..."可以指定标签信息；
    • 命令git tag可以查看所有标签。
    • 命令git push origin 可以推送一个本地标签；
    • 命令git push origin --tags可以推送全部未推送过的本地标签；
    • 命令git tag -d 可以删除一个本地标签；
    • 命令git push origin :refs/tags/可以删除一个远程标签。

6、使用GitHub

  • 如何参与一个开源项目呢？比如人气极高的bootstrap项目，这是一个非常强大的CSS框架，你可以访问它的项目主页https://github.com/twbs/bootstrap，点“Fork”就在自己的账号下克隆了一个bootstrap仓库，然后，从自己的账号下clone：

    git clone git@github.com:michaelliao/bootstrap.git

  • 一定要从自己的账号下clone仓库，这样你才能推送修改。如果从bootstrap的作者的仓库地址git@github.com:twbs/bootstrap.git克隆，因为没有权限，你将不能推送修改。

  • 如果你希望bootstrap的官方库能接受你的修改，你就可以在GitHub上发起一个pull request。当然，对方是否接受你的pull request就不一定了。


iwehdio的博客园：https://www.cnblogs.com/iwehdio/

posted @ 2020-05-10 20:24  iwehdio  阅读(182)  评论(0)  编辑  收藏  举报