Chargement de l’outil…

Guide

Chargement…

Aide-mémoire des commandes GitNouveau

149 commandes Git classées par situation, chacune avec explication, exemple et niveau de risque, avec recherche, copie en un clic et favoris ; schémas et terminal d’entraînement inclus

Cet outil n’est pas entièrement traduit ; certains contenus utilisent la langue source ou une langue de repli.

Commandes risquées uniquementTotal : 149 commandes

Les données circulent entre les quatre zones : add vers la zone de préparation, commit vers le dépôt local, push vers le dépôt distant ; dans l’autre sens, fetch / restore / switch. pull = fetch + merge.

初始化与配置

14 entrées· 新仓库、克隆、身份与常用配置

把当前目录变成 Git 仓库（生成 .git/）
```
git init
git init -b main    # 指定初始分支名
```

克隆远程仓库到本地，自动配置 origin

git clone https://github.com/git/git.git
git clone git@github.com:user/repo.git my-dir

浅克隆：只取最新一次提交，省时间与空间
```
git clone --depth 1 --branch v2.0 https://github.com/user/repo.git
```
克隆并直接检出指定分支
```
git clone -b develop https://github.com/user/repo.git
```
设置提交者姓名（--global 对本机所有仓库生效）
```
git config --global user.name "Zhang San"
git config --global user.email "zs@example.com"
```
只给当前仓库设置身份（公司 / 个人邮箱分开时用）
```
git config user.email "me@company.com"
```
列出全部配置及其来自哪个文件
```
git config --list --show-origin
git config --get user.name
```
让以后 git init 的默认分支叫 main
换行符策略：Windows 常用 true，macOS/Linux 用 input
```
git config --global core.autocrlf input
```
设置提交信息编辑器（这里是 VS Code）
定义别名，把长命令缩短
```
git config --global alias.lg "log --oneline --graph --all"
git lg
```
让 git pull 默认用变基而不是合并，避免多余的合并提交
记住 HTTPS 用户名密码 / token（明文存于 ~/.git-credentials）
Windows 通常已带 manager；macOS 用 osxkeychain 更安全。
打开该子命令的完整手册（等价 git <command> --help）
```
git help rebase
git reset -h    # 简短用法
```

日常提交

19 entrées· 看状态、暂存、提交、看差异

查看工作区 / 暂存区状态：哪些改了、哪些已暂存、哪些未跟踪
```
git status
git status -s    # 短格式：M 修改 A 新增 D 删除 ?? 未跟踪
```

把文件的当前内容放进暂存区（下次提交的内容）

git add src/app.js
git add src/          # 整个目录
git add "*.md"        # 通配

暂存所有改动：新增、修改、删除（git add . 在 2.x 里等价）
```
git add -A
git add -u    # 只暂存已跟踪文件的修改与删除，不含新文件
```
交互式按「块」挑选要暂存的改动，一个文件里只提交一部分
```
git add -p src/app.js
# y 暂存这块  n 跳过  s 拆得更小  q 退出
```
把暂存区内容做成一个提交
```
git commit -m "fix: 修正登录超时判断"
```
跳过 add：自动暂存已跟踪文件的修改后提交（新文件不会包含）Attention
```
git commit -am "docs: update readme"
```
容易把不想提交的改动一起带进去，提交前先 git status。
用暂存区内容 + 新说明替换最近一次提交（改错字、补漏文件）Attention
```
git add forgotten.js
git commit --amend --no-edit    # 补文件但不改说明
git commit --amend -m "新说明"
```
产生新的提交 id；已经推送过的提交不要 amend，否则需要强推。
创建一个没有改动的空提交（触发 CI、标记节点）
工作区 vs 暂存区：还没 add 的改动
```
git diff
git diff src/app.js    # 只看一个文件
```
暂存区 vs 最新提交：即将被提交的内容（--cached 同义）
```
git diff --staged
```

比较两个提交 / 分支之间的差异

git diff main feature
git diff HEAD~3 HEAD -- src/
git diff main...feature    # feature 相对分叉点的改动

只看每个文件改了多少行的统计
```
git diff --stat HEAD~1
```
按单词而不是按行显示差异，看文案改动更清楚
```
git diff --word-diff=color README.md
```

查看提交历史

git log
git log -5              # 最近 5 条
git log --oneline       # 一行一条

所有分支的历史画成图，带引用名
```
git log --oneline --graph --all --decorate
```

查看某个提交的信息与改动内容

git show HEAD
git show a1b2c3d --stat
git show HEAD:src/app.js    # 看某版本的文件内容

删除文件并把「删除」放入暂存区
```
git rm old.txt
git rm -r legacy/
```
只从版本库移除、保留本地文件（误提交了 node_modules / .env 时用）
```
git rm --cached .env
echo ".env" >> .gitignore
```
重命名 / 移动文件并暂存（等于 mv + git add）
```
git mv utils.js helpers.js
```

分支

14 entrées· 创建、切换、重命名、删除

列出本地分支（* 是当前分支）

git branch
git branch -a    # 含远程分支
git branch -vv   # 带最新提交与跟踪关系

在当前提交创建分支，但不切换过去

git branch feature/login
git branch hotfix a1b2c3d    # 从指定提交创建

切换到已有分支（2.23+；旧写法 git checkout <branch>）
```
git switch main
git switch -    # 回到上一个分支
```

创建并切换到新分支（旧写法 git checkout -b）

git switch -c feature/search
git switch -c hotfix origin/main    # 基于远程分支

创建并切换（老写法，所有版本可用）
```
git checkout -b release/1.2
```

重命名分支（省略 old 则重命名当前分支）

git branch -m master main
git push -u origin main && git push origin --delete master

删除已合并的本地分支（未合并会拒绝）
```
git branch -d feature/login
```
强制删除本地分支，不管是否合并Danger
```
git branch -D experiment
```
分支上的独有提交会成为孤儿，短期内可用 reflog 找回。
列出已合并进当前分支的分支（清理时先看这个）
```
git branch --merged main
git branch --no-merged    # 反过来
```
把当前分支的上游设为某远程分支（之后 pull / push 不用写参数）
```
git branch -u origin/feature/login
```
哪些分支包含这个提交
```
git branch -a --contains a1b2c3d
```
检出某个提交进入「分离头指针」状态，只看不改时用Attention
```
git checkout v1.0
git switch -c fix-from-v1    # 想保留改动就在此建分支
```
此状态下的提交不属于任何分支，切走后容易丢。
按最近提交时间排序列出分支，找最近在忙什么
```
git branch --sort=-committerdate | head
```
拉取时顺便删掉远程已不存在的分支引用（prune）
```
git fetch -p
git remote prune origin
```

合并与变基

16 entrées· merge / rebase / cherry-pick，及冲突处理

把 branch 合进当前分支：能快进就快进，否则生成合并提交
```
git switch main
git merge feature/login
```
总是生成合并提交，保留「这里有过一个分支」的历史
```
git merge --no-ff feature/login
```
把分支所有改动压成一次暂存，由你手动做一个提交
```
git merge --squash feature/login
git commit -m "feat: login"
```
合并冲突时放弃，回到合并前的状态
```
git merge --abort
```
解决冲突后：暂存已修好的文件，再提交完成合并
```
git add src/app.js
git commit    # 默认说明 Merge branch ...
```
冲突时整文件采用我方（当前分支）版本；--theirs 采用对方Attention
```
git checkout --theirs package-lock.json
git add package-lock.json
```
rebase 时 ours / theirs 含义反过来：ours 是被变基到的分支。
把当前分支的提交「搬」到 base 之后重放，得到直线历史Attention
```
git switch feature
git rebase main
```
所有被搬的提交 id 都会变；已推送并有人基于它工作的分支不要 rebase。

交互式变基：合并 / 改写 / 重排 / 删除从 commit 之后的提交Attention

git rebase -i HEAD~3
# pick 保留  reword 改说明  squash 并入上一条  fixup 并入且丢说明  drop 删除

变基遇到冲突：解决并 add 后继续
```
git add .
git rebase --continue
```
放弃这次变基，回到开始前
```
git rebase --abort
```
把 old-base..branch 这段提交移植到 new-base 之上
```
git rebase --onto main server client
```
适合「分支开错了地方」的情形。
先做 fixup 提交，变基时自动并入目标提交
```
git commit --fixup a1b2c3d
git rebase -i --autosquash a1b2c3d~1
```

把某个提交的改动复制到当前分支（新 id）

git cherry-pick a1b2c3d
git cherry-pick a1b2c3d..e5f6g7h    # 一段范围（不含 a1b2c3d）

只应用改动到工作区与暂存区，不自动提交
```
git cherry-pick -n a1b2c3d
```

用配置的图形工具逐个解决冲突

git config --global merge.tool vscode
git config --global mergetool.vscode.cmd "code --wait $MERGED"
git mergetool

记住冲突解决方式，下次同样冲突自动复用

回退与撤销

16 entrées· 撤销工作区 / 暂存区 / 提交，找回丢失内容

丢弃工作区改动，恢复成暂存区版本（旧写法 git checkout -- <file>）Danger
```
git restore src/app.js
git restore .    # 整个目录
```
未暂存的改动会直接丢失，无法用 Git 找回。
取消暂存（把文件从暂存区拿出来，工作区改动保留）
```
git restore --staged src/app.js
git reset HEAD src/app.js    # 旧写法
```
把某个文件恢复到指定提交时的版本
```
git restore --source HEAD~2 config.yml
git restore --source v1.0 -- src/
```
撤销最近一次提交，改动保留在暂存区（重新组织提交）
```
git reset --soft HEAD~1
git commit -m "更合适的说明"
```
撤销最近一次提交，改动回到工作区未暂存（默认 --mixed）
```
git reset HEAD~1
```
分支指针、暂存区、工作区全部回到 commit，未提交改动丢弃Danger
```
git reset --hard HEAD~1     # 扔掉最后一次提交
git reset --hard origin/main    # 与远程完全一致
```
工作区改动不可恢复；已提交的可用 git reflog 找回。
把某文件从暂存区移出（保留工作区），等价 restore --staged
```
git reset package-lock.json
```
生成一个新提交来抵消 commit 的改动，历史不变，可安全推送
```
git revert HEAD
git revert a1b2c3d --no-edit
```
批量撤销一段提交，最后一起提交
```
git revert --no-commit HEAD~3..HEAD
git commit -m "revert last 3 commits"
```
撤销一次合并（-m 1 表示保留第一个父提交那一侧）Attention
```
git revert -m 1 f00ba12
```
撤销合并后再想合入同一分支需先 revert 这个 revert。

HEAD 移动记录：reset / rebase / 删分支后找回「消失」的提交

git reflog
git reset --hard HEAD@{2}    # 回到 2 步之前的状态
git branch rescue a1b2c3d     # 给孤儿提交建分支

删除所有未跟踪的文件和目录（先用 -n 预览）Danger

git clean -n      # 预览会删什么
git clean -fd     # 执行
git clean -fdx    # 连 .gitignore 里忽略的也删（如 node_modules）

（旧写法）丢弃工作区改动，等价 git restoreDanger
```
git checkout -- src/app.js
```
修正最近一次提交的作者Attention
```
git commit --amend --author="Zhang San <zs@example.com>" --no-edit
```
列出不可达对象，reflog 也没有时的最后手段
```
git fsck --lost-found
git show <dangling-commit-id>
```
找回误 drop 的 stash（stash 本质也是提交）
```
git fsck --unreachable | grep commit | cut -d" " -f3 | xargs git log --merges --no-walk
```

远程协作

18 entrées· remote / fetch / pull / push

列出远程仓库及地址
```
git remote -v
```
添加远程仓库（本地 init 后关联 GitHub 时用）
```
git remote add origin git@github.com:user/repo.git
```
修改远程地址（HTTPS ↔ SSH、换仓库）
```
git remote set-url origin git@github.com:user/repo.git
```
重命名远程
```
git remote rename origin upstream
```
删除远程配置（不影响远程仓库本身）
```
git remote remove upstream
```
下载远程的新提交与分支到本地引用（origin/xxx），不改动工作区
```
git fetch
git fetch origin main
git fetch --all --prune
```
fetch + merge：把上游分支合进当前分支
```
git pull
git pull origin main
```
fetch + rebase：把本地提交搬到远程最新之后，不产生合并提交
```
git pull --rebase origin main
```
把当前分支推到上游分支
```
git push
git push origin main
```
首次推送新分支并建立跟踪关系（之后 git push 即可）
```
git push -u origin feature/login
```
删除远程分支（等价 git push origin :<branch>）Attention
```
git push origin --delete feature/old
git push origin --delete v0.1    # 也可删远程标签
```
改写历史后的「安全强推」：远程若被别人更新过会拒绝Danger
```
git push --force-with-lease origin feature/login
```
优先用它而不是 --force。
无条件用本地覆盖远程分支Danger
```
git push -f origin feature/login
```
会抹掉别人推上去的提交；共享分支禁止。
推送所有本地标签（默认 push 不带标签）
```
git push --tags
git push origin v1.2.0    # 只推一个
```
推送所有本地分支Attention
```
git push --all origin
```

不克隆，直接列出远程的分支与标签

git ls-remote --heads origin
git ls-remote --tags https://github.com/git/git.git

fork 工作流：同步上游仓库的更新到本地

git remote add upstream https://github.com/original/repo.git
git fetch upstream
git switch main && git merge upstream/main

只允许快进拉取，有分叉就报错而不是悄悄合并
```
git pull --ff-only
```

贮藏 stash

9 entrées· 暂时收起未完成的改动

把工作区与暂存区改动收起来，回到干净状态（等价 stash push）
```
git stash
git stash push -m "登录页半成品"
```
连未跟踪的新文件一起 stash（默认不含）
```
git stash -u
git stash -a    # 连忽略文件也收
```
列出所有 stash（stash@{0} 最新）
```
git stash list
```
取出最新 stash 应用到工作区并删除它
```
git stash pop
git stash pop stash@{2}
```
应用 stash 但保留它（同一份改动要用到多个分支时）
```
git stash apply stash@{1}
```
看某个 stash 改了什么
```
git stash show -p stash@{0}
```

删除一个 stashDanger

git stash drop stash@{0}
git stash clear    # 全部删除

从 stash 创建新分支并应用（stash 与当前分支冲突时最省事）
```
git stash branch fix-from-stash stash@{0}
```

只 stash 指定文件

git stash push -m "只收起样式" -- src/styles/

子模块与工作树

10 entrées· submodule / worktree / sparse-checkout

把另一个仓库作为子模块引入
```
git submodule add https://github.com/user/lib.git vendor/lib
```
克隆后拉取所有子模块内容
```
git submodule update --init --recursive
```
克隆时顺带把子模块也拉下来
```
git clone --recurse-submodules https://github.com/user/repo.git
```

把子模块更新到其远程分支最新提交

git submodule update --remote vendor/lib
git add vendor/lib && git commit -m "bump lib"

查看各子模块当前指向的提交
```
git submodule status
```
删除子模块（三步：deinit、rm、清 .git/modules）Attention
```
git submodule deinit -f vendor/lib
git rm -f vendor/lib
rm -rf .git/modules/vendor/lib
```
在另一个目录同时检出另一个分支（不用 stash 来回切）
```
git worktree add ../repo-hotfix hotfix/1.2.1
git worktree add -b review ../repo-review origin/pr-42
```
列出所有工作树
```
git worktree list
```

删除一个工作树（目录与登记一起清掉）

git worktree remove ../repo-hotfix
git worktree prune    # 清理已手工删除目录的登记

只检出仓库的部分目录（大型单体仓库）

git clone --filter=blob:none --sparse <url>
cd repo && git sparse-checkout set apps/web packages/ui

查历史与排错

18 entrées· 谁改的、什么时候坏的、搜历史

某个文件的每次改动内容

git log -p -- src/app.js
git log --follow -- src/app.js    # 跨重命名跟踪

按作者筛选提交

git log --author="zhang" --since="2 weeks ago"

按提交说明搜索
```
git log --grep="登录" -i --oneline
```

找出增加或删除了某字符串的提交（pickaxe）

git log -S"validateToken" --oneline
git log -G"regex" --oneline    # 正则版

b 有而 a 没有的提交

git log main..feature --oneline
git log origin/main..HEAD    # 还没推送的提交

自定义输出格式（%h 短 id %an 作者 %ar 相对时间 %s 说明）
```
git log --pretty=format:"%h %ad %an %s" --date=short -10
```
按时间范围筛选
```
git log --since="2026-09-01" --until="2026-09-09" --oneline
```
按作者统计提交数
```
git shortlog -sn --all --no-merges
```

逐行显示最后修改者与提交

git blame -L 40,60 src/app.js
git blame -w -C src/app.js    # 忽略空白、跟踪移动

二分查找引入 bug 的提交

git bisect start
git bisect bad              # 当前是坏的
git bisect good v1.1.0      # 这个版本是好的
# 反复测试并执行 git bisect good/bad
git bisect reset

让脚本自动判定好坏，全自动二分
```
git bisect run npm test
```
在已跟踪文件中搜索（比 grep -r 快且不搜 node_modules）
```
git grep -n "TODO" -- "*.ts"
git grep "foo" v1.0    # 在某个版本里搜
```
直接看某版本某文件内容，不切分支
```
git show HEAD~5:src/config.js > old-config.js
```

只列出改动过的文件名

git diff --name-only HEAD~3 HEAD
git diff --name-status main    # 带 M/A/D 状态

查看仓库对象数量与占用空间
```
git count-objects -vH
```
打包对象、清理垃圾，缩小 .gitAttention
```
git gc --aggressive --prune=now
```
prune 会真正删除不可达对象，reflog 里的后悔药会一起消失。

把引用解析成完整提交 id；--abbrev-ref 得到分支名

git rev-parse --short HEAD
git rev-parse --abbrev-ref HEAD
git rev-parse --show-toplevel    # 仓库根目录

把某版本的文件导出成压缩包（不含 .git）
```
git archive -o release.zip v1.2.0
git archive HEAD src/ | tar -x -C /tmp/out
```

忽略与属性

7 entrées· .gitignore / .gitattributes / 大文件

每行一个模式：node_modules/、*.log、!keep.log（取反）、/build（仅根目录）
```
# .gitignore
node_modules/
dist/
*.log
.env*
!.env.example
```
解释某个文件为什么被忽略（哪条规则）
```
git check-ignore -v dist/app.js
```
.gitignore 改了但已跟踪文件仍在：重新按规则加一遍Attention
```
git rm -r --cached .
git add .
git commit -m "chore: apply .gitignore"
```
全局忽略文件（.DS_Store、Thumbs.db、编辑器目录）
```
echo ".DS_Store" >> ~/.gitignore_global
git config --global core.excludesFile ~/.gitignore_global
```

本地改了配置文件但不想提交也不想被覆盖Attention

git update-index --skip-worktree config/local.php
git update-index --no-skip-worktree config/local.php    # 取消

按路径设置换行、diff 方式、LFS 等属性

* text=auto
*.sh text eol=lf
*.png binary
*.psd filter=lfs diff=lfs merge=lfs -text

用 Git LFS 管理大文件（先安装 git-lfs）
```
git lfs install
git lfs track "*.psd"
git add .gitattributes
```

Combinaisons courantes

Enchaînez quelques commandes dans une recette « faire une chose » ; dépliez-la pour copier l’ensemble.

撤销最近一次提交，但保留改动

提交早了 / 说明写错 / 想拆成两个提交（且尚未推送）

git reset --soft HEAD~1提交撤掉，改动仍在暂存区
git status确认文件都在「要提交的变更」里
git commit -m "新的说明"

撤销一个已经推送的提交

别人可能已经拉取了，不能改写历史

git revert <commit>生成反向提交
git push

回退到某个版本（本地）Danger

本地实验搞乱了，想彻底回到某个提交

git log --oneline找到目标提交 id
git stash -u（可选）先收起还想保留的改动
git reset --hard <commit>

在 main 上提交了，想挪到新分支Attention

忘了开分支就提交了 N 次

git branch feature/x在当前位置建分支（把这些提交「存」起来）
git reset --hard origin/mainmain 回到远程状态
git switch feature/x

把多个零碎提交合成一个Attention

开 PR 之前整理历史（分支未被他人使用）

git rebase -i HEAD~4把后面几行的 pick 改成 squash 或 fixup
git push --force-with-lease分支已推送过才需要

让功能分支跟上 main 的最新进度

main 已经有新提交，功能分支要在其之上继续

git fetch origin
git switch feature/x
git rebase origin/main或 git merge origin/main（保留合并提交）

把 master 改名为 main（含远程）Attention

统一默认分支名

git branch -m master main
git push -u origin main
git push origin --delete master先在托管平台把默认分支切到 main

找回误删的分支

git branch -D 之后发现还有用

git reflog找到该分支最后一次提交的 id（如 "commit: xxx"）
git branch <name> <commit-id>

误提交了密钥 / 大文件Danger

.env 或几百 MB 的文件进了历史

git rm --cached .env && echo ".env" >> .gitignore若只在最近一次提交：接着 git commit --amend
git filter-repo --path .env --invert-paths已在历史深处：用 git-filter-repo 重写全部历史（需单独安装）
git push --force-with-lease --all所有协作者都要重新克隆；泄露的密钥无论如何都要作废重发

把一个修复带到发布分支

main 上修好的 bug 也要进 release/1.2

git switch release/1.2
git cherry-pick <commit>
git push

合并冲突标准处理流程

git merge / pull 报 CONFLICT

git status看哪些文件「双方修改」
code <file>在编辑器里处理 <<<<<<< ======= >>>>>>> 标记，保留正确内容
git add <file>每修好一个就 add 一个
git commitrebase 时则是 git rebase --continue

本地已有项目，推到新建的空远程仓库

先在本地写了代码，后来才在 GitHub 建了仓库

git init -b main && git add -A && git commit -m "init"
git remote add origin git@github.com:user/repo.git
git push -u origin main

Schéma des opérations : ce que chaque commande fait au graphe de commits

Les points sont des commits et les flèches pointent vers le commit parent ; une étiquette verte indique une branche, une violette la branche où se trouve HEAD ; un point gris n’est plus référencé par aucune branche (récupérable via le reflog) et un point plein est un commit créé par l’opération en cours.

Commit : ajouter un nœud à la pointe de la branche courante

git add . && git commit -m "…"

Chaque commit retient son commit parent ; une branche n’est qu’un pointeur mobile vers un commit, donc après un commit, main et HEAD avancent ensemble.

Créer une branche : juste un pointeur, aucun fichier copié

git switch -c feature

La nouvelle branche et main pointent vers le même commit, donc la création est instantanée ; ensuite, les commits sur feature ne font avancer que feature.

Fusion en avance rapide : déplacer directement le pointeur quand main n’a aucun commit propre

git switch main && git merge feature

Aucun nouveau commit n’est créé et l’historique reste une ligne droite. Pour garder la trace qu’une branche a existé, utilisez --no-ff.

Fusion à trois points : créer un commit de fusion quand les deux côtés ont de nouveaux commits

git merge feature

Git trouve l’ancêtre commun b2, combine les modifications de chaque côté par rapport à b2 et crée m6 avec deux commits parents. Un conflit n’apparaît que si la même zone a été modifiée différemment.

Rebase : rejouer les commits de feature par-dessus main

git switch feature && git rebase main

L’historique devient une ligne droite, mais c3 et d4 sont remplacés par de nouveaux commits c3′ et d4′ (les id changent). Ne faites pas de rebase sur une branche déjà poussée, sinon l’historique des autres divergera du vôtre.

reset : reculer le pointeur de branche (les commits deviennent orphelins pour l’instant)

git reset --hard HEAD~1

--soft ne déplace que le pointeur ; --mixed vide en plus la zone de préparation ; --hard rétablit aussi l’arbre de travail. Le commit orphelin c3 reste récupérable via le reflog (conservé au moins 30 jours par défaut).

revert : annuler par un commit inverse, sans réécrire l’historique

git revert HEAD

c3 reste dans l’historique et le nouveau commit r4 contient l’inverse des modifications de c3. Pour annuler un commit déjà poussé, utilisez revert plutôt que reset.

cherry-pick : appliquer un seul commit

git cherry-pick x7

Rejoue sur main les modifications que x7 a introduites par rapport à son parent, ce qui donne x7′ au contenu identique mais à l’id différent. Idéal pour porter un correctif isolé vers une branche de publication.

Terminal d’entraînement : tapez les commandes dans le navigateur

Un simulateur Git entièrement en mémoire (pas le vrai Git, aucune connexion réseau) : il prend en charge les sous-commandes courantes init / add / commit / branch / switch / merge / rebase / reset / revert / stash / tag / remote / push / pull, et le graphe à droite se met à jour en temps réel. 10 niveaux, de la première validation à la résolution d’un conflit de fusion. Pour les commandes Linux, l’entraînement se trouve dansAide-mémoire des commandes Linux.

git-lab — bashTab pour compléter · ↑↓ historique · Ctrl+L pour effacer

Terminal d’entraînement Git de Toolun : un Git en mémoire, à manipuler librement sans rien casser.

Tapez git help pour voir les sous-commandes prises en charge ; choisissez un niveau à droite et suivez l’objectif : le graphe de commits se met à jour à chaque commande.

user@toolun-lab:~$

Niveaux d’entraînement 1/10

Initialisez un dépôt Git dans ~/project, créez README.md et faites un commit (message au choix).

Graphe des commits (en temps réel)

Aucun dépôt pour l’instant : lancez git init et le graphe des commits apparaîtra ici.

Fichiers ~

▸ project/