git 订阅
Git(读音为/gɪt/)是一个开源的分布式版本控制系统,可以有效、高速地处理从很小到非常大的项目版本管理。 [1]  Git 是 Linus Torvalds 为了帮助管理 Linux 内核开发而开发的一个开放源码的版本控制软件。Torvalds 开始着手开发 Git 是为了作为一种过渡方案来替代 BitKeeper [1]  。 展开全文
Git(读音为/gɪt/)是一个开源的分布式版本控制系统,可以有效、高速地处理从很小到非常大的项目版本管理。 [1]  Git 是 Linus Torvalds 为了帮助管理 Linux 内核开发而开发的一个开放源码的版本控制软件。Torvalds 开始着手开发 Git 是为了作为一种过渡方案来替代 BitKeeper [1]  。
信息
软件授权
GNU General Public License version 2.0 [4]
软件名称
Git
更新时间
2020-04-19 [2]
软件版本
2.26.2 [2]
软件平台
Windows、Mac OS X、Linux/Unix [2]
软件语言
C、Shell、Perl、Tcl、Python、Makefile等 [3]
GIT特点
分布式相比于集中式的最大区别在于开发者可以提交到本地,每个开发者通过克隆(git clone),在本地机器上拷贝一个完整的Git仓库。下图是经典的git开发过程。 Git的功能特性:从一般开发者的角度来看,git有以下功能:1、从服务器上克隆完整的Git仓库(包括代码和版本信息)到单机上。2、在自己的机器上根据不同的开发目的,创建分支,修改代码。3、在单机上自己创建的分支上提交代码。4、在单机上合并分支。5、把服务器上最新版的代码fetch下来,然后跟自己的主分支合并。6、生成补丁(patch),把补丁发送给主开发者。7、看主开发者的反馈,如果主开发者发现两个一般开发者之间有冲突(他们之间可以合作解决的冲突),就会要求他们先解决冲突,然后再由其中一个人提交。如果主开发者可以自己解决,或者没有冲突,就通过。8、一般开发者之间解决冲突的方法,开发者之间可以使用pull 命令解决冲突,解决完冲突之后再向主开发者提交补丁。从主开发者的角度(假设主开发者不用开发代码)看,git有以下功能:1、查看邮件或者通过其它方式查看一般开发者的提交状态。2、打上补丁,解决冲突(可以自己解决,也可以要求开发者之间解决以后再重新提交,如果是开源项目,还要决定哪些补丁有用,哪些不用)。3、向公共服务器提交结果,然后通知所有开发人员。优点:适合分布式开发,强调个体。公共服务器压力和数据量都不会太大。速度快、灵活。任意两个开发者之间可以很容易的解决冲突。离线工作。缺点:资料少(起码中文资料很少)。学习周期相对而言比较长。不符合常规思维。代码保密性差,一旦开发者把整个库克隆下来就可以完全公开所有代码和版本信息。
收起全文
精华内容
参与话题
问答
  • Git教程(完整)

    万次阅读 多人点赞 2018-06-03 21:54:04
    1.Git简介Git是目前世界上最先进的分布式版本控制系统,在处理各种项目时都十分高效,而且非常的高大上。SVN是集中式版本控制系统,版本库是集中放在中央服务器的,而干活的时候,用的都是自己的电脑,所以首先要从...

    1.Git简介

    Git是目前世界上最先进的分布式版本控制系统,在处理各种项目时都十分高效,而且非常的高大上。

    SVN是集中式版本控制系统,版本库是集中放在中央服务器的,而干活的时候,用的都是自己的电脑,所以首先要从中央服务器哪里得到最新的版本,然后干活,干完后,需要把自己做完的活推送到中央服务器。而且集中式版本控制系统是必须联网才能工作。

    Git是分布式版本控制系统,它就没有中央服务器的,每个人的电脑就是一个完整的版本库,这样,工作的时候就不需要联网了,因为版本都是在自己的电脑上。


    2.Git安装(仅列出在Windows系统下的安装过程)

    打开Git官网下载安装程序,然后按照默认选项安装即可。

    安装完成后,打开Git bash软件,弹出一个类似cmd的命令行窗口,证明安装成功。

    安装完成后,需要进行设置,在命令行输入以下代码:

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

    顾名思义,这是设置你的名字和Email地址。

    我们可以查看一下用户名和密码:

    $ git config user.name
    $ git config user.email

    假如我们这时候报错,证明Git的用户名和密码没有配置成功,我们还可以这样做:

    在用户主目录下找到 .git 文件夹:

    然后打开 config 文件,这是专门用来配置和读取相应的工作环境变量的,在里面加上如图所示内容:

    这样也就完成了对Git用户名和邮箱的配置。


    3.创建版本库

    版本库(repository)也叫仓库,可以看做一个目录,这个目录里的所以文件都由Git进行管理,每个文件的修改、删除,Git都能跟踪。

    1.选择一个合适的地方,创建一个空目录:

    $ mkdir learngit //创建一个名叫learngit的空目录
    $ cd learngit //把learngit设置为当前目录
    $ pwd //查看当前目录
    /c/Users/Administrator/learngit

    如果使用Windows系统,要保证目录名不包含中文。

    2.通过如下命令把这个目录变成Git可以管理的仓库:

    $ git init
    Initialized empty Git repository in /Users/Administrator/learngit/.git/
    这样Git就把仓库建好啦,我们可以看到在当前目录下多了一个 .git 的目录,这个目录是Git来跟踪管理版本库的。

    3.把文件添加到版本库

    我们在 learngit 目录下编写一个 readme.txt 文件,内容如下:

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

    (1) 用 git add 命令,把文件添加到仓库:

    $ git add readme.txt

    执行以上命令,没有任何显示。

    (2) 用 git commit 命令,把文件提交到仓库:

    $ git commit -m "wrote a readme file" //-m后面输入的是本次提交的说明,可以输入任意内容。
    [master (root-commit) eaadf4e] wrote a readme file
     1 file changed, 2 insertions(+) //1 file changed:1个文件被改动(新添加的readme.txt文件);2 insertions:插入了两行内容(readme.txt内有两行内容)
     create mode 100644 readme.txt


    4.修改文件

    我们已经成功添加并提交了一个 readme.txt 文件,继续修改 readme.txt 文件,改成如下内容:

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

    上面的命令告诉我们,readme.txt 文件被修改过了,但还没有准备提交的修改。

    如果我们想知道上次是怎么修改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.

    接下来还是那两步:

    (1) git add

    $ git add readme.txt
    没有任何输出,这时候可以用 git status 查看一下当前仓库状态:

    $ git status
    On branch master
    Changes to be committed: //将要被提交的文件包括 readme.txt
      (use "git reset HEAD <file>..." to unstage)
    
        modified:   readme.txt

    (2) git commit

    $ git commit -m "add distributed"
    [master e475afc] add distributed
     1 file changed, 1 insertion(+), 1 deletion(-)

    再用 git status 查看一下当前仓库状态:

    $ git status
    On branch master
    nothing to commit, working tree clean //当前没有需要提交的修改,而且,工作目录是干净的。


    5.版本回退

    如果我们继续对 readme.txt 文件进行修改,改成如下内容:

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

    然后添加并提交:

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

    到目前为止,readme.txt 文件一共有三个版本被提交到了 Git 仓库里,我们可以用 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

    我们还可以加上 --pretty=oneline 参数:

    $ git log --pretty=oneline
    1094adb7b9b3807259d8cb349e7df1d4d6477073 (HEAD -> master) append GPL
    e475afc93c209a690c39c13a46716e8fa000c366 add distributed
    eaadf4e385e865d25c48e7ca9c8395c3f7dfaef0 wrote a readme file //一大串数字是 commit id ,而且每个人的都不一样。

    好了,现在如果我们想把 readme.txt 文件退回到上一个版本,就可以使用 git reset 命令:

    $ git reset --hard HEAD^ //HEAD表示当前版本,则HEAD^表示上一个版本,那么上上版本就是HEAD^^
    HEAD is now at e475afc add distributed

    这时候用 cat 命令查看一下 readme.txt 的内容:

    $ cat readme.txt //查看 readme.txt 文件的内容
    Git is a distributed version control system.
    Git is free software.

    果然 readme.txt 文件返回到了上一个版本。


    我们现在想要回到最新的版本,还是使用 git reset 命令:

    $ git reset --hard 1094a //这里不能用HEAD而必须使用 commit id ,因为最新版本在之前返回时已经被删除了,1094a就是最新版本的 commit id,可以在之前的代码中查到
    HEAD is now at 83b0afe append GPL

    这时再查看一下 readme.txt 文件内容:

    $ cat readme.txt
    Git is a distributed version control system.
    Git is free software distributed under the GPL.
    果然,又回到了最新的版本。


    6.工作区和暂存区

    工作区(Working Directory)

    learngit 文件夹就是一个工作区。

    版本库(Repository)

    工作区有个隐藏目录 .git ,这个不算工作区,而是 Git 的版本库。

    版本库里面的 index(stage) 文件叫暂存区,还有Git为我们自动创建的第一个分支 master ,以及指向 master 的一个指针叫做 HEAD。


    前面我们提到过,如果我们想把文件添加到Git里面时,需要分两步:

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

    第二步是用 git commit 提交更改,实际上就是把暂存区的所有内容提交到当前分支。(我们现在只有唯一一个分支 master,所以现在就是往 master 分支上提交更改)


    我们可以实践一下:

    在 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 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

    现在,暂存区的状态就变成这样了:


    再使用 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

    这时候版本库就变成了这样:


    7.管理修改

    Git 如此的优秀是因为,Git 跟踪并管理的不是文件,而是修改。

    我们对 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.

    然后,添加:

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

    然后再修改 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 commit -m "git tracks changes"
    [master 519219b] git tracks changes
     1 file changed, 1 insertion(+)

    这时候我们查看一下状态:

    $ 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 commit 命令只负责把暂存区的修改提交了。

    提交后,我们可以用 git diff HEAD -- readme.txt 命令去查看工作区和版本库里面最新版本的区别:

    $ git diff HEAD -- readme.txt 
    diff --git a/readme.txt b/readme.txt
    index 76d770f..a9c5755 100644
    --- a/readme.txt
    +++ b/readme.txt
    @@ -1,4 +1,4 @@
     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 tracks changes of files.


    8.撤销修改

    假如说你在 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.

    最后一行是万万不能让BOSS看到的,应该怎么撤销呢?

    (1) 没有 git add 之前

    可以手动删除最后一行,手动把文件恢复到上一个版本的状态。然后再用 git checkout -- file 命令丢弃工作区的修改:

    $ git checkout -- readme.txt //把readme.txt文件在工作区的修改全部撤销。
    

    现在看一下 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.

    果然复原了。

    (2) git add了,但没有git commit

    这时候的修改添加到了暂存区,但没有提交到分支,用 git status 查看一下:

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

    这时候我们可以使用 git reset HEAD file 命令把把暂存区的修改撤销掉,重新放回工作区:

    $ git reset HEAD readme.txt //git reset命令既可以回退版本,也可以把暂存区的修改回退到工作区,HEAD表示最新版本。
    Unstaged changes after reset:
    M    readme.txt

    现在再用 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 //暂存区是干净的,工作区有修改。

    这时候再丢弃工作区的修改就OK了:

    $ git checkout -- readme.txt //丢弃工作区的修改。
    
    $ git status
    On branch master
    nothing to commit, working tree clean

    终于大功告成了。

    (3) 既 git add 了,也 git commit

    可以回退到上一个版本,见回退版本内容。


    9.删除文件

    在工作区即 learngit 文件夹下新建一个 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

    这时工作区和版本库就不一样了。

    现在又分两种情况:

    (1) 确实要从版本库中删除该文件,那就用 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
    这时候文件就从版本库被删除了。

    (2) 文件被删错了。因为版本库里有,所以很好恢复:

    $ git checkout -- test.txt //用版本库里的版本替换工作区的版本。


    10.远程仓库准备工作

    在开始这部分之前,我们需要自行注册GitHub账号。而且,因为你的本地Git仓库和GitHub仓库之间的传输是通过SSH加密的,所以需要设置:

    (1) 创建SSH Key。在用户主目录下,看看有没有.ssh 目录,如果有的话,看此目录下有没有 id_rsa 和 id_rsa.pub 这两个文件,如果有,直接跳到下一步。如果没有,打开Git Bash,创建SSH

    (2) 登陆GitHub,打开"Account settings"


    然后点击"Add SSH and GPG Keys",再点击"New SSH Key"进行SSH Key 的创建,填上任意 Title ,把 id_rsa.pub 中的内容复制到Key文本框内:



    11.添加远程库

    现在我们已经在本地创建了一个Git仓库了,又想在GitHub上创建一个Git仓库,然后让这两个仓库进行远程同步,这样,GitHub上的仓库既可以作为备份,又可以让其他人通过该仓库来协作。那么我们应该怎么做呢?

    首先,登陆GitHub,在右上角找到“Create a new repo”按钮,创建一个新的仓库:


    在Repository name填入 learngit (因为我已经创建完成了,所以提示此用户名存在)其他保持默认设置,点击“Create repository”按钮,就成功地创建了一个新的Git仓库:


    如上图所示我已经把本地仓库的内容推送到了GitHub上了,大家创建完以后应该是一个空的仓库。这时候我们可以在本地learngit仓库下运行命令:

    $ git remote add origin git@github.com:RFHzhj/learngit.git //“RFHzhj”是我的GitHub的账户名,你需要填写你自己的账户名

    添加后,远程库的名字就是 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:RFHzhj/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 分支关联起来,在以后的推送或者拉取时就可以简化命令。

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

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

    $ git push origin master
    
    把本地 master 分支的最新修改推送至GitHub。现在,我们拥有了真正的分布式版本库。


    12.从远程库克隆

    我们的学习过程是先有了本地库,后有了远程库,然后再对远程库进行关联。

    其实,我们大部分时候是先创建远程库,然后再从远程库克隆。




    展开全文
  • Git使用详细教程

    万次阅读 多人点赞 2018-01-02 15:41:45
    一:Git是什么?  Git是目前世界上最先进的分布式版本控制系统。  二:SVN与Git的最主要的区别?  SVN是集中式版本控制系统,版本库是集中放在中央服务器的,而干活的时候,用的都是自己的电脑,所以首先要从...

    一:Git是什么?

      Git是目前世界上最先进的分布式版本控制系统。

      二:SVN与Git的最主要的区别?

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

      Git是分布式版本控制系统,那么它就没有中央服务器的,每个人的电脑就是一个完整的版本库,这样,工作的时候就不需要联网了,因为版本都是在自己的电脑上。既然每个人的电脑都有一个完整的版本库,那多个人如何协作呢?比如说自己在电脑上改了文件A,其他人也在电脑上改了文件A,这时,你们两之间只需把各自的修改推送给对方,就可以互相看到对方的修改了。

      三:在windows上如何安装Git?

      msysgit是 windows版的Git,如下:

         

      需要从网上下载一个,然后进行默认安装即可。安装完成后,在开始菜单里面找到 "Git --> Git Bash",如下:

      

      会弹出一个类似的命令窗口的东西,就说明Git安装成功。如下:

     

      安装完成后,还需要最后一步设置,在命令行输入如下:

     

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

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

      四:如何操作?

      一:创建版本库。

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

      所以创建一个版本库也非常简单,如下我是D盘 –> www下 目录下新建一个testgit版本库。

       

      pwd 命令是用于显示当前的目录。

      1. 通过命令 git init 把这个目录变成git可以管理的仓库,如下:

          

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

        

      2. 把文件添加到版本库中。

      首先要明确下,所有的版本控制系统,只能跟踪文本文件的改动,比如txt文件,网页,所有程序的代码等,Git也不列外,版本控制系统可以告诉你每次的改动,但是图片,视频这些二进制文件,虽能也能由版本控制系统管理,但没法跟踪文件的变化,只能把二进制文件每次改动串起来,也就是知道图片从1kb变成2kb,但是到底改了啥,版本控制也不知道。

      下面先看下demo如下演示:

      我在版本库testgit目录下新建一个记事本文件 readme.txt 内容如下:11111111

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

        

      如果和上面一样,没有任何提示,说明已经添加成功了。

      第二步:用命令 git commit告诉Git,把文件提交到仓库。

       

      现在我们已经提交了一个readme.txt文件了,我们下面可以通过命令git status来查看是否还有文件未提交,如下:

      

      说明没有任何文件未提交,但是我现在继续来改下readme.txt内容,比如我在下面添加一行2222222222内容,继续使用git status来查看下结果,如下:

     

      上面的命令告诉我们 readme.txt文件已被修改,但是未被提交的修改。

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

      git diff readme.txt 如下:

     

      如上可以看到,readme.txt文件内容从一行11111111改成 二行 添加了一行22222222内容。

      知道了对readme.txt文件做了什么修改后,我们可以放心的提交到仓库了,提交修改和提交文件是一样的2步(第一步是git add  第二步是:git commit)。

      如下:

     

      二:版本回退:

      如上,我们已经学会了修改文件,现在我继续对readme.txt文件进行修改,再增加一行

      内容为33333333333333.继续执行命令如下:

       

      现在我已经对readme.txt文件做了三次修改了,那么我现在想查看下历史记录,如何查呢?我们现在可以使用命令 git log 演示如下所示:

      

      git log命令显示从最近到最远的显示日志,我们可以看到最近三次提交,最近的一次是,增加内容为333333.上一次是添加内容222222,第一次默认是 111111.如果嫌上面显示的信息太多的话,我们可以使用命令 git log –pretty=oneline 演示如下:

      

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

      

      如果想回退到上一个版本的命令如下操作:

      再来查看下 readme.txt内容如下:通过命令cat readme.txt查看

      可以看到,内容已经回退到上一个版本了。我们可以继续使用git log 来查看下历史记录信息,如下:

      我们看到 增加333333 内容我们没有看到了,但是现在我想回退到最新的版本,如:有333333的内容要如何恢复呢?我们可以通过版本号回退,使用命令方法如下:

      git reset  --hard 版本号 ,但是现在的问题假如我已经关掉过一次命令行或者333内容的版本号我并不知道呢?要如何知道增加3333内容的版本号呢?可以通过如下命令即可获取到版本号:git reflog  演示如下:

      通过上面的显示我们可以知道,增加内容3333的版本号是 6fcfc89.我们现在可以命令

      git reset  --hard 6fcfc89来恢复了。演示如下:

      可以看到 目前已经是最新的版本了。 

      三:理解工作区与暂存区的区别?

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

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

      我们前面说过使用Git提交文件到版本库有两步:

      第一步:是使用 git add 把文件添加进去,实际上就是把文件添加到暂存区。

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

      我们继续使用demo来演示下:

      我们在readme.txt再添加一行内容为4444444,接着在目录下新建一个文件为test.txt 内容为test,我们先用命令 git status来查看下状态,如下:

      现在我们先使用git add 命令把2个文件都添加到暂存区中,再使用git status来查看下状态,如下:

      接着我们可以使用git commit一次性提交到分支上,如下:

     

      四:Git撤销修改和删除文件操作。

      一:撤销修改:

      比如我现在在readme.txt文件里面增加一行 内容为555555555555,我们先通过命令查看如下:

      在我未提交之前,我发现添加5555555555555内容有误,所以我得马上恢复以前的版本,现在我可以有如下几种方法可以做修改:

      第一:如果我知道要删掉那些内容的话,直接手动更改去掉那些需要的文件,然后add添加到暂存区,最后commit掉。

      第二:我可以按以前的方法直接恢复到上一个版本。使用 git reset  --hard HEAD^

      但是现在我不想使用上面的2种方法,我想直接想使用撤销命令该如何操作呢?首先在做撤销之前,我们可以先用 git status 查看下当前的状态。如下所示:

      可以发现,Git会告诉你,git checkout  -- file 可以丢弃工作区的修改,如下命令:

      git checkout  --  readme.txt,如下所示:

      命令 git checkout --readme.txt 意思就是,把readme.txt文件在工作区做的修改全部撤销,这里有2种情况,如下:

    1. readme.txt自动修改后,还没有放到暂存区,使用 撤销修改就回到和版本库一模一样的状态。
    2. 另外一种是readme.txt已经放入暂存区了,接着又作了修改,撤销修改就回到添加暂存区后的状态。

      对于第二种情况,我想我们继续做demo来看下,假如现在我对readme.txt添加一行 内容为6666666666666,我git add 增加到暂存区后,接着添加内容7777777,我想通过撤销命令让其回到暂存区后的状态。如下所示:

      

      注意:命令git checkout -- readme.txt 中的 -- 很重要,如果没有 -- 的话,那么命令变成创建分支了。

      二:删除文件。

      假如我现在版本库testgit目录添加一个文件b.txt,然后提交。如下:

      

      如上:一般情况下,可以直接在文件目录中把文件删了,或者使用如上rm命令:rm b.txt ,如果我想彻底从版本库中删掉了此文件的话,可以再执行commit命令 提交掉,现在目录是这样的,

     

      只要没有commit之前,如果我想在版本库中恢复此文件如何操作呢?

      可以使用如下命令 git checkout  -- b.txt,如下所示:

      再来看看我们testgit目录,添加了3个文件了。如下所示:

     

      五:远程仓库。

      在了解之前,先注册github账号,由于你的本地Git仓库和github仓库之间的传输是通过SSH加密的,所以需要一点设置:

      第一步:创建SSH Key。在用户主目录下,看看有没有.ssh目录,如果有,再看看这个目录下有没有id_rsa和id_rsa.pub这两个文件,如果有的话,直接跳过此如下命令,如果没有的话,打开命令行,输入如下命令:

      ssh-keygen  -t rsa –C “youremail@example.com”, 由于我本地此前运行过一次,所以本地有,如下所示:

     

      id_rsa是私钥,不能泄露出去,id_rsa.pub是公钥,可以放心地告诉任何人。

      第二步:登录github,打开” settings”中的SSH Keys页面,然后点击“Add SSH Key”,填上任意title,在Key文本框里黏贴id_rsa.pub文件的内容。

      点击 Add Key,你就应该可以看到已经添加的key。

    1. 如何添加远程库?

      现在的情景是:我们已经在本地创建了一个Git仓库后,又想在github创建一个Git仓库,并且希望这两个仓库进行远程同步,这样github的仓库可以作为备份,又可以其他人通过该仓库来协作。

      首先,登录github上,然后在右上角找到“create a new repo”创建一个新的仓库。如下:

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

      目前,在GitHub上的这个testgit仓库还是空的,GitHub告诉我们,可以从这个仓库克隆出新的仓库,也可以把一个已有的本地仓库与之关联,然后,把本地仓库的内容推送到GitHub仓库。

      现在,我们根据GitHub的提示,在本地的testgit仓库下运行命令:

      git remote add origin https://github.com/tugenhua0707/testgit.git

      所有的如下:

      

      把本地库的内容推送到远程,使用 git push命令,实际上是把当前分支master推送到远程。

      由于远程库是空的,我们第一次推送master分支时,加上了 –u参数,Git不但会把本地的master分支内容推送的远程新的master分支,还会把本地的master分支和远程的master分支关联起来,在以后的推送或者拉取时就可以简化命令。推送成功后,可以立刻在github页面中看到远程库的内容已经和本地一模一样了,上面的要输入github的用户名和密码如下所示:

      从现在起,只要本地作了提交,就可以通过如下命令:

      git push origin master

      把本地master分支的最新修改推送到github上了,现在你就拥有了真正的分布式版本库了。

      2. 如何从远程库克隆?

      上面我们了解了先有本地库,后有远程库时候,如何关联远程库。

      现在我们想,假如远程库有新的内容了,我想克隆到本地来 如何克隆呢?

      首先,登录github,创建一个新的仓库,名字叫testgit2.如下:

      如下,我们看到:

      现在,远程库已经准备好了,下一步是使用命令git clone克隆一个本地库了。如下所示:

      接着在我本地目录下 生成testgit2目录了,如下所示:

      六:创建与合并分支。

      在版本回填退里,你已经知道,每次提交,Git都把它们串成一条时间线,这条时间线就是一个分支。截止到目前,只有一条时间线,在Git里,这个分支叫主分支,即master分支。HEAD严格来说不是指向提交,而是指向master,master才是指向提交的,所以,HEAD指向的就是当前分支。

      首先,我们来创建dev分支,然后切换到dev分支上。如下操作:

     

      git checkout 命令加上 –b参数表示创建并切换,相当于如下2条命令

      git branch dev

      git checkout dev

      git branch查看分支,会列出所有的分支,当前分支前面会添加一个星号。然后我们在dev分支上继续做demo,比如我们现在在readme.txt再增加一行 7777777777777

      首先我们先来查看下readme.txt内容,接着添加内容77777777,如下:

      现在dev分支工作已完成,现在我们切换到主分支master上,继续查看readme.txt内容如下:

      现在我们可以把dev分支上的内容合并到分支master上了,可以在master分支上,使用如下命令 git merge dev 如下所示:

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

      注意到上面的Fast-forward信息,Git告诉我们,这次合并是“快进模式”,也就是直接把master指向dev的当前提交,所以合并速度非常快。

      合并完成后,我们可以接着删除dev分支了,操作如下:

      总结创建与合并分支命令如下:

      查看分支:git branch

      创建分支:git branch name

      切换分支:git checkout name

      创建+切换分支:git checkout –b name

      合并某分支到当前分支:git merge name

      删除分支:git branch –d name

    1. 如何解决冲突?

      下面我们还是一步一步来,先新建一个新分支,比如名字叫fenzhi1,在readme.txt添加一行内容8888888,然后提交,如下所示:

      同样,我们现在切换到master分支上来,也在最后一行添加内容,内容为99999999,如下所示:

      现在我们需要在master分支上来合并fenzhi1,如下操作:

      Git用<<<<<<<,=======,>>>>>>>标记出不同分支的内容,其中<<<HEAD是指主分支修改的内容,>>>>>fenzhi1 是指fenzhi1上修改的内容,我们可以修改下如下后保存:

      如果我想查看分支合并的情况的话,需要使用命令 git log.命令行演示如下:

      3.分支管理策略。

      通常合并分支时,git一般使用”Fast forward”模式,在这种模式下,删除分支后,会丢掉分支信息,现在我们来使用带参数 –no-ff来禁用”Fast forward”模式。首先我们来做demo演示下:

    1. 创建一个dev分支。
    2. 修改readme.txt内容。
    3. 添加到暂存区。
    4. 切换回主分支(master)。
    5. 合并dev分支,使用命令 git merge –no-ff  -m “注释” dev
    6. 查看历史记录

      截图如下:

     

      分支策略:首先master主分支应该是非常稳定的,也就是用来发布新版本,一般情况下不允许在上面干活,干活一般情况下在新建的dev分支上干活,干完后,比如上要发布,或者说dev分支代码稳定后可以合并到主分支master上来。

      七:bug分支:

      在开发中,会经常碰到bug问题,那么有了bug就需要修复,在Git中,分支是很强大的,每个bug都可以通过一个临时分支来修复,修复完成后,合并分支,然后将临时的分支删除掉。

      比如我在开发中接到一个404 bug时候,我们可以创建一个404分支来修复它,但是,当前的dev分支上的工作还没有提交。比如如下:

     

      并不是我不想提交,而是工作进行到一半时候,我们还无法提交,比如我这个分支bug要2天完成,但是我issue-404 bug需要5个小时内完成。怎么办呢?还好,Git还提供了一个stash功能,可以把当前工作现场 ”隐藏起来”,等以后恢复现场后继续工作。如下:

      

      所以现在我可以通过创建issue-404分支来修复bug了。

      首先我们要确定在那个分支上修复bug,比如我现在是在主分支master上来修复的,现在我要在master分支上创建一个临时分支,演示如下:

     

      修复完成后,切换到master分支上,并完成合并,最后删除issue-404分支。演示如下:

      现在,我们回到dev分支上干活了。

      工作区是干净的,那么我们工作现场去哪里呢?我们可以使用命令 git stash list来查看下。如下:

      工作现场还在,Git把stash内容存在某个地方了,但是需要恢复一下,可以使用如下2个方法:

    1. git stash apply恢复,恢复后,stash内容并不删除,你需要使用命令git stash drop来删除。
    2. 另一种方式是使用git stash pop,恢复的同时把stash内容也删除了。

      演示如下

      八:多人协作。

      当你从远程库克隆时候,实际上Git自动把本地的master分支和远程的master分支对应起来了,并且远程库的默认名称是origin。

    1. 要查看远程库的信息 使用 git remote
    2. 要查看远程库的详细信息 使用 git remote –v

      如下演示:

     

      一:推送分支:

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

          使用命令 git push origin master

      比如我现在的github上的readme.txt代码如下:

      本地的readme.txt代码如下:

     

      现在我想把本地更新的readme.txt代码推送到远程库中,使用命令如下:

      我们可以看到如上,推送成功,我们可以继续来截图github上的readme.txt内容 如下:

      可以看到 推送成功了,如果我们现在要推送到其他分支,比如dev分支上,我们还是那个命令 git push origin dev

      那么一般情况下,那些分支要推送呢?

    1. master分支是主分支,因此要时刻与远程同步。
    2. 一些修复bug分支不需要推送到远程去,可以先合并到主分支上,然后把主分支master推送到远程去。

      二:抓取分支:

      多人协作时,大家都会往master分支上推送各自的修改。现在我们可以模拟另外一个同事,可以在另一台电脑上(注意要把SSH key添加到github上)或者同一台电脑上另外一个目录克隆,新建一个目录名字叫testgit2

      但是我首先要把dev分支也要推送到远程去,如下

      接着进入testgit2目录,进行克隆远程的库到本地来,如下:

     

      现在目录下生成有如下所示:

      现在我们的小伙伴要在dev分支上做开发,就必须把远程的origin的dev分支到本地来,于是可以使用命令创建本地dev分支:git checkout  –b dev origin/dev

      现在小伙伴们就可以在dev分支上做开发了,开发完成后把dev分支推送到远程库时。

      如下:

      小伙伴们已经向origin/dev分支上推送了提交,而我在我的目录文件下也对同样的文件同个地方作了修改,也试图推送到远程库时,如下:

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

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

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

      我们可以先来看看readme.txt内容了。

      现在手动已经解决完了,我接在需要再提交,再push到远程库里面去。如下所示:

      因此:多人协作工作模式一般是这样的:

    1. 首先,可以试图用git push origin branch-name推送自己的修改.
    2. 如果推送失败,则因为远程分支比你的本地更新早,需要先用git pull试图合并。
    3. 如果合并有冲突,则需要解决冲突,并在本地提交。再用git push origin branch-name推送。

      Git基本常用命令如下:

      mkdir:         XX (创建一个空目录 XX指目录名)

      pwd:          显示当前目录的路径。

      git init          把当前的目录变成可以管理的git仓库,生成隐藏.git文件。

      git add XX       把xx文件添加到暂存区去。

      git commit –m “XX”  提交文件 –m 后面的是注释。

      git status        查看仓库状态

      git diff  XX      查看XX文件修改了那些内容

      git log          查看历史记录

      git reset  --hard HEAD^ 或者 git reset  --hard HEAD~ 回退到上一个版本

      (如果想回退到100个版本,使用git reset –hard HEAD~100 )

      cat XX         查看XX文件内容

      git reflog       查看历史记录的版本号id

      git checkout -- XX  把XX文件在工作区的修改全部撤销。

      git rm XX          删除XX文件

      git remote add origin https://github.com/tugenhua0707/testgit 关联一个远程库

      git push –u(第一次要用-u 以后不需要) origin master 把当前master分支推送到远程库

      git clone https://github.com/tugenhua0707/testgit  从远程库中克隆

      git checkout –b dev  创建dev分支 并切换到dev分支上

      git branch  查看当前所有的分支

      git checkout master 切换回master分支

      git merge dev    在当前的分支上合并dev分支

      git branch –d dev 删除dev分支

      git branch name  创建分支

      git stash 把当前的工作隐藏起来 等以后恢复现场后继续工作

      git stash list 查看所有被隐藏的文件列表

      git stash apply 恢复被隐藏的文件,但是内容不删除

      git stash drop 删除文件

      git stash pop 恢复文件的同时 也删除文件

      git remote 查看远程库的信息

      git remote –v 查看远程库的详细信息

      git push origin master  Git会把master分支推送到远程库对应的远程分支上

    原文地址:http://www.imooc.com/article/20411

     

    展开全文
  • Git实战视频教程

    万人学习 2016-05-05 21:26:47
    Git视频培训课程通过深入浅出的内部机制解析、实际操作、动画演示、使用场景模拟等教学方式,让你提升Git技能,知其然知其所以然,大大缩短您的Git学习曲线,节省您的时间成本!本教程适用于开发者,如果您是企业Git...
  • git最新版下载(Git-2.14.1-64-bit.exe)

    千次下载 热门讨论 2017-08-11 17:29:47
    git下载,上传百度云吧
  • Git是用于Linux内核开发的版本控制工具。与CVS、Subversion一类的集中式版本控制工具不同,它采用了分布式版本库的作法,不需要服务器端软件,就可以运作版本控制,使得源代码的发布和交流极其方便。Git的速度很快,...
  • 预警:因为详细,所以行文有些长,新手边看边操作效果出乎你的预料)一:Git是什么?Git是目前世界上最先进的分布式版本控制系统。工作原理 / 流程:Workspace:工作区Index / Stage:暂存区Repository:仓库区(或...

    预警:因为详细,所以行文有些长,新手边看边操作效果出乎你的预料)
    一:Git是什么?
    Git是目前世界上最先进的分布式版本控制系统。
    工作原理 / 流程:
    图片描述
    Workspace:工作区
    Index / Stage:暂存区
    Repository:仓库区(或本地仓库)
    Remote:远程仓库

    二:SVN与Git的最主要的区别?

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

    Git是分布式版本控制系统,那么它就没有中央服务器的,每个人的电脑就是一个完整的版本库,这样,工作的时候就不需要联网了,因为版本都是在自己的电脑上。既然每个人的电脑都有一个完整的版本库,那多个人如何协作呢?比如说自己在电脑上改了文件A,其他人也在电脑上改了文件A,这时,你们两之间只需把各自的修改推送给对方,就可以互相看到对方的修改了。

    三、在windows上如何安装Git?

    msysgit是 windows版的Git,如下:
    图片描述
    需要从网上下载一个,然后进行默认安装即可。安装完成后,在开始菜单里面找到 "Git --> Git Bash",如下:
    图片描述
    会弹出一个类似的命令窗口的东西,就说明Git安装成功。如下:
    图片描述

    安装完成后,还需要最后一步设置,在命令行输入如下:

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

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

    四:如何操作?

    一:创建版本库。

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

    所以创建一个版本库也非常简单,如下我是D盘 –> www下 目录下新建一个testgit版本库。

    图片描述
    pwd 命令是用于显示当前的目录。

    1. 通过命令 git init 把这个目录变成git可以管理的仓库,如下:

      图片描述

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

      图片描述

      1. 把文件添加到版本库中。

        首先要明确下,所有的版本控制系统,只能跟踪文本文件的改动,比如txt文件,网页,所有程序的代码等,Git也不列外,版本控制系统可以告诉你每次的改动,但是图片,视频这些二进制文件,虽能也能由版本控制系统管理,但没法跟踪文件的变化,只能把二进制文件每次改动串起来,也就是知道图片从1kb变成2kb,但是到底改了啥,版本控制也不知道。

      下面先看下demo如下演示:

      我在版本库testgit目录下新建一个记事本文件 readme.txt 内容如下:11111111

      第一步:使用命令 git add readme.txt添加到暂存区里面去。如下:
      图片描述
      如果和上面一样,没有任何提示,说明已经添加成功了。

      第二步:用命令 git commit告诉Git,把文件提交到仓库。
      图片描述
      现在我们已经提交了一个readme.txt文件了,我们下面可以通过命令git status来查看是否还有文件未提交,如下:
      图片描述
      说明没有任何文件未提交,但是我现在继续来改下readme.txt内容,比如我在下面添加一行2222222222内容,继续使用git status来查看下结果,如下:
      图片描述
      上面的命令告诉我们 readme.txt文件已被修改,但是未被提交的修改。

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

    git diff readme.txt 如下:
    图片描述
    如上可以看到,readme.txt文件内容从一行11111111改成 二行 添加了一行22222222内容。

    知道了对readme.txt文件做了什么修改后,我们可以放心的提交到仓库了,提交修改和提交文件是一样的2步(第一步是git add 第二步是:git commit)。

    如下:
    图片描述
    二:版本回退:
    如上,我们已经学会了修改文件,现在我继续对readme.txt文件进行修改,再增加一行

    内容为33333333333333.继续执行命令如下:

    图片描述
    现在我已经对readme.txt文件做了三次修改了,那么我现在想查看下历史记录,如何查呢?我们现在可以使用命令 git log 演示如下所示:
    图片描述
    git log命令显示从最近到最远的显示日志,我们可以看到最近三次提交,最近的一次是,增加内容为333333.上一次是添加内容222222,第一次默认是 111111.如果嫌上面显示的信息太多的话,我们可以使用命令 git log –pretty=oneline 演示如下:
    图片描述
    现在我想使用版本回退操作,我想把当前的版本回退到上一个版本,要使用什么命令呢?可以使用如下2种命令,第一种是:git reset --hard HEAD^ 那么如果要回退到上上个版本只需把HEAD^ 改成 HEAD^^ 以此类推。那如果要回退到前100个版本的话,使用上面的方法肯定不方便,我们可以使用下面的简便命令操作:git reset --hard HEAD~100 即可。未回退之前的readme.txt内容如下:
    图片描述
    如果想回退到上一个版本的命令如下操作:

    图片描述

    再来查看下 readme.txt内容如下:通过命令cat readme.txt查看
    图片描述

    可以看到,内容已经回退到上一个版本了。我们可以继续使用git log 来查看下历史记录信息,如下:
    图片描述

    我们看到 增加333333 内容我们没有看到了,但是现在我想回退到最新的版本,如:有333333的内容要如何恢复呢?我们可以通过版本号回退,使用命令方法如下:

    git reset --hard 版本号 ,但是现在的问题假如我已经关掉过一次命令行或者333内容的版本号我并不知道呢?要如何知道增加3333内容的版本号呢?可以通过如下命令即可获取到版本号:git reflog 演示如下:
    图片描述

    通过上面的显示我们可以知道,增加内容3333的版本号是 6fcfc89.我们现在可以命令

    git reset --hard 6fcfc89来恢复了。演示如下:
    图片描述

    可以看到 目前已经是最新的版本了。

    三:理解工作区与暂存区的区别?
    工作区:就是你在电脑上看到的目录,比如目录下testgit里的文件(.git隐藏目录版本库除外)。或者以后需要再新建的目录文件等等都属于工作区范畴。
    版本库(Repository):工作区有一个隐藏目录.git,这个不属于工作区,这是版本库。其中版本库里面存了很多东西,其中最重要的就是stage(暂存区),还有Git为我们自动创建了第一个分支master,以及指向master的一个指针HEAD。

    我们前面说过使用Git提交文件到版本库有两步:

    第一步:是使用 git add 把文件添加进去,实际上就是把文件添加到暂存区。

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

    我们继续使用demo来演示下:

    我们在readme.txt再添加一行内容为4444444,接着在目录下新建一个文件为test.txt 内容为test,我们先用命令 git status来查看下状态,如下:

    图片描述

    现在我们先使用git add 命令把2个文件都添加到暂存区中,再使用git status来查看下状态,如下:

    图片描述

    接着我们可以使用git commit一次性提交到分支上,如下:

    图片描述

    四:Git撤销修改和删除文件操作。
    一:撤销修改:
    比如我现在在readme.txt文件里面增加一行 内容为555555555555,我们先通过命令查看如下:
    图片描述
    在我未提交之前,我发现添加5555555555555内容有误,所以我得马上恢复以前的版本,现在我可以有如下几种方法可以做修改:

    第一:如果我知道要删掉那些内容的话,直接手动更改去掉那些需要的文件,然后add添加到暂存区,最后commit掉。

    第二:我可以按以前的方法直接恢复到上一个版本。使用 git reset --hard HEAD^

    但是现在我不想使用上面的2种方法,我想直接想使用撤销命令该如何操作呢?首先在做撤销之前,我们可以先用 git status 查看下当前的状态。如下所示:

    图片描述

    可以发现,Git会告诉你,git checkout -- file 可以丢弃工作区的修改,如下命令:
    git checkout -- readme.txt,如下所示:

    图片描述

    命令 git checkout --readme.txt 意思就是,把readme.txt文件在工作区做的修改全部撤销,这里有2种情况,如下:

    1.readme.txt自动修改后,还没有放到暂存区,使用 撤销修改就回到和版本库一模一样的状态。
    2.另外一种是readme.txt已经放入暂存区了,接着又作了修改,撤销修改就回到添加暂存区后的状态。
    对于第二种情况,我想我们继续做demo来看下,假如现在我对readme.txt添加一行 内容为6666666666666,我git add 增加到暂存区后,接着添加内容7777777,我想通过撤销命令让其回到暂存区后的状态。如下所示:

    图片描述

    注意:命令git checkout -- readme.txt 中的 -- 很重要,如果没有 -- 的话,那么命令变成创建分支了。

    二:删除文件。
    假如我现在版本库testgit目录添加一个文件b.txt,然后提交。如下:
    图片描述

    如上:一般情况下,可以直接在文件目录中把文件删了,或者使用如上rm命令:rm b.txt ,如果我想彻底从版本库中删掉了此文件的话,可以再执行commit命令 提交掉,现在目录是这样的,

    图片描述

    只要没有commit之前,如果我想在版本库中恢复此文件如何操作呢?

    可以使用如下命令 git checkout -- b.txt,如下所示:

    图片描述

    再来看看我们testgit目录,添加了3个文件了。如下所示:

    图片描述

    五:远程仓库。
    在了解之前,先注册github账号,由于你的本地Git仓库和github仓库之间的传输是通过SSH加密的,所以需要一点设置:
    第一步:创建SSH Key。在用户主目录下,看看有没有.ssh目录,如果有,再看看这个目录下有没有id_rsa和id_rsa.pub这两个文件,如果有的话,直接跳过此如下命令,如果没有的话,打开命令行,输入如下命令:

    ssh-keygen -t rsa –C “youremail@example.com”, 由于我本地此前运行过一次,所以本地有,如下所示:

    图片描述

    id_rsa是私钥,不能泄露出去,id_rsa.pub是公钥,可以放心地告诉任何人。

    第二步:登录github,打开” settings”中的SSH Keys页面,然后点击“Add SSH Key”,填上任意title,在Key文本框里黏贴id_rsa.pub文件的内容。
    图片描述

    点击 Add Key,你就应该可以看到已经添加的key。
    图片描述

    如何添加远程库?
    现在的情景是:我们已经在本地创建了一个Git仓库后,又想在github创建一个Git仓库,并且希望这两个仓库进行远程同步,这样github的仓库可以作为备份,又可以其他人通过该仓库来协作。

    首先,登录github上,然后在右上角找到“create a new repo”创建一个新的仓库。如下:

    图片描述

    在Repository name填入testgit,其他保持默认设置,点击“Create repository”按钮,就成功地创建了一个新的Git仓库:
    图片描述

    目前,在GitHub上的这个testgit仓库还是空的,GitHub告诉我们,可以从这个仓库克隆出新的仓库,也可以把一个已有的本地仓库与之关联,然后,把本地仓库的内容推送到GitHub仓库。

    现在,我们根据GitHub的提示,在本地的testgit仓库下运行命令:

    git remote add origin https://github.com/tugenhua0707/testgit.git

    所有的如下:
    图片描述

    把本地库的内容推送到远程,使用 git push命令,实际上是把当前分支master推送到远程。

    由于远程库是空的,我们第一次推送master分支时,加上了 –u参数,Git不但会把本地的master分支内容推送的远程新的master分支,还会把本地的master分支和远程的master分支关联起来,在以后的推送或者拉取时就可以简化命令。推送成功后,可以立刻在github页面中看到远程库的内容已经和本地一模一样了,上面的要输入github的用户名和密码如下所示:
    图片描述

    从现在起,只要本地作了提交,就可以通过如下命令:

    git push origin master

    把本地master分支的最新修改推送到github上了,现在你就拥有了真正的分布式版本库了。

    1. 如何从远程库克隆?

      上面我们了解了先有本地库,后有远程库时候,如何关联远程库。

      现在我们想,假如远程库有新的内容了,我想克隆到本地来 如何克隆呢?

      首先,登录github,创建一个新的仓库,名字叫testgit2.如下:

    图片描述

    如下,我们看到:

    图片描述

    现在,远程库已经准备好了,下一步是使用命令git clone克隆一个本地库了。如下所示:

    图片描述

    接着在我本地目录下 生成testgit2目录了,如下所示:

    图片描述

    六:创建与合并分支。
    在 版本回填退里,你已经知道,每次提交,Git都把它们串成一条时间线,这条时间线就是一个分支。截止到目前,只有一条时间线,在Git里,这个分支叫主分支,即master分支。HEAD严格来说不是指向提交,而是指向master,master才是指向提交的,所以,HEAD指向的就是当前分支。

    首先,我们来创建dev分支,然后切换到dev分支上。如下操作:

    图片描述

    git checkout 命令加上 –b参数表示创建并切换,相当于如下2条命令

    git branch dev

    git checkout dev

    git branch查看分支,会列出所有的分支,当前分支前面会添加一个星号。然后我们在dev分支上继续做demo,比如我们现在在readme.txt再增加一行 7777777777777

    首先我们先来查看下readme.txt内容,接着添加内容77777777,如下:

    图片描述

    现在dev分支工作已完成,现在我们切换到主分支master上,继续查看readme.txt内容如下:

    图片描述

    现在我们可以把dev分支上的内容合并到分支master上了,可以在master分支上,使用如下命令 git merge dev 如下所示:
    图片描述

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

    注意到上面的Fast-forward信息,Git告诉我们,这次合并是“快进模式”,也就是直接把master指向dev的当前提交,所以合并速度非常快。

    合并完成后,我们可以接着删除dev分支了,操作如下:

    图片描述

    总结创建与合并分支命令如下:

    查看分支:git branch

    创建分支:git branch name

    切换分支:git checkout name

    创建+切换分支:git checkout –b name

    合并某分支到当前分支:git merge name

    删除分支:git branch –d name

    如何解决冲突?
    下面我们还是一步一步来,先新建一个新分支,比如名字叫fenzhi1,在readme.txt添加一行内容8888888,然后提交,如下所示:
    图片描述
    同样,我们现在切换到master分支上来,也在最后一行添加内容,内容为99999999,如下所示:

    图片描述

    现在我们需要在master分支上来合并fenzhi1,如下操作:

    图片描述

    Git用<<<<<<<,=======,>>>>>>>标记出不同分支的内容,其中<<<HEAD是指主分支修改的内容,>>>>>fenzhi1 是指fenzhi1上修改的内容,我们可以修改下如下后保存:
    图片描述

    如果我想查看分支合并的情况的话,需要使用命令 git log.命令行演示如下:
    图片描述

    3.分支管理策略。
    
      通常合并分支时,git一般使用”Fast forward”模式,在这种模式下,删除分支后,会丢掉分支信息,现在我们来使用带参数 –no-ff来禁用”Fast forward”模式。首先我们来做demo演示下:

    创建一个dev分支。
    修改readme.txt内容。
    添加到暂存区。
    切换回主分支(master)。
    合并dev分支,使用命令 git merge –no-ff -m “注释” dev
    查看历史记录
    截图如下:
    图片描述

    分支策略:首先master主分支应该是非常稳定的,也就是用来发布新版本,一般情况下不允许在上面干活,干活一般情况下在新建的dev分支上干活,干完后,比如上要发布,或者说dev分支代码稳定后可以合并到主分支master上来。

    七:bug分支:
    在开发中,会经常碰到bug问题,那么有了bug就需要修复,在Git中,分支是很强大的,每个bug都可以通过一个临时分支来修复,修复完成后,合并分支,然后将临时的分支删除掉。

    比如我在开发中接到一个404 bug时候,我们可以创建一个404分支来修复它,但是,当前的dev分支上的工作还没有提交。比如如下:

    图片描述

    并不是我不想提交,而是工作进行到一半时候,我们还无法提交,比如我这个分支bug要2天完成,但是我issue-404 bug需要5个小时内完成。怎么办呢?还好,Git还提供了一个stash功能,可以把当前工作现场 ”隐藏起来”,等以后恢复现场后继续工作。如下:

    图片描述

    所以现在我可以通过创建issue-404分支来修复bug了。

    首先我们要确定在那个分支上修复bug,比如我现在是在主分支master上来修复的,现在我要在master分支上创建一个临时分支,演示如下:

    图片描述

    修复完成后,切换到master分支上,并完成合并,最后删除issue-404分支。演示如下:

    图片描述
    现在,我们回到dev分支上干活了。
    图片描述

    工作区是干净的,那么我们工作现场去哪里呢?我们可以使用命令 git stash list来查看下。如下:

    图片描述

    工作现场还在,Git把stash内容存在某个地方了,但是需要恢复一下,可以使用如下2个方法:

    1.git stash apply恢复,恢复后,stash内容并不删除,你需要使用命令git stash drop来删除。
    2.另一种方式是使用git stash pop,恢复的同时把stash内容也删除了。
    演示如下

    图片描述

    八:多人协作。
    当你从远程库克隆时候,实际上Git自动把本地的master分支和远程的master分支对应起来了,并且远程库的默认名称是origin。

    要查看远程库的信息 使用 git remote
    要查看远程库的详细信息 使用 git remote –v
    如下演示:

    图片描述

    一:推送分支:

      推送分支就是把该分支上所有本地提交到远程库中,推送时,要指定本地分支,这样,Git就会把该分支推送到远程库对应的远程分支上:
    
      使用命令 git push origin master

    比如我现在的github上的readme.txt代码如下:

    图片描述

    本地的readme.txt代码如下:
    图片描述

    现在我想把本地更新的readme.txt代码推送到远程库中,使用命令如下:
    图片描述

    我们可以看到如上,推送成功,我们可以继续来截图github上的readme.txt内容 如下:

    图片描述

    可以看到 推送成功了,如果我们现在要推送到其他分支,比如dev分支上,我们还是那个命令 git push origin dev

    那么一般情况下,那些分支要推送呢?

    master分支是主分支,因此要时刻与远程同步。
    一些修复bug分支不需要推送到远程去,可以先合并到主分支上,然后把主分支master推送到远程去。
    二:抓取分支:

    多人协作时,大家都会往master分支上推送各自的修改。现在我们可以模拟另外一个同事,可以在另一台电脑上(注意要把SSH key添加到github上)或者同一台电脑上另外一个目录克隆,新建一个目录名字叫testgit2

    但是我首先要把dev分支也要推送到远程去,如下

    图片描述

    接着进入testgit2目录,进行克隆远程的库到本地来,如下:
    图片描述

    现在目录下生成有如下所示:
    图片描述
    现在我们的小伙伴要在dev分支上做开发,就必须把远程的origin的dev分支到本地来,于是可以使用命令创建本地dev分支:git checkout –b dev origin/dev

    现在小伙伴们就可以在dev分支上做开发了,开发完成后把dev分支推送到远程库时。

    如下:
    图片描述

    小伙伴们已经向origin/dev分支上推送了提交,而我在我的目录文件下也对同样的文件同个地方作了修改,也试图推送到远程库时,如下:
    图片描述

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

    图片描述

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

    图片描述

    这回git pull成功,但是合并有冲突,需要手动解决,解决的方法和分支管理中的 解决冲突完全一样。解决后,提交,再push:
    我们可以先来看看readme.txt内容了。

    图片描述

    现在手动已经解决完了,我接在需要再提交,再push到远程库里面去。如下所示:
    图片描述

    因此:多人协作工作模式一般是这样的:

    首先,可以试图用git push origin branch-name推送自己的修改.
    如果推送失败,则因为远程分支比你的本地更新早,需要先用git pull试图合并。
    如果合并有冲突,则需要解决冲突,并在本地提交。再用git push origin branch-name推送。

    感谢龙恩的贡献:http://www.cnblogs.com/tugenhua0707/p/4050072.html



    参考阮老师整理的部分命令:http://www.ruanyifeng.com/blog/2015/12/git-cheat-sheet.html
    一、新建代码库

    # 在当前目录新建一个Git代码库
    $ git init
    
    # 新建一个目录,将其初始化为Git代码库
    $ git init [project-name]
    
    # 下载一个项目和它的整个代码历史
    $ git clone [url]

    二、配置

    # 显示当前的Git配置
    $ git config --list
    
    # 编辑Git配置文件
    $ git config -e [--global]
    
    # 设置提交代码时的用户信息
    $ git config [--global] user.name "[name]"
    $ git config [--global] user.email "[email address]"

    三、增加/删除文件

    # 添加指定文件到暂存区
    $ git add [file1] [file2] ...
    
    # 添加指定目录到暂存区,包括子目录
    $ git add [dir]
    
    # 添加当前目录的所有文件到暂存区
    $ git add .
    
    # 添加每个变化前,都会要求确认
    # 对于同一个文件的多处变化,可以实现分次提交
    $ git add -p
    
    # 删除工作区文件,并且将这次删除放入暂存区
    $ git rm [file1] [file2] ...
    
    # 停止追踪指定文件,但该文件会保留在工作区
    $ git rm --cached [file]
    
    # 改名文件,并且将这个改名放入暂存区
    $ git mv [file-original] [file-renamed]

    四、代码提交

    # 提交暂存区到仓库区
    $ 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 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]

    六、标签

    # 列出所有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 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]
    
    # 显示当前分支的最近几次提交
    $ git reflog

    八、远程同步

    # 下载远程仓库的所有变动
    $ 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 checkout [file]
    
    # 恢复某个commit的指定文件到暂存区和工作区
    $ git checkout [commit] [file]
    
    # 恢复暂存区的所有文件到工作区
    $ git checkout .
    
    # 重置暂存区的指定文件,与上一次commit保持一致,但工作区不变
    $ git reset [file]
    
    # 重置暂存区与工作区,与上一次commit保持一致
    $ git reset --hard
    
    # 重置当前分支的指针为指定commit,同时重置暂存区,但工作区不变
    $ git reset [commit]
    
    # 重置当前分支的HEAD为指定commit,同时重置暂存区和工作区,与指定commit一致
    $ git reset --hard [commit]
    
    # 重置当前HEAD为指定commit,但保持暂存区和工作区不变
    $ git reset --keep [commit]
    
    # 新建一个commit,用来撤销指定commit
    # 后者的所有变化都将被前者抵消,并且应用到当前分支
    $ git revert [commit]
    
    # 暂时将未提交的变化移除,稍后再移入
    $ git stash
    $ git stash pop

    作者:
    链接:https://www.imooc.com/article/20411
    来源:慕课网
    展开全文
  • 本套课程将会讲解git的使用基础,主要包括:git的安装与配置、深刻理解工作区、暂存区的区别,git分支合并的原理、深入理解git对象的组成,总结来讲就是将基础知识的同时也同时讲解实现原理,带领大家更加深刻地理解...
  • 小猪的Git使用总结

    万次阅读 多人点赞 2017-01-11 19:26:04
    小猪用Git一年多后的精华总结标签: Git描述性文字:不要问我为什么用这种骚猪风格的标题,现在写博文,标题不骚,人家都不乐意看~接触Git到现在有一年多了,对Git使用也是日渐精进,虽说不上很熟络,但也算 ...

    小猪的Git使用总结



    目录


    概述

    接触Git也些年头了,对于Git的使用也算是略有心得,想着
    出于自己日后回顾,也便于他人查阅学习的目的,遂有此文,
    相信看完此文你的Git使用会更进一步,谢谢~

    PS:有些童鞋曾私信问我为什么有图形化的Git工具还要学
    命令行,原因挺多的,我觉得最主要的原因有三点:

    • 1.减少跨平台使用Git成本,不用另外花时间去熟悉各种工具;
    • 2.知道原理,出问题的时候不会一脸懵逼;
    • 3.装逼,敲起来命令噼里啪啦,不知道还以为你真的是大神;

    在线版(排版更佳,优先更新):https://www.zybuluo.com/coder-pig/note/581320
    本文不收取任何费用,欢迎转载,但请注明原文出处!
    禁止将本文用于商业用途,想了解更多内容可见:
    http://blog.csdn.net/coder_pig
    如果本文对你学习Git有一定帮助,不妨小额打赏下小猪,
    你的鼓励是我不断写博客的动力, 万分感谢~

    微信: 支付宝:

    如有什么疑问欢迎加群:421858269 反馈,谢谢~


    安装配置与文档


    1.下载安装

    • Windows系统:到 Git For Windowsgit-for-windows.github.io下载,傻瓜式下一步。
    • Linux系统:到 Download for Linux and Unix 下载,如果是Ubuntu的话,直接Terminal键入:
      sudo apt-get install git 安装。
    • Mac系统:到 Installing on Mac 下载,不过新系统貌似默认已经带有Git了,另外如果安装了
      Homebrew的话可以直接命令行键入:brew install git 进行安装。

    2.文档教程相关


    概念


    1.Git的四个组成部分

    2.文件的几个状态

    按大类划分,分为两种状态:Tracked(已跟踪)和Untracked(未跟踪),
    依据是:该文件是否已加入版本控制

    流程简述:

    假设某个项目已加入版本控制系统

    • 1.新建一个文件,该文件处于 Untracked 状态;
    • 2.通过git add命令添加到缓存区,此时文件处于Tracked状态又或者说
      此时这个文件已经被版本控制系统所跟踪,而且他处于Staged(暂存)状态;
    • 3.通过git commit命令把暂存区的文件提交提交到本地仓库,此时文件
      处于Unmodified(未修改)状态;
    • 4.此时如果去编辑这个文件,文件又会变成Modified(修改)状态;

    3.Git与SVN版本版本控制存储差异

    Git关心的是:文件整体是否发生变化,而SVN关心的是:文件内容的具体差异!
    SVN每次提交记录的是:哪些文件进行了修改,以及修改了哪些行的哪些内容

    如图:版本2中记录的是文件A和C的变化,而版本3中记录文件C的变化,以此类推;
    而Git中,并不保存这些前后变化的差异数据,而是保证整个缓存区中的所有文件,
    又叫快照,有变化的文件保存没变化的文件不保存而是对上一次的保存的快照
    做一个链接!因为这种不同的保存方式,Git切换分支的速度比SVN快很多!

     

    4.每次Commit时仓库中的数据结构

    分为四个对象:

    blob对象:存放文件数据;
    tree对象:目录,内容为blob对象的指针或其他tree对象的指针
    commit对象:快照,包含指向前一次提交对象的指针,commit相关的信
    通过索引找到文件快照。
    tag对象:一种特殊的commit对象,一般对某次重要的commit加TAG,以示重要(方便找)


    本地操作命令


    1.相关配置【git config】

    区分globallocal,前者代表 全局设置,就是设置了在整个系统中,
    所有的带Git版本管理的项目都是这样的配置;后者代表 本地设置
    即在某个项目中独立的设置,后者优先级高于前者。比如全局设置
    的用户名是”Coder-pig”,本地设置的是”Jay”,commit的时候author
    就是Jay而不是Coder-pig。除了通过命令行修改,还可以直接修改
    对应文件:

    全局配置文件:etc/gitconfig (Mac下是隐藏文件,用户/.gitconfig)
    本地配置文件:当前仓库/.git/config

    # 安装完Git后第一件要做的事,设置用户信息(global可换成local在单独项目生效):
    git config --global user.name "用户名" # 设置用户名
    git config --global user.email "用户邮箱"   #设置邮箱
    git config --global user.name   # 查看用户名是否配置成功
    git config --global user.email   # 查看邮箱是否配置
    
    # 其他查看配置相关
    git config --global --list  # 查看全局设置相关参数列表
    git config --local --list # 查看本地设置相关参数列表
    git config --system --list # 查看系统配置参数列表
    git config --list  # 查看所有Git的配置(全局+本地+系统)
    

    2.获取帮助【git help】

    git help 命令   # 如:git help init

    3.创建本地仓库【git init】

    git init 仓库名 # 创建一个新的带Git仓库的项目
    git init # 为已存在的项目生成一个Git仓库

    4.添加文件到暂存区/文件跟踪标记【git add】

    可以使用git add 文件名,将工作空间的文件添加到暂存区,或批量添加文件

    git add 文件名 # 将工作区的某个文件添加到暂存区   
    git add -u # 添加所有被tracked文件中被修改或删除的文件信息到暂存区,不处理untracked的文件
    git add -A # 添加所有被tracked文件中被修改或删除的文件信息到暂存区,包括untracked的文件
    git add . # 将当前工作区的所有文件都加入暂存区
    git add -i # 进入交互界面模式,按需添加文件到缓存区

    附:交互界面模式示例

    上图流程:

    1.先在GitForTest的文件夹里创建了两个文件
    2.键入git add -i,进入后,键入4,选择添加untracked的文件
    3.他给我们列出了untracked的文件,然后我们根据序号来添加文件
    4.输入?会弹出相关提示,然后直接回车,结束选择!
    5.然后再次输入git add -i,输入4,可以看到已不存在untacked的文件了!


    5.让Git不Tracked特定文件【.gitignore文件配置】

    将未tracked的文件添加到缓存区后,Git就会开始跟踪这个文件了!
    对于一些比如:自动生成的文件日志临时编译文件等,就
    没必要进行跟踪了,这个时候可以编写.gitignore文件,在里面
    把不需要跟踪的文件或文件夹都写上,git就不会对这些文件进行跟踪!
    另外.gitignore文件与.git文件夹在同级目录下

    如果不想自己写,可以直接到:https://github.com/github/gitignore 复制粘贴!
    也可以自行编写,支持简化了的正则表达式(规范与示例模板摘自:Git王者超神之路)

    • * : 匹配零个或多个任意字符
    • [abc]:只匹配括号内中的任意一个字符
    • [0-9]:- 代表范围,匹配0-9之间的任何字符
    • ?:匹配任意一个字符
    • *:匹配任意的中间目录,例如a/*/z可以匹配:a/z,a/b/z,a/b/c/z等

    示例模板

    # 忽略所有以 .c结尾的文件
    *.c
    
    # 但是 stream.c 会被git追踪
    !stream.c
    
    # 只忽略当前文件夹下的TODO文件, 不包括其他文件夹下的TODO例如: subdir/TODO
    /TODO
    
    # 忽略所有在build文件夹下的文件
    build/
    
    # 忽略 doc/notes.txt, 但不包括多层下.txt例如: doc/server/arch.txt
    doc/*.txt
    
    # 忽略所有在doc目录下的.pdf文件
    doc/**/*.pdf

    !!!特别要注意一点!!!:

    配置.gitignore只对那些没有添加到版本控制系统的文件生效(未Tracked的文件)!

    举个例子:

    有A,B两个文件,你先把他两个add了,然后在.gitignore文件中
    配置了不跟踪这两个文件,但是你会发现根本不会生效。

    git add A
    git add B
    # 配置不跟踪A和B
    git add .gitignore

    所以,最好的做法就是在项目刚开始的时候,先添加.gitignore文件。
    当然,即使是发生了,还是有解决方法的,可以键入下述命令清除标
    记状态,然后先添加.gitignore,再添加文件即可:

    git rm -r --cached . # 清除版本控制标记,.代表所有文件,也可指定具体文件

    还有,如果你用的是IDEA的编辑器的话,可以下一个.ignore的插件,可以手动
    直接勾选不需要跟踪的文件。


    6.将暂存区内容提交到本地仓库【git commit】

    git commit -m "提交说明" # 将暂存区内容提交到本地仓库
    git commit -a -m "提交说明" # 跳过缓存区操作,直接把工作区内容提交到本地仓库

    如果不加-m “提交说明”,git会让用你让默认编辑器(如vi)来编写提交说明,
    可能有些朋友用不惯vi,要么别漏掉-m “提交说明”,要么自己设置编译器:

    git config --global core.edit 喜欢的编辑器

    除此之外,有时可能需要修改上次提交的内容,比如修改提交说明,或者修改文件等:

    # 合并暂存区和最近的一次commit,生成新的commit并替换掉老的
    # 如果缓存区没内容,利用amend可以修改上次commit的提交说明
    # 注:因为amend后生成的commit是一个全新的commit,旧的会被
    # 删除,所以别在公共的commit上使用amend!切记!!!
    
    git commit --amend 
    git commit --amend --no-edit # 沿用上次commit的提交说明

    7.查看工作区与缓存区的状态【git status】

    git status # 查看工作区与暂存区的当前情况
    git status -s # 让结果以更简短的形式输出

    8.差异对比(内容变化)【git diff】

    git diff # 工作区与缓存区的差异
    git diff 分支名 #工作区与某分支的差异,远程分支这样写:remotes/origin/分支名
    git diff HEAD  # 工作区与HEAD指针指向的内容差异
    git diff 提交id 文件路径 # 工作区某文件当前版本与历史版本的差异
    git diff --stage # 工作区文件与上次提交的差异(1.6 版本前用 --cached)
    git diff 版本TAG # 查看从某个版本后都改动内容
    git diff 分支A 分支B # 比较从分支A和分支B的差异(也支持比较两个TAG)
    git diff 分支A...分支B # 比较两分支在分开后各自的改动
    
    # 另外:如果只想统计哪些文件被改动,多少行被改动,可以添加 --stat 参数

    9.查看历史提交记录【git log】

    git log # 查看所有commit记录(SHA-A校验和,作者名称,邮箱,提交时间,提交说明)
    git log -p -次数 # 查看最近多少次的提交记录
    git log --stat # 简略显示每次提交的内容更改
    git log --name-only # 仅显示已修改的文件清单
    git log --name-status # 显示新增,修改,删除的文件清单
    git log --oneline # 让提交记录以精简的一行输出
    git log –graph –all --online # 图形展示分支的合并历史
    git log --author=作者  # 查询作者的提交记录(和grep同时使用要加一个--all--match参数)
    git log --grep=过滤信息 # 列出提交信息中包含过滤信息的提交记录
    git log -S查询内容 # 和--grep类似,S和查询内容间没有空格
    git log fileName # 查看某文件的修改记录,找背锅专用

    除此之外,还可以通过 –pretty 对提交信息进行定制,比如:

    更多规则与定制如下(摘自:Git王者超神之路),或参见:Viewing the Commit History

    format对应的常用占位符:(注:作者是指最后一次修改文件的人,提交者是提交该文件的人)

    占位符 说明 占位符 说明
    %H 提交对象(commit)的完整哈希字串 %h 提交对象的简短哈希字串
    %T 树对象(tree)的完整哈希字串 %t 树对象的简短哈希字串
    %P 父对象(parent)的完整哈希字串 %p 父对象的简短哈希字串
    %an 作者(author)的名字 %ae 作者的电子邮件地址
    %ad 作者修订日期(可以用 –date= 选项定制格式) %ar 按多久以前的方式显示
    %cn 提交者(committer)的名字 %ce 提交者的电子邮件地址
    %cd 提交日期 %cr 提交日期,按多久以前的方式显示
    %s 提交说明

    一些其他操作:

    选项 说明
    -p 按补丁格式显示每个更新之间的差异
    stat 显示每次更新的文件修改统计信息(行数)
    shortstat 只显示 –stat 中最后的行数修改添加移除统计
    name-only 仅在提交信息后显示已修改的文件清单
    name-status 显示新增、修改、删除的文件清单
    abbrev-commit 仅显示 SHA-1 的前几个字符,而非所有的 40 个字符
    relative-date 使用较短的相对时间显示(比如,“2 weeks ago”)
    graph 显示 ASCII 图形表示的分支合并历史
    pretty 格式定制,可选选项有:oneline,short,full,Fullerton和format(后跟指定格式)

    还有一些限制log输出的选项

    选项 说明
    -(n) 仅显示最近的 n 条提交
    since, –after 仅显示指定时间之后的提交。
    until, –before 仅显示指定时间之前的提交。
    author 仅显示指定作者相关的提交。
    committer 仅显示指定提交者相关的提交。
    grep 仅显示含指定关键字的提交
    -S 仅显示添加或移除了某个关键字的提交

    10.查看某行代码是谁写的【git blame】

    git blame 文件名 # 查看某文件的每一行代码的作者,最新commit和提交时间

    Tip:

    如果你用的IDEA系列的编译器,右键行号,选择Annotate也可以实现同样的效果


    11.设置Git命令别名【git config –global alias】

    可以为常见的命令起个简单的别名,就不用每次都敲完整命令,比如可以设置:
    status为st,checkout为co ; commit为ci ; branch为br等

    git config --global alias.st status


    12.为重要的commit打标签【git tag】

    对于某些提交,我们可以为它打上Tag,表示这次提交很重要,
    比如为一些正式发布大版本的commit,打上TAG,当某个版本
    出问题了,通过TAG可以快速找到此次提交,拿到SHA1值,再
    去查找问题,比起一个个commit看,省事很多!

    Git标签分两种:轻量标签附加标签
    前者只是在提交上加个Tag,指向提交的Hash值;
    而后者还会保存打标签者的信息,时间和附加信息;

    git tag 标记内容 # 轻量标签
    git tag -a 标记内容 -m "附加信息" # 附加标签

    如果想为之前的某次commit打TAG的话,可以先找出SHA1值,设置调下述命令:

    git tag -a 标记内容 版本id # 比如:git tag -a v1.1 bcfed96

    默认情况,git push不会把标签推送TAG到远程仓库,如果想推送到服务器,可以:

    git push origin 标记内容 # 推送某标签到
    
    # 删除所有本地仓库中不存在的TAG:
    git push origin --tags 

    另外,可以在新建分支的时候也加上TAG

    git checkout -b 分支名 标记内容

    还可以用show命令查看标签对应的信息

    git show 标记内容

    如果你想删除本地Tag:

    git tag -d 标记内容

    如果是删除远程Tag:

    git push origin --delete tag 标记内容

    13.Git命令自动补全【输命令的时候按两次tab键】


    文件回复/版本回退


    1.文件恢复(未commit)【git checkout】

    如果在工作区直接删除被Git Tracked的文件,暂存区中还会存在该文件,
    此时键入:git status,会是这样:

    Git告诉你工作区的文件被删除了,你可以 删掉暂存区里的文件恢复被删文件

    # 删除暂存区中的文件:
    git rm 文件名
    git commit -m "提交说明"
    
    # 误删恢复文件
    git checkout -- 文件名
    
    # 另外注意:git checkout会抛弃当前工作区的更改!!!不可恢复!!!务必小心!!!
    

    2.文件恢复(已add未commit)【git reset HEAD】

    如果更改后add到了暂存区,想恢复原状,下述指令可以让文件恢复原状:

    git reset HEAD 文件名   
    git checkout 文件名

    3.版本回退(已commit)【git reset –hard】

    文件已经commit了,想恢复成上次commit的版本或者上上次,可以:

    git reset HEAD^ # 恢复成上次提交的版本
    git reset HEAD^^ # 恢复成上上次提交的版本,就是多个^,以此类推或用~次数
    git reset --hard 版本号 # git log查看到的SHA1值,取前七位即可,根据版本号回退

    reset命令其实就是:重置HEAD指针,让其指向另一个commit
    而这个动作可能会对工作区与缓存区造成影响,举个例子

    • 本来的分支线:- A - B - C (HEAD, master)
    • git reset B后:- A - B (HEAD, master)
      解释:看不到C了,但是他还是存在的,可以通过git reset C版本号找回,前提是
      C没有被Git当做垃圾处理掉(一般是30天)。

    reset三个可选参数解析

    • –soft:只是改变HEAD指针指向,缓存区和工作区不变;
    • –mixed:修改HEAD指针指向,暂存区内容丢失,工作区不变;
    • –hard:修改HEAD指针指向,暂存区内容丢失,工作区恢复以前状态;

    4.查看输入指令记录【git reflog】

    Git会记住你输入的每个Git指令,比如上面的git reset 切换成一个旧的
    commit,然后git log后发现新提交的记录没了,想切换回新的那次commit,
    可以先调git reflog 获取新commit的SHA1码,然后git reset 回去。

    git reflog

    注意:这个指令记录不会永久保存!Git会定时清理用不到的对象!!!


    5.撤销某次提交【git revert】

    有时可能我们想撤销某次提交所做的更改,可以使用revert命令

    git revert HEAD # 撤销最近的一个提交
    git revert 版本号 # 撤销某次commit

    不是真的把提交给撤销了,而是生成一个新的提交来覆盖旧的提交,被撤销的提交
    和新的提交记录都会保存!!!不信你再调一次revert HEAD 会发现被撤销的更改
    又变回来了,另外,每次revert后,都需要发起新的commit!
    简单点说,撤销的只是文件变化,提交记录依旧是存在的


    6.查看某次提交修改内容【git show】

    git show 提交id # 查看某次commit的修改内容

    7.查看某个分支的版本号【git rev-parse】

    git rev-parse 分支名 # 查看分支commit的版本号,可以写HEAD

    8.找回丢失对象的最后一点希望【git fsck】

    因为你的某次误操作导致commit丢失,如果git reflog都找不到,你
    可以考虑使用git fsck,找到丢失的对象的版本id,然后恢复即可。

    git fsck --lost-found


    本地分支


    1.分支概念

    提交记录串成的时间线,默认初始创建的分支(时间线) —— master分支
    如果不切换到其他分支上,每次commit生成的快照都会串在这条分支上!
    另外还有个 —— HEAD指针,该指针指向正在工作的本地分支,前面的版
    本回退其实修改的就是这个HEAD指针的指向

    比如:在master分支上执行四次commit,分支的状态图如下

    不难发现这样的规律:

    • 每次commit,master都会向前移动一步,指向最新的提交
    • HEAD则指向正在工作的本地分支,而git reset修改的就是HEAD指针的指向!

    2.创建其他分支的原因

    通过两个场景来体会创建其他分支的必要性

    • 场景一
      项目一般都是一步步迭代升级的,有大版本和小版本的更新:
      大版本一般是改头换面的更新,比如UI大改,架构大改,版本是:
      v2.0.0这样;小版本的更新一般是UI小改,Bug修复优化等,版本是:
      v2.0.11这样;只有一条master分支,意味着:你的分支线会
      非常非常的长,假如你已经发布到了第二个大版本,然后用户反馈
      第一个版本有很严重的BUG,这时候想切回第一个版本改BUG,
      然后改完BUG切回第二个大版本,想想也是够呛的。
      (PS:可能你说我可以对重要的commit打tag,然后找到这个tag
      切回去,当然也行这里是想告诉你引入其他分支会给你带来的便利)
    • 场景二
      只有一个master分支的话,假如某次提交冲突了,而这个冲突很难解决或者
      解决不了, 那么,那个整个开发就卡住在这里了,无法继续向后进行了!

    3.一个最简单实用的分支管理策略

    为了解决只有一个master分支引起的问题,可以引入分支管理,最简单的一种策略如下:

    master分支上开辟一个新的develop分支,然后我们根据功能或者业务,再在develop
    分支上另外开辟其他分支,完成分支上的任务后,再将这个分支合并到develop分支上!
    然后这个功能分支的任务也到此结束,可以删掉,而当发布正式版后,再把develop分支
    合并到master分支上,并打上TAG。

    master与develop分支都作为长期分支,而其他创建的分支作为临时性分支
    简述各个分支的划分:

    • master分支:可直接用于产品发布的代码,就是正式版的代码
    • develop分支:日常开发用的分支,团队中的人都在这个分支上进行开发
    • 临时性分支:根据特定目的开辟的分支,包括功能(feature)分支,或者预发布(release)分支
      又或者是修复bug (fixbug)分支,当完成目的后,把该分支合并到develop分支,
      然后删除 该分支,使得仓库中的常用分支始终只有:master和develop两个长期分支

    4.分支创建与切换【git branch】

    git branch 分支名 # 创建分支
    git branch # 查看本地分支

    比如在master分支上创建develop分支,此时的分支状况如下:

    git checkout 分支名 # 切换分支
    git checkout -b 分支名 # 创建分支同时切换到这个分支

    切换到develop分支后,改点东西,再commit,此时的分支状况如下:

    git checkout master 切回master分支,打开之前修改的文件,发现内容
    并没有发生更改,因为刚刚的更改是在develop上提交的,而master上没有
    变化,此时的分支状况如下:


    5.分支的合并【git merge】 VS 【git rebase】

    Git中,可以使用 git mergegit rebase 两个命令来进行分支的合并

    git merge合并分支

    合并的方式分为两种:快速合并普通合并,两者的区别在于:
    前者合并后看不出曾经做过合并,而后合并后的历史会有分支记录,如图:

    快速合并普通合并

    示例

    快速合并,把develop分支合并到master分支上,来到master分支后,键入下述命令

    git merge develop

    打开文件:

    普通合并,切到develop分支下,修改note_2.txt的内容,再通过下述指令合并分支:
    注:–no-ff参数表示禁用快速合并

    git merge --no-ff -m "合并的信息(TAG)" develop

    分支线情况:

    git reabse合并分支

    rebase(衍合或变基),发现很多所谓的教程把这个东西写得太深奥了,
    其实并没有那么复杂,只是这种合并会使得树整洁,易于跟踪,
    举个简单的例子来对比下,有一个项目由两个人同时开发,
    当前远程仓库的提交记录是这样的:

    然后A和B各自开了一个条分支来完成相应功能,接着他们在自己的
    分支上都做了多次的commit,此时两人的分别分支线是这样的:

      

    A先合并,再到B合并,这里我们假设两人做的是完全不关联的模块,合并没有冲突

    merge合并

    rebase合并

    用法:

    git rebase 想合并到哪个分支的分支名

    6.解决合并冲突

    在我们合并分支的时候,有时会遇到合并冲突,然后合并失败的问题,
    此时需要我们先解决冲突后才能进行合并,个人开发倒很少会遇到,多人
    开发的时候遇到合并冲突则是家常便饭。

    一个最简单的例子,A和B在develop分支上开辟出两个分支来完成相关的
    功能,A做完了,把自己的分支合并到develop分支,此时develop分支向前
    移动了几次commit,接着B也完成了他的功能,想把自己分支合并到develop
    分支,如果改动的文件和和A改动的文件相同的话,此时就会合并失败,
    然后需要处理完冲突,才能够继续合并!简单模拟下这个例子,先试试merge!

    merge分支后处理冲突

    打开冲突文件,然后处理冲突部分,保留什么代码你自己决定,处理完后把
    <<< 和 >>> 这些去掉:

    处理后:

    然后add,然后commit即可,合并结束:

    此时的分支线:

    接着试试

    rebase分支后处理冲突

    重新来一遍,然后把A直接merge到master,再切到B,rebase master,此时出现
    合并冲突,这里有三个可选的操作:

    git rebase --continue # 处理完冲突后,继续处理下一个补丁
    git rebase --abort # 放弃所有的冲突处理,恢复rebase前的情况
    git rebase --skip # 跳过当前的补丁,处理下一个补丁,不建议使用,补丁部分的commit会丢失!

    好的,有三次补丁要处理,一个个来:

    处理后:

    接着git add 添加修改后的文件,git rebase –continue继续处理补丁:

    接着重复之前的过程:

    处理后:

    第三个补丁是与A分支无关联的改动,所以没有冲突,所以也就直接合并了!
    如果合并中途出了什么差错可以git rebase –abort 恢复rebase前的状况!

    最后看下分支线会发现是一条直线,这也是用rebase合并分支的优点:

    附上栗子,可以自己试试GitTest.7z


    7.删除分支

    对于合并完的分支,基本都没什么作用了,可以使用下述命令删除:

    git branch -d 分支名 # 删除分支,分支上有未提交更改是不能删除的
    git branch -D 分支名 # 强行删除分支,尽管这个分支上有未提交的更改

    8.恢复误删分支

    两步,找出被删除分支的最新commit的版本号,然后恢复分支

    git log --branches="被删除的分支名" # 找到被删分支最新的commitb版本号
    git branch 分支名 版本号(前七位即可) # 恢复被删分支

    9.切换分支时保存未commit的更改【git stash】

    有时我们可能在某个分支上正编写着代码,然后有一些突发的情况,需要
    我们暂时切换到其他分支上,比如要紧急修复bug,或者切换分支给同事
    review代码,此时如果直接切换分支是会提示切换失败的,因为这个分支
    上做的更改还没有提交,你可以直接add后commit,然后再切换,不过我们
    习惯写完某个功能再提交,我们想:

    先暂存这个分支上的改动,切去其他分支上搞完事,然后回来继续
    继续在之前的改动上写代码。

    那么可以使用:

    git stash # 保存当前的改动

    然后放心的切换分支,然后再切换回来,接着使用:

    git stash apply # 恢复保存改动

    另外有一点一定要注意!!!可以stash多个改动!!如果你切换
    到另一个分支又stash了,然后切换回来stash apply是恢复成另一个
    分支的stash!!!

    如果你这样stash了多次的话,我建议你先键入:

    git stash list # 查看stash列表

    找到自己想恢复的那个

    比如我这里恢复的应该是netword上的stash,而第一个stash是devlop上的
    直接git stash apply恢复的就是这个,然而恢复的应该是network的那个stash:

    git stash apply stash@{1}

    就是这样,按自己需要恢复即可!


    10.分支重命名

    git branch -m 老分支名 新分支名 # 分支重命名

    远程仓库与远程分支


    1.远程仓库简述

    用于代码托管,可以自己搭建远程仓库,或者选择专业的代码托管平台:
    自己搭建的好处有:可控,内网安全,可以做一些定制,比如集成编译,IM等,
    当然,肯定是需要一些学习成本的,(PS:我厂就是自己搭的Gitlab,自己配置
    还是比较麻烦的,简单点的可以试试 Gogs)

    常见的代码托管平台(自己搜关键字去~):

    Github,Git@OSC,GitCafe,GitLab,coding.net,gitc,BitBucket,Geakit,Douban CODE


    2.推送本地仓库到远程仓库【git push】

    首先建立好与本地仓库同名的远程仓库,然后复制下远程仓库的地址,比如:

    键入下述命令关联本地与远程仓库

    git remote add origin 远程仓库地址 

    可以键入下述命令可查看远程仓库状况

    接着把本地仓库推送到远程仓库,这里的 -u参数 作为第一次提交使用,
    作用是把本地master分支和远程master分支关联起来(设置默认远程主机),
    后续提交不需要这个参数!

    git push -u origin master

    另外,如果想修改远程仓库地址,可键入:

    git remote set-url origin 远程仓库地址
    
    # 也可以先删除origin后再添加
    
    git remote rm origin    # 删除仓库关联
    git remote add origin 远程仓库地址 # 添加仓库关联

    或直接修改.git文件夹中的config文件,直接替换圈住位置

    还要说明一点,origin 并不是固定的东西,只是后面仓库地址的一个 别名!!
    可以写成其他的东西,然后你也可以设置多个仓库关联,用不同的别名标志,比如:

    git remote add github https://github.com/coder-pig/SimpleTea.git
    git remote add osc git@git.oschina.net:coder-pig/SimpleTea.git

    3.克隆远程仓库【git clone】

    把项目推送到远程仓库后,其他开发者就可以把项目clone到本地

    git clone 仓库地址 # 克隆项目到当前文件夹下
    git clone 仓库地址 目录名 # 克隆项目到特定目录下

    4.同步远程仓库更新【git fetch】VS 【git pull】

    关于获取远程服务器更新的方式有两种,他们分别是fetch和pull,
    尽管都可以获取远程服务器更新,但是两者却又是不一样的。

    git fetch

    仅仅只是从远处服务器获取到最新版本到本地,假如你不去合并(merge)
    的话,本地工作空间是不会发生变化的!比如:
    我们在Github上创建一个README.md文件,然后调 git fetch 去获取远程
    仓库的更新。

    git pull

    一步到位,或者说:pull = fetch + merge,比如:同样修改Github上的
    README.md 文件,然后git pull 同步远程仓库的更新

    区别显而易见,实际开发中,使用git fetch会更安全一些,毕竟merge的时候
    我们可以查看更新的情况,再决定是否进行合并,当然看实际需要吧!


    5.推送本地分支到远程仓库

    按照前面所讲,在本地开辟分支来完成某些工作,本地提交了多次后,
    你想把分支推送到远程仓库,此时远程仓库并没有这个分支,你可以:

    git push origin 分支名 # 推送本地分支的内容到远程分支

    6.查看远程分支

    git branch -r # 查看所有分支

    7.拉取远程分支到本地仓库

    git checkout -b 本地分支 远程分支 # 会在本地新建分支,并自动切换到该分支
    git fetch origin 远程分支:本地分支 # 会在本地新建分支,但不会自动切换,还需checkout
    git branch --set-upstream 本地分支 远程分支 # 建立本地分支与远程分支的链接

    8.删除远程分支

    git push origin :分支名 

    9.重命名远程分支

    先删除远程分支,然后重命名本地分支,接着再Push到远程仓库


    10.为项目添加SSH Key免去提交输入账号密码的麻烦

    不知道细心的你有没有发现,仓库地址除了Https外,还有一个SSH,
    这里我们简单介绍下两者的区别,第一点:使用Https url可以任意克隆
    Github上的项目;而是用SSH url克隆的话,你必须是项目的拥有者或
    管理员,而且还要添加SSH Key,否则会无法克隆。还有一点是,
    Https每次push都需要输入用户名和密码,而使用SSH则不需要输入
    用户名如果配置SSH Key时设置了密码,则需要输入密码,否则直接
    git push就可以了!

    另外,SSH,Secure shell(安全外壳协议),专为远程登陆会话
    与其他网络服务提供安全性的协议,而SSH传输的数据是可以经过压缩的,
    可以加快传输的速度,出于安全性与速度,我们优先考虑使用SSH协议,
    而SSH的安全验证规则又分为基于密码基于密钥两种!
    我们这里用的是基于第二种的,即在本地创建一对密钥,
    公钥(id_rsa.pub)私钥(id_rsa),然后把公钥的内容贴到
    Github账号的ssh keys中,这样就建立了本地和远程的认证关系,
    当我们再push到远程仓库,会将你本地的公共密钥与服务器的进行匹配,
    如果一致验证通过直接推送更新!

    下面我们来建立ssh key,首先来到电脑的根目录下,这里假定我们没
    创建过SSH key:

    执行完ssh-keygen那个指令后,后面依次要你输入文件名,
    直接回车会生成两个默认的秘钥文件,接着提示输入密码,
    直接回车,如果这里你输入密码了的话,那么push的时候
    你还是需要输入密码,接着又输多一次密码,同样回车,
    然后出现最下面的这串东西就说明ssh key已经创建成功了!

    我们接着可以用编辑器打开id_rsa.pub文件或者键入:

    clip <id_rsa.pub

    复制文件内容,然后打开Github,点击你的头像,选择:Settings
    然后点击左侧SSH Keys,然后New SSH Key

    然后Github会给你发来一个提示创建了一个新ssh key的邮件,
    无视就好,接下来我们可以键入:ssh -T git@github.com
    然后如果你上面设置过密码则需要输入密码,
    否则直接输入yes然后一直按回车就好!,最后出现Hi xxx那句话
    就说明ssh key配置成功了!

    PS:其他远程仓库配置方法与此类同,
    内容参考自:https://help.github.com/articles/generating-an-ssh-key/


    附1:Github客户端

    其实,安装好Git后,就一有一个GitGui的东东了,就可以直接
    用有用户界面的Git来做版本管理的工作了,而Github客户端则是
    Github给我们提供的一个专门用来管理Github项目的一个工具而已。
    比如,假如你装了Github客户端,在Clone项目的时候,你只需点击:

    就能直接把项目clone下来,就是一些Git操作的图形化罢了,首先来到下面的链接
    下载Github客户端:https://desktop.github.com/
    文件很小,后面点击运行文件后,他还要在线下载安装,100多m,
    然后傻瓜式安装,安装完成后,会自动打开Github客户端,然后
    使用你的Github账号登陆,接着他会默认为你创建SSH Key信息,
    接着的你自己摸索了!

    这里另外补充一点,就是win 8.1装Github客户端的问题,
    昨晚安装的时候一直报这个错误:

    直接,win + x,选择”命令行提示符(管理员)“,执行以下下面的这个指令:

    %SYSTEMROOT%\SYSTEM32\REGSVR32.EXE %SYSTEMROOT%\SYSTEM32\WUAUENG.DLL

    然后再点击Github的安装程序,等待安装完成即可,下载并不需梯子。


    附2:删除Git仓库

    点击进入你的仓库,点击Setting,拉到最后:

    点击Delete this repository

    弹出的对话框中输入要删除的仓库名称,接着点击删除


    附3:为开源项目贡献代码

    你可以Clone别人的开源项目,在看别人代码的时候,你觉得作者有
    某些地方写得不好,写错,或者你有更好的想法,你在本地修改后,
    想把修改push推送到开源项目上,想法很好,但是你不是项目的拥
    有着和参与者,是无法推送更改的!!!这样是为了
    避免熊孩子,毕竟熊孩子无处不在,参与开源项目的方法有两种:

    第一种方法
    是让作者把你加为写作者,添加协作者流程:点击仓库的Settings
    –>Collaborators然后输入想添加的人的用户名或者邮箱,点击
    添加即可。

    第二种方法
    点击Fork按钮,把这个项目fork到自己的账号下,然后Clone
    到本地,然后做你想做的修改,commit提交,然后push到自己账
    号里的仓库,然后打开开源项目,点击,然后新建一个
    pull request,接着设置自己的仓库为源仓库,设置源分支
    目标仓库目标分支,然后还有pull request的标题和描述信息,
    填写完毕后,确定,这个时候开源项目的作者就会收到一个pull
    request的请求,由他来进行审核,作者审查完代码觉得没问题
    的话,他可以点击一下merge按钮即可将这个pull request合并
    到自己的项目中,假如作者发现了你代码中还有些bug,他可以
    通过Pull Request跟你说明,要修复了xxBUG才允许合并,那么
    你再修改下BUG,提交,更改后的提交会进入Pull Request,
    然后作者再审核这样!

    PS:假如作者不关闭或者merge你的这个Pull Request,你可以一直
    commit骚扰主项目…( ╯□╰ )


    Git工作流

    关于Git工作流,看到一篇图文并茂很好的文章,就不重复造轮子了,
    此处只是做下对应工作流的简述,详情见:Git Workflows and Tutorials


    1.集中式工作流

    类似于SVN,不过只有一条master分支,然后一群人就在这条分支上嗨,比如有小A和小B:
    (冲突解决参照上面的套路)

    • 1.项目管理者初始化仓库,然后推到远程仓库
    • 2.其他人克隆远程仓库项目到本地
    • 3.小A和小B完成各自的工作
    • 4.小A先完成了,git push origin master 把代码推送到远程仓库
    • 5.小B后完成了,此时推送代码到远程仓库,出现文件修改冲突
    • 6.小B需要先解决冲突,git pull –rebase origin master,然后rebase慢慢玩
    • 7.小B把冲突解决后,git push origin master 把代码推送到远程仓库

    2.功能分支工作流

    和集中式分部流相比只是分支再不是只有master,而是根据功能开辟新的分支而已,示例:
    注:这里的仓库管理者是拥有仓库管理权限的人

    • 1.小A要开发新功能,git branch -b new-feature 开辟新分支
    • 2.小A在new-feature上新功能相关的编写,他可以这个分支推到远程仓库
    • 3.功能完成后,发起请求pull request(合并请求),把new-feature合并到master分支
    • 4.仓库管理员可以看到小A的更改,可以进行一些评注,让小A做某些更改,
      然后再发起pull request,或者把pull request拉到本地自行修改。
    • 5.仓库管理员觉得可以了,合并分支到master上,然后把new-feature分支删掉

    3.Gitflow工作流

    其实就是功能分支工作流做了一些规范而已,大概流程参见上面Git分支里的:
    一个最简单实用的分支管理策略。


    4.Forking工作流

    分布式工作流,每个开发者都拥有自己独立的仓库,和上面的附3:为开源项目贡献代码
    套路类似,把项目fork到自己的远程仓库,完成相应更改,然后pull request到源仓库,
    源仓库管理者可以决定是否合并。


    5.Pull Request工作流

    和Forking工作流类似,Pull Requests是Bitbucket上方便开发者之间协作的功能


    查缺补漏

    一些高级技巧,工具,插件安利


    1.巨好用的Git图形化工具SourceTree

    命令行虽酷炫可装逼,但是有时用图形化工具还是能提高我们不少效率的,
    如题,SourceTree,官网下载地址:https://www.sourcetreeapp.com/


    2.把提交的commit从一个分支放到另一个分支【git cherry-pick】

    有时你可能需要把某个分支上的commit放到另一个分支上,这个时候可以
    使用cherry-pick,比如有下面这样两个分支:

    master分支:A -> B -> C
    feature分支:a -> b

    现在想把feature上的b,放到master的C后,可以这样:

    • Step 1:切换到feature分支上,git log拿到b commit的版本号(SHA1)
    • Step 2:切换到master分支,键入:git cherry-pick 版本号

    出现上面这种情况的话说明出现冲突了,处理冲突后,git add 和 git commit 走一波
    即可。


    问题解决

    1.fatal: refusing to merge unrelated histories

    问题描述:在Github上新建了一个仓库,里面带有一个licence文件,然后本地
    本地项目想推到这个远程仓库上,git remote 设置了远程仓库后,push提示先pull,
    pull的时候就报这个错了,解决方法如下:

    git pull origin master --allow-unrelated-histories

    待续…(最近更新:2017.10.26)

    编辑日志:

    • 2017.5.3: 添加.gitignore注意事项
    • 2017.9.5: 排版与内容优化,勘误,新增查缺补漏
    • 2017.10.26:新增问题解决模块
    展开全文
  • Git&GitHub

    2019-04-21 12:23:12
    2、Git优势 ·大部分操作在本地完成,不需要联网 ·完整性保证 ·尽可能添加数据而不是删除或修改数据 ·分支操作非常快捷流畅(快照的形式进行管理) ·与 Linux 命令全面兼容 3、Git安装 ...
  • Git&GitHub;

    2018-11-20 10:12:21
    原本是一个网课的pdf课件,我又加上自己的整理、修改,对入门 git 和 github 有帮助。
  • git&github全解

    2020-11-21 21:23:21
    git原理: 本地包含三个部分:工作区、缓存区、版本库。工作区就是我们操作的文件,修改后的文件add到缓存取,也就是将修改保存到缓存区,缓存区确认无误的话可以commi到版本库,成为一个新的版本。 不过这个版本...
  • Git下载、安装与环境配置

    万次阅读 多人点赞 2018-10-12 20:34:22
    一、git下载与安装 百度git官网,下载链接,根据自己电脑系统下载相应的安装包, 下载最新版本,点击红框或篮筐处即可 点击下载好的安装包安装这个软件 一直点击next,直到出现install,点击install,安装完成...
  • Windows10下安装Git

    万次阅读 多人点赞 2018-06-04 17:55:05
    Git是一个开源的分布式版本控制系统,可以有效、高速的处理从很小到非常大的项目版本管理。具体安装步骤如下:第一步:先从官网下载最新版本的Git官网地址:https://git-scm.com/downloads点击上图中表示的地方进行...
  • Git的安装与使用教程(超详细!!!)

    万次阅读 多人点赞 2019-10-18 09:53:45
    git 提交 全部文件 1、get.add . git add xx 命令可以将xx文件添加到暂存区,如果有很多改动可以通过get add -A .来一次添加所有改变的文件。注意 -A 选项后面还有一个句点。git add -A 表示添加所有内容,git add ....
  • (详解)IDEA中使用git教程

    万次阅读 多人点赞 2019-06-08 21:26:12
    最近学习了一下VCS(Version Control System),这里我选择的是Git而不是SVN,因为Git在本地磁盘上就保留着所有当前项目的历史更新,所以处理起来速度飞快,这是使用空间换时间的处理方式。使用Git,即使在没有网络或...
  • GitHub教程 Git Bash详细教程

    万次阅读 多人点赞 2018-01-17 16:12:58
    作为一个萌新,我翻遍了网上的Git Bash教程,可能因为我理解力比较差,经常看不懂教程上在说什么。 (。-`ω´-)所以我决定自己一边摸索一边记录,写教程造福那些理解力跟我一样差的人…… 第一篇教程会涉及...
  • 03-廖雪峰Git教程笔记

    千次阅读 2018-07-29 20:54:01
    廖雪峰Git教程笔记 廖雪峰Git教程笔记 教程导图 集中式和分布式 配置信息 创建版本库 修改文件并提交 版本回退 工作区和暂存区 管理修改 撤销修改 删除文件 远程仓库 分支管理: 创建与合并分支: 删除指针,也...
  • Git fetch和git pull的区别

    万次阅读 多人点赞 2012-06-14 20:56:10
    Git中从远程的分支获取最新的版本到本地有这样2个命令:1.git fetch:相当于是从远程获取最新版本到本地,不会自动merge git fetch origin mastergit log -p master..origin/mastergit merge origin/maste...
  • 说明:该篇博客是博主一字一码编写的,实属不易,请尊重原创,...Git 是 Linus Torvalds 为了帮助管理 Linux 内核开发而开发的一个开放源码的版本控制软件。 2.首先要去GitHub官网注册一个账号 详细教程:https://b...
  •  作为集中式版本控制软件, svn并不是一无是处, 小型的开发, 还经常用到呢。... 现在, 我真心真意地向你推荐廖雪峰的Git教程, 网址:http://www.liaoxuefeng.com/wiki/0013739516305929606dd18361248578c...
  • git中文安装教程

    万次阅读 多人点赞 2018-05-06 00:06:36
    Git 中文安装教程 AUTHOR:谢宗南 https://creativecommons.org/licenses/by-nc-nd/4.0/deed.zh 本人 GitHub 原文地址 https://github.com/xiezongnan/Summarize/blob/master/git/Git_Setup.md Step 1...
  • Git撤销&回滚操作

    万次阅读 多人点赞 2017-05-02 19:32:00
    开发过程中,你肯定会遇到这样的场景:场景一: 糟了,我刚把不想要的代码,commit到...撤销上述场景一,在未进行git push前的所有操作,都是在“本地仓库”中执行的。我们暂且将“本地仓库”的代码还原操作叫做“撤
  • 廖雪峰的Git教程

    千次阅读 2016-04-08 17:06:09
    分布式版本控制 集中式版本控制系统版本库集中存放在中央服务器,中央服务器保存着最新最全的版本信息问题在于必须联网才能正常工作 ...git config --global user.email "email"其中,config命令的–global参数,表示
  • vscode使用git教程

    千次阅读 2020-03-14 09:49:19
    vscode使用git教程 git基本配置就不写了 vscode配置 直接上图清晰明了 按照图片出现的顺序 "git.path": "D:/Git/bin/git.exe", "terminal.integrated.shell.windows": "D://Git//bin//bash.exe", "git....
  • Git系列教材 (二)- 在Eclipse中使用 Git教程 步骤1:目的步骤2:eclipse 版本步骤3:使用git方式导入项目步骤4:选择Clone URI步骤5:输入git参数步骤6:是否提供密码提示步骤7:选择分支步骤8:本地存放位置步骤9:导入此...
  • 史上最详细Git使用教程

    万次阅读 多人点赞 2018-07-23 21:20:56
    本篇为廖雪峰老师官方网站中Git教程的学习笔记 Git是世界上最先进的分布式版本控制系统,克隆一个项目的速度非常快 每个开发都可以从master上克隆一个本地版本库,就算没有网络,也可以提交代码到本地仓库、查看...
  • 一、问题描述 在利用github实现多人合作程序开发的过程中,我们有时会出现错误提交的情况,此时... 使用git的每次提交,Git都会自动把它们串成一条时间线,这条时间线就是一个分支。如果没有新建分支,那么...
  • 史上最浅显易懂的Git教程

    万次阅读 多人点赞 2013-08-21 07:19:35
    从零起步的Git教程,让你无痛苦上手世界上最流行的分布式版本控制系统Git! 既然号称史上最浅显易懂的Git教程,那这个教程有什么让你怦然心动的特点呢? 首先,本教程绝对面向初学者,没有接触过版本控制概念的...
  • git 更新代码到本地

    万次阅读 多人点赞 2017-11-28 10:44:13
    git status(查看本地分支文件信息,确保更新时不产生冲突) git checkout – [file name] (若文件有修改,可以还原到最初状态; 若文件需要更新到服务器上,应该先merge到服务器,再更新到本地) git branch(查看...
  • 学习廖雪峰的Git教程

    千次阅读 2016-03-17 15:15:43
    学习廖雪峰的git教程:http://www.liaoxuefeng.com/wiki/0013739516305929606dd18361248578c67b8067c8c017b000 1.创建版本库: 在一个空目录下:git init 把这个目录变成Git可以管理的仓库。 2.添加文件到仓库: ...

空空如也

1 2 3 4 5 ... 20
收藏数 865,701
精华内容 346,280
关键字:

git