zoukankan      html  css  js  c++  java
  • git 的使用

    一、创建版本库
     
    cd 到 项目目录后:
    初始化一个Git仓库,使用git init命令。
    添加文件到Git仓库,分两步:
    • 第一步,使用命令git add <file>,注意,可反复多次使用,添加多个文件;
    • 第二步,使用命令git commit,完成。
    二、时光机穿梭
         
     
            版本回退
                
    • HEAD指向的版本就是当前版本,因此,Git允许我们在版本的历史之间穿梭,使用命令git reset --hard commit_id。
    • 穿梭前,用git log可以查看提交历史,以便确定要回退到哪个版本。
    • 要重返未来,用git reflog查看命令历史,以便确定要回到未来的哪个版本。
     
     
     
        工作区和暂存区
     
        

    工作区(Working Directory)

    就是你在电脑里能看到的目录,比如我的learngit文件夹就是一个工作区:

    版本库(Repository)

    工作区有一个隐藏目录.git,这个不算工作区,而是Git的版本库。
    Git的版本库里存了很多东西,其中最重要的就是称为stage(或者叫index)的暂存区,还有Git为我们自动创建的第一个分支master,以及指向master的一个指针叫HEAD。
    分支和HEAD的概念我们以后再讲。
    前面讲了我们把文件往Git版本库里添加的时候,是分两步执行的:
    第一步是用git add把文件添加进去,实际上就是把文件修改添加到暂存区;
    第二步是用git commit提交更改,实际上就是把暂存区的所有内容提交到当前分支。
    因为我们创建Git版本库时,Git自动为我们创建了唯一一个master分支,所以,现在,git commit就是往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 status查看一下状态:
    $ git status
    # On branch master# Changes not staged for commit:# (use "git add <file>..." to update what will be committed)# (use "git checkout -- <file>..." to discard changes in working directory)## modified: readme.txt## Untracked files:# (use "git add <file>..." to include in what will be committed)## LICENSE
    no changes added to commit (use "git add" and/or "git commit -a")
    Git非常清楚地告诉我们,readme.txt被修改了,而LICENSE还从来没有被添加过,所以它的状态是Untracked。
    现在,使用两次命令git add,把readme.txt和LICENSE都添加后,用git status再查看一下:
    $ git status
    # On branch master# Changes to be committed:# (use "git reset HEAD <file>..." to unstage)## new file: LICENSE# modified: readme.txt#
    现在,暂存区的状态就变成这样了:
    所以,git add命令实际上就是把要提交的所有修改放到暂存区(Stage),然后,执行git commit就可以一次性把暂存区的所有修改提交到分支。
    $ git commit -m "understand how stage works"
    [master 27c9860] understand how stage works
    2 files changed, 675 insertions(+)
    create mode 100644 LICENSE
    一旦提交后,如果你又没有对工作区做任何修改,那么工作区就是“干净”的:
    $ git status
    # On branch master
    nothing to commit (working directory clean)
    现在版本库变成了这样,暂存区就没有任何内容了:
     
     
     
        管理修改
     
    你会问,什么是修改?比如你新增了一行,这就是一个修改,删除了一行,也是一个修改,更改了某些字符,也是一个修改,删了一些又加了一些,也是一个修改,甚至创建一个新文件,也算一个修改。
    为什么说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 d4f25b6] 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 add -> 第二次修改 -> git commit
    你看,我们前面讲了,Git管理的是修改,当你用git add命令后,在工作区的第一次修改被放入暂存区,准备提交,但是,在工作区的第二次修改并没有放入暂存区,所以,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.
     
     
    撤销修改
     
    自然,你是不会犯错的。不过现在是凌晨两点,你正在赶一份工作报告,你在readme.txt中添加了一行:
    $ cat readme.txt
    Git is a distributed version control system.
    Git is free software distributed under the GPL.
    Git has a mutable index called stage.
    Git tracks changes of files.
    My stupid boss still prefers SVN.
    在你准备提交前,一杯咖啡起了作用,你猛然发现了“stupid boss”可能会让你丢掉这个月的奖金!
    既然错误发现得很及时,就可以很容易地纠正它。你可以删掉最后一行,手动把文件恢复到上一个版本的状态。如果用git status查看一下:
    $ git status
    # On branch master# Changes not staged for commit:# (use "git add <file>..." to update what will be committed)# (use "git checkout -- <file>..." to discard changes in working directory)## modified: readme.txt#
    no changes added to commit (use "git add" and/or "git commit -a")
    你可以发现,Git会告诉你,git checkout -- file可以丢弃工作区的修改:
    $ git checkout -- readme.txt
    命令git checkout -- readme.txt意思就是,把readme.txt文件在工作区的修改全部撤销,这里有两种情况:
    一种是readme.txt自修改后还没有被放到暂存区,现在,撤销修改就回到和版本库一模一样的状态;
    一种是readme.txt已经添加到暂存区后,又作了修改,现在,撤销修改就回到添加到暂存区后的状态。
    总之,就是让这个文件回到最近一次git commit或git add时的状态。
    现在,看看readme.txt的文件内容:
    $ cat readme.txt
    Git is a distributed version control system.
    Git is free software distributed under the GPL.
    Git has a mutable index called stage.
    Git tracks changes of files.
    文件内容果然复原了。
    git checkout -- file命令中的--很重要,没有--,就变成了“切换到另一个分支”的命令,我们在后面的分支管理中会再次遇到git checkout命令。
     
     
    删除文件
     
     

    删除文件

    阅读: 558500

    在Git中,删除也是一个修改操作,我们实战一下,先添加一个新文件test.txt到Git并且提交:
    $ git add test.txt
    $ git commit -m "add test.txt"
    [master 94cdc44] add test.txt
    1 file changed, 1 insertion(+)
    create mode 100644 test.txt
    一般情况下,你通常直接在文件管理器中把没用的文件删了,或者用rm命令删了:
    $ rm test.txt
    这个时候,Git知道你删除了文件,因此,工作区和版本库就不一致了,git status命令会立刻告诉你哪些文件被删除了:
    $ git status
    # On branch master# Changes not staged for commit:# (use "git add/rm <file>..." to update what will be committed)# (use "git checkout -- <file>..." to discard changes in working directory)## deleted: test.txt#
    no changes added to commit (use "git add" and/or "git commit -a")
    现在你有两个选择,一是确实要从版本库中删除该文件,那就用命令git rm删掉,并且git commit:
    $ git rm test.txt
    rm 'test.txt'
    $ git commit -m "remove test.txt"
    [master d17efd8] remove test.txt
    1 file changed, 1 deletion(-)
    delete mode 100644 test.txt
    现在,文件就从版本库中被删除了。
     
     
    另一种情况是删错了,因为版本库里还有呢,所以可以很轻松地把误删的文件恢复到最新版本:
    $ git checkout -- test.txt
    git checkout其实是用版本库里的版本替换工作区的版本,无论工作区是修改还是删除,都可以“一键还原”。
     
    三、远程仓库
     
    添加远程仓库
     
    现在的情景是,你已经在本地创建了一个Git仓库后,又想在GitHub创建一个Git仓库,并且让这两个仓库进行远程同步,这样,GitHub上的仓库既可以作为备份,又可以让其他人通过该仓库来协作,真是一举多得。
    首先,登陆GitHub,然后,在右上角找到“Create a new repo”按钮,创建一个新的仓库:
    在Repository name填入learngit,其他保持默认设置,点击“Create repository”按钮,就成功地创建了一个新的Git仓库:
    目前,在GitHub上的这个learngit仓库还是空的,GitHub告诉我们,可以从这个仓库克隆出新的仓库,也可以把一个已有的本地仓库与之关联,然后,把本地仓库的内容推送到GitHub仓库。
    现在,我们根据GitHub的提示,在本地的learngit仓库下运行命令:
    $ git remote add origin git@github.com:michaelliao/learngit.git
    请千万注意,把上面的michaelliao替换成你自己的GitHub账户名,否则,你在本地关联的就是我的远程库,关联没有问题,但是你以后推送是推不上去的,因为你的SSH Key公钥不在我的账户列表中。
    添加后,远程库的名字就是origin,这是Git默认的叫法,也可以改成别的,但是origin这个名字一看就知道是远程库。
    下一步,就可以把本地库的所有内容推送到远程库上:
    $ git push -u origin master
    Counting objects: 19, done.
    Delta compression using up to 4 threads.
    Compressing objects: 100% (19/19), done.
    Writing objects: 100% (19/19), 13.73 KiB, done.
    Total 23 (delta 6), reused 0 (delta 0)
    To git@github.com:michaelliao/learngit.git
    * [new branch] master -> master
    Branch master set up to track remote branch master from origin.
    把本地库的内容推送到远程,用git push命令,实际上是把当前分支master推送到远程。
    由于远程库是空的,我们第一次推送master分支时,加上了-u参数,Git不但会把本地的master分支内容推送的远程新的master分支,还会把本地的master分支和远程的master分支关联起来,在以后的推送或者拉取时就可以简化命令。
     
     
     
    推送成功后,可以立刻在GitHub页面中看到远程库的内容已经和本地一模一样:
    从现在起,只要本地作了提交,就可以通过命令:
    $ git push origin master
    把本地master分支的最新修改推送至GitHub,现在,你就拥有了真正的分布式版本库!

    SSH警告

    当你第一次使用Git的clone或者push命令连接GitHub时,会得到一个警告:
    The authenticity of host 'github.com (xx.xx.xx.xx)' can't be established.
    RSA key fingerprint is xx.xx.xx.xx.xx.
    Are you sure you want to continue connecting (yes/no)?
    这是因为Git使用SSH连接,而SSH连接在第一次验证GitHub服务器的Key时,需要你确认GitHub的Key的指纹信息是否真的来自GitHub的服务器,输入yes回车即可。
    Git会输出一个警告,告诉你已经把GitHub的Key添加到本机的一个信任列表里了:
    Warning: Permanently added 'github.com' (RSA) to the list of known hosts.
    这个警告只会出现一次,后面的操作就不会有任何警告了。
    如果你实在担心有人冒充GitHub服务器,输入yes前可以对照GitHub的RSA Key的指纹信息是否与SSH连接给出的一致。
     
     
    从远程仓库克隆
     
     
     
    上次我们讲了先有本地库,后有远程库的时候,如何关联远程库。
    现在,假设我们从零开发,那么最好的方式是先创建远程库,然后,从远程库克隆。
    首先,登陆GitHub,创建一个新的仓库,名字叫gitskills:
    我们勾选Initialize this repository with a README,这样GitHub会自动为我们创建一个README.md文件。创建完毕后,可以看到README.md文件:
    现在,远程库已经准备好了,下一步是用命令git clone克隆一个本地库:
    $ git clone git@github.com:michaelliao/gitskills.git
    Cloning into 'gitskills'...
    remote: Counting objects: 3, done.
    remote: Total 3 (delta 0), reused 0 (delta 0)
    Receiving objects: 100% (3/3), done.
     
    $ cd gitskills
    $ ls
    README.md
    注意把Git库的地址换成你自己的,然后进入gitskills目录看看,已经有README.md文件了。
     
     
     
    四、分支管理
     
    创建与合并分支
     
        
              查看分支:git branch
            创建分支:git branch <name>
             切换分支:git checkout <name>
            创建+切换分支:git checkout -b <name>
            合并某分支到当前分支:git merge <name>
            删除分支:git branch -d <name>
     
     
    解决分支冲突
     
     
    人生不如意之事十之八九,合并分支往往也不是一帆风顺的。
    准备新的feature1分支,继续我们的新分支开发:
    $ git checkout -b feature1
    Switched to a new branch 'feature1'
    修改readme.txt最后一行,改为:
    Creating a new branch is quick AND simple.
    在feature1分支上提交:
    $ git add readme.txt
    $ git commit -m "AND simple"
    [feature1 75a857c] AND simple
    1 file changed, 1 insertion(+), 1 deletion(-)
    切换到master分支:
    $ git checkout master
    Switched to branch 'master'
    Your branch is ahead of 'origin/master' by 1 commit.
    Git还会自动提示我们当前master分支比远程的master分支要超前1个提交。
    在master分支上把readme.txt文件的最后一行改为:
    Creating a new branch is quick & simple.
    提交:
    $ git add readme.txt
    $ git commit -m "& simple"
    [master 400b400] & simple
    1 file changed, 1 insertion(+), 1 deletion(-)
    现在,master分支和feature1分支各自都分别有新的提交,变成了这样:
    这种情况下,Git无法执行“快速合并”,只能试图把各自的修改合并起来,但这种合并就可能会有冲突,我们试试看:
    $ git merge feature1
    Auto-merging readme.txt
    CONFLICT (content): Merge conflict in readme.txt
    Automatic merge failed; fix conflicts and then commit the result.
    果然冲突了!Git告诉我们,readme.txt文件存在冲突,必须手动解决冲突后再提交。git status也可以告诉我们冲突的文件:
    $ git status
    # On branch master# Your branch is ahead of 'origin/master' by 2 commits.## Unmerged paths:# (use "git add/rm <file>..." as appropriate to mark resolution)## both modified: readme.txt#
    no changes added to commit (use "git add" and/or "git commit -a")
    我们可以直接查看readme.txt的内容:
    Git is a distributed version control system.
    Git is free software distributed under the GPL.
    Git has a mutable index called stage.
    Git tracks changes of files.
    <<<<<<< HEADCreating a new branch is quick & simple.
    =======Creating a new branch is quick AND simple.
    >>>>>>> feature1
    Git用<<<<<<<,=======,>>>>>>>标记出不同分支的内容,我们修改如下后保存:
    Creating a new branch is quick and simple.
    再提交:
    $ git add readme.txt
    $ git commit -m "conflict fixed"
    [master 59bc1cb] conflict fixed
    现在,master分支和feature1分支变成了下图所示:
    用带参数的git log也可以看到分支的合并情况:
    $ git log --graph --pretty=oneline --abbrev-commit
    * 59bc1cb conflict fixed
    |
    | * 75a857c AND simple
    * | 400b400 & simple
    |/
    * fec145a branch test
    ...
    最后,删除feature1分支:
    $ git branch -d feature1
    Deleted branch feature1 (was 75a857c).
    工作完成。
     
     
    分支管理策略
     
    通常,合并分支时,如果可能,Git会用Fast forward模式,但这种模式下,删除分支后,会丢掉分支信息。
    如果要强制禁用Fast forward模式,Git就会在merge时生成一个新的commit,这样,从分支历史上就可以看出分支信息。
    下面我们实战一下--no-ff方式的git merge:
    首先,仍然创建并切换dev分支:
    $ git checkout -b dev
    Switched to a new branch 'dev'
    修改readme.txt文件,并提交一个新的commit:
    $ git add readme.txt
    $ git commit -m "add merge"
    [dev 6224937] add merge
    1 file changed, 1 insertion(+)
    现在,我们切换回master:
    $ git checkout master
    Switched to branch 'master'
    准备合并dev分支,请注意--no-ff参数,表示禁用Fast forward:
    $ git merge --no-ff -m "merge with no-ff" dev
    Merge made by the 'recursive' strategy.
    readme.txt | 1 +
    1 file changed, 1 insertion(+)
    因为本次合并要创建一个新的commit,所以加上-m参数,把commit描述写进去。
    合并后,我们用git log看看分支历史:
    $ git log --graph --pretty=oneline --abbrev-commit
    * 7825a50 merge with no-ff
    |
    | * 6224937 add merge
    |/
    * 59bc1cb conflict fixed
    ...
    可以看到,不使用Fast forward模式,merge后就像这样:
     
     
    feature分支
     
     
     
    件开发中,总有无穷无尽的新的功能要不断添加进来。
    添加一个新功能时,你肯定不希望因为一些实验性质的代码,把主分支搞乱了,所以,每添加一个新功能,最好新建一个feature分支,在上面开发,完成后,合并,最后,删除该feature分支。
    现在,你终于接到了一个新任务:开发代号为Vulcan的新功能,该功能计划用于下一代星际飞船。
    于是准备开发:
    $ git checkout -b feature-vulcan
    Switched to a new branch 'feature-vulcan'
    5分钟后,开发完毕:
    $ git add vulcan.py
    $ git status
    # On branch feature-vulcan# Changes to be committed:# (use "git reset HEAD <file>..." to unstage)## new file: vulcan.py#$ git commit -m "add feature vulcan"
    [feature-vulcan 756d4af] add feature vulcan
    1 file changed, 2 insertions(+)
    create mode 100644 vulcan.py
    切回dev,准备合并:
    $ git checkout dev
    一切顺利的话,feature分支和bug分支是类似的,合并,然后删除。
    但是,
    就在此时,接到上级命令,因经费不足,新功能必须取消!
    虽然白干了,但是这个分支还是必须就地销毁:
    $ git branch -d feature-vulcan
    error: The branch 'feature-vulcan' is not fully merged.
    If you are sure you want to delete it, run 'git branch -D feature-vulcan'.
    销毁失败。Git友情提醒,feature-vulcan分支还没有被合并,如果删除,将丢失掉修改,如果要强行删除,需要使用命令git branch -D feature-vulcan。
    现在我们强行删除:
    $ git branch -D feature-vulcan
    Deleted branch feature-vulcan (was 756d4af).
    终于删除成功!
     
    总结:        开发一个新feature,最好新建一个分支;
                    如果要丢弃一个没有被合并过的分支,可以通过git branch -D <name>强行删除。
     
     
        协作开发
     
    当你从远程仓库克隆时,实际上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分支是否推到远程,取决于你是否和你的小伙伴合作在上面开发。
    总之,就是在Git中,分支完全可以在本地自己藏着玩,是否推送,视你的心情而定!
     
     

    抓取分支

    多人协作时,大家都会往master和dev分支上推送各自的修改。
    现在,模拟一个你的小伙伴,可以在另一台电脑(注意要把SSH Key添加到GitHub)或者同一台电脑的另一个目录下克隆:
    $ git clone git@github.com:michaelliao/learngit.git
    Cloning into 'learngit'...
    remote: Counting objects: 46, done.
    remote: Compressing objects: 100% (26/26), done.
    remote: Total 46 (delta 16), reused 45 (delta 15)
    Receiving objects: 100% (46/46), 15.69 KiB | 6 KiB/s, done.
    Resolving deltas: 100% (16/16), done.
    当你的小伙伴从远程库clone时,默认情况下,你的小伙伴只能看到本地的master分支。不信可以用git branch命令看看:
    $ git branch
    * master
    现在,你的小伙伴要在dev分支上开发,就必须创建远程origin的dev分支到本地,于是他用这个命令创建本地dev分支:
    $ git checkout -b dev origin/dev
    现在,他就可以在dev上继续修改,然后,时不时地把dev分支push到远程:
    $ git commit -m "add /usr/bin/env"
    [dev 291bea8] add /usr/bin/env
    1 file changed, 1 insertion(+)
    $ git push origin dev
    Counting objects: 5, done.
    Delta compression using up to 4 threads.
    Compressing objects: 100% (2/2), done.
    Writing objects: 100% (3/3), 349 bytes, done.
    Total 3 (delta 0), reused 0 (delta 0)
    Togit@github.com:michaelliao/learngit.git
    fc38031..291bea8 dev -> dev
     
     
     
    你的小伙伴已经向origin/dev分支推送了他的提交,而碰巧你也对同样的文件作了修改,并试图推送:
    $ git add hello.py
    $ git commit -m "add coding: utf-8"
    [dev bd6ae48] add coding: utf-8
    1 file changed, 1 insertion(+)
    $ git push origin dev
    Togit@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. Merge the remote changes (e.g. 'git pull')
    hint: before pushing again.
    hint: See the 'Note about fast-forwards' in 'git push --help' for details.
    推送失败,因为你的小伙伴的最新提交和你试图推送的提交有冲突,解决办法也很简单,Git已经提示我们,先用git pull把最新的提交从origin/dev抓下来,然后,在本地合并,解决冲突,再推送:
    $ git pull
    remote: Counting objects: 5, done.
    remote: Compressing objects: 100% (2/2), done.
    remote: Total 3 (delta 0), reused 3 (delta 0)
    Unpacking objects: 100% (3/3), done.
    fc38031..291bea8 dev -> origin/dev
    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 dev origin/<branch>
    git pull也失败了,原因是没有指定本地dev分支与远程origin/dev分支的链接,根据提示,设置dev和origin/dev的链接:
    $ git branch --set-upstream dev origin/dev
    Branch dev set up to track remote branch dev from origin.
    再pull:
    $ git pull
    Auto-merging hello.py
    CONFLICT (content): Merge conflict in hello.py
    Automatic merge failed; fix conflicts and then commit the result.
    这回git pull成功,但是合并有冲突,需要手动解决,解决的方法和分支管理中的解决冲突完全一样。解决后,提交,再push:
    $ git commit -m "merge & fix hello.py"
    [dev adca45d] merge & fix hello.py
    $ git push origin dev
    Counting objects: 10, done.
    Delta compression using up to 4 threads.
    Compressing objects: 100% (5/5), done.
    Writing objects: 100% (6/6), 747 bytes, done.
    Total 6 (delta 0), reused 0 (delta 0)
    Togit@github.com:michaelliao/learngit.git
    291bea8..adca45d dev -> dev
     
     
     
    总结 :
                
    • 查看远程库信息,使用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,如果有冲突,要先处理冲突。
     
     
    五、标签管理
     
        创建标签
            
    • 命令git tag <name>用于新建一个标签,默认为HEAD,也可以指定一个commit id;
    • git tag -a <tagname> -m "blablabla..."可以指定标签信息;
    • git tag -s <tagname> -m "blablabla..."可以用PGP签名标签;
    • 命令git tag可以查看所有标签。
     
        操作标签
     
            如果标签打错了,也可以删除:
    $ git tag -d v0.1Deleted tag 'v0.1' (was e078af9)
    因为创建的标签都只存储在本地,不会自动推送到远程。所以,打错的标签可以在本地安全删除。
    如果要推送某个标签到远程,使用命令git push origin <tagname>:
    $ git push origin v1.0Total 0 (delta 0), reused 0 (delta 0)
    To git@github.com:michaelliao/learngit.git
    * [new tag] v1.0 -> v1.0
    或者,一次性推送全部尚未推送到远程的本地标签:
    $ git push origin --tags
    Counting objects: 1, done.
    Writing objects: 100% (1/1), 554 bytes, done.
    Total 1 (delta 0), reused 0 (delta 0)
    To git@github.com:michaelliao/learngit.git
    * [new tag] v0.2 -> v0.2
    * [new tag] v0.9 -> v0.9
    如果标签已经推送到远程,要删除远程标签就麻烦一点,先从本地删除:
    $ git tag -d v0.9Deleted tag 'v0.9' (was 6224937)
    然后,从远程删除。删除命令也是push,但是格式如下:
    $ git push origin :refs/tags/v0.9To git@github.com:michaelliao/learngit.git
    - [deleted] v0.9
    要看看是否真的从远程库删除了标签,可以登陆GitHub查看。
     
     
     
     
     
     
        
     
  • 相关阅读:
    angularJS之路由
    angularJS之ng-repeat
    智能算法之Matlab实现(1)——遗传算法(1)
    如何快速处理线上故障
    测试计划怎么写
    接口测试基础
    HTTP 的一些问题
    DevOps简介
    什么是DevOps?
    HTTPS 如何保证数据传输的安全性
  • 原文地址:https://www.cnblogs.com/zuoshoushizi/p/8066235.html
Copyright © 2011-2022 走看看