git学习笔记

git常用命令示例说明

http://www.cnblogs.com/xuange306/p/6403907.html
https://www.cnblogs.com/hafiz/p/8146324.html

commit --amend -F   常常用来修改某个branch上最顶端的commit，大多数情况下，这个命令给人的感觉是用新的commit替换了原来的commit

https://www.cnblogs.com/chaoguo1234/p/5331586.html

git恢复本地误删除的分支

1、使用git log -g查看你刚刚那波手贱的操作
2、使用git rebase或者git branch来恢复。
git branch newBranchName commit_id 来建立一个新的分支
或者git rebase commit_id （注意，这个会将当前branch的代码变成你需要回复的branch的代码， 所以一般建议使用第一个）

#回退远程分支
一 查看git提交历史记录
git log //查看提交的历史
git log --pretty=oneline　//如果嫌上面的输出信息过多可以使用这条（只输出版本号）
二 回退到你想要的那一次提交
git reset --hard d0d8fa0c505569d89a06c0f0baf1ac898f7749cf
执行完git命令后你会发现你的本地已经回退到指定的版本了，如果你是想远程仓库也回退，可以将本次执行结果强制推送到远程仓库。
git push -f -u origin master
这种回退操作不会保留两次版本中间的提交记录，请注意备份好数据文件。


/*1.新建分支*/
git checkout -b temp              //新建分支并切换到temp分支
git push origin temp:temp         //将代码push到temp分支
/*2.删除主分支*/
git push origin --delete master   //删除远端主分支
git branch -d master              //删除本地主分支
/*3.新建主分支*/
git checkout -b master            //新建主分支并切换到主分支
git push origin master            //提交主分支
/*4.删除暂存分支*/
git branch -d temp
git push origin --delete temp

git reverse和git reset的区别
git revert是用一次新的commit来回滚之前的commit，git reset是直接删除指定的commit。
在回滚这一操作上看，效果差不多。但是在日后继续merge以前的老版本时有区别。因为git revert是用一次逆向的commit“中和”之前的提交，因此日后合并老的branch时，导致这部分改变不会再次出现，但是git reset是之间把某些commit在某个branch上删除，因而和老的branch再次merge时，这些被回滚的commit应该还会被引入。
git reset 是把HEAD向后移动了一下，而git revert是HEAD继续前进，只是新的commit的内容和要revert的内容正好相反，能够抵消要被revert的内容。

1.启动合并工具
 git mergetool 
根据所需的内容手动合并
a:编辑受影响的文件
b:采用--ours或者--theirs选项,选择只选用自己或者别人那个版本的文件
 git checkout --theirs <name>
2.提交修改
 git add .
 git commit -m "<message>"
当然我们也可以取消合并
 git reset --merge

Base：需要合并的两个文件最近的共同祖先版本
Local：当前分支文件
Remote：需要合并的另外分支文



git checkout feature
git merge master

等同：git merge feature master




git checkout feature
git rebase master
git rebase -i master  更改commits

git rebase -i HEAD~3更改commits

等同：git rebase feature master


git fetch
git rebase orgin_branch

git pull --rebase


git pull origin --tags
git tag -a tag-name -m 'msg'
git push origin tag-name


git log -p | grep
git show c8746301

ssh -T git@192.168.1.5 #配置应用ssh
https://blog.csdn.net/leo8729/article/details/75459549
https://www.cnblogs.com/popfisher/p/5731232.html
https://blog.csdn.net/xyzchenxiaolin/article/details/51852333
git clone git://192.168.1.5:888/beer.git

Git global setup
git config --global user.name "aaaaa"
git config --global user.email "aaaaa@aaa.com"

Create a new repository
git clone http://192.168.1.5:888/beer.git
cd beer
touch README.md
git add README.md
git commit -m "add README"
git push -u origin master

Existing folder
cd existing_folder
git init
git remote add origin http://192.168.1.5:888/beer.git
git add .
git commit -m "Initial commit"
git push -u origin master

Existing Git repository
cd existing_repo
git remote rename origin old-origin
git remote add origin http://192.168.1.5:888/beer.git
git push -u origin --all
git push -u origin --tags

查看远程仓库地址

git remote -v

git remote  show origin

git branch -vv  // git查看当前分支所属

git branch -r //列出所有远程分支
git branch -a //列出所有本地分支和远程分支
git remote show origin  #查看远程分支和本地分支的对应关系
git remote prune origin #删除远程已经删除过的分支

git fetch --prune origin或git fetch -p 获取被删减后的远程分支

1. 回到指定版本

git reflog   //查看命令历史，以便确定要回到未来的哪个版本

git reset --hard HEAD  //彻底丢掉本地修改

git reset --hard HEAD^   //在Git中，用HEAD表示当前版本 也就是最新的提交  上一个版本就是HEAD^ 上上一个版本就是HEAD^^  往上100个版本HEAD~100

git reset --hard  commit_id   //具体的提交版本号  版本号没必要写全，前几位就可以了，Git会自动去找

https://my.oschina.net/MinGKai/blog/144932


https://my.oschina.net/zmf/blog/501207
https://segmentfault.com/q/1010000016006569

临时忽略本地文件
https://blog.csdn.net/csfreebird/article/details/13509409
# 执行命令将db.php加入不提交队列
git update-index --assume-unchanged include/db.php

# 执行命令将db.php取消加入不提交队列
git update-index --no-assume-unchanged include/db.php

#找出所有被忽略的文件
git ls-files -v | grep '^h\ ' | awk '{print $2}'

ignored = !git ls-files -v | grep "^[[:lower:]]"
#所有被忽略的文件，取消忽略的方法
git ls-files -v | grep '^h' | awk '{print $2}' | xargs git update-index --no-assume-unchanged 


https://my.oschina.net/zmf/blog/501207
.gitignore 文件 与 exclude
 .git/info/exclude 这里设置的则是你自己本地需要排除的文件， 他不会影响到其他人，也不会提交到版本库中去。

设置excludesfile  绝对路径  
git config --global core.excludesfile

默认.git/info/exclude

reset --hard 说明

2. 撤销修改

https://www.cnblogs.com/haima/p/13365483.html

git checkout -- file //丢弃工作区的修改 如果已add暂存区,恢复至暂存区,否则恢复到最新版本 即恢复到最近一次git commit或git add时的状态

git reset HEAD file //暂存区的修改撤销掉（unstage），重新放回工作区

git checkout . #本地所有修改的。没有的提交的，都返回到原来的状态
git stash #把所有没有提交的修改暂存到stash里面。可用git stash pop回复。
git reset --hard HASH #返回到某个节点，不保留修改。
git reset --soft HASH #返回到某个节点。保留修改

git clean -df #返回到某个节点
git clean 参数
    -n 显示 将要 删除的 文件 和  目录
    -f 删除 文件
    -df 删除 文件 和 目录



本地工作区（尚未暂存） ---> add . 到暂存区 ---> commit 到本地仓库 ---> pull拉取关联远程仓库分支合并到本地的分支---> push 到远程分支

# 修改最后一次提交 
git add sample.txt #修改文件添加到暂存区 
git commit --amend -m"说明" #合并提交到上一次的commit里
git commit --amend  #或者 进入到编辑里编写提交注释


git commit --amend  #修改上一次commit提交的备注

### 当修改文件后，还没有add提交到暂存区,也没有commit时,想要放弃修改
git checkout 11.txt #放弃11.txt文件的修改
git checkout .  # 放弃所有文件的修改

git checkout – . 丢弃全部，也包括：新增的文件会被删除、删除的文件会恢复回来、修改的文件会回去。这几个前提都说的是，回到暂存区之前的样子。对之前保存在暂存区里的代码不会有任何影响。对commit提交到本地分支的代码就更没影响了。当然，如果你之前压根都没有暂存或commit，那就是回到你上次pull下来的样子了。

###当文件add提交到暂存区,还没有commit时,发现文件提交错了，这时想撤回文件  这个命令仅改变暂存区，并不改变工作区
git reset HEAD a.php #只撤消a.php
git reset HEAD * #撤消所有


### 当文件add提交到暂存区,也commit了,发现文件提交错了，这时想撤回文件
git reset HEAD^ # 撤消上一次的commit 不带参数默认是--mixed 例：git reset --mixed HEAD^  也可以写成git reset HEAD~1
git reset HEAD~2 如果你进行了2次commit，想都撤回，可以使用HEAD~2
git reset fdaeaf208f0e142ceba5766d17786d60fcebc1dd #撤消指定的commitId
git reset --hard fdaeaf208f0e1 # 回退到指定版本 放弃工作区的所有修改，还原到指定版本的代码

    --soft：不删除工作空间改动代码，撤销commit，不撤销git add .操作，重置位置的同时，保留working Tree工作目录和index暂存区的内容，只让repository中的内容和 reset 目标节点保持一致，因此原节点和reset节点之间的【差异变更集】会放入index暂存区中(Staged files)。所以效果看起来就是工作目录的内容不变，暂存区原有的内容也不变，只是原节点和Reset节点之间的所有差异都会放到暂存区中。
    --mixed（默认）：不删除工作空间改动代码，撤销commit，并且撤销git add . 操作，重置位置的同时，只保留Working Tree工作目录的內容，但会将 Index暂存区 和 Repository 中的內容更改和reset目标节点一致，因此原节点和Reset节点之间的【差异变更集】会放入Working Tree工作目录中。所以效果看起来就是原节点和Reset节点之间的所有差异都会放到工作目录中。
    --hard：删除工作空间改动代码，撤销commit，撤销git add . 操作，重置位置的同时，直接将 working Tree工作目录、 index 暂存区及 repository 都重置成目标Reset节点的內容,所以效果看起来等同于清空暂存区和工作区。
注意完成这个操作后，就恢复到了指定版本的commit状态。

3. 删除文件

git rm file   //确实要从版本库中删除该文件

4. 工作现场“储藏”、“恢复”

git stash apply 's1'  //将当前工作区储藏 再创建分支来修复bug
git stash list  //查看储藏的工作区列表

 //恢复储藏的工作区   git stash apply stash@{0}  
//如果不在同一分支上，则在新分支上应用当前的workspace和index里面变动
git stash apply 

git stash drop //删除储藏的工作区

git stash pop //恢复的同时把stash内容也删了

git stash clear #  删除所有储藏
http://www.softwhy.com/article-8628-1.html

http://www.softwhy.com/article-8630-1.html


git stash save "message"
#无论根目录还是子目录的修改文件都被储藏起来 后面跟着路径无效，并不能精确储藏指定路径下的修改文件
git stash save subDir/subDir.txt


git stash push -m "message"  #需要-m参数，是--message的缩写，不能省略否则会报错
#子目录下的修改文件subDir.txt文件被储藏起来，根目录下的修改文件依然保持原来状态
git stash push subDir/subDir.txt

5. 分支

git log --graph --pretty=oneline --abbrev-commit  //graph可以看到分支合并图
git checkout -b [branch]  //创建本地分支

git remote show origin //同步远程分支名字

//创建远程分支以当前的本地分支
git push origin [branch]（本地指定分支） 

git push origin lbr:rbr

//创建远程分支映射到本地命名为local-branchname的一分支(已有关联)
git checkout -b local-branchname origin/remote_branchname 

git push -f origin lbranch-2:refs/rbranch-1  #覆盖远程分支

强制push
git push -u

git checkout -b 本地分支名x origin/远程分支名x  //在本地新建分支x，并自动切换到该本地分支x(已有关联)
git fetch origin 远程分支名x:本地分支名x  //在本地新建分支x，但是不会自动切换到该本地分支x，需要手动checkout

git fetch origin master //从远程的origin仓库的master分支下载代码到本地的origin master

//从远程创建本地分支（已关联）
git checkout --track origin/2.0.1.20120806

git branch -vv  // git查看当前分支所属

git branch -r //列出所有远程分支
git branch -a //列出所有本地分支和远程分支

# 根据tag创建新的分支
例如:git branch newbranch vtest.1.0.FINAL
会以tag vtest.1.0.FINAL创建新的分支newbranch;

git remote -v  //显示所有远程仓库

git branch  //列出本地分支
git checkout dev  //切换分支

重命名分支 git branch (-m | -M) <oldbranch> <newbranch>

git branch -d [branch]  //删除分支
git branch -D [branch]  //强行删除未合并的分支
git branch -dr [remote/branch]  //删除远程分支
git branch -d -r branchname 删除远程branchname分支
git push origin :branch-name  //删除远程版本
git push origin --delete [branch-name] //删除远程分支

#恢复删除的分支
通过git log -g命令来找到我们需要恢复的信息对应的commit_id
通过git branch recover_branch[新分支] commit_id 来建立一个新的分支


git merge [branch]  //合并指定分支到当前分支
git merge --no-ff -m "merge with no-ff" dev  //合并不用Fast forward

git merge --no-ff

(master) git merge feature --squash 意思是把feature分支不同于master分支的所有文件罗列出来(无论有几个提交)，然后就可以方便的git commit提交了
https://www.cnblogs.com/xinmengwuheng/p/7115549.html

有冲突了先处理冲突，然后先add,再commit,即合并成功为最新的版本

6.推送、抓取分支

//指定本地dev分支与远程origin/dev分支的链接、关联
git branch --set-upstream [branch] [remote-branch]
git branch --set-upstream-to=origin/dev 
git branch --set-upstream-to=origin/master master
git branch --unset-upstream master //取消对master的跟踪

git pull   //同步远程分支origin/dev（与当前本地分支关联的远程分支）并合并

//表示把你的本地当前分支里的每个提交(commit)取消掉，并且把它们临时 保存为补丁(patch)(这些补丁放到".git/rebase"目录中),然后把本地当前分支更新 为最新的"origin"分支，最后把保存的这些补丁应用到本地当前分支上
git pull --rebase  

git pull [remote] [branch] //取回远程仓库的变化，并与本地分支合并


//一般当前如果不在该分支时，使用这种方式提交。如果当前在20120806 分支下，也可以直接提交git push | git pull
git push origin 20120806:20120806
git push origin <local_branch_name>:<remote_branch_name>

git remote add [shortname] [url]  // 增加一个新的远程仓库，并命名

7.创建远程分支

//创建远程分支以当前的本地分支（先在本地创建分支）
git push origin [branch]（本地指定分支）



//指定本地dev分支与远程origin/dev分支的链接、关联
git branch --set-upstream [branch] [remote-branch]
git branch --set-upstream dev origin/dev
git branch --set-upstream-to=origin/dev 
git branch --unset-upstream master


git push origin :[branch] //删除远程分支
git push origin --delete [branch] //删除远程分支


//推送指定本地分支到远程分支上
git push origin  <local_branch_name>:<remote_branch_name>

tag

git tag v1.4-lw

git tag -a v1.4 -m 'my version 1.4'

git tag -a v1.2 9fceb02

git tag
git tag -l 'v1.4.2.*'

git show v1.4-lw


 git push origin v1.5


#推送所有本地新增的标签
git push origin --tags

# 删除本地标签
git tag -d 标签名
git tag -d v3.1.0  

# 删除远程标签
git push origin :refs/tags/标签名
git push origin :refs/tags/v3.1.0


# git 删除模块标签
git submodule foreach git tag -d 标签名
git submodule foreach git push origin :refs/tags/标签名


1.执行:Git origin fetch 获得最新.
2.通过:git branch <new-branch-name> <tag-name> 会根据tag创建新的分支.
例如:git branch newbranch v1.0 . 会以tag v1.0创建新的分支newbranch;
3.可以通过git checkout newbranch 切换到新的分支.
4.通过 git push origin newbranch 把本地创建的分支提交到远程仓库.

git submodule

git clone <repository> --recursive 递归的方式克隆整个项目
git submodule add <repository> <path> 添加子模块
git submodule init 初始化子模块
git submodule update 更新子模块
git submodule foreach git pull 拉取所有子模块

# 添加子模块
git submodule add ../moduleA.git moduleA

git submodule add https://github.com/name/xxx.git

# 克隆带子模块的版本库
git clone project.git project3 --recursive

git clone --recursive https://github.com/name/xxx.git


#更新子模块
git submodule foreach git pull

#把子模块存储起来
git submodule foreach 'git stash'

#子模块修改的内容是否推送，如果没有，主仓库推送也会失败
git push --recurse-submodules=check
#自动推送子模块，然后再推送主模块
git push --recurse-submodules=on-demand

git submodule foreach 'git checkout -b featureA'

git submodule update --remote --merge

# 删除子模块
git rm moduleA

https://git-scm.com/book/zh/v1/Git-工具-子模块
 https://www.cnblogs.com/nicksheng/p/6201711.html
https://blog.csdn.net/guotianqing/article/details/82391665
https://www.jianshu.com/p/491609b1c426

tag 钩子

8.rebase衍合变基

多数情况下推荐在未提交到远程仓库之前修改本地git提交记录格式时使用

//从上游分支获取最新commit信息，并有机的将当前分支和上游分支进行合并
git rebase [branch] 

git rebase
    [-i | --interactive] 
    [options]
    [--exec <cmd>] 
    [--onto <newbase>]
    [<upstream> [<branch>]]
//如果指定了<branch>，git rebase 将会在执行其它动作之前自动执行git checkout <branch>
//假设upstream分支已经有一个commit A'，而在你的新分支上有一个commit A,这个commit所修改的内容都一样，那么在rebase过程中，A将会被跳过
    
git rebase 
    [-i | --interactive] 
    [options] 
    [--exec <cmd>] 
    [--onto <newbase>]
    --root 
    [<branch>]
    
git rebase --continue | --skip | --abort | --quit | --edit-todo


git rebase --onto master server client  //检出 client 分支，找出 client 分支和 server 分支的共同祖先之后的变化，然后把它们在master 上重演一遍


#先检出特性分支 server，然后在主分支 master 上重演
git rebase master server //把 server 分支衍合到 master 而不用手工转到 server分支再衍合


不要对在你的仓库外有副本的分支执行变基。变基操作的 实质是丢弃一些现有的提交，然后相应地新建一些内容一样但实际上不同的提交。 如果你已经将提交推送至某个仓库，而其他人也已经从该仓库拉取提交并进行了后续工作，此时，如果你用 git rebase 命令重新整理了提交并再次推送，你的同伴因此将不得不再次将他们手头的工作与你的提交进行整合，如果接下来你还要拉取并整合他们修改过的提交，事情就会变得一团糟。

http://gitbook.liuhui998.com/4_2.html
https://www.jianshu.com/p/9cfd206635c0      ***
https://www.cnblogs.com/wangiqngpei557/p/5989292.html

https://git-scm.com/docs

https://www.jianshu.com/p/4a8f4af4e803





//多个commit 需要合并为一个完整的commit
git rebase -i branch


git log -10


git rebase -i [commit_log]

git rebase -i HEAD~2 (索引从1开始，同理若更改前n次的commit，此处改为n即可) 
    选择pick操作，git会应用这个补丁，以同样的提交信息（commit message）保存提交
    选择reword操作，git会应用这个补丁，但需要重新编辑提交信息
    选择edit操作，git会应用这个补丁，但会因为amending而终止
    选择squash操作，git会应用这个补丁，但会与之前的提交合并
    选择fixup操作，git会应用这个补丁，但会丢掉提交日志
    选择exec操作，git会在shell中运行这个命令
将第二个pick改成squash或者s，然后保存退出。



https://www.cnblogs.com/wangiqngpei557/p/5989292.html
https://blog.csdn.net/LosingCarryJie/article/details/78838082
http://gitbook.liuhui998.com/4_3.html

合并指定某个commit

#单个commit只需要git cherry-pick commitid
git cherry-pick  branch_commit_id

#中间的两个点，表示把两个commit区间的所有commit多复制过去
git cherry-pick <start-commit-id>..<end-commit-id>
或
git cherry-pick <start-commit-id>^..<end-commit-id>
前者表示把到之间(左开右闭，不包含start-commit-id)的提交cherry-pick到当前分支；
后者表示把到之间(闭区间，包含start-commit-id)的提交cherry-pick到当前分支。 


https://blog.csdn.net/fightfightfight/article/details/81039050
git cherry-pick master
git cherry-pick ..< branchname >
git cherry-pick ^HEAD < branchname >

Git增量发布 - --diff-filter

https://blog.csdn.net/xhzq1986/article/details/75327465

git diff --diff-filter 可以过滤几种不同的变化
--diff-filter=[(A|C|D|M|R|T|U|X|B)…[*]]

git diff 608e120 4abe32e --name-only | xargs zip update.zip

git flow

https://www.cnblogs.com/lcngu/p/5770288.html
https://www.jianshu.com/p/9a76e9aa9534

https://www.git-tower.com/learn/git/ebook/cn/command-line/advanced-topics/git-flow
https://www.cnblogs.com/antball/p/7727185.html

https://www.jianshu.com/p/62b4ebe283f3
https://www.jianshu.com/p/857319a84161

git 持续集成

命令补全  初始化: git flow init

开始新Feature: git flow feature start MYFEATURE

Publish一个Feature(也就是push到远程): git flow feature publish MYFEATURE

获取Publish的Feature: git flow feature pull origin MYFEATURE
 git flow feature track MYFEATURE 跟踪在origin上的特性分支

完成一个Feature: git flow feature finish MYFEATURE

开始一个Release: git flow release start RELEASE [BASE]
[BASE]参数，即提交记录的 sha-1 hash 值，来开启动 release 分支. 这个提交记录的 sha-1 hash 值必须是'develop' 分支下的

Publish一个Release: git flow release publish RELEASE
发布Release: git flow release finish RELEASE
别忘了git push --tags
git push origin --tags

开始一个Hotfix: git flow hotfix start VERSION [BASENAME]
[BASENAME]为finish release时填写的版本号

发布Hotfix
git flow hotfix publish VERSION 

发布一个Hotfix: git flow hotfix finish VERSION

git flow init -f
git flow config --local

9.文件忽略

经测试发现，若要忽略一个文件夹下的部分文件夹，应该一个一个的标示。可能有更好的方法。
若test下有多个文件和文件夹。若要ignore某些文件夹，应该这个配置.gitignore文件。若test下有test1，test2,test3文件。要track test3，则.gitignore文件为：
test/test1
test/test2
!test/test3
若为：
test/
!test/test3 ，则不能track test3。
Git 中的文件忽略

共享式忽略新建 .gitignore 文件，放在工程目录任意位置即可。.gitignore 文件可以忽略自己。忽略的文件，只针对未跟踪文件有效，对已加入版本库的文件无效。
独享式忽略针对具体版本库：.git/info/exclude针对本地全局： git config --global core.excludefile ~/.gitignore
忽略的语法规则：
(#)表示注释
(*) 表示任意多个字符;
(?) 代表一个字符;
([abc]) 代表可选字符范围
如果名称最前面是路径分隔符 (/) ，表示忽略的该文件在此目录下。
如果名称的最后面是 (/) ，表示忽略整个目录，但同名文件不忽略。
通过在名称前面加 (!) ，代表不忽略。
例子如下：

# 这行是注释
*.a                   # 忽略所有 .a 伟扩展名的文件
!lib.a                # 但是 lib.a 不忽略，即时之前设置了忽略所有的 .a
/TODO            # 只忽略此目录下 TODO 文件，子目录的 TODO 不忽略 
build/               # 忽略所有的 build/ 目录下文件
doc/*.txt           # 忽略如 doc/notes.txt, 但是不忽略如 doc/server/arch.txt

gitignore需要忽略子目录中，拥有某后缀的文件。用**代表所有子目录
例如，我要忽略以iml结尾的文件，可以如下所示
!application/

application/*
!application/language/

application/language/*
!application/language/gr/

git config --global core.longpaths true

git alias 配置

git alias 配置
 https://www.cnblogs.com/Sir-Lin/p/6933705.html

[alias]
co = checkout
cm = commit -m
br = branch
st = status

mgnf = merge --no-ff -m

unstage = reset HEAD --
restore = checkout --
last = log -1 HEAD

ignore = update-index --assume-unchanged
unignore = update-index --no-assume-unchanged
ignored = !git ls-files -v | grep "^[[:lower:]]"

ignoredfiles = ls-files -v | grep '^h\ ' | awk '{print $2}'
unignorefiles = ls-files -v | grep '^h' | awk '{print $2}' | xargs git update-index --no-assume-unchanged 

lg = log --color --graph --pretty=format:'%Cred%h%Creset -%C(yellow)%d%Creset %s %Cgreen(%cr) %C(bold blue)<%an>%Creset' --abbrev-commit
hist = log --pretty=format:'%h %ad | %s%d [%an]' --graph --date=short

gist = log --graph --decorate --oneline --simplify-by-decoration --all

// flow
ffs = flow feature start
ffp = flow feature publish
ffpull = flow feature pull origin
fff = flow feature finish

frs = flow release start
frp = flow release publish
frf = flow release finish


fhots = flow hotfix start
fhotp = flow hotfix publish
fhotf = flow hotfix finish

fbugs = flow bugfix start
fbugp = flow bugfix publish
fbugf = flow bugfix finish



co = checkout // 切换分支，或去到特定的commit
ss = status
cm = commit -m
br = branch
bm = branch -m  // 修改当前分支的名称
bd = branch -D  // 删除某个分支
cb = checkout -b    // 新建一个和当前分支一样的分支，并切换过去
df = diff
ls = log --stat // 查看每次提交修改了哪些文件， git ls -n， 只看最近的n次提交
lp = log -p // 查看每次提交修改了那些行,git lp -n， 只看最近n次提交
plo = pull origin
pho = push origin
 
 
 ls = log --stat
    lp = log -p
    plo = pull origin
    plode = pull origin develop
    pho = push origin

[core]
	autocrlf = true
	longpaths = true

多个仓库控制

# 查看添加的远程库列表
git remote


-- 只提交第一个
git remote rm origin

git remote add gitosc https://gitee.com/
git push -u gitosc master

git remote add github https://github.com/
git push -u github master

git remote -v


git push gitosc master
git push github master

[remote "github"]
[remote "gitosc"]

----- push 一次全部提交
git remote  rm github
git remote rm gitosc
git remote add all https://gitee.com
git remote set-url --add all https://github.com

git push all --all

[remote "all"]

https://www.cnblogs.com/hongdada/p/7573923.html
https://blog.csdn.net/weixin_41196185/article/details/81482675