git 命令大全

按场景分组,一条命令一句解释,不按字母排。查的时候不必先想起命令名,先想清楚眼下要干什么: 改完没交、交错了要撤、分支乱了要接、推到远程被拒。

安装与初始配置

命令

作用

git --version

看装没装:git version 2.52.0.windows.1

git config --global user.name "名字"

提交者名字,每次提交都写进历史

git config --global user.email "邮箱"

和 GitHub 账号一致,否则提交不关联头像

git config --global init.defaultBranch main

新仓库默认分支叫 main(老版本是 master)

git config --global core.quotepath false

中文文件名不再显示成 "\347\254\224\350\256\260.txt" 这种转义

git config --global core.autocrlf true

Windows 行尾转换,避免和 Linux 之间整文件差异

git config --global core.editor "code --wait"

默认编辑器换 VS Code,漏写 -m 不卡在 VIM

git config --global credential.helper manager

Windows 记住 HTTPS 凭据,不用每次输

git config --global https.proxy http://127.0.0.1:(代理端口)

设置 HTTPS 代理

git config --list

列出当前所有生效配置

git config --global --list

只看全局那一层

git config --global --unset user.name

删掉某一项配置

配置作用域与别名

同名配置项在三个文件里按系统、用户、仓库的顺序查找,后一层覆盖前一层。 --show-origin 直接指出手上这个值来自哪个文件。

命令

作用

git config --system user.name "名字"

整台机器所有用户,改 Git 安装目录下的 gitconfig,需要管理员权限

git config --global user.name "名字"

当前用户的所有仓库,写在 ~/.gitconfig

git config user.name "名字"

只写当前仓库 .git/config,这是默认作用域,等价 --local

git config --show-origin --get user.name

查这个值从哪来:file:.git/config 张三

git config --list --show-origin

列出全部配置并标注来源文件

git config --unset user.name

删掉当前作用域的那一项

git config --edit --global

直接打开配置文件手改

git config alias.st "status -s"

起别名,之后 git st 就是 git status -s

git config alias.lg "log --oneline --graph --all"

长命令也能被别名包住

git -c alias.st="status -s" st

只在这一次调用里生效,不写进配置

创建与克隆

命令

作用

git init

当前目录变成仓库,生成隐藏的 .git,只执行一次

git init -b main

建仓库同时把默认分支定为 main(2.28+)

git clone <地址>

复制整个仓库到同名目录,含全部历史

git clone <地址> 目录名

克隆到指定名字的目录,目录名不必和仓库同名

git clone -b 分支名 <地址>

只检出指定分支

git clone --depth 1 <地址>

只拉最近一次提交,快,但历史不全

git fetch --unshallow

把 --depth 1 的浅历史补全

git clone --filter=blob:none <地址>

部分克隆:先只要提交和目录树,文件内容用时再取

git clone --bare <地址>

只建裸仓库,没有工作区,服务器端那种仓库

git clone --mirror <地址>

连远程分支引用一起镜像,用于整体搬迁

--filter 要服务端支持。本地 file:// 克隆会直接打印 warning: filtering not recognized by server, ignoring,然后退化成一次完整克隆。

日常三件套

git add 之后文件进暂存区,git commit 时才写进历史。 中间这一层是 git 和 SVN 最要紧的结构差别:一次提交可以只包含十处改动里的三处。

命令

作用

git status

哪个分支、哪些改了、哪些已暂存

git status -s

精简格式:左列是暂存区状态,右列是工作区状态;M 改、A 新增、D 删除、?? 未跟踪、UU 冲突

git add <文件>

把这次改动放进暂存区

git add .

当前目录下全部改动,新增、修改、删除都要

git add -A

整个仓库的全部改动,在子目录里执行也等效

git add -u

只加已跟踪文件的修改和删除,不含新文件

git add -p

逐块询问,一次提交只挑想提交的那几行

git add -f <文件>

被 .gitignore 挡住时强行加进去

git mv 旧名 新名

重命名并直接进暂存区,等价于手动改名再 git add,输出 R base.txt -> renamed.txt

git commit -m "说明"

暂存区做成一次提交;漏写 -m 会打开编辑器,存盘退出用 :wq

git commit -am "说明"

跳过 add,只暂存已跟踪文件的修改,新文件仍要 add

git commit --amend -m "新说明"

改上一次提交的说明,还没 push 时才能用

git commit --amend --no-edit

把刚暂存的改动补进上一次提交,说明不动

git commit --allow-empty -m "说明"

空提交,用于触发 CI 或标记一个节点

简写格式的两列各管一段,三种状态一眼分开:A a.txt 是新增已进暂存区, M a.txt 是改了没 add, M a.txt 是改了也 add 了。

历史与差异

命令

作用

git log

提交号、作者、时间、说明

git log --oneline

一行一条

git log --oneline --graph --all

带分支线、看所有分支,最常用的一条

git log -p <文件>

某个文件每次具体改了什么

git log --stat

每次提交动了哪些文件、增删多少行

git log --author="名字"

只看某人的提交

git log -S "关键词"

哪次提交引入或删掉了这个词

git log --grep="说明里的词"

按提交说明搜

git log -1 --name-only

上次提交动了哪些文件

git log --pretty=format:'%h %an %ad %s' --date=short

自定义列,方便接管道处理

git shortlog -sn

每人提交数排名

git describe --tags

用最近的标签描述当前提交:v0.1-2-g6053950

git diff

工作区 vs 暂存区,也就是还没 add 的改动

git diff --staged

暂存区 vs 上次提交,这次 commit 到底会提交什么

git diff HEAD

工作区 vs 上次提交,含已暂存和未暂存

git diff --stat / --name-only

只看行数统计或文件清单

git diff <分支A> <分支B>

两个分支差在哪

git show <提交>

某次提交改了什么,带完整 diff

git show <提交>:<文件>

看那个版本里这个文件的内容,不动工作区

git show v1.1

附注标签带作者、时间、说明和对应提交

git blame <文件>

每一行是谁、哪次提交写的

git blame -L 1,10 <文件>

只看前十行

撤销与回退

三件事别混:git restore 动工作区,git reset 动提交指针, git revert 造一个新提交去抵消旧的。前两个改写本地历史,第三个不动历史。

命令

作用

危险度

git restore <文件>

丢掉工作区改动,回到上次提交的样子

高

git restore --staged <文件>

移出暂存区,改动还在工作区

低

git restore --source=HEAD~1 <文件>

把某文件恢复成上上次提交的版本

低

git reset --soft HEAD~1

撤销上次提交,改动留在暂存区

低

git reset HEAD~1

撤销上次提交,改动回工作区(默认就是 --mixed)

中

git reset --hard HEAD~1

提交和改动一起丢掉

极高

git reset --hard <提交号>

整个仓库退回那次提交的状态,只影响本地

极高

git revert <提交号>

生成反向提交抵消它,历史不改写,已推送的错用它

低

git checkout -- <文件>

老写法,等价 git restore <文件>

高

git clean -n

演练:列出会被删的未跟踪文件

低

git clean -fd

真删未跟踪的文件和目录,输出 Removing junkdir/ 这样的行

极高

git clean -xfd

连 .gitignore 忽略掉的一起删

极高

撤错了还能回头:git reflog 记着刚才的位置,见「救命」一节。

新旧命令对照

2.23 之后 checkout 一个命令干两件事的毛病被拆开了:切分支归 switch,丢改动归 restore。 老写法仍然能用,网上和脚本里到处都是。

旧写法

新写法

差别

git checkout <分支>

git switch <分支>

只切分支,不会顺手覆盖文件

git checkout -b <新分支>

git switch -c <新分支>

新建并切过去

git checkout -- <文件>

git restore <文件>

丢弃工作区改动

git checkout <提交号>

git switch --detach <提交号>

明确进入 detached HEAD

git reset <文件>

git restore --staged <文件>

把文件移出暂存区

git reset --hard <提交号>

没有替代

仍要 reset,会连工作区一起丢

分支

命令

作用

git branch

列出本地分支,* 是当前分支

git branch -vv

每个分支的上游和领先、落后几个提交

git branch -a

连远程分支一起列

git branch <名字>

新建分支但不切过去

git switch <名字>

切换分支

git switch -c <名字>

新建并切过去

git switch -

切回上一个分支

git branch -m 新名

重命名当前分支,master 改 main 就用这条

git branch -d <名字>

删已合并的分支,输出 Deleted branch feature (was 7c30887).

git branch -D <名字>

强删没合并的分支

git branch --merged

已经合进当前分支的

git branch --no-merged

还没合的

git merge <分支>

把它合进当前分支

git push origin --delete <名字>

删远程分支

合并的三档

同样是 git merge,三种参数给出三种历史形状。分开记的理由很实际:形状一旦推上去就改不回来了。

命令

生成的形状

什么时候用

git merge --ff-only <分支>

只允许快进,接不上就停手报 hint: Diverging branches can't be fast-forwarded

想让历史保持一条直线

git merge <分支>

能快进就快进,不能就生成合并提交

默认行为

git merge --no-ff <分支>

一定生成合并提交,留住分支痕迹

功能分支合并,以后想看出「这里合过一次」

git merge --squash <分支>

把对方的提交压成一次未提交的改动

对方历史很乱,只要最终代码

git merge --abort

放弃这次合并,回到合并前

冲突太多,先退出

--squash 之后要自己 git commit,它不替你提交。输出里那行 Squash commit -- not updating HEAD 说的就是这个。

变基与摘取

git rebase 把当前分支的提交逐个重放到目标分支之后,历史变一条直线,代价是提交号全变。 已经推送过的分支不要 rebase:别人的历史接不上你。

命令

作用

git rebase main

把当前分支的提交搬到 main 之后

git rebase -i HEAD~3

交互式整理最近三次:合并、改说明、删、调顺序

git rebase --onto main 旧基点 分支

只搬「旧基点之后」的那几个提交,前面的一律不带

git rebase --continue

冲突改完、git add 之后继续

git rebase --skip

跳过当前这个提交

git rebase --abort

整个变基取消,回到开始前

git cherry-pick <提交号>

只摘一次提交到当前分支

git cherry-pick -x <提交号>

摘过来的说明里记上原提交号,方便追溯

git cherry-pick --no-commit <提交号>

只把改动放进暂存区,先不提交

git cherry-pick --abort

放弃这次摘取

git pull --rebase

拉取后用变基接上,历史不成麻花

git range-diff main~3..main 旧分支~3..旧分支

比较 rebase 前后两组提交的差异,一行一个对应关系

冲突发生在重放某一次提交的时候。三种结局里只有「改完继续」需要手动操作:文件里删掉三行冲突标记、留下最终内容, git add 之后 git rebase --continue。

git pull --rebase
Auto-merging readme.txt
CONFLICT (content): Merge conflict in readme.txt
error: could not apply bc9850b... 改成本地句子
hint: Resolve all conflicts manually, mark them as resolved with
hint: "git add/rm <conflicted_files>", then run "git rebase --continue".
hint: You can instead skip this commit: run "git rebase --skip".
hint: To abort and get back to the state before "git rebase", run "git rebase --abort". git status
interactive rebase in progress; onto 6b52245
Last command done (1 command done): pick bc9850b # 改成本地句子
No commands remaining.
You are currently rebasing branch 'main' on '6b52245'. (fix conflicts and then run "git rebase --continue") (use "git rebase --skip" to skip this patch) (use "git rebase --abort" to check out the original branch) Unmerged paths: (use "git restore --staged <file>..." to unstage) (use "git add <file>..." to mark resolution) both modified: readme.txt git add readme.txt
git rebase --continue
[detached HEAD 4ec6ef1] 改成本地句子 1 file changed, 1 insertion(+), 1 deletion(-)
Successfully rebased and updated refs/heads/main.

远程

三个名字先分清:origin 是远程仓库的默认别名(可以改,约定叫 origin),main 是 分支名,origin/main 是远程分支在本地的只读镜像,只有 fetch 和 pull 会更新它。

命令

作用

git remote -v

看关联了哪些地址,fetch 和 push 各一行

git remote add origin <地址>

关联远程仓库,origin 是别名

git remote set-url origin <新地址>

换地址,HTTPS 与 SSH 互换、换仓库都用它

git remote rename origin old

改别名

git remote remove origin

解除关联

git remote show origin

看这个远程有哪些分支、跟踪关系怎么设的

git ls-remote origin

不下载,只列远程有哪些引用:3b61224... refs/heads/main

git push -u origin main

第一次推,同时记住上游,输出 branch 'main' set up to track 'origin/main'.

git push

推当前分支到记住的上游,没有新东西时输出 Everything up-to-date

git push origin <分支>

没设上游时推指定分支

git push origin HEAD

把当前提交推到同名远程分支

git push --all origin

推所有本地分支

git push --force-with-lease

强推前先确认远程没被别人动过,动过就拒

git push -f

无条件覆盖远程历史

git push origin --delete <分支>

删远程分支,输出 - [deleted] feature

git fetch

只下载远程新提交到 origin/*,不动工作区

git fetch --prune

顺便清掉远程已经删掉的分支引用

git pull

fetch 加 merge

git pull --rebase

fetch 加 rebase,历史更干净

git pull origin main --allow-unrelated-histories

两边各自 init 过、历史完全无关时强行合并

git merge origin/main

fetch 之后手动合并

被拒的样子长这样:! [rejected] main -> main (non-fast-forward),远程有你本地没有的提交,先 git pull --rebase 再推。换成 --force-with-lease 被拒时是另一行 ! [rejected] main -> main (stale info),说明远程确实被别人改过,这时候不该覆盖。

三个典型动作:

  • 本地已有代码:GitHub 上新建一个空仓库,然后照「首次上传完整流程」抄。

  • GitHub 上已有仓库:git clone <地址>,之后循环 pull → 改 → add → commit → push。

  • 换地址:git remote set-url origin <新地址> → git remote -v 确认 → git push -u origin main。

两个会让第一次推送直接失败的初始状态:

  • 网页建仓库时勾了 README、.gitignore、license。远程已经有一个提交,本地历史与它无关,git push 被拒,得先 git pull origin main --allow-unrelated-histories。

  • .gitignore 在第一次 git add . 之后才写。__pycache__、数据集、.env、模型权重一起进了历史,之后只能靠 git rm --cached 收尾,或者用 git filter-repo 重写全部历史。

关联 GitHub:SSH 密钥与 HTTPS token

HTTPS 地址用账号加 Personal Access Token 认证,GitHub 已经取消密码认证;SSH 地址用本机私钥。 配好 SSH 之后永久免密,长期开发走 SSH。

对比项

HTTPS

SSH

地址长相

https://github.com/用户/仓库.git

git@github.com:用户/仓库.git

认证方式

账号加 token

本机私钥,对应 GitHub 上的公钥

每次要输吗

配了 credential.helper 才不用

配好后永久免密

适合

临时用、代理受限的网络

长期开发

命令

作用

ssh-keygen -t ed25519 -C "邮箱"

生成密钥,一路回车,默认存到 ~/.ssh/id_ed25519

cat ~/.ssh/id_ed25519.pub

复制整行,粘到 GitHub 的 Settings → SSH and GPG keys → New SSH key

ssh -T git@github.com

测连通,出现 Hi 用户名! You've successfully authenticated 就成功

git config --global credential.helper manager

Windows 记住 HTTPS 凭据

git config --global credential.helper store

Linux 上明文存一份,方便但不安全

看到 Support for password authentication was removed 就是在用账号密码登录,换 token 或换 SSH。 Permission denied (publickey) 则是公钥没配上,ssh -T git@github.com 测一遍就知道。

冲突处理

冲突不是报错,是 git 在说「同一处有两个版本,我判断不了」。合并时它把两个版本一起写进文件,中间夹三行标记:

{"git merge origin/main\n" + "Auto-merging readme.txt\n" + "CONFLICT (content): Merge conflict in readme.txt\n" + "Automatic merge failed; fix conflicts and then commit the result.\n" + "\n" + "cat readme.txt\n" + "<<<<<<< HEAD\n" + "远程带来的版本\n" + "=======\n" + "本地写的版本\n" + ">>>>>>> origin/main\n" + "\n" + "git add readme.txt\n" + "git commit -m \"合并冲突\"\n" + "[main b6aa645] 合并冲突"}

<<<<<<< HEAD 之下是当前分支的版本,======= 之下是对方的版本。删掉三行标记、留下最终内容, git add 标记已解决,git commit 收尾。整个合并想放弃就 git merge --abort。

命令

作用

git status

列出 both modified 的文件

git diff --name-only --diff-filter=U

只列冲突文件

git ls-files -u

冲突文件的三份索引版本,stage 1/2/3 分别是共同祖先、我方、对方

git checkout --ours <文件>

冲突处全取当前分支的版本,输出 Updated 1 path from the index

git checkout --theirs <文件>

全取对方的版本

git merge --abort

整个合并取消,回到合并前

git rebase --abort

整个变基取消

临时存盘 stash

切分支前手上还有做一半的改动,git stash 把它收进栈里,工作区回到干净状态,回来再取。

命令

作用

git stash

收起已跟踪文件的改动,输出 Saved working directory and index state WIP on main: ...

git stash push -u -m "带未跟踪"

连未跟踪的新文件一起收,输出 Saved working directory and index state On main: 带未跟踪

git stash push -m "半成品"

存一份并打上标签,栈里好认

git stash push -m "说明" <文件>

只收指定文件

git stash list

看栈里有几份:stash@{0}: On main: 半成品

git stash show -p

看最近一份具体改了什么

git stash pop

取出最近一份并从栈里删掉

git stash apply

取出但保留记录

git stash drop

丢掉最近一份记录,输出 Dropped refs/stash@{0} (...)

git stash clear

清空整个栈

标签 tag

命令

作用

git tag

列出所有标签

git tag v1.0

轻量标签:只是一个指向提交的名字

git tag -a v1.0 -m "说明"

附注标签:带作者、时间、说明,正式发布用它

git tag -l "v*"

按模式筛

git tag --sort=version:refname

按版本号语义排序,v0.9 排在 v0.10 前

git show v1.1

看标签信息和对应提交

git push origin v1.0

推单个标签,git push 默认不推标签

git push --tags

推全部标签

git tag -d v1.0

删本地标签,输出 Deleted tag 'v1.0' (was 4e303a7)

git push origin --delete v1.0

删远程标签

git switch --detach v1.0

按标签检出,进入 detached HEAD

轻量和附注的差别用 git cat-file -t 一看就出:轻量返回 commit,附注返回 tag。

.gitignore 忽略规则

.gitignore 写在仓库根目录,一行一条,从上往下匹配,后面的规则覆盖前面的,! 开头是取消忽略。 它只对未跟踪文件生效。

写法

含义

foo.txt

任意层级的 foo.txt 都忽略

/foo.txt

只忽略仓库根目录下的 foo.txt

doc/foo.txt

只忽略根下 doc 里的那个

doc/

所有层级的 doc 目录

**/logs

任意层级的 logs 目录

**/logs/**

该目录里所有内容,含子目录

*.log

所有 .log 文件

!important.log

取消忽略,白名单

foo?.txt

? 匹配单个字符

foo[0-9].txt

[0-9] 匹配一个数字

训练类项目常用的模板,一次写全:

__pycache__/
*.py[cod]
.ipynb_checkpoints/
.venv/
.env
data/
*.pth
*.safetensors
*.ckpt
node_modules/
.vscode/
.DS_Store

命令

作用

git check-ignore -v <文件>

查是哪条规则忽略了它:.gitignore:2:*.log app.log

git status --short --ignored

连被忽略的文件一起列,标记 !!

git rm --cached <文件>

停止跟踪,文件留在硬盘上,输出 rm 'app.log'

git rm -r --cached <目录>

整个目录停止跟踪

git add -f <文件>

强行跟踪被忽略的文件

git ls-files

列出所有已跟踪文件

已经提交过的文件不受 .gitignore 管。删掉跟踪之后 git status -s 显示 D app.log,下一次提交才真的把它移出仓库,磁盘上的文件一直在。

Git LFS 大文件

GitHub 单文件超过 100 MB 直接拒收,仓库建议小于 1 GB。模型权重和数据集交给 LFS:仓库里存一个文本 指针,实体走另一条通道。

git lfs install
Updated Git hooks.
Git LFS initialized. git lfs track "*.safetensors"
Tracking "*.safetensors" cat .gitattributes
*.safetensors filter=lfs diff=lfs merge=lfs -text git add .gitattributes
git add model.safetensors
git commit -m "模型文件走 LFS"
[main (root-commit) 37df3dd] 模型文件走 LFS 2 files changed, 4 insertions(+) create mode 100644 .gitattributes create mode 100644 model.safetensors git lfs ls-files
4f58fa94d8 * model.safetensors

.gitattributes 必须先提交。远程没开 LFS、或者没提交这个文件时,别人拉下来只有一行指针文本,模型是空的。

命令

作用

git lfs install

启用 LFS 并装 hook,每台机器一次,输出 Git LFS initialized.

git lfs track "*.bin"

让这类文件走 LFS,写进 .gitattributes

git lfs untrack "*.bin"

取消这条规则

git lfs ls-files

列出在 LFS 里的文件,前面是短哈希

git lfs ls-files --long

带完整哈希

git lfs version

看装没装:git-lfs/3.7.1 (GitHub; windows amd64; ...)

git lfs pull --include="某个.bin"

只下载指定的大文件

GIT_LFS_SKIP_SMUDGE=1 git clone <地址>

只拉指针,不下载实体,克隆一个模型仓库不至于几十 GB

git lfs migrate import --include="*.psd"

把历史里的文件改写成 LFS,会重写提交号

查找与检视

命令

作用

git grep -n "词"

在已跟踪文件里搜,带行号:t1.txt:1:t1

git grep -n "词" <提交>

在那个提交的文件树里搜,不看工作区

git ls-files

列出已跟踪文件

git ls-files -s

带暂存区的 mode、对象哈希、stage 号

git ls-tree HEAD

一个提交下的文件和子目录

git ls-tree -r --name-only HEAD

递归列出全部文件名

git cat-file -t HEAD

对象类型:commit / tag / tree / blob

git cat-file -s HEAD

对象字节数

git cat-file -p HEAD

对象内容:父提交、作者、说明

git rev-parse --short HEAD

短提交号

git rev-parse --abbrev-ref HEAD

当前分支名

git rev-parse --show-toplevel

仓库根目录的绝对路径

git show-ref

列出所有分支和标签的完整引用与哈希

补丁、归档与搬运

没有网络、也没有共享远程的时候,用文件搬提交:format-patch 导成补丁,am 应用回来, bundle 把整个仓库打成单个文件拷走。

命令

作用

git format-patch -1 -o ../patches

把最近一次提交导成 ../patches/0001-说明.patch

git format-patch HEAD~3

导出最近三次,一个提交一个文件

git am 0001-xxx.patch

应用补丁并保留原作者和时间,输出 Applying: 说明

git am --abort

放弃这次应用,回到应用前

git archive --format=zip -o src.zip HEAD

把某个提交的文件打成压缩包,不含 .git

git archive --format=tar HEAD

输出到标准输出,可以接管道

git bundle create all.bundle --all

把所有分支和标签打成一个文件

git bundle verify all.bundle

检查这个包完整可用,列出里面的引用

git clone all.bundle 目录名

从 bundle 克隆出完整仓库

git notes add -m "备注" <提交>

给提交挂一条备注,不改提交号、不改哈希

git notes show <提交>

看备注

git notes list

列出有备注的提交

git config rerere.enabled true

记住冲突的解法,同样的冲突再出现自动套用

git rerere

手动触发一次记录,配合 rerere.enabled 用

仓库维护

日常开发碰不到这组,仓库变大、要清理历史或者怀疑对象库坏了才用。

命令

作用

git count-objects -v

数对象:count、size、in-pack、size-pack 各一行

git gc

打包松散对象,清理不可达对象

git gc --prune=now

立刻删掉不可达对象,不等宽限期

git repack -ad

把所有对象重新打成一个 pack,丢掉旧的

git prune --dry-run

预览哪些不可达对象会被删

git fsck

检查对象库完整性,有问题才输出

git fsck --lost-found

把悬空对象写到 .git/lost-found,用来捞丢掉的提交

git maintenance run --task=gc

按计划跑一次后台维护任务

git filter-repo --path 大文件 --invert-paths

从全部历史里删掉一个文件,重写所有提交号

pip install git-filter-repo

先装它,git 自带没有这个子命令

git filter-repo 不随 git 发行,本机直接调是 git: 'filter-repo' is not a git command.。 它会重写全部提交号,属于仓库搬迁级别的操作,推之前先备份一份。

钩子 hooks

.git/hooks/ 里放脚本,git 在提交、推送这些动作前后调用它。文件名决定什么时候跑,退出码非 0 就拦下这次操作。 目录里初始全是 .sample 结尾的样本,去掉后缀、加上执行权限才生效。

钩子

什么时候跑

常见用途

pre-commit

提交之前

格式化、跑 lint,不过就拦下这次提交

commit-msg

提交之前,脚本收到说明文件的路径

检查说明格式,比如必须以 feat: 或 fix: 开头

pre-push

推送之前

跑一遍测试,红了就不推

post-checkout

切换分支、检出之后

自动装依赖

post-merge

合并成功之后

依赖文件变了就重新装一遍

命令

作用

ls .git/hooks

看有哪些样本:pre-commit.sample、pre-push.sample、commit-msg.sample 等

git config core.hooksPath .githooks

把钩子放进仓库里的 .githooks 目录,跟代码一起提交,团队共享

git commit --no-verify -m "说明"

跳过 pre-commit 和 commit-msg,直接提交

工作树、子模块与稀疏检出

一个仓库同时开几个目录、把别人的仓库嵌进来、只检出部分目录,这三件事都不复制历史。

命令

作用

git worktree add ../wt 分支名

另开一个目录检出指定分支,共用同一个 .git

git worktree list

列出所有工作树、各自的位置、提交号和分支

git worktree remove ../wt

删掉这个工作树

git worktree prune

清理目录已被手动删掉留下的记录

git submodule add <地址> vendor/lib

把对方仓库嵌成子模块,生成 .gitmodules

git submodule status

子模块当前钉在哪个提交上

git submodule update --init --recursive

克隆之后把子模块内容拉下来

git submodule foreach 'git log --oneline -1'

对每个子模块执行同一条命令,输出带 Entering 行

git submodule update --remote

把子模块更新到远程最新

git subtree add --prefix=vendor/lib <地址> main

把对方仓库作为一个目录嵌进来,不留 .gitmodules

git subtree pull --prefix=vendor/lib <地址> main

更新这个目录

git subtree push --prefix=vendor/lib <地址> main

把目录里的改动推回对方仓库

git sparse-checkout init --cone

开启稀疏检出

git sparse-checkout set vendor

只检出 vendor 目录,其余留在仓库里但不落盘

git sparse-checkout list

看当前检出了哪些目录

git sparse-checkout disable

关掉,恢复全量检出

救命

弄丢的提交通常还在,只是没有分支指向它。git reflog 记着 HEAD 去过的每个位置,包括被 reset --hard 抹掉的那些。

命令

作用

git reflog

HEAD 的每次移动,带 HEAD@{0}、HEAD@{1} 编号

git reset --hard HEAD@{1}

回到上一步,输出 HEAD is now at 7c30887 第四次提交

git reset --hard <提交号>

回到 reflog 里查到的那个提交

git fsck --lost-found

找出没有被任何引用指向的提交

git bisect start

开始二分定位

git bisect bad

标记当前是坏点

git bisect good <提交号>

标记一个已知好点

git bisect run sh -c '测试命令'

自动逐点测试,最后输出 ... is the first bad commit

git bisect reset

结束二分,回到原来的分支

git revert <提交号>

已经推上去的错误用它抵消,不重写历史

常见报错速查

报错

意思

怎么办

fatal: not a git repository

当前目录不是仓库

cd 到仓库根目录,或 git init

fatal: remote origin already exists

已经关联过 origin

git remote set-url origin <新地址>

! [rejected] main -> main (non-fast-forward)

远程有你本地没有的提交

先 git pull --rebase origin main,再 push

error: src refspec main does not match any

本地还没有提交,或者分支不叫 main

git log 看有没有提交,git branch 看分支名

fatal: refusing to merge unrelated histories

两边历史完全无关,各自 init 过

git pull origin main --allow-unrelated-histories

fatal: The current branch main has no upstream branch

没设上游

git push -u origin main

Permission denied (publickey)

SSH 公钥没配

ssh -T git@github.com 测一遍,重配密钥

Support for password authentication was removed

用了账号密码登录

换 Personal Access Token,或换 SSH

Please commit your changes or stash them before you switch branches

有未提交的改动

先 git commit 或 git stash

Your local changes would be overwritten by merge

改动和要拉的内容撞了

git stash → git pull → git stash pop

warning: LF will be replaced by CRLF

行尾提示,不是错误

设了 core.autocrlf true 就可以不管

remote: error: File xxx is ...; this exceeds GitHub's file size limit

单文件超过 100 MB

该文件走 LFS,并从历史里剔除

fatal: unable to access ... Could not resolve host

网络、DNS 或代理

检查代理,改用 SSH,或设 http.proxy

fatal: no rebase in progress

当前没有变基要做

git status 先看状态,别乱 continue

满屏 ~、卡在黑屏

没写 -m,进了 VIM

输入 :wq 回车退出;长期把 core.editor 改成别的

首次上传完整流程

从空目录到 GitHub 上一份完整仓库,中间只有五条命令。顺序上一个字都别换:先写 .gitignore,再 git add .。

git init -b main
Initialized empty Git repository in D:/work/demo/.git/ git add .
git commit -m "first commit"
[main (root-commit) cb341ef] first commit 2 files changed, 3 insertions(+) create mode 100644 .gitignore create mode 100644 index.html git remote add origin https://github.com/用户名/仓库名.git git push -u origin main
To https://github.com/用户名/仓库名.git * [new branch] main -> main
branch 'main' set up to track 'origin/main'.

之后每次改完就循环这几条:git pull → 改文件 → git add . → git commit -m "这次改了什么" → git push。仓库已经存在时省掉前面所有步骤,git clone <地址> 一次就够。

Git 是什么

Git 是一个分布式版本控制系统(DVCS):记录一个文件夹里所有文件随时间的每一次变化,于是一个月前的版本能翻回来, 两条互不干扰的开发线能同时存在,谁的哪一行改的都有记录。

和「复制一份 项目_最终版_改3_真的最终」的差别是结构性的:Git 存的是快照加指针,能精确 diff、能自动三方合并、 带作者和时间,占的空间还小得多。

Git 不是 GitHub。Git 是装在本机的程序,2005 年 Linus 为管理 Linux 内核开发;GitHub 是托管 Git 仓库的网站, 同类还有 GitLab、Gitee、自建 Gitea。一个远程都不配,Git 照样完整工作。

三个区域与提交模型

改文件、暂存、提交、推送,四步对应四个区域。箭头方向就是命令方向:

工作区 暂存区 (Index) 本地仓库 (.git) 远程仓库 (origin)
你正在编辑的文件 --add--> 下次提交的清单 --commit--> 提交历史 --push--> GitHub <--restore-- <--reset-- <--pull/fetch--

区域

是什么

相关命令

工作区

资源管理器里看到的那份文件

改文件、git restore

暂存区(Index)

「下次提交包含哪些改动」的清单

git add / git restore --staged

本地仓库(.git)

全部提交历史,断网也在

git commit / git reset / git log

远程仓库

GitHub 上那份副本

git push / git pull / git fetch

购物车是最好用的比喻:git add 把商品放进购物车,还没付钱、随时能拿出来;git commit 结账出一张小票, 本地历史多一条、收据改不了;git push 才是发货,送到 GitHub,别人才看得见。

一次提交是当时全部文件的一个快照加元信息:作者、时间、说明、父提交、文件树。所有提交连起来是一张 有向无环图,分支只是指向其中某个提交的可移动指针,所以新建和切换分支几乎零成本。

核心特点

特点

意味着什么

分布式

每人本地一份完整仓库,看日志、提交、开分支、diff 都不用联网,只有 push、pull、fetch 要网络

快照而非差异

每次提交记录当时所有文件的状态,没改的文件只存一个指针,切分支和回退是瞬时的

内容寻址、不可篡改

每个对象拿内容的 SHA-1 当名字,改动一个字节,其后的提交号全变

分支极轻量

一个分支就是一个指针文件,创建、切换、删除都是毫秒级

有暂存区这层中间结构

先改十个文件,再挑三个 add,凑成一次逻辑完整的提交

支持非线性开发

merge 保留分叉,rebase 搬成直线,cherry-pick 只摘一条

可恢复性强

reflog 记着 HEAD 的每次移动,误 reset --hard 通常能找回

与平台解耦

同一份仓库可以同时推到 GitHub、GitLab、Gitee,也可以一个远程都不配

Git、GitHub 与 SVN 的区别

对比项

Git

GitHub

SVN

是什么

版本控制程序,装在本机

托管 Git 仓库的网站

集中式版本控制系统

完整本地历史

有,分布式

——

没有,要连服务器

分支成本

极低,一个指针

——

高,等于复制目录

离线提交

可以

——

不行

合并能力

强,三方合并加变基

——

较弱

典型用法

本地管理,再推到平台

协作、评审、CI

老企业项目

分支、HEAD 与 HEAD~1

分支是指向某个提交的可移动指针,提交一次它就自动前移一格。HEAD 指向你现在所在的那个分支。 两者都是指针,不是目录,所以切换分支不会复制任何文件。

写法

指什么

HEAD

当前提交

HEAD~1

当前提交的父提交,HEAD~2 是父的父

HEAD^

等价 HEAD~1;合并提交有多个父时 HEAD^2 取第二个父

HEAD@{1}

reflog 里的上一步,和 HEAD~1 不是一回事

origin/main

远程分支在本地的只读镜像,只有 fetch 和 pull 会更新

main

本地分支名,本质是一个文件,里面只有一个提交号

git switch --detach HEAD~1 之后 HEAD 直接指向提交而不是分支,git status 第一行是 HEAD detached at bfb12c9。这时提交的内容不属于任何分支,切走就可能丢;想留下就 git switch -c 新分支名。

好习惯与团队约定

  • 小步提交:一次提交只做一件事,说明写「做了什么加为什么」,别写 update、fix、111。

  • 推之前先拉:pull --rebase → 解决冲突 → push,挡掉绝大多数 non-fast-forward。

  • .gitignore 先写:第一次 git add . 之前就位。

  • 不提交密钥:.env、token、id_rsa 一律进 .gitignore;一旦推到公开仓库就当泄露处理,立刻换。

  • 不对已推送的提交做 rebase 或 reset --hard,已推送的错误用 revert 抵消。

  • 主分支保护:main 只接受 PR 合并,日常在 feature/xxx 上做,合完删分支。

  • 大文件走 LFS:单文件小于 100 MB,仓库小于 1 GB。

  • 强推用 --force-with-lease,不用 -f。

  • 多敲 git status,它是「我该干什么」的提示器。

常见误解

误解

事实

commit 就等于上传了

commit 只在本地,要别人看到必须 push

push 会覆盖别人的代码

默认不会,non-fast-forward 被服务端拒;只有 -f 会

git rm 删了文件就完事

还要 git commit 才记进历史

clone 会把所有分支都检出

只检出默认分支,其余以 origin/xxx 存在,要用时 git switch xxx

本地文件夹名必须和仓库名一样

不必,git clone <地址> 任意名字 就行

reset --hard 之后彻底没了

多数情况能用 reflog 加 reset --hard <提交号> 找回

加了 .gitignore,历史里的大文件就消失了

只影响未跟踪文件,已进历史的要 git rm --cached 或 filter-repo

删除远程分支会删掉代码

只删指针,提交对象在别的分支或标签还引用时依然存在

私有仓库等于绝对安全

密钥、口令仍不该提交,仓库权限随时可能被改

一分钟速记卡

命令

记法

git init -b main

建仓库

git status

我现在什么状态

git add .

全部放进购物车

git commit -m "说明"

结账

git remote add origin <地址>

记住发货地址

git push -u origin main

第一次发货

git push

以后发货

git pull --rebase

先收货再发货

git switch -c 新分支

开个分支干活

git merge 分支

合回来

git log --oneline --graph --all

看全貌

git restore <文件>

改废了,扔掉重来

git reset --soft HEAD~1

提交早了,撤回但保留改动

git revert <提交号>

已推送的错误,用反向提交抵消

git reflog

弄丢了,来这儿捞

git stash / git stash pop

临时存一下,之后拿回来

这一页覆盖的是「命令怎么用」。命令背后的对象模型,也就是提交其实是 tree 加 blob 的一串哈希、 分支和标签只是 refs/ 下的文件,不在这里展开。