git命令_git命令总结 - CSDN
精华内容
参与话题
  • git命令大全(非常齐全)

    万次阅读 多人点赞 2016-02-25 13:05:02
    git命令大全
    $ git init  // 初始化一个Git仓库
    $ git status   // 查看仓库的状态
    $ git add .   // 将所有修改添加到暂存区
    $ git add *  // Ant风格添加修改
    $ git add *Controller   // 将以Controller结尾的文件的所有修改添加到暂存区
    $ git add Hello*   // 将所有以Hello开头的文件的修改添加到暂存区 例如:HelloWorld.txt,Hello.java,HelloGit.txt ...
    $ git add Hello?   // 将以Hello开头后面只有一位的文件的修改提交到暂存区 例如:Hello1.txt,HelloA.java 如果是HelloGit.txt或者Hello.java是不会被添加的
    可以多次添加然后在提交
    $ git commit -m "comment"  // 将暂存区的修改提交到仓库 后面添加上有意义的注视信息
    $ git diff  file  // 在file被修改了还未提交的时候查看修改的部分(和版本库中最新版本的不同 diff == difference 不同)
    $ git log  // 查看git的commit信息,每次提交的信息包括注视在内,从最新提交到最久提交
    $ git log --pretty=oneline   // 将commit 信息简化成一行显示
    注意Git的版本号(commit id)是SHA1值ea34578d5496d7dd233c827ed32a8cd576c5ee85
    $ git reset --hard HEAD^   // 退回到相对于当前版本的上一个版本 HEAD 表示当前版本
    $ git reset --hard HEAD^^  // 退回到相对于当前版本的上上一个版本  HEAD 代表当前版本
    $ git reset --hard HEAD~100 //退回到相对于当前版本的上 100 个版本去  HEAD 表示当前版本
    $ git reset --hard 3628164  // 退回到指定的版本   这里不需要全部写commit id  Git 回去自动适配
    Git的版本回退速度非常快,因为Git在内部有个指向当前版本的HEAD指针,当你回退版本的时候,Git仅仅是把HEAD从指向append GPL
    $ git reflog   // 在退回到旧版本之后可以查看旧版本之前的提交日志
    当我们想从一个旧版本退回到新版本但是我们关闭了shell窗口,不能查看之前的commit id了,就可以通过
    $ git reflog 查看到之前的版本的commit id
    $ git reset --hard 3628164


    工作区和暂存区
    工作区: 就是我们通$ git init 创建的代码库的所有文件但是不包括 .git文件(版本库)
    暂存区: 我们通过$ git add ./*/*Xxx/Xxxx* 添加的修改,都是进入到暂存区了,肉眼不可见 通过 $ git status  可以看到修改的状态
    什么是修改?
      比如你新增了一行,这就是一个修改,
      删除了一行,也是一个修改,
      更改了某些字符,也是一个修改,
      删了一些又加了一些,也是一个修改,
      甚至创建一个新文件,也算一个修改。


    修改只能在被add 到暂存区以后才能被提交
    在file 已经修改还未add的时候
    $ git checkout --file  // 表示丢弃工作区的修改退回原始状态(不包括以及添加到暂存区的修改)
    file已经修改和添加到了暂存区,还未commit
    $ git reset HEAD file   // 丢弃file已经添加到暂存区的修改  HEAD 表示最新版本


    如果file修改已经提交到本地仓库
    $ git reset --hard HEAD^   //退回到上一个版本


    $ rm file  // 从文件系统中删除文件(Git 中还是有记录),$ git status 的时候Git 会告诉你有一个file 被删除了
    $ git rm file  // 从Git版本库中删除文件(同时从文件系统中删除文件) $ git status  正常


    $ git rm file  // 从git版本库中删除文件
    $ git commit -m "delete file" // 提交删除
    $ git checkout file  // 想要从git恢复 会出现:error: pathspec 'README.txt' did not match any file(s) known to git.
    $ git reset --hard HEAD^  // 恢复到上一个版本 可以恢复文件


    $ rm file   //在文件系统中删除文件
    $ git checkout file  // 由于是通过文件系统删除的所以可以通过checkout恢复


    $ ssh-keygen -t rsa -C "youremail@example.com"  // 创建SSH Key
    由于这个Key也不是用于军事目的,所以也无需设置密码,所以一路回车就好,
    如果顺利会在user下UserName目录中生成一个.ssh目录里面有id_rsa和id_rsa.pub两个文件
    id_rsa是私钥,不能泄露出去,id_rsa.pub是公钥,可以告诉他人还有在github上添加的也是这个公钥
    登陆GitHub,打开“Account settings”,“SSH Keys”页面,点“Add SSH Key”,填上任意Title,在Key文本框里粘贴id_rsa.pub文件的内容
    GitHub允许你添加多个Key。假定你有若干电脑,你一会儿在公司提交,一会儿在家里提交,只要把每台电脑的Key都添加到GitHub,就可以在每台电脑上往GitHub推送了


    添加远程库
    做全局的配置
    $ git config --global user.name "zhangsan"
    $ git config --global user.email "zhangsan@139.com"
    $ git remote add origin git@github.com:zhangsan/ylez.git // 添加一个远程仓库
      // add origin 就是添加一个远程仓库
      // git@github.com:zhangsan/ylez.git  是远程仓库的地址
      // git@github.com 主机的地址  我们可以通过GitLab大家自己的git服务器
      // zhangsan 是你的用户名
      // /ylez.git 是你的仓库名
    $ git push -u origin master  // 将本地的master分支推送到远程的master分支中
    $ git push -u origin dev    // 本地切换到dev分支然后将本地的dev分支推送到远程


    克隆远程仓库到本地
    Git支持多种协议,包括https,但通过ssh支持的原生git协议速度最快。
    $ git clone git@192.168.0.8:zhangsan/test.git  // 讲一个远程的仓库克隆到本地




    每次提交,Git都把它们串成一条时间线,这条时间线就是一个分支
    在Git里,默认有一个主分支,即master分支
    HEAD严格来说不是指向提交,而是指向master,master才是指向提交的,所以,HEAD指向的就是当前分支
    master分支是一条线,Git用master指向最新的提交,再用HEAD指向master
    每次提交,master分支都会向前移动一步,这样,随着你不断提交,master分支的线也越来越长
    Git新建了一个指针叫dev,指向master相同的提交,再把HEAD指向dev,就表示当前分支在dev上


    $ git branch   // 查看git的所有分支
    $ git branch dev  // 创建dev分支
    $ git checkout dev  // 切换到一个已经存在的分支
    $ git checkout -b dev  // 创建dev分支,并切换到dev分支
    $ git branch -d dev  // 删除dev分支


    $ git checkout master  // 切换到主分支
    $ git merge dev   // 将dev分支合并到master分支
    Updating d17efd8..fec145a
    Fast-forward
     readme.txt |    1 +
     1 file changed, 1 insertion(+)
    Fast-forward信息,Git告诉我们,这次合并是“快进模式”,就是直接把master指向dev的当前提交,所以合并速度非常快
    $ git branch -d dev  // 删除dev分支


    现在只是剩下master分支,感觉什么事情都没又发生一样


    处理冲突
    $ git checkout -b feature1
    Switched to a new branch 'feature1'


    修改readme.txt最后一行,改为:
    Creating a new branch is quick AND simple.


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


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


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


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


    Git用<<<<<<<,=======,>>>>>>>标记出不同分支的内容,我们修改如下后保存:
    Creating a new branch is quick and simple.


    再提交:
    $ git add readme.txt
    $ git commit -m "conflict fixed"
    [master 59bc1cb] conflict fixed


    用带参数的git log也可以看到分支的合并情况:
    $ git log --graph --pretty=oneline --abbrev-commit
    $ 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,这样,从分支历史上就可以看出分支信息
    $ git merge --no-ff -m "comment" dev  // 准备合并dev分支,请注意--no-ff参数,表示禁用Fast forward


    $ git log --graph --pretty=oneline --abbrev-commit  //图形化展示分支情况
    *   7825a50 merge with no-ff
    |\
    | * 6224937 add merge
    |/
    *   59bc1cb conflict fixed
    ...


    修复一个代号101的bug的任务时,很自然地,你想创建一个分支issue-101来修复它
    在修复bug时候,手里还有工作没有完成但是又不能提交可以将进度冻结
    在你当前的工作区(分支)
    $ git stash  // 冻结当前的分支修改


    查看所有的stash
    $ git stash list  // 列出所有的工作现场存储
    $ git stash list
    stash@{0}: WIP on dev: 6224937 add merge
    $ git stash apply (stash@{n}) // 恢复工作现场(只有一个的时候可以省略后面的,如果有多个可以恢复指定的某一个stash)但是不删除存储中的stash
    $ git stash drop (stash@{n})  // 删除存储的工作现场(只有一个的时候可以省略后面的,如果又多个就指定删除某一个)
    $ git stash pop (stash@{n})  // 恢复的同时把stash内容也删了(只有一个的时候可以省略后面的,如果又多个就指定删除某一个)


    $ git branch -d branchName  // 删除某一个分支,前提是在该分支和产生该分支的主分支已经合并了(merge)
    $ git branch -D branchName  // 删除某一个分支,无论是否合并都强制删除




    当你从远程仓库克隆时,实际上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)


    并不是一定要把本地分支往远程推送,那么,哪些分支需要推送,哪些不需要呢?
      master分支是主分支,因此要时刻与远程同步;
      dev分支是开发分支,团队所有成员都需要在上面工作,所以也需要与远程同步;
      bug分支只用于在本地修复bug,就没必要推到远程了,除非老板要看看你每周到底修复了几个bug;
      feature分支是否推到远程,取决于你是否和你的小伙伴合作在上面开发。


    推送的时候如果有人在你之前已经推送了,推送失败
    $ git push origin dev
      To git@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  //抓去远程的分支的提交到本地


    没有指定本地dev分支与远程origin/dev分支的链接,推送也会失败,所以首先我们需要建立本地分支和远程分支的联系
    $ git branch --set-upstream dev origin/dev  // 建立本地dev 分支和远程dev分支的联系
    Branch dev set up to track remote branch dev from origin.


    总结:
    查看远程库信息,使用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的标签虽然是版本库的快照,但其实它就是指向某个commit的指针(跟分支很像对不对?但是分支可以移动,标签不能移动),所以,创建和删除标签都是瞬间完成的。


    标签一般打在master分支上
    $ git tag v1.0  // 在当前版本HEAD上打一个名称为v1.0 的标签
    $ git tag   // 查看所有标签,会列表出所有的标签名


    为历史commit打tag(有时候忘记打标签了本来该星期一打结果星期五才想起来)
    $ git log --pretty=oneline --abbrev-commit
    6a5819e merged bug fix 101
    cc17032 fix bug 101
    7825a50 merge with no-ff
    6224937 add merge
    59bc1cb conflict fixed
    400b400 & simple
    75a857c AND simple
    fec145a branch test
    d17efd8 remove test.txt


    $ git tag v0.8 59bc1cb // 为commit id 为59bc1cb...的commit打上v0.8 标签
    标签不是按时间顺序列出,而是按字母排序的。可以用git show <tagname>查看标签信息


    还可以创建带有说明的标签,用-a指定标签名,-m指定说明文字:
    $ git tag -a v0.1 -m "version 0.1 released" 3628164  // 为commit id为3628164...的commit打上v0.1 的标签注视内容是version 0.1 released


    $ git tag v0.1 //可以查看标签的信息包括文字说明
    还可以通过-s用私钥签名一个标签:
    $ git tag -s v0.2 -m "signed version 0.2 released" fec145a
    签名采用PGP签名,因此,必须首先安装gpg(GnuPG),如果没有找到gpg,或者没有gpg密钥对,就会报错:
    gpg: signing failed: secret key not available
    error: gpg failed to sign the data
    error: unable to sign the tag
    如果报错,请参考GnuPG帮助文档配置Key。


    用命令git show <tagname>可以看到PGP签名信息:
    $ git show v0.2


    $ git tag -d v0.1   // 删除标签 v0.1
    $ git push -u origin v1.0  // 将标签v1.0 推送到远程仓库
    $ git push -u origin --tags   // 一次性推送全部标签


    如果标签已经推送到远程,要删除远程标签就麻烦一点,先从本地删除:
    $ git tag -d v0.9
    Deleted tag 'v0.9' (was 6224937)


    然后,从远程删除。删除命令也是push,但是格式如下:
    $ git push origin :refs/tags/v0.9
    To git@github.com:michaelliao/learngit.git
     - [deleted]         v0.9


    在Git工作区的根目录下创建一个特殊的.gitignore文件,然后把要忽略的文件名填进去,Git就会自动忽略这些文件
    忽略文件的原则是:


    忽略操作系统自动生成的文件,比如缩略图等;
    忽略编译生成的中间文件、可执行文件等,也就是如果一个文件是通过另一个文件自动生成的,那自动生成的文件就没必要放进版本库,比如Java编译产生的.class文件;
    忽略你自己的带有敏感信息的配置文件,比如存放口令的配置文件。
    一个完整的.gitignore文件
    # Windows:
    Thumbs.db
    ehthumbs.db
    Desktop.ini


    #project
    *.class
    *.war
    classes
    target


    首先从git上checkout最新的代码默认是checkout主分支master分支的代码,所以我们需要再次checkout开发分支的代码
    master分支是最新稳定版,而dev分支是最新的开发版
    一定要记得从服务器上checout而不是在本地创建新分支,如果做新的功能是在前面2步后,在本地的dev分支上checkout新的子分支

    然后开发,提交合并到dev,push到代码服务器中.


    如果想要详细的学习请参考:

    http://www.liaoxuefeng.com/wiki/0013739516305929606dd18361248578c67b8067c8c017b000

    展开全文
  • Git 常用命令大全

    万次阅读 多人点赞 2012-09-20 16:30:03
    Git 是一个很强大的分布式版本控制系统。它不但适用于管理大型开源软件的源代码,管理私人的文档和源代码也有很多优势。 Git常用操作命令: 1) 远程仓库相关命令 检出仓库:$ git clone git://github...
    
    

    Git 是一个很强大的分布式版本控制系统。它不但适用于管理大型开源软件的源代码,管理私人的文档和源代码也有很多优势。

    Git常用操作命令:

    1) 远程仓库相关命令

    检出仓库:$ git clone git://github.com/jquery/jquery.git

    查看远程仓库:$ git remote -v

    添加远程仓库:$ git remote add [name] [url]

    删除远程仓库:$ git remote rm [name]

    修改远程仓库:$ git remote set-url --push [name] [newUrl]

    拉取远程仓库:$ git pull [remoteName] [localBranchName]

    推送远程仓库:$ git push [remoteName] [localBranchName]

     

    *如果想把本地的某个分支test提交到远程仓库,并作为远程仓库的master分支,或者作为另外一个名叫test的分支,如下:

    $git push origin test:master         // 提交本地test分支作为远程的master分支

    $git push origin test:test              // 提交本地test分支作为远程的test分支

     

    2)分支(branch)操作相关命令

    查看本地分支:$ git branch

    查看远程分支:$ git branch -r

    创建本地分支:$ git branch [name] ----注意新分支创建后不会自动切换为当前分支

    切换分支:$ git checkout [name]

    创建新分支并立即切换到新分支:$ git checkout -b [name]

    删除分支:$ git branch -d [name] ---- -d选项只能删除已经参与了合并的分支,对于未有合并的分支是无法删除的。如果想强制删除一个分支,可以使用-D选项

    合并分支:$ git merge [name] ----将名称为[name]的分支与当前分支合并

    创建远程分支(本地分支push到远程):$ git push origin [name]

    删除远程分支:$ git push origin :heads/[name] 或 $ gitpush origin :[name] 

     

    *创建空的分支:(执行命令之前记得先提交你当前分支的修改,否则会被强制删干净没得后悔)

    $git symbolic-ref HEAD refs/heads/[name]

    $rm .git/index

    $git clean -fdx

     

    3)版本(tag)操作相关命令

    查看版本:$ git tag

    创建版本:$ git tag [name]

    删除版本:$ git tag -d [name]

    查看远程版本:$ git tag -r

    创建远程版本(本地版本push到远程):$ git push origin [name]

    删除远程版本:$ git push origin :refs/tags/[name]

    合并远程仓库的tag到本地:$ git pull origin --tags

    上传本地tag到远程仓库:$ git push origin --tags

    创建带注释的tag:$ git tag -a [name] -m 'yourMessage'

     

    4) 子模块(submodule)相关操作命令

    添加子模块:$ git submodule add [url] [path]

       如:$git submodule add git://github.com/soberh/ui-libs.git src/main/webapp/ui-libs

    初始化子模块:$ git submodule init  ----只在首次检出仓库时运行一次就行

    更新子模块:$ git submodule update ----每次更新或切换分支后都需要运行一下

    删除子模块:(分4步走哦)

     1) $ git rm --cached [path]

     2) 编辑“.gitmodules”文件,将子模块的相关配置节点删除掉

     3) 编辑“ .git/config”文件,将子模块的相关配置节点删除掉

     4) 手动删除子模块残留的目录

     

    5)忽略一些文件、文件夹不提交

    在仓库根目录下创建名称为“.gitignore”的文件,写入不需要的文件夹名或文件,每个元素占一行即可,如

    target

    bin

    *.db

     

    =====================

    Git 常用命令

    git branch 查看本地所有分支
    git status 查看当前状态 
    git commit 提交 
    git branch -a 查看所有的分支
    git branch -r 查看本地所有分支
    git commit -am "init" 提交并且加注释 
    git remote add origin git@192.168.1.119:ndshow
    git push origin master 将文件给推到服务器上 
    git remote show origin 显示远程库origin里的资源 
    git push origin master:develop
    git push origin master:hb-dev 将本地库与服务器上的库进行关联 
    git checkout --track origin/dev 切换到远程dev分支
    git branch -D master develop 删除本地库develop
    git checkout -b dev 建立一个新的本地分支dev
    git merge origin/dev 将分支dev与当前分支进行合并
    git checkout dev 切换到本地dev分支
    git remote show 查看远程库
    git add .
    git rm 文件名(包括路径) 从git中删除指定文件
    git clone git://github.com/schacon/grit.git 从服务器上将代码给拉下来
    git config --list 看所有用户
    git ls-files 看已经被提交的
    git rm [file name] 删除一个文件
    git commit -a 提交当前repos的所有的改变
    git add [file name] 添加一个文件到git index
    git commit -v 当你用-v参数的时候可以看commit的差异
    git commit -m "This is the message describing the commit" 添加commit信息
    git commit -a -a是代表add,把所有的change加到git index里然后再commit
    git commit -a -v 一般提交命令
    git log 看你commit的日志
    git diff 查看尚未暂存的更新
    git rm a.a 移除文件(从暂存区和工作区中删除)
    git rm --cached a.a 移除文件(只从暂存区中删除)
    git commit -m "remove" 移除文件(从Git中删除)
    git rm -f a.a 强行移除修改后文件(从暂存区和工作区中删除)
    git diff --cached 或 $ git diff --staged 查看尚未提交的更新
    git stash push 将文件给push到一个临时空间中
    git stash pop 将文件从临时空间pop下来
    ---------------------------------------------------------
    git remote add origin git@github.com:username/Hello-World.git
    git push origin master 将本地项目给提交到服务器中
    -----------------------------------------------------------
    git pull 本地与服务器端同步
    -----------------------------------------------------------------
    git push (远程仓库名) (分支名) 将本地分支推送到服务器上去。
    git push origin serverfix:awesomebranch
    ------------------------------------------------------------------
    git fetch 相当于是从远程获取最新版本到本地,不会自动merge
    git commit -a -m "log_message" (-a是提交所有改动,-m是加入log信息) 本地修改同步至服务器端 :
    git branch branch_0.1 master 从主分支master创建branch_0.1分支
    git branch -m branch_0.1 branch_1.0 将branch_0.1重命名为branch_1.0
    git checkout branch_1.0/master 切换到branch_1.0/master分支
    du -hs

    -----------------------------------------------------------
    mkdir WebApp
    cd WebApp
    git init
    touch README
    git add README
    git commit -m 'first commit'
    git remote add origin git@github.com:daixu/WebApp.git
    git push -u origin master

     

    Git 常用命令图表 


    图片转自:http://www.cnblogs.com/1-2-3/archive/2010/07/18/git-commands.html

    本文转自:http://hi.baidu.com/sunboy_2050/item/ffab7396672895d11a49dfcc

    建议参考文献:

    Git 命令参数及用法详解

    Windows环境中使用版本管理工具Git

    GitRef

    展开全文
  • Git常用命令详解

    万次阅读 多人点赞 2018-09-23 18:13:42
    文章目录Git简介三个区主要的几个命令git commit用法git stash用法git reset用法git refloggit addgit checkoutgit checkout切换分支git checkout 回退修改git revertreset,checkout,revert总结删除分支git pushgit ...

    Git简介

    Git是Linux之父Linus的第二个伟大的作品,它最早是在Linux上开发的,被用来管理Linux核心的源代码。后来慢慢地有人将其移植到了Unix、Windows、Max OS等操作系统中。

    Git是一个分布式的版本控制系统,与集中式的版本控制系统不同的是,每个人都工作在通过克隆建立的本地版本库中。也就是说每个人都拥有一个完整的版本库,查看提交日志、提交、创建里程碑和分支、合并分支、回退等所有操作都直接在本地完成而不需要网络连接。

    对于Git仓库来说,每个人都有一个独立完整的仓库,所谓的远程仓库或是服务器仓库其实也是一个仓库,只不过这台主机24小时运行,它是一个稳定的仓库,供他人克隆、推送,也从服务器仓库中拉取别人的提交。

    Git是目前世界上最先进的分布式版本控制系统,没有之一,对,没有之一!

    三个区

    git_three_rigon.png-212.9kB

    工作区(working diretory) 用于修改文件
    缓存区(stage) 是用来暂时存放工作区中修改的内容
    提交历史(commit history) 提交代码的历史记录

    主要的几个命令

    git add # 将工作区的修改提交到暂存区
    git commit # 将暂存区的修改提交到当前分支
    git reset # 回退到某一个版本
    git stash # 保存某次修改
    git pull # 从远程更新代码
    git push # 将本地代码更新到远程分支上
    git reflog # 查看历史命令
    git status # 查看当前仓库的状态
    git diff # 查看修改
    git log # 查看提交历史
    git revert # 回退某个修改

    git commit用法

    git commit –m “本次提交描述”

    该命令会将git add .存入暂存区修改内容提交至本地仓库中,若文件未添加至暂存区,则提交时不会提交任何修改。

    git commit -a

    相当于运行 git add -u把所有当前目录下的文件加入缓存区域再运行git commit.
    注意!对于新增的文件,并没有被commit

    git commit –am “本次提交描述”
    或者git commit –a –m“本次提交描述”

    等同于上面的-a和-m

    git commit --amend

    修改最近一次提交。有时候如果提交注释书写有误或者漏提文件,可以使用此命令。对于漏提交的文件,需要git add到缓存区之后,git commit --amend才能将修改追加到最近的一次提交上。

    git stash用法

    $ git stash
    所有未提交的修改都保存起来,用于后续恢复当前工作目录

    $ git stash save “stash_name”
    给每个stash加一个message,用于记录版本

    $ git stash pop / git stash apply
    恢复最新缓存的工作目录(第一个),并删除缓存堆栈中的那一个stash删除(pop), apply则只恢复不删除

    $ git stash list
    查看现有所有stash
    在使用git stash pop(apply)命令时可以通过名字指定使用哪个stash,默认使用最近的stash(即stash@{0})

    $ git stash drop
    移除最新的stash,后面也可以跟指定stash的名字

    git reset用法

    git reset根据–soft –mixed –hard,会对working tree和index和HEAD进行重置

    $ git reset HEAD^

    回退版本,一个^表示一个版本,可以多个,另外也可以使用 git reset HEAD~n这种形式。
    也可以回退到指定版本:
    $ git reset commit-id

    soft 参数:git reset --soft HEAD~1 意为将版本库软回退1个版本,所谓软回退表示将本地版本库的头指针全部重置到指定版本,且将这次提交之后的所有变更都移动到暂存区

    默认的mixed参数:git reset HEAD~1 意为将版本库回退1个版本,将本地版本库的头指针全部重置到指定版本,且会重置暂存区,即这次提交之后的所有变更都移动到工作区

    hard参数:git reset --hard HEAD~1 意为将版本库回退1个版本,但是不仅仅是将本地版本库的头指针全部重置到指定版本,也会重置暂存区,并且会将工作区代码清空(工作区是clean状态)

    注意,soft参数与默认参数都不会修改工作区代码,只有hard参数才会修改工作区代码。

    另外,git reset HEAD filename
    回退文件,将文件从暂存区回退到工作区(unstage),此时不能带hard,soft参数

    git reflog

    如果在回退以后又想再次回到之前的版本,git reflog 可以查看所有分支的所有操作记录(包括commit和reset的操作),包括已经被删除的commit记录,git log则不能察看已经删除了的commit记录

    615ce06 HEAD@{44}: rebase -i (finish): returning to refs/heads/my_test_branch
    615ce06 HEAD@{45}: rebase -i (fixup): zancun_new
    702356c HEAD@{46}: rebase -i (fixup): # This is a combination of 2 commits.
    c997622 HEAD@{47}: rebase -i (reword): zancun_new
    fb74ec2 (origin/master, origin/HEAD) HEAD@{48}: rebase -i (start): checkout FETCH_HEAD
    f3ef592 HEAD@{49}: commit: zancun3
    6b82c75 HEAD@{50}: commit: zancun2
    e900fa0 HEAD@{51}: commit: zancun
    

    比如说,回退到commit: zancun3,只需要:
    git reset --hard f3ef592 (或者HEAD@{49}) 即可
    这个命令对于找回丢失的代码非常有用。

    git add

    删除文件后需要 git add -A, 光 git add. 不行,区别如下:

    git add -A 保存所有的修改
    git add . 保存新的添加和修改,但是不包括删除
    git add -u 保存修改和删除,但是不包括新建文件。
    所以默认使用git add -A就行

    git checkout

    git checkout既可以操作分支,也可以操作文件

    git checkout切换分支

    $ git checkout -b newBranchName
    Switched to a new branch ‘newBranchName’

    这相当于执行下面这两条命令:
    git branch newBranchName
    git checkout newBranchName(工作区一定要是clean的)

    $ git checkout -b newBranchName remote_branch_name
    拉取远程分支remote_branch_name创建一个本地分支newBranchName,并切到本地分支newBranchName,采用此种方法建立的本地分支会和远程分支建立映射关系。

    git checkout 回退修改

    git checkout – fileName
    这条命令把fileName从当前HEAD中检出,也就是回退当前工作区的这个文件的修改
    –可以省略不写

    如果需要回退工作区的全部文件修改,可以使用:
    git checkout --hard HEAD
    而不需要对每个文件进行checkout,这样太累

    git revert

    git revert,反转提交, 撤销一个提交的同时会创建一个新的提交,也就是用一个新提交来消除一个历史提交所做的任何修改.

    git revert commit-id revert指定的一个commit
    git revert HEAD~3 revert指定倒数第四个commit

    revert过程有可能遇到冲突,要么git revert --abort终止此次revert操作,代码还原至revert命令前。要么手动消除冲突(同普通的冲突解决),然后add commit

    reset,checkout,revert总结

    下面这个表格总结了这些命令最常用的使用场景。记得经常对照这个表格,因为你使用Git时一定会经常用到。
    命令 | 作用域 | 常用情景
    ---- | —
    git reset | 提交层面 | 在私有分支上舍弃一些没有提交的更改
    git reset| 文件层面 | 将文件从缓存区中移除
    git checkout| 提交层面| 切换分支或查看旧版本
    git checkout| 文件层面| 舍弃工作目录中的更改
    git revert| 提交层面| 在公共分支上回滚更改
    git revert| 文件层面| (然而并没有)

    删除分支

    删除分支: $ git branch -d branchName
    或者, git branch -D branchName 删除分支(不管它有没有merge)
    前提是先要切换到其他分支

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

    git push

    git push命令用于将本地分支的更新,推送到远程主机。

    $ git push <远程主机名> <本地分支名>:<远程分支名>
    
    $ git push origin master
    

    上面命令表示,将本地的master分支推送到origin主机的master分支。如果master不存在,则会被新建。

    如果省略本地分支名,则表示删除指定的远程分支,因为这等同于推送一个空的本地分支到远程分支。

    $ git push origin :master
    # 等同于
    $ git push origin --delete master
    

    上面命令表示删除origin主机的master分支。如果当前分支与远程分支之间存在追踪关系,则本地分支和远程分支都可以省略。

     $ git push origin
    

    上面命令表示,将当前分支推送到origin主机的对应分支。如果当前分支只有一个追踪分支,那么主机名都可以省略。

    $ git push
    

    如果当前分支与多个主机存在追踪关系,则可以使用-u选项指定一个默认主机,这样后面就可以不加任何参数使用git push

    $ git push -u origin master
    

    上面命令将本地的master分支推送到origin主机,同时指定origin为默认主机,后面就可以不加任何参数使用git push了。

    将当前分支推送到远程的同名的简单方法,如下:

    $ git push origin HEAD
    

    将当前分支推送到源存储库中的远程引用匹配主机。 这种形式方便推送当前分支,而不考虑其本地名称。如下:

    $ git push origin HEAD:master
    

    单独使用git push时,没有指定push的remote分支名,假如当前本地分支名称与其对应的remote分支名称不一样,则会有一下提示:

    fatal: The upstream branch of your current branch does not match
    the name of your current branch.  To push to the upstream branch
    on the remote, use
    
        git push origin HEAD:my_new_test_branch
    
    To push to the branch of the same name on the remote, use
    
        git push origin test
    
    To choose either option permanently, see push.default in 'git help config'.
    

    当执行git push origin test时,会在远程重新创建一个新的分支,名称就是test,然后把修改同步到test分支。

    git pull

    git pull命令用于从另一个存储库或本地分支获取并集成(整合)。git pull命令的作用是:取回远程主机某个分支的更新,再与本地的指定分支合并,

    $ git pull <远程主机名> <远程分支名>:<本地分支名>
    

    比如,要取回origin主机的master分支,与本地的test分支合并,需要写成下面这样

    $ git pull origin master:test
    

    如果远程分支(master)要与当前分支合并,则冒号后面的部分可以省略。上面命令可以简写:

    $ git pull origin master
    

    将远程存储库中的更改合并到当前分支中。在默认模式下,git pull是git fetch后跟git merge FETCH_HEAD的缩写。

    更准确地说,git pull使用给定的参数运行git fetch,并调用git merge将检索到的分支头合并到当前分支中。 使用–rebase,它运行git rebase而不是git merge。也就是说

    git pull = git fetch + git merge
    git pull --rebase = git fetch + git rebase
    

    git中都fetch命令是将远程分支的最新内容拉到了本地,但是fetch后是看不到变化的,此时本地多了一个FETCH_HEAD的指针,checkout到该指针后可以查看远程分支的最新内容。然后checkout到master分支,执行metch,选中FETCH_HEAD指针,合并后如果出现冲突则解决冲突,最后commit。

    pull的作用就相当于fetch和merge,自动合并

    git fetch origin master
    git merge FETCH_HEAD

    git fetch origin isoda-android_1.3.0_feature :branch1
    使用远程isoda-android_1.3.0_feature分支在本地创建branch1分支(但不会切换到该分支)

    1. git merge

    将 origin 分支合并到 mywork 分支最简单的办法就是用下面这些命令

    git checkout mywork
    git merge origin

    或者,你也可以把它们压缩在一行里:

    git merge origin mywork

    假设远程分支上有3次提交A,B,C:
    image_1chevldmmedu4f45ur9o6rp3g.png-13.4kB

    在远程分支origin的基础上创建一个名为"mywork"的本地分支并提交了修改E,同时有其他人在"origin"上做了一些修改并提交了修改D。
    image_1chevnkgpshs17133n5bqrfpjt.png-20.6kB

    用git merge命令把"origin"分支与本地提交合并(merge)成版本M,mywork 分支中新的合并提交(merge-commit)将两个分支的历史连在了一起,但这样会形成图中的菱形,让人很困惑。
    image_1chevr3p71knutjj1lv3f4e5391a.png-26kB

    Merge 好在它是一个安全的操作,比较安全,现有的分支不会被更改,避免了 rebase 潜在的缺点(后面会说)。另一方面,这同样意味着每次合并上游更改时 feature 分支都会引入一个外来的合并提交。如果 master非常活跃的话,这或多或少会污染你的分支历史。虽然高级的 git log 选项可以减轻这个问题,但对于开发者来说,还是会增加理解项目历史的难度。

    2. git rebase

    作为 merge 的替代选择,你可以像下面这样将 mywork 分支并入 origin 分支:

    git checkout mywork
    git rebase origin

    它会把整个 mywork 分支移动到 origin 分支的后面,有效地把所有 master 分支上新的提交并入过来。但是,rebase为原分支上每一个提交创建一个新的提交,重写了项目历史,并且不会带来合并提交。rebase的好处是避免了菱形的产生,保持提交曲线为直线,让大家易于理解。
    image_1chip8e1b1t1vo01m3t1g2bne91u.png-26.2kB

    rebase最大的好处是你的项目历史会非常整洁。首先,它不像 git merge 那样引入不必要的合并提交。其次,如上图所示,rebase 导致最后的项目历史呈现出完美的线性——你可以从项目终点到起点浏览而不需要任何的 fork。这让你更容易使用 git log、git reset 和 gitk 来查看项目历史。

    不过,这种简单的提交历史会带来两个后果:安全性和可跟踪性。如果你违反了 rebase 黄金法则,重写项目历史可能会给你的协作工作流带来灾难性的影响。此外,rebase 不会有合并提交中附带的信息——你看不到 mywork 分支中并入了上游的哪些更改。

    在rebase的过程中,有时也会有conflict,这时Git会停止rebase并让用户去解决冲突,解决完冲突后,用git add命令去更新这些内容,然后不用执行git commit,直接执行git rebase --continue,这样git会继续apply余下的补丁。
    在任何时候,都可以用git rebase --abort参数来终止rebase的行动,并且mywork分支会回到rebase开始前的状态。

    官方的两张merge和rebase对比图:
    merge示例图:
    屏幕快照 2018-09-21 下午11.01.48.png-126kB

    rebase示例图:
    rebase_wrong.png-150.4kB

    3. rebase的高级操作–交互式rebase

    交互式的 rebase 允许你更改并入新分支的提交。这比自动的 rebase 更加强大,因为它提供了对分支上提交历史完整的控制。一般来说,这被用于将 feature 分支并入 master 分支之前,清理混乱的历史。

    把 -i 传入 git rebase 选项来开始一个交互式的rebase过程:

    git checkout feature
    git rebase -i master

    它会打开一个文本编辑器,显示所有将被移动的提交:

    pick e900fa0 zancun
    pick 6b82c75 zancun2
    pick f3ef592 zancun3
    
    # Rebase fb74ec2..f3ef592 onto fb74ec2 (3 commands)
    #
    # Commands:
    # p, pick = use commit
    # r, reword = use commit, but edit the commit message
    # e, edit = use commit, but stop for amending
    # s, squash = use commit, but meld into previous commit
    # f, fixup = like "squash", but discard this commit's log message
    # x, exec = run command (the rest of the line) using shell
    # d, drop = remove commit
    #
    # These lines can be re-ordered; they are executed from top to bottom.
    #
    # If you remove a line here THAT COMMIT WILL BE LOST.
    #
    # However, if you remove everything, the rebase will be aborted.
    #
    # Note that empty commits are commented out
    

    这个列表定义了 rebase 将被执行后分支会是什么样的。更改 pick 命令或者重新排序,这个分支的历史就能如你所愿了。比如说,如果第二个和第三个提交只是修复了第一个提交中的小问题,你可以用 fixup 命令把它们合到第一个提交中,并修改第一个的日志:

    r e900fa0 zancun
    f 6b82c75 zancun2
    f f3ef592 zancun3
    

    这样三个提交合并成了一个提交,并可以重新修改提交日志,非常实用。
    忽略不重要的提交会让你的 feature 分支的历史更清晰易读。这是 git merge 做不到的。

    4. Rebase的黄金法则

    当你理解rebase是什么的时候,最重要的就是什么时候不能用rebase。git rebase 的黄金法则便是,绝不要在公共的分支上使用它。

    比如说,如果你把 master分支rebase到你的feature 分支上会发生什么:
    rebase_wrong.png-150.4kB

    这次 rebase 将 master 分支上的所有提交都移到了 feature 分支后面。问题是它只发生在你的代码仓库中,其他所有的开发者还在原来的 master 上工作。因为 rebase 引起了新的提交,Git 会认为你的 master 分支和其他人的 master 已经分叉了。

    同步两个 master 分支的唯一办法是把它们 merge 到一起,导致一个额外的合并提交和两堆包含同样更改的提交。不用说,这会让人非常困惑。

    所以,在你运行 git rebase 之前,一定要问问你自己「有没有别人正在这个分支上工作?」。如果答案是肯定的,那么把你的爪子放回去,重新找到一个无害的方式(如 git merge)来提交你的更改。不然的话,你可以随心所欲地重写历史。

    5. rebae的本地清理功能

    在你工作流中使用 rebase 最好的用法之一就是清理本地正在开发的分支。隔一段时间执行一次交互式 rebase,你可以保证你 feature 分支中的每一个提交都是专注和有意义的。

    调用 git rebase 的时候,你有两个基(base)可以选择:上游分支(比如 master)或者你 feature 分支中早先的一个提交。我们在「交互式 rebase」一节看到了第一种的例子。后一种在当你只需要修改最新几次提交时也很有用。比如说,下面的命令对最新的 3 次提交进行了交互式 rebase:

    git checkout feature
    git rebase -i HEAD~3(或者第四个commit-id)
    

    这样,就可以对本地提交历史中最新的三个提交进行重新整理了,包括提交合并,提交日志修改等等。

    通过指定 HEAD~3 作为新的基提交,你实际上没有移动分支——你只是将之后的 3 次提交重写了。注意它不会把上游分支(master)的更改并入到 feature 分支中。

    交互式 rebase 是在你工作流中引入 git rebase 的的好办法,因为它只影响本地分支。其他开发者只能看到你已经完成的结果,那就是一个非常整洁、易于追踪的分支历史。

    追踪关系

    建立test仓库 并建立追踪关系

    $ git branck --track test origin/master
    

    修改追踪关系
    先切换到test

    $ git checkout test
    

    修改追踪仓库(一定要先切换)

    $ git branch --set-upstream-to  origin/master
    

    建立追踪关系之后,本地分支名称和远程一样时,使用git push时不用带上远程名称,git pull也不用带上远程分支名

    git冲突的修复

    1. 直接编辑冲突文件

    使用git pull --rebase经常会出现冲突
    冲突产生后,文件系统中冲突了的文件里面的内容会显示为类似下面这样:

    <<<<<<< HEAD
     * test2
     * test3
    =======
     * this is my modify, my be conflicked
     * test1000
    >>>>>>> my_modify
    

    其中:<<<<<<<(7个<)HEAD与=之间的内容是remote上的修改,冲突标记=与>>>>>>>之间的内容是我的修改内容。
    在这两者之间选择任何你需要的内容保留下来,并删除所有的===,<<<,>>>即可解决冲突,解决完成之后,git add -A, git rebase --continue就提交了代码

    2. 利用图形界面工具解决冲突

    当然我们也可以利用图形工具解决冲突
    如果要解决的冲突很多,且比较复杂,图形界面的冲突解决工具就显得很重要了。
    执行git mergetool用预先配置的Meld(Beyond Compare)解决冲突:
    屏幕快照 2018-07-06 下午2.43.55.png-630.8kB

    上面左右两个窗口依次是“LOCAL”、“REMOTE”,它们只是提供解决冲突需要的信息,是无法编辑的。中间的窗口是合并后的结果,可以手动修改,也可以点击相应颜色的箭头选择“LOCAL”或者“REMOTE”。

    如果不向解决冲突,回到之前状态,可执行:

    $ git rebase --abort
    

    3. 代码提交完整流程

    步骤如下:
    git add -A
    git commit -m “message”
    git pull --rebase (或者git fetch + git rebase)
    解决冲突
    git add 冲突文件
    git rebase –continue
    git push
    其中,3、4、5点,如果没遇到冲突就不用进行,直接push上去。
    当遇到冲突时,git会提示patch failed,并要我们解决问题了再执行git rebase --continue

    常用命令速查表

    屏幕快照 2018-09-21 下午11.05.05.png-4548kB

    展开全文
  • GIT常用命令以及使用详解图示

    万次阅读 2020-01-20 15:50:42
    获取Git配置信息,执行以下命令git config --list 如果你还没有设置名字 user.name 和 user.email的话,可以用以下指令设置: git config --global user.name "user"git config --global user.email "user@...

    1配置个人信息,方便提交代码管理

    获取Git配置信息,执行以下命令:

    git config --list

    如果你还没有设置名字 user.name 和 user.email的话,可以用以下指令设置:

    git config --global user.name "user"
    git config --global user.email "user@gmail.com"                           

    图示很详细了。 user.name 和 user.email 已经设置好了

    2.创建版本库

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

    初始化一个仓库:

    git init

    在本地新建一个repo,进入一个项目目录,执行git init,会初始化一个repo,并在当前文件夹下创建一个.git文件夹.可以发现当前目录下多了一个.git的目录,默认是隐藏的。

     

    在本地创建一个test.txt文件,使用git status 查看文件的状态,发现是红色的,说明没有和仓库关联。

    那我我们可以把文件添加到仓库。

    git status

    一次可以add多个不同的文件,以空格分隔:

    git add test.txt

    然后执行提交操作,然后用命令git commit告诉Git把文件提交到仓库:

    git commit -m "提交的备注"

    提交后,在使用git status命令查看,则可以发现没有需要提交的文件。

     

    3.Git常用指令:

    git init

         在本地新建一个repo,进入一个项目目录,执行gitinit,会初始化一个repo,并在当前文件夹下创建一个.git文件夹.

    git clone

         获取一个url对应的远程Git repo, 创建一个local copy.

         一般的格式是git clone [url].

         clone下来的repo会以url最后一个斜线后面的名称命名,创建一个文件夹,如果想要指定特定的名称,可以git clone [url] newname指定.

    git status

         查询repo的状态.

         git status -s: -s表示short, -s的输出标记会有两列,第一列是对staging区域而言,第二列是对working目录而言.

    git log

         show commit history of a branch.

         git log --oneline --number: 每条log只显示一行,显示number条.

         git log --oneline --graph:可以图形化地表示出分支合并历史.

         git log branchname可以显示特定分支的log.

         git log --oneline branch1 ^branch2,可以查看在分支1,却不在分支2中的提交.^表示排除这个分支(Window下可能要给^branch2加上引号).

         git log --decorate会显示出tag信息.

         git log --author=[author name] 可以指定作者的提交历史.

         git log --since --before --until --after 根据提交时间筛选log.

         --no-merges可以将merge的commits排除在外.

         git log --grep 根据commit信息过滤log:git log --grep=keywords

         默认情况下, git log --grep --author是OR的关系,即满足一条即被返回,如果你想让它们是AND的关系,可以加上--all-match的option.

         git log -S: filter by introduced diff.

         比如: git log -SmethodName (注意S和后面的词之间没有等号分隔).

         git log -p: show patch introduced at eachcommit.

         每一个提交都是一个快照(snapshot),Git会把每次提交的diff计算出来,作为一个patch显示给你看.

         另一种方法是git show [SHA].

         git log --stat: show diffstat of changesintroduced at each commit.

         同样是用来看改动的相对信息的,--stat比-p的输出更简单一些.  

    git add

         在提交之前,Git有一个暂存区(staging area),可以放入新添加的文件或者加入新的改动. commit时提交的改动是上一次加入到staging area中的改动,而不是我们disk上的改动.

         git add .

         会递归地添加当前工作目录中的所有文件.

    git diff

         不加参数的git diff:

         show diff of unstaged changes.

         此命令比较的是工作目录中当前文件和暂存区域快照之间的差异,也就是修改之后还没有暂存起来的变化内容.

     

         若要看已经暂存起来的文件和上次提交时的快照之间的差异,可以用:

         git diff --cached 命令.

         show diff of staged changes.

         (Git 1.6.1 及更高版本还允许使用 git diff --staged,效果是相同的).

     

         git diff HEAD

         show diff of all staged or unstatedchanges.

         也即比较woking directory和上次提交之间所有的改动.

     

         如果想看自从某个版本之后都改动了什么,可以用:

         git diff [version tag]

         跟log命令一样,diff也可以加上--stat参数来简化输出.

     

         git diff [branchA] [branchB]可以用来比较两个分支.

         它实际上会返回一个由A到B的patch,不是我们想要的结果.

         一般我们想要的结果是两个分支分开以后各自的改动都是什么,是由命令:

         git diff [branchA]…[branchB]给出的.

         实际上它是:git diff $(git merge-base [branchA] [branchB]) [branchB]的结果.

     

     

    git commit

         提交已经被add进来的改动.

         git commit -m “the commit message"

         git commit -a 会先把所有已经track的文件的改动add进来,然后提交(有点像svn的一次提交,不用先暂存). 对于没有track的文件,还是需要git add一下.

         git commit --amend 增补提交. 会使用与当前提交节点相同的父节点进行一次新的提交,旧的提交将会被取消.

     

    git reset

         undo changes and commits.

         这里的HEAD关键字指的是当前分支最末梢最新的一个提交.也就是版本库中该分支上的最新版本.

         git reset HEAD: unstage files from indexand reset pointer to HEAD

         这个命令用来把不小心add进去的文件从staged状态取出来,可以单独针对某一个文件操作: git reset HEAD - - filename, 这个- - 也可以不加.

         git reset --soft

         move HEAD to specific commit reference,index and staging are untouched.

         git reset --hard

         unstage files AND undo any changes in theworking directory since last commit.

         使用git reset —hard HEAD进行reset,即上次提交之后,所有staged的改动和工作目录的改动都会消失,还原到上次提交的状态.

         这里的HEAD可以被写成任何一次提交的SHA-1.

         不带soft和hard参数的gitreset,实际上带的是默认参数mixed.

     

         总结:

         git reset --mixed id,是将git的HEAD变了(也就是提交记录变了),但文件并没有改变,(也就是working tree并没有改变). 取消了commit和add的内容.

         git reset --soft id. 实际上,是git reset –mixed id 后,又做了一次git add.即取消了commit的内容.

         git reset --hard id.是将git的HEAD变了,文件也变了.

         按改动范围排序如下:

         soft (commit) < mixed (commit + add)< hard (commit + add + local working)

     

    git revert

         反转撤销提交.只要把出错的提交(commit)的名字(reference)作为参数传给命令就可以了.

         git revert HEAD: 撤销最近的一个提交.

         git revert会创建一个反向的新提交,可以通过参数-n来告诉Git先不要提交.

       

    git rm

         git rm file: 从staging区移除文件,同时也移除出工作目录.

         git rm --cached: 从staging区移除文件,但留在工作目录中.

         git rm --cached从功能上等同于git reset HEAD,清除了缓存区,但不动工作目录树.

     

    git clean

         git clean是从工作目录中移除没有track的文件.

         通常的参数是git clean -df:

         -d表示同时移除目录,-f表示force,因为在git的配置文件中, clean.requireForce=true,如果不加-f,clean将会拒绝执行.

     

    git mv

         git rm - - cached orig; mv orig new; gitadd new

     

    git stash

         把当前的改动压入一个栈.

         git stash将会把当前目录和index中的所有改动(但不包括未track的文件)压入一个栈,然后留给你一个clean的工作状态,即处于上一次最新提交处.

         git stash list会显示这个栈的list.

         git stash apply:取出stash中的上一个项目(stash@{0}),并且应用于当前的工作目录.

         也可以指定别的项目,比如git stash apply stash@{1}.

         如果你在应用stash中项目的同时想要删除它,可以用gitstash pop

     

         删除stash中的项目:

         git stash drop: 删除上一个,也可指定参数删除指定的一个项目.

         git stash clear: 删除所有项目.

     

    git branch

         git branch可以用来列出分支,创建分支和删除分支.

         git branch -v可以看见每一个分支的最后一次提交.

         git branch: 列出本地所有分支,当前分支会被星号标示出.

         git branch (branchname): 创建一个新的分支(当你用这种方式创建分支的时候,分支是基于你的上一次提交建立的).

         git branch -d (branchname): 删除一个分支.

         删除remote的分支:

         git push (remote-name) :(branch-name):delete a remote branch.

         这个是因为完整的命令形式是:

         git push remote-namelocal-branch:remote-branch

         而这里local-branch的部分为空,就意味着删除了remote-branch

     

    git checkout

      gitcheckout (branchname)

     

     

     

     切换到一个分支.

         git checkout -b (branchname): 创建并切换到新的分支.

         这个命令是将git branch newbranch和git checkout newbranch合在一起的结果.

         checkout还有另一个作用:替换本地改动:

         git checkout --<filename>

         此命令会使用HEAD中的最新内容替换掉你的工作目录中的文件.已添加到暂存区的改动以及新文件都不会受到影响.

         注意:git checkout filename会删除该文件中所有没有暂存和提交的改动,这个操作是不可逆的.

     

    git merge

         把一个分支merge进当前的分支.

         git merge [alias]/[branch]

         把远程分支merge到当前分支.

     

         如果出现冲突,需要手动修改,可以用gitmergetool.

         解决冲突的时候可以用到git diff,解决完之后用git add添加,即表示冲突已经被resolved.

     

    git tag

         tag a point in history as import.

         会在一个提交上建立永久性的书签,通常是发布一个release版本或者ship了什么东西之后加tag.

         比如: git tag v1.0

         git tag -a v1.0, -a参数会允许你添加一些信息,即make an annotated tag.

         当你运行git tag -a命令的时候,Git会打开一个编辑器让你输入tag信息.

        

         我们可以利用commit SHA来给一个过去的提交打tag:

         git tag -a v0.9 XXXX

     

         push的时候是不包含tag的,如果想包含,可以在push时加上--tags参数.

         fetch的时候,branch HEAD可以reach的tags是自动被fetch下来的,tags that aren’t reachable from branch heads will be skipped.如果想确保所有的tags都被包含进来,需要加上--tags选项.

     

    git remote

         list, add and delete remote repositoryaliases.

         因为不需要每次都用完整的url,所以Git为每一个remoterepo的url都建立一个别名,然后用git remote来管理这个list.

         git remote: 列出remote aliases.

         如果你clone一个project,Git会自动将原来的url添加进来,别名就叫做:origin.

         git remote -v:可以看见每一个别名对应的实际url.

         git remote add [alias] [url]: 添加一个新的remote repo.

         git remote rm [alias]: 删除一个存在的remote alias.

         git remote rename [old-alias] [new-alias]:重命名.

         git remote set-url [alias] [url]:更新url. 可以加上—push和fetch参数,为同一个别名set不同的存取地址.

     

    git fetch

         download new branches and data from aremote repository.

         可以git fetch [alias]取某一个远程repo,也可以git fetch --all取到全部repo

         fetch将会取到所有你本地没有的数据,所有取下来的分支可以被叫做remotebranches,它们和本地分支一样(可以看diff,log等,也可以merge到其他分支),但是Git不允许你checkout到它们.

     

    git pull

         fetch from a remote repo and try to mergeinto the current branch.

         pull == fetch + merge FETCH_HEAD

         git pull会首先执行git fetch,然后执行git merge,把取来的分支的head merge到当前分支.这个merge操作会产生一个新的commit.   

         如果使用--rebase参数,它会执行gitrebase来取代原来的git merge.

     

     

    git rebase

         --rebase不会产生合并的提交,它会将本地的所有提交临时保存为补丁(patch),放在”.git/rebase”目录中,然后将当前分支更新到最新的分支尖端,最后把保存的补丁应用到分支上.

         rebase的过程中,也许会出现冲突,Git会停止rebase并让你解决冲突,在解决完冲突之后,用git add去更新这些内容,然后无需执行commit,只需要:

         git rebase --continue就会继续打余下的补丁.

         git rebase --abort将会终止rebase,当前分支将会回到rebase之前的状态.

     

    git push

         push your new branches and data to aremote repository.

         git push [alias] [branch]

         将会把当前分支merge到alias上的[branch]分支.如果分支已经存在,将会更新,如果不存在,将会添加这个分支.

         如果有多个人向同一个remote repo push代码, Git会首先在你试图push的分支上运行git log,检查它的历史中是否能看到server上的branch现在的tip,如果本地历史中不能看到server的tip,说明本地的代码不是最新的,Git会拒绝你的push,让你先fetch,merge,之后再push,这样就保证了所有人的改动都会被考虑进来.

     

    git reflog

         git reflog是对reflog进行管理的命令,reflog是git用来记录引用变化的一种机制,比如记录分支的变化或者是HEAD引用的变化.

         当git reflog不指定引用的时候,默认列出HEAD的reflog.

         HEAD@{0}代表HEAD当前的值,HEAD@{3}代表HEAD在3次变化之前的值.

         git会将变化记录到HEAD对应的reflog文件中,其路径为.git/logs/HEAD, 分支的reflog文件都放在.git/logs/refs目录下的子目录中.

     

     

    特殊符号:

         ^代表父提交,当一个提交有多个父提交时,可以通过在^后面跟上一个数字,表示第几个父提交: ^相当于^1.

         ~<n>相当于连续的<n>个^.

     

    有点小懒,这里我就不一个一个敲打了,主要是给自己做个笔记,方便以后查阅。看一下熟悉一下指令。

    想更深刻的了解可以参考网址:http://www.runoob.com/git/git-tutorial.html

    展开全文
  • git基本用法命令大全

    万次阅读 2018-03-06 18:37:07
    1.新建本地git仓库,并将本地库关联远程仓库GitHub1.1. git拉取远程分支并创建本地分支1.1.1 查看远程分支 git branch -r 查看所有远程分支:1.1.2 拉取远程分支并创建本地分支 方法一 git checkout -b 本地分支...
  • git常用命令与常见面试题总结

    千次阅读 多人点赞 2019-07-08 14:12:01
    2、列举工作中常用的几个git命令? 3、提交时发生冲突,如何解决? 4、新建git功能分支的步骤? 5、说明GIT合并的两种方法以及区别。 6、Git提交代码的步骤 7、 idea集成git 7.1 File-->settings-->...
  • git常用命令大全

    万次阅读 多人点赞 2020-08-04 15:20:14
    git push -- force 2.创建文件等小命令 touch a // 创建一个a文件 echo 1234 >> a // 把1234这个内容放入a文件 cat a // 打开a文件 读取出a文件中的内容 mkdir test // 创建test文件夹 rm 文件名 // 删除...
  • git-命令查看版本记录

    万次阅读 2020-07-08 19:51:13
    轻松使用git命令查看版本记录 2017年11月30日 15:37:23梦幻贝壳阅读数 27419 目前开始使用git的用户大部分都经历过subversion,对于这两种版本管控系统的切换需要一定时间去适应。本文旨在帮助这些用户恢复部分...
  • git命令使用详解(版本回退)

    千次阅读 2018-10-17 18:27:38
    现在我们以gitProject 仓库为例子 一些git命令如下 1、git status 假如我们之前已经把gitProject提交了 可是我们想看目前的状态 就可以输入git status 因为之前已经提交没有改变任何东西 现在我们修...
  • git 常用命令

    千次阅读 2018-11-04 01:18:47
    这里说下,工作了一段时间,常用的一些命令,这里不打算从暂存区之类最基本的说起,直接上实战,干货。 注:我这里是在扣钉上分别创建了两个账号来模拟公司团队开发git日常操作。这里假设你已经正确安装了git,并且...
  • Git命令

    万次阅读 2019-05-30 17:23:49
    git init 初始化 git status 查看仓库当前的状态 git diff <file> 查看具体修改了什么内容 git diff HEAD --<file> 命令可以查看工作区和版本库里面最新版本的区别 git add <file> 添加到暂存...
  • git常用命令

    万次阅读 多人点赞 2019-11-18 15:07:59
    git:分布式的版本管理系统,一般的开发模式: 如果是开发人员,忽略此步骤,从下面大字的开始即可: 项目开始阶段,初始化项目(init),提交本地的代码到仓库,将本地仓库的代码推送到远端库(push); 项目...
  • git命令下载代码到本地

    万次阅读 2018-11-02 16:09:49
    有的代码编辑工具里没有导入功能,可以用git命令导入 第一步:创建一个本地的版本库(即新建一个文件夹) 第二步:选中文件夹右键--Git bash here--进入控制面板,输入命令git init 初始化化文件夹,把这个文件夹...
  • Git 常用命令速查表(三)

    万次阅读 多人点赞 2014-03-04 17:48:44
    前面两篇博客 Git 版本管理工具 和 Git 常用命令详解,分别介绍了Git 基础知识和命令用法本文将对Git 命令,做一下全面而系统的简短总结,整理成简洁、明了的图表结构,方便查询一、 Git 常用命令速查git branch ...
  • GIT 命令查看分支

    万次阅读 2017-10-19 12:11:59
    git branch -l :查看本地分支 git branch -r :查看远程分支 git branch -a :查看全部分支(远程的和本地的)
  • git命令拉取以及提交代码

    万次阅读 2018-05-14 10:15:02
    $ git add//查询当前远程的版本$ git remote -v//直接拉取并合并最新代码$ git pull origin master [示例1:拉取远端origin/master分支并合并到当前分支]$ git pull origin dev [示例2:拉取远端origin/dev分支并...
  • git如何卸载

    万次阅读 2016-09-30 13:51:36
    找到git的位置 终端命令:which -a git cd进入git所在的目录 终端命令:cd /usr/bin/git(这个是一般的默认位置) 删除命令 终端命令:sudo rm -rf git
  • 查看git版本的cmd命令

    万次阅读 2018-03-16 09:57:20
    Git --version
  • git pull命令

    万次阅读 2019-04-05 19:02:54
    git pull命令作用:从另一个存储库或本地分支关联的远端分支获取最新代码,并与本地代码资源整合。git pull命令执行过程:取回远程主机某个分支的更新,再与本地的指定分支合并(可能存在需手动解决的冲突)。 使用...
  • git查看远程仓库地址命令

    万次阅读 2019-02-23 03:54:24
    it查看远程仓库地址命令: $git remote -v
1 2 3 4 5 ... 20
收藏数 334,619
精华内容 133,847
关键字:

git命令