git常用命令梳理及常见开发场景总结

一、新建代码库

1.git clone用法：git clone [<选项>] [--] <仓库> [<路径>]

# 用法：git clone [<选项>] [--] <仓库> [<路径>]

    -v, --verbose         #更加详细
    -q, --quiet           #更加安静
    --progress            #强制显示进度报告
    -n, --no-checkout     #不创建一个检出
    --bare                #创建一个纯仓库
    --mirror              #创建一个镜像仓库（也是纯仓库）
    -l, --local           #从本地仓库克隆
    --no-hardlinks        #不使用本地硬链接，始终复制
    -s, --shared          #设置为共享仓库
    --recurse-submodules[=<路径规格>] #在克隆时初始化子模组
    --recursive ...       --recurse-submodules #别名
    -j, --jobs <n>        #并发克隆的子模组的数量
    --template <模板目录>  #模板目录将被使用
    --reference <仓库>       #参考仓库
    --reference-if-able <仓库> #参考仓库
    --dissociate          #仅在克隆时参考 --reference 指向的本地仓库
    -o, --origin <名称>   #使用 <名称> 而不是 'origin' 去跟踪上游
    -b, --branch <分支>   #检出 <分支> 而不是远程 HEAD
    -u, --upload-pack <路径> #远程 git-upload-pack 路径
    --depth <深度>        #创建一个指定深度的浅克隆
    --shallow-since <时间> #从一个特定时间创建一个浅克隆
    --shallow-exclude <版本>#深化浅克隆的历史，除了特定版本
    --single-branch       #只克隆一个分支、HEAD 或 --branch
    --no-tags             #不要克隆任何标签，并且后续获取操作也不下载它们
    --shallow-submodules  #子模组将以浅下载模式克隆
    --separate-git-dir <git目录>#git目录和工作区分离
    -c, --config <key=value>#在新仓库中设置配置信息
    --server-option <server-specific>#传输选项
    -4, --ipv4            #只使用 IPv4 地址
    -6, --ipv6            #只使用 IPv6 地址
    --filter <参数>       #对象过滤
    --remote-submodules   #任何克隆的子模组将使用它们的远程跟踪分支
    --sparse              #初始化稀疏检出文件，只包含根目录文件

# 下载一个项目和它的整个代码历史
$ git clone [url]

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

$ git clone [url] newname

2.git init 用法：git init [-q | --quiet] [--bare] [--template=] [--shared[=]][]

git init [-q | --quiet] [--bare] [--template=<template-directory>] [--shared[=<permissions>]][<directory>]

#将使用模板的目录/ directory from which templates will be used

    --template <template-directory>

#创建一个空仓库/create a bare repository

    --bare

#指定 git 存储库将在多个用户之间共享/specify that the git repository is to be shared amongst several users

    --shared[=<permissions>]

#安静/be quiet

    -q, --quiet

#将 git dir 与工作树分开/separate git dir from working tree

    --separate-git-dir <gitdir>

#覆盖初始分支的名称/override the name of the initial branch

    -b, --initial-branch <name>

#指定要使用的哈希算法/specify the hash algorithm to use

    --object-format <hash>

# git-init - 创建一个空的 Git 存储库或重新初始化一个现有的存储库
$ git init

# 在本地新建一个repo,进入一个项目目录,执行git init,会初始化一个repo,并在当前文件夹下创建一个.git文件夹.
$ git init [project-name]
$ git init repo

二、配置

1.git config 用法：git config [<选项>]

#用法：git config [<选项>]

#配置文件位置
    --global              #使用全局配置文件
    --system              #使用系统级配置文件
    --local               #使用仓库级配置文件
    --worktree            #使用工作区级别的配置文件
    -f, --file <文件>     #使用指定的配置文件
    --blob <数据对象 ID>  #从给定的数据对象读取配置

#操作
    --get                 #获取值：name [value-regex]
    --get-all             #获得所有的值：key [value-regex]
    --get-regexp          #根据正则表达式获得值：name-regex [value-regex]
    --get-urlmatch        #获得 URL 取值：section[.var] URL
    --replace-all         #替换所有匹配的变量：name value [value_regex]
    --add                 #添加一个新的变量：name value
    --unset               #删除一个变量：name [value-regex]
    --unset-all           #删除所有匹配项：name [value-regex]
    --rename-section      #重命名小节：old-name new-name
    --remove-section      #删除一个小节：name
    -l, --list            #列出所有
    -e, --edit            #打开一个编辑器
    --get-color           #获得配置的颜色：配置 [默认]
    --get-colorbool       #获得颜色设置：配置 [stdout-is-tty]

#类型
    -t, --type <>         #取值为该类型
    --bool                #值是 "true" 或 "false"
    --int                 #值是十进制数
    --bool-or-int         #值是 --bool or --int
    --path                #值是一个路径（文件或目录名）
    --expiry-date         #值是一个到期日期

#其它
    -z, --null            #终止值是 NUL 字节
    --name-only           #只显示变量名
    --includes            #查询时参照 include 指令递归查找
    --show-origin         #显示配置的来源（文件、标准输入、数据对象，或命令行）
    --show-scope          #显示配置的作用域（工作区、本地、全局、系统、命令）
    --default <取值>      #使用 --get 参数，当缺少设置时使用默认值

#Git的设置文件为.gitconfig，它可以在用户主目录下（全局配置），也可以在项目目录下（项目配置）。
# 显示当前的Git配置
$ git config --list

# 编辑Git配置文件
$ git config -e --global

# 设置提交代码时的用户信息
$ git config --global user.name "[name]"
$ git config --global user.email "[email address]"

三、增加/删除文件

1.git add 用法：git add [<选项>] [--] <路径规格>...

#用法：git add [<选项>] [--] <路径规格>...

    -n, --dry-run         #演习
    -v, --verbose         #冗长输出

    -i, --interactive     #交互式拣选
    -p, --patch           #交互式挑选数据块
    -e, --edit            #编辑当前差异并应用
    -f, --force           #允许添加忽略的文件
    -u, --update          #更新已跟踪的文件
    --renormalize         #对已跟踪文件（暗含 -u）重新归一换行符
    -N, --intent-to-add   #只记录，该路径稍后再添加
    -A, --all             #添加所有改变的已跟踪文件和未跟踪文件
    --ignore-removal      #忽略工作区中移除的路径（和 --no-all 相同）
    --refresh             #不添加，只刷新索引
    --ignore-errors       #跳过因出错不能添加的文件
    --ignore-missing      #检查在演习模式下文件（即使不存在）是否被忽略
    --chmod (+|-)x        #覆盖列表里文件的可执行位
    --pathspec-from-file <文件> #从文件读取路径表达式
    --pathspec-file-nul   #使用 --pathspec-from-file，路径表达式用空字符分隔

# 添加指定文件到暂存区
$ git add [file1] [file2] ...

# 添加指定目录到暂存区，包括子目录
$ git add [dir]

# 添加当前目录的所有文件到暂存区，会递归地添加当前工作目录中的所有文件.
$ git add .

# 对于同一个文件的多处变化，可以实现分次提交
$ git add -p

2.git rm 用法：git rm [<选项>] [--] <文件>...

#用法：git rm [<选项>] [--] <文件>...
    -n, --dry-run         #演习
    -q, --quiet           #不列出删除的文件
    --cached              #只从索引区删除
    -f, --force           #忽略文件更新状态检查
    -r                    #允许递归删除
    --ignore-unmatch      #即使没有匹配，也以零状态退出
    --pathspec-from-file <文件> #从文件读取路径表达式
    --pathspec-file-nul   #使用 --pathspec-from-file，路径表达式用空字符分隔

# 删除工作区文件，并且将这次删除放入暂存区
$ git rm [file1] [file2] ...

# 停止追踪指定文件，但该文件会保留在工作区
$ git rm --cached [file]

# 改名文件，并且将这个改名放入暂存区

3.git mv 用法：git mv [<选项>] <源>... <目标>

#用法：git mv [<选项>] <源>... <目标>

    -v, --verbose         #冗长输出
    -n, --dry-run         #演习
    -f, --force           #强制移动/重命令，即使目标存在
    -k                    #跳过移动/重命名错误

$ git mv [file -original] [file -renamed ="token punctuation"]

4.git clean 用法：git clean [-d] [-f] [-i] [-n] [-q] [-e <模式>] [-x | -X] [--] <路径>...

#用法：git clean [-d] [-f] [-i] [-n] [-q] [-e <模式>] [-x | -X] [--] <路径>...
    -q, --quiet           #不打印删除文件的名称
    -n, --dry-run         #演习
    -f, --force           #强制
    -i, --interactive     #交互式清除
    -d                    #删除整个目录
    -e, --exclude <模式>  #添加 <模式> 到忽略规则
    -x                    #也删除忽略的文件
    -X                    #只删除忽略的文件

#从工作目录中移除没有追踪的文件.
$ git clean -df
-d表示同时移除目录,-f表示force,因为在git的配置文件中,clean.requireForce=true,如果不加-f,clean将会拒绝执行.

四、代码提交

1.git commit 用法：git commit [<选项>] [--] <路径规格>...

#用法：git commit [<选项>] [--] <路径规格>...

    -q, --quiet           #提交成功后不显示概述信息
    -v, --verbose         #在提交说明模板里显示差异

#提交说明选项
    -F, --file <文件>     #从文件中读取提交说明
    --author <作者>       #提交时覆盖作者
    --date <日期>         #提交时覆盖日期
    -m, --message <说明>  #提交说明
    -c, --reedit-message <提交>
                          #重用并编辑指定提交的提交说明
    -C, --reuse-message <提交>
                          #重用指定提交的提交说明
    --fixup <提交>        #使用 autosquash 格式的提交说明用以修正指定的提交
    --squash <提交>       #使用 autosquash 格式的提交说明用以压缩至指定的提交
    --reset-author        #现在将该提交的作者改为我（和 -C/-c/--amend 参数共用）
    -s, --signoff         #添加 Signed-off-by: 签名
    -t, --template <文件>
                          #使用指定的模板文件
    -e, --edit            #强制编辑提交
    --cleanup <模式>      #设置如何删除提交说明里的空格和#注释
    --status              #在提交说明模板里包含状态信息
    -S, --gpg-sign[=<key-id>]
                          #GPG 提交签名
#提交内容选项
    -a, --all             #提交所有改动的文件
    -i, --include         #添加指定的文件到索引区等待提交
    --interactive         #交互式添加文件
    -p, --patch           #交互式添加变更
    -o, --only            #只提交指定的文件
    -n, --no-verify       #绕过 pre-commit 和 commit-msg 钩子
    --dry-run             #显示将要提交的内容
    --short               #以简洁的格式显示状态
    --branch              #显示分支信息
    --ahead-behind        #计算完整的领先/落后值
    --porcelain           #机器可读的输出
    --long                #以长格式显示状态（默认）
    -z, --null            #条目以 NUL 字符结尾
    --amend               #修改先前的提交
    --no-post-rewrite     #绕过 post-rewrite 钩子
    -u, --untracked-files[=<模式>]
                          #显示未跟踪的文件，“模式”的可选参数：all、normal、no。（默认：all）
    --pathspec-from-file <文件>
                          #从文件读取路径表达式
    --pathspec-file-nul   #使用 --pathspec-from-file，路径表达式用空字符分隔

# 提交暂存区到仓库区
$ git commit -m [message]

# 提交暂存区的指定文件到仓库区
$ git commit [file1] [file2] ... -m [message]

# 提交工作区自上次commit之后的变化，直接到仓库区
$ git commit -a

# 提交时显示所有diff信息
$ git commit -v

# 如果代码没有任何新变化，则用来改写上一次commit的提交信息
$ git commit --amend -m [message]

# 重做上一次commit，并包括指定文件的新变化
$ git commit --amend [file1] [file2] ...

五、分支

1.git branch 用法：git branch [通用选项] [具体的 git-branch 动作] [--merged | --no-merged]

#用法：git branch [<选项>] [-r | -a] [--merged | --no-merged]
  或：git branch [<选项>] [-l] [-f] <分支名> [<起始点>]
  或：git branch [<选项>] [-r] (-d | -D) <分支名>...
  或：git branch [<选项>] (-m | -M) [<旧分支>] <新分支>
  或：git branch [<选项>] (-c | -C) [<老分支>] <新分支>
  或：git branch [<选项>] [-r | -a] [--points-at]
  或：git branch [<选项>] [-r | -a] [--format]

#通用选项
    -v, --verbose         #显示哈希值和主题，若参数出现两次则显示上游分支
    -q, --quiet           #不显示信息
    -t, --track           #设置跟踪模式（参见 git-pull(1)）
    -u, --set-upstream-to <上游>
                          #改变上游信息
    --unset-upstream      #取消上游信息的设置
    --color[=<何时>]      #使用彩色输出
    -r, --remotes         #作用于远程跟踪分支
    --contains <提交>     #只打印包含该提交的分支
    --no-contains <提交>  #只打印不包含该提交的分支
    --abbrev[=<n>]        #用 <n> 位数字显示 SHA-1 哈希值

#具体的 git-branch 动作：
    -a, --all             #列出远程跟踪及本地分支
    -d, --delete          #删除完全合并的分支
    -D                    #删除分支（即使没有合并）
    -m, --move            #移动/重命名一个分支，以及它的引用日志
    -M                    #移动/重命名一个分支，即使目标已存在
    -c, --copy            #拷贝一个分支和它的引用日志
    -C                    #拷贝一个分支，即使目标已存在
    -l, --list            #列出分支名
    --show-current        #显示当前分支名
    --create-reflog       #创建分支的引用日志
    --edit-description    #标记分支的描述
    -f, --force           #强制创建、移动/重命名、删除
    --merged <提交>       #只打印已经合并的分支
    --no-merged <提交>    #只打印尚未合并的分支
    --column[=<风格>]     #以列的方式显示分支
    --sort <key>         #排序的字段名
    --points-at <对象>    #只打印指向该对象的分支
    -i, --ignore-case     #排序和过滤属于大小写不敏感
    --format <格式>       #输出格式

# 列出所有本地分支
$ git branch

# 列出所有远程分支
$ git branch -r

# 列出所有本地分支和远程分支
$ git branch -a

# 新建一个分支，但依然停留在当前分支
$ git branch [branch-name]

# 新建一个分支，指向指定commit
$ git branch [branch] [commit]

# 新建一个分支，与指定的远程分支建立追踪关系
$ git branch --track [branch] [remote-branch]

# 建立追踪关系，在现有分支与指定的远程分支之间
$ git branch --set-upstream [branch] [remote-branch]

#远程建立一个和本地一样的分支,本地分支和远程分支建立跟踪关系
git branch --set-upstream-to=origin/develop  develop

# 删除本地分支
$ git branch -d [branch-name]

# 删除远程分支
$ git branch -dr [remote/branch]

2. git checkout用法：git checkout [<选项>] [<分支>] -- <文件>...

#用法：git checkout [<选项>] <分支>
  或：git checkout [<选项>] [<分支>] -- <文件>...

    -b <分支>             #创建并检出一个新的分支
    -B <分支>             #创建/重置并检出一个分支
    -l                    #为新的分支创建引用日志
    --guess               #二次猜测 'git checkout <无此分支>'（默认）
    --overlay             #使用叠加模式（默认）
    -q, --quiet           #不显示进度报告
    --recurse-submodules[=<checkout>]
                          control recursive updating of submodules
    --progress            #强制显示进度报告
    -m, --merge           #和新的分支执行三方合并
    --conflict <风格>     #冲突输出风格（merge 或 diff3）
    -d, --detach          #HEAD 从指定的提交分离
    -t, --track           #为新的分支设置上游信息
    -f, --force           #强制检出（丢弃本地修改）
    --orphan <新分支>     #新的没有父提交的分支
    --overwrite-ignore    #更新忽略的文件（默认）
    --ignore-other-worktrees
                          #不检查指定的引用是否被其他工作区所占用
    -2, --ours            #对尚未合并的文件检出我们的版本
    -3, --theirs          #对尚未合并的文件检出他们的版本
    -p, --patch           #交互式挑选数据块
    --ignore-skip-worktree-bits
                          #对路径不做稀疏检出的限制
    --pathspec-from-file <文件>
                          #从文件读取路径表达式
    --pathspec-file-nul   #使用 --pathspec-from-file，路径表达式用空字符分隔

# 新建一个分支，并切换到该分支
$ git checkout -b [branch]

# 切换到指定分支，并更新工作区
$ git checkout [branch-name]

# 切换到上一个分支
$ git checkout -

# 恢复暂存区的指定文件到工作区
$ git checkout [file]

# 恢复某个commit的指定文件到暂存区和工作区
$ git checkout [commit] [file]

# 恢复暂存区的所有文件到工作区
$ git checkout .

3.git merge 用法: git merge [<选项>] [<提交>...]

#用法：git merge [<选项>] [<提交>...]
  或：git merge --abort
  或：git merge --continue

    -n                    #在合并的最后不显示差异统计
    --stat                #在合并的最后显示差异统计
    --summary             （和 --stat 同义）
    --log[=<n>]           #在合并提交信息中添加（最多 <n> 条）精简提交记录
    --squash              #创建一个单独的提交而不是做一次合并
    --commit              #如果合并成功，执行一次提交（默认）
    -e, --edit            #在提交前编辑提交说明
    --cleanup <模式>      #设置如何删除提交说明里的空格和#注释
    --ff                  #允许快进（默认）
    --ff-only             #如果不能快进就放弃合并
    --rerere-autoupdate   #如果可能，重用冲突解决更新索引
    --verify-signatures   #验证指定的提交是否包含一个有效的 GPG 签名
    -s, --strategy <策略>
                          #要使用的合并策略
    -X, --strategy-option <option=value>
                          #所选的合并策略的选项
    -m, --message <说明>  #合并的提交说明（针对非快进式合并）
    -F, --file <路径>     #从文件中读取提交说明
    -v, --verbose         #更加详细
    -q, --quiet           #更加安静
    --abort               #放弃当前正在进行的合并
    --quit                --abort，#但是保留索引和工作区
    --continue            #继续当前正在进行的合并
    --allow-unrelated-histories
                          #允许合并不相关的历史
    --progress            #强制显示进度报告
    -S, --gpg-sign[=<key-id>]
                          GPG #提交签名
    --autostash           #在操作前后执行自动贮藏和弹出贮藏
    --overwrite-ignore    #更新忽略的文件（默认）
    --signoff             #添加 Signed-off-by: 签名
    --no-verify           #绕过 pre-merge-commit 和 commit-msg 钩子

# 合并指定分支到当前分支
$ git merge [branch]

# 选择一个commit，合并进当前分支
$ git merge [commit-id]

4.git cherry-pick用法：git cherry-pick [<选项>] <提交号>...

#用法：git cherry-pick [<选项>] <提交号>...
  或：git cherry-pick <子命令>

    --quit                #终止反转或拣选操作
    --continue            #继续反转或拣选操作
    --abort               #取消反转或拣选操作
    --skip                #跳过当前提交并继续
    --cleanup <模式>      #设置如何删除提交说明里的空格和#注释
    -n, --no-commit       #不要自动提交
    -e, --edit            #编辑提交说明
    -s, --signoff         #添加 Signed-off-by: 签名
    -m, --mainline <父编号>
                          #选择主干父提交编号
    --rerere-autoupdate   #如果可能，重用冲突解决更新索引
    --strategy <策略>     #合并策略
    -X, --strategy-option <选项>
                          #合并策略的选项
    -S, --gpg-sign[=<key-id>]
                          #GPG 提交签名
    -x                    #追加提交名称
    --ff                  #允许快进式
    --allow-empty         #保留初始化的空提交
    --allow-empty-message
                          #允许提交说明为空
    --keep-redundant-commits
                          #保持多余的、空的提交

$ git cherry-pick [commit]

5.用法：git push [<选项>] [<仓库> [<引用规格>...]]

#用法：git push [<选项>] [<仓库> [<引用规格>...]]
    -v, --verbose         #更加详细
    -q, --quiet           #更加安静
    --repo <仓库>         #仓库
    --all                 #推送所有引用
    --mirror              #镜像所有引用
    -d, --delete          #删除引用
    --tags                #推送标签（不能使用 --all or --mirror）
    -n, --dry-run         #演习
    --porcelain           #机器可读的输出
    -f, --force           #强制更新
    --force-with-lease[=<引用名>:<期望值>]
                          #要求引用旧的取值为设定值
    --recurse-submodules (check|on-demand|no)
                          #控制子模组的递归推送
    --thin                #使用精简打包
    --receive-pack <receive-pack>
                          #接收包程序
    --exec <receive-pack>
                          #接收包程序
    -u, --set-upstream    #设置 git pull/status 的上游
    --progress            #强制显示进度报告
    --prune               #清除本地删除的引用
    --no-verify           #绕过 pre-push 钩子
    --follow-tags         #推送缺失但有关的标签
    --signed[=(yes|no|if-asked)]
                          #用 GPG 为推送签名
    --atomic              #需要远端支持原子事务
    -o, --push-option <server-specific>
                          #传输选项
    -4, --ipv4            #只使用 IPv4 地址
    -6, --ipv6            #只使用 IPv6 地址

六、标签

1.git tag用法

#用法：git tag [-a | -s | -u <key-id>] [-f] [-m <消息> | -F <文件>] <标签名> [<头>]
  或：git tag -d <标签名>...
  或：git tag -l [-n[<数字>]] [--contains <提交>] [--no-contains <提交>] [--points-at <对象>]
		[--format=<格式>] [--[no-]merged [<提交>]] [<模式>...]
  或：git tag -v [--format=<格式>] <标签名>...

    -l, --list            #列出标签名称
    -n[<n>]               #每个标签信息打印 <n> 行
    -d, --delete          #删除标签
    -v, --verify          #验证标签

#标签创建选项
    -a, --annotate        #附注标签，需要一个说明
    -m, --message <说明>  #标签说明
    -F, --file <文件>     #从文件中读取提交说明
    -e, --edit            #强制编辑标签说明
    -s, --sign            #附注并附加 GPG 签名的标签
    --cleanup <模式>      #设置如何删除提交说明里的空格和#注释
    -u, --local-user <key-id>
                          #使用另外的私钥签名该标签
    -f, --force           #如果存在，替换现有的标签
    --create-reflog       #创建引用日志

#标签列表选项
    --column[=<风格>]     #以列的方式显示标签列表
    --contains <提交>     #只打印包含该提交的标签
    --no-contains <提交>  #只打印不包含该提交的标签
    --merged <提交>       #只打印已经合并的标签
    --no-merged <提交>    #只打印尚未合并的标签
    --sort <key>          #排序的字段名
    --points-at <对象>    #只打印指向该对象的标签
    --format <格式>       #输出格式
    --color[=<何时>]      #遵照格式中的颜色输出
    -i, --ignore-case     #排序和过滤属于大小写不敏感

# 列出所有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]

七、查看信息

1.git status用法：git status [<选项>] [--] <路径规格>...

#用法：git status [<选项>] [--] <路径规格>...
    -v, --verbose         #冗长输出
    -s, --short           #以简洁的格式显示状态
    -b, --branch          #显示分支信息
    --show-stash          #显示贮藏区信息
    --ahead-behind        #计算完整的领先/落后值
    --porcelain[=<版本>]  #机器可读的输出
    --long                #以长格式显示状态（默认）
    -z, --null            #条目以 NUL 字符结尾
    -u, --untracked-files[=<模式>]
                          #显示未跟踪的文件，“模式”的可选参数：all、normal、no。（默认：all）
    --ignored[=<模式>]    #显示已忽略的文件，可选模式：traditional、matching、no。（默认：traditional）
    --ignore-submodules[=<何时>]
                          #忽略子模组的更改，“何时”的可选参数：all、dirty、untracked。（默认：all）
    --column[=<风格>]     #以列的方式显示未跟踪的文件
    --no-renames          #不检测重命名
    -M, --find-renames[=<n>]
                          #检测重命名，可以设置索引相似度

#查询repo的状态.
git status

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

2.git log用法：git log [<选项>] [<版本范围>] [[--] <路径>...]

用法：git log [<选项>] [<版本范围>] [[--] <路径>...]
或：git show [<选项>] <对象>...

    -q, --quiet           不显示差异输出
    --source              显示源
    --use-mailmap         使用邮件映射文件
    --mailmap             --use-mailmap 的别名
    --decorate-refs <模式>
                          只修饰与 <模式> 匹配的引用
    --decorate-refs-exclude <模式>
                          不修饰和 <模式> 匹配的引用
    --decorate[=...]      修饰选项
    -L <n,m:file>         处理文件中第 n 到 m 之间的行，从 1 开始

# 显示当前分支的版本历史
$ 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 reflog

# 显示指定文件是什么人在什么时间修改过
$ 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

HEAD@{0}代表HEAD当前的值,HEAD@{3}代表HEAD在3次变化之前的值.git会将变化记录到HEAD对应的reflog文件中,其路径为.git/logs/HEAD, 分支的reflog文件都放在.git/logs/refs目录下的子目录中

# 从本地master拉取代码更新当前分支：branch 一般为master
$ git rebase [branch]

3.git rebase -i 用法

#用法：git rebase [-i] [options] [--exec <命令>] [--onto <新基线> | --keep-base] [<上游> [<分支>]]
  或：git rebase [-i] [选项] [--exec <命令>] [--onto <新基线>] --root [<分支>]
  或：git rebase --continue | --abort | --skip | --edit-todo

    --onto <版本>         #变基到给定的分支而非上游
    --keep-base           #使用上游和分支的合并基线做为当前基线
    --no-verify           #允许执行 pre-rebase 钩子
    -q, --quiet           #安静。暗示 --no-stat
    -v, --verbose         #显示上游变化的差异统计
    -n, --no-stat         #不显示上游变化的差异统计
    --signoff             #为每一个提交添加一个 Signed-off-by: 签名
    --ignore-whitespace   #传递给 'git am
    --committer-date-is-author-date
                          #传递给 'git am
    --ignore-date         #传递给 'git am
    -C <n>                #传递给 'git apply'
    --whitespace <动作>   #传递给 'git apply'
    -f, --force-rebase    #拣选所有提交，即使未修改
    --no-ff               #拣选所有提交，即使未修改
    --continue            #继续
    --skip                #跳过当前补丁并继续
    --abort               #终止并检出原有分支
    --quit                #终止但保持 HEAD 不变
    --edit-todo           #在交互式变基中编辑待办列表
    --show-current-patch  #显示正在应用或合并的补丁文件
    --apply               #使用应用策略进行变基
    -m, --merge           #使用合并策略进行变基
    -i, --interactive     #让用户编辑要变基的提交列表
    --rerere-autoupdate   #如果可能，重用冲突解决更新索引
    --empty <{drop,keep,ask}>
                          #如何处理成为空提交的提交
    --autosquash          #在 -i 交互模式下，移动以 squash!/fixup! 开头的提交
    -S, --gpg-sign[=<key-id>]
                          #使用 GPG 签名提交
    --autostash           #在操作前后执行自动贮藏和弹出贮藏
    -x, --exec <exec>     #MkDocs可编辑列表的每一个提交下面增加一行 exec
    -r, --rebase-merges[=<模式>]
                          #尝试对合并提交变基而不是忽略它们
    --fork-point          #使用 'merge-base --fork-point' 来优化上游
    -s, --strategy <策略>
                          #使用给定的合并策略
    -X, --strategy-option <选项>
                          #将参数传递给合并策略
    --root                #将所有可达的提交变基到根提交
    --reschedule-failed-exec
                          #自动重新安排任何失败的 `exec`
    --reapply-cherry-picks
                          #应用所有更改，甚至那些已在上游存在的

八、远程同步

1.git remote 用法

用法：git remote [-v | --verbose]
  或：git remote add [-t <分支>] [-m <master>] [-f] [--tags | --no-tags] [--mirror=<fetch|push>] <名称> <地址>
  或：git remote rename <旧名称> <新名称>
  或：git remote remove <名称>
  或：git remote set-head <名称> (-a | --auto | -d | --delete | <分支>)
  或：git remote [-v | --verbose] show [-n] <名称>
  或：git remote prune [-n | --dry-run] <名称>
  或：git remote [-v | --verbose] update [-p | --prune] [(<组> | <远程>)...]
  或：git remote set-branches [--add] <名称> <分支>...
  或：git remote get-url [--push] [--all] <名称>
  或：git remote set-url [--push] <名称> <新的地址> [<旧的地址>]
  或：git remote set-url --add <名称> <新的地址>
  或：git remote set-url --delete <名称> <地址>
    -v, --verbose         冗长输出；必须置于子命令之前
$ git remote update  --更新远程仓储
# 下载远程仓库的所有变动
$ git fetch [remote]

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

# 显示某个远程仓库的信息
$ git remote show [remote]

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

2.git pull 用法：git pull [<选项>] [<仓库> [<引用规格>...]]

#用法：git pull [<选项>] [<仓库> [<引用规格>...]]

    -v, --verbose         #更加详细
    -q, --quiet           #更加安静
    --progress            #强制显示进度报告
    --recurse-submodules[=<on-demand>]
                          #控制子模组的递归获取
#和合并相关的选项
    -r, --rebase[=(false|true|merges|preserve|interactive)]
                          #使用变基操作取代合并操作以合入修改
    -n                    #在合并的最后不显示差异统计
    --stat                #在合并的最后显示差异统计
    --log[=<n>]           #在合并提交信息中添加（最多 <n> 条）精简提交记录
    --signoff[=...]       #添加 Signed-off-by: 签名
    --squash              #创建一个单独的提交而不是做一次合并
    --commit              #如果合并成功，执行一次提交（默认）
    --edit                #在提交前编辑提交说明
    --cleanup <模式>      #设置如何删除提交说明里的空格和#注释
    --ff                  #允许快进式
    --ff-only             #如果不能快进就放弃合并
    --verify-signatures   #验证指定的提交是否包含一个有效的 GPG 签名
    --autostash           #在操作前后执行自动贮藏和弹出贮藏
    -s, --strategy <策略>
                          #要使用的合并策略
    -X, --strategy-option <option=value>
                          #所选的合并策略的选项
    -S, --gpg-sign[=<key-id>]
                          #GPG 提交签名
    --allow-unrelated-histories
                          #允许合并不相关的历史
#和获取相关的参数
    --all                 #从所有的远程抓取
    -a, --append          #追加到 .git/FETCH_HEAD 而不是覆盖它
    --upload-pack <路径>  #上传包到远程的路径
    -f, --force           #强制覆盖本地分支
    -t, --tags            #抓取所有的标签和关联对象
    -p, --prune           #清除远程已经不存在的分支的跟踪分支
    -j, --jobs[=<n>]      #并发拉取的子模组的数量
    --dry-run             #演习
    -k, --keep            #保持下载包
    --depth <深度>        #深化浅克隆的历史
    --shallow-since <时间>
                          #基于时间来深化浅克隆的历史
    --shallow-exclude <版本>
                          #深化浅克隆的历史，除了特定版本
    --deepen <n>          #深化浅克隆的历史
    --unshallow           #转换为一个完整的仓库
    --update-shallow      #接受更新 .git/shallow 的引用
    --refmap <引用映射>   #指定获取操作的引用映射
    -o, --server-option <server-specific>
                          #传输选项
    -4, --ipv4            #只使用 IPv4 地址
    -6, --ipv6            #只使用 IPv6 地址
    --negotiation-tip <版本>
                          #报告我们只拥有从该对象开始可达的对象
    --show-forced-updates
                          #在所有更新分支上检查强制更新
    --set-upstream        #为 git pull/fetch 设置上游

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

3.git push用法：git push [<选项>] [<仓库> [<引用规格>...]]

#用法：git push [<选项>] [<仓库> [<引用规格>...]]

    -v, --verbose         #更加详细
    -q, --quiet           #更加安静
    --repo <仓库>         #仓库
    --all                 #推送所有引用
    --mirror             # 镜像所有引用
    -d, --delete          #删除引用
    --tags                #推送标签（不能使用 --all or --mirror）
    -n, --dry-run         #演习
    --porcelain           #机器可读的输出
    -f, --force           #强制更新
    --force-with-lease[=<引用名>:<期望值>]
                          #要求引用旧的取值为设定值
    --recurse-submodules (check|on-demand|no)
                          #控制子模组的递归推送
    --thin                #使用精简打包
    --receive-pack <receive-pack>
                          #接收包程序
    --exec <receive-pack>
                          #接收包程序
    -u, --set-upstream    #设置 git pull/status 的上游
    --progress            #强制显示进度报告
    --prune               #清除本地删除的引用
    --no-verify           #绕过 pre-push 钩子
    --follow-tags         #推送缺失但有关的标签
    --signed[=(yes|no|if-asked)]
                          #用 GPG 为推送签名
    --atomic              #需要远端支持原子事务
    -o, --push-option <server-specific>
                          #传输选项
    -4, --ipv4            #只使用 IPv4 地址
    -6, --ipv6            #只使用 IPv6 地址

# 上传本地指定分支到远程仓库
$ git push [remote] [branch]

# 强行推送当前分支到远程仓库，即使有冲突
$ git push [remote] --force

# 推送所有分支到远程仓库
$ git push [remote] --all

# 本地存在一个分支，名称叫：develop_dev，但远程没有怎么办？
$ git push origin develop_dev

# 提交指定 tag
$ git push [remote] [tag]

# 提交所有 tag
$ git push [remote] --tags

# 删除远程分支
$ git push origin --delete [branch-name]

九、撤销

1.git reset 用法

usage: git reset [--mixed | --soft | --hard | --merge | --keep] [-q] [<commit>]
   or: git reset [-q] [<tree-ish>] [--] <pathspec>...
   or: git reset [-q] [--pathspec-from-file [--pathspec-file-nul]] [<tree-ish>]
   or: git reset --patch [<tree-ish>] [--] [<pathspec>...]
    -q, --quiet           #be quiet, only report errors
    --mixed               #reset HEAD and index
    --soft                #reset only HEAD
    --hard                #reset HEAD, index and working tree
    --merge               #reset HEAD, index and working tree
    --keep                #reset HEAD but keep local changes
    --recurse-submodules[=<reset>]
                          #control recursive updating of submodules
    -p, --patch           #select hunks interactively
    -N, --intent-to-add   #record only the fact that removed paths will be added later
    --pathspec-from-file <file>
                          #read pathspec from file
    --pathspec-file-nul   #with --pathspec-from-file, pathspec elements are separated with NUL character

# 重置暂存区的指定文件，与上一次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]

十、储藏

1.git stash 用法

usage: git stash list [<options>]
   or: git stash show [<options>] [<stash>]
   or: git stash drop [-q|--quiet] [<stash>]
   or: git stash ( pop | apply ) [--index] [-q|--quiet] [<stash>]
   or: git stash branch <branchname> [<stash>]
   or: git stash clear
   or: git stash [push [-p|--patch] [-k|--[no-]keep-index] [-q|--quiet]
          [-u|--include-untracked] [-a|--all] [-m|--message <message>]
          [--pathspec-from-file=<file> [--pathspec-file-nul]]
          [--] [<pathspec>...]]
   or: git stash save [-p|--patch] [-k|--[no-]keep-index] [-q|--quiet]
          [-u|--include-untracked] [-a|--all] [<message>]

1.1 stash当前修改,查看储存

#实际应用中推荐给每个stash加一个message，用于记录版本，使用git stash save取代git stash命令。示例如下：
$ git stash save "保存一个readme.md文件"

#会显示这个栈的list.
$ git stash list
stash@{0}: On master: 保存一个readme.md文件
stash@{1}: On master: groups.cs
stash@{2}: WIP on master: 6a9a740 添加了一个文件
stash@{3}: WIP on master: 77acf37 初始提交

1.2 重新应用缓存的stash

#git stash pop这个指令将缓存堆栈中的第一个stash删除，并将对应修改应用到当前的工作目录下
$ git stash pop

#git stash apply命令，将缓存堆栈中的stash多次应用到工作目录中，但并不删除stash拷贝

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

#也可以指定别的项目
$ git stash apply stash@{1}

1.3 移除stash

#删除stash中的项目，删除上一个,也可指定参数删除指定的一个项目.
$ git stash list
stash@{0}: On master: groups.cs
stash@{1}: WIP on master: 6a9a740 添加了一个文件
stash@{2}: WIP on master: 77acf37 初始提交
$ git stash drop stash@{0}
Dropped stash@{0} (6fa4af7aa7fc9f33547b3f62493d3c7c3ba9923f)

#或者使用git stash clear命令，删除所有缓存的stash
$ git stash clear

1.4 查看指定stash的diff

#可以使用git stash show命令，后面可以跟着stash名字
$ git stash show

 user.cs | 0
 1 file changed, 0 insertions(+), 0 deletions(-)

#在该命令后面添加-p或--patch可以查看特定stash的全部diff
$ git stash show -p

1.5 从stash创建分支

#想用更方便的方法来重新检验储藏的变更，可以运行 git stash branch，会创建一个新的分支，检出储藏工作时所处的提交，重新应用.
$ git stash branch stash_dev

1.5 暂存未跟踪或忽略的文件

#默认情况下，git stash会缓存下列文件：
  添加到暂存区的修改（staged changes）
  Git跟踪的但并未添加到暂存区的修改（unstaged changes）

#默认情况下，git stash不会缓存下列文件：
  在工作目录中新的文件（untracked files）
  被忽略的文件（ignored files）

#git stash命令提供了参数用于缓存上面两种类型的文件;
   #使用-u或者--include-untracked可以stash untracked文件;
   git stash push -u -m "全部储藏"

   #使用-a或者--all命令可以stash当前目录下的所有修改;
   git stash push -a -m "全部储藏"
   git stash -a -m "全部储藏"

十一、常见开发场景

1.开发新功能

#从dev分支新建feature01分支并切换到该分支
git checkout -b feature01

#开发完成后，添加所有修改到暂存区
git add .

#提交暂存区文件到本地库

#切换到dev分支
git switch dev/git checkout dev

#合并feature01分支到dev分支
git merge feature01

#将本地dev分支推送到远程库
git push origin dev

2.解决冲突

#不同分支合并时，产生冲突
git merge feature02

#冲突文件test.py内容为

#修改文件后，提交到本地仓库

3.新功能开发到一半，需要同步远程库最新代码

#提交修改到本地库
git add .
git commit -m [message]
#从远程库的dev分支更新
git pull origin dev

4.复制某个commit对应代码到当前分支

#提交修改到本地库
git add .
git commit -m [message]

#查看要复制分支的commit id
git log feature01

#复制对应commit
git cherry-pick [commit id]

5.dev分支Bug修复

#暂存当前修改
git stash

#切换到dev分支
git checkout dev/git checkout dev
#从dev分支创建bug-fix分支，并切换到该分支
git checkout -b bug-fix

#在bug-fix修复bug后，将修改提交到bug-fix分支
git add .
git commit -m “buf fix”

#切换到dev分支，合并bug-fix分支
git checkout dev
git merge  --no-ff -m “merge bug-fix” bug-fix

#切换到正在开发的分支feature01
git checkout feature01
#查看暂存的stash记录
git stash list

#恢复暂存的修改，并删除stash记录
git statsh pop

#将dev分支的修改合并到本分支
git merge dev

6.版本回退

#查看对应分支的commit id
git log [branch-name]

git reset --hard [commit-id]

======================================================================
创作不易，本人热衷开源共享 《git常用命令梳理总结》
======================================================================

转载请附上链接：
https://www.cnblogs.com/cndevops/p/14993331.html