Cargando herramienta…

Guía

Cargando…

Guía rápida de comandos GitNuevo

149 comandos Git agrupados por situación, cada uno con explicación, ejemplo y nivel de riesgo; búsqueda, copia con un clic y favoritos; incluye diagramas y una terminal de práctica

Esta herramienta no está traducida por completo; parte del contenido usa el idioma de origen o uno de reserva.

Solo comandos de riesgoTotal 149 comandos

Los datos fluyen entre las cuatro zonas: add a la zona de preparación, commit al repositorio local, push al remoto; en sentido inverso, con fetch / restore / switch. pull = fetch + merge.

初始化与配置

14 entradas· 新仓库、克隆、身份与常用配置

把当前目录变成 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 entradas· 看状态、暂存、提交、看差异

查看工作区 / 暂存区状态：哪些改了、哪些已暂存、哪些未跟踪
```
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：自动暂存已跟踪文件的修改后提交（新文件不会包含）Precaución
```
git commit -am "docs: update readme"
```
容易把不想提交的改动一起带进去，提交前先 git status。
用暂存区内容 + 新说明替换最近一次提交（改错字、补漏文件）Precaución
```
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 entradas· 创建、切换、重命名、删除

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

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
```
强制删除本地分支，不管是否合并Peligro
```
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
```
检出某个提交进入「分离头指针」状态，只看不改时用Precaución
```
git checkout v1.0
git switch -c fix-from-v1    # 想保留改动就在此建分支
```
此状态下的提交不属于任何分支，切走后容易丢。
按最近提交时间排序列出分支，找最近在忙什么
```
git branch --sort=-committerdate | head
```
拉取时顺便删掉远程已不存在的分支引用（prune）
```
git fetch -p
git remote prune origin
```

合并与变基

16 entradas· 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 采用对方Precaución
```
git checkout --theirs package-lock.json
git add package-lock.json
```
rebase 时 ours / theirs 含义反过来：ours 是被变基到的分支。
把当前分支的提交「搬」到 base 之后重放，得到直线历史Precaución
```
git switch feature
git rebase main
```
所有被搬的提交 id 都会变；已推送并有人基于它工作的分支不要 rebase。

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

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 entradas· 撤销工作区 / 暂存区 / 提交，找回丢失内容

丢弃工作区改动，恢复成暂存区版本（旧写法 git checkout -- <file>）Peligro
```
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，未提交改动丢弃Peligro
```
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 表示保留第一个父提交那一侧）Precaución
```
git revert -m 1 f00ba12
```
撤销合并后再想合入同一分支需先 revert 这个 revert。

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

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

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

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

（旧写法）丢弃工作区改动，等价 git restorePeligro
```
git checkout -- src/app.js
```
修正最近一次提交的作者Precaución
```
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 entradas· 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>）Precaución
```
git push origin --delete feature/old
git push origin --delete v0.1    # 也可删远程标签
```
改写历史后的「安全强推」：远程若被别人更新过会拒绝Peligro
```
git push --force-with-lease origin feature/login
```
优先用它而不是 --force。
无条件用本地覆盖远程分支Peligro
```
git push -f origin feature/login
```
会抹掉别人推上去的提交；共享分支禁止。
推送所有本地标签（默认 push 不带标签）
```
git push --tags
git push origin v1.2.0    # 只推一个
```
推送所有本地分支Precaución
```
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 entradas· 暂时收起未完成的改动

把工作区与暂存区改动收起来，回到干净状态（等价 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}
```

删除一个 stashPeligro

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 entradas· 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）Precaución
```
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 entradas· 谁改的、什么时候坏的、搜历史

某个文件的每次改动内容

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
```
打包对象、清理垃圾，缩小 .gitPrecaución
```
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 entradas· .gitignore / .gitattributes / 大文件

每行一个模式：node_modules/、*.log、!keep.log（取反）、/build（仅根目录）
```
# .gitignore
node_modules/
dist/
*.log
.env*
!.env.example
```
解释某个文件为什么被忽略（哪条规则）
```
git check-ignore -v dist/app.js
```
.gitignore 改了但已跟踪文件仍在：重新按规则加一遍Precaución
```
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
```

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

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
```

Combinaciones frecuentes

Encadenar varios comandos en una receta de «quiero hacer una cosa»; al desplegarla se copia entera.

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

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

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

撤销一个已经推送的提交

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

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

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

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

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

在 main 上提交了，想挪到新分支Precaución

忘了开分支就提交了 N 次

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

把多个零碎提交合成一个Precaución

开 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（含远程）Precaución

统一默认分支名

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>

误提交了密钥 / 大文件Peligro

.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

Diagrama: qué hace cada comando con el grafo de commits

Los círculos son commits y las flechas apuntan al commit padre; las etiquetas verdes son ramas y la violeta indica la rama donde está HEAD; los círculos grises ya no están referenciados por ninguna rama (recuperables con reflog) y los rellenos son los commits que crea esta operación.

Commit: añadir un nodo en la punta de la rama actual

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

Cada commit recuerda su propio commit padre; una rama no es más que un puntero móvil a un commit, así que al confirmar, main y HEAD avanzan juntos.

Crear una rama: solo un puntero, sin copiar archivos

git switch -c feature

La nueva rama y main apuntan al mismo commit, por lo que crearla es instantáneo; los commits posteriores en feature solo avanzan feature.

Fusión fast-forward: mover el puntero cuando main no tiene commits propios

git switch main && git merge feature

No se crea ningún commit nuevo y el historial sigue siendo una línea recta. Para conservar el rastro de que aquí hubo una rama, hay que usar --no-ff.

Fusión a tres bandas: cuando ambos lados tienen commits nuevos se crea un commit de fusión

git merge feature

Git busca el ancestro común b2, combina los cambios de cada lado respecto a b2 y crea m6 con dos commits padre. Solo hay conflicto cuando la misma zona cambia de forma distinta.

Rebase: reaplicar los commits de feature sobre main

git switch feature && git rebase main

El historial se vuelve una línea recta, pero c3 y d4 se sustituyen por los nuevos commits c3′ y d4′ (los id cambian). No se debe hacer rebase de una rama ya publicada, o el historial de los demás divergirá.

reset: retroceder el puntero de la rama (los commits quedan huérfanos por ahora)

git reset --hard HEAD~1

--soft solo mueve el puntero; --mixed además vacía la zona de preparación; --hard revierte también el árbol de trabajo. El commit huérfano c3 todavía se puede recuperar desde el reflog (se conserva al menos 30 días por defecto).

revert: cancelar con un commit inverso, sin reescribir el historial

git revert HEAD

c3 sigue en el historial y el nuevo commit r4 contiene la inversa de los cambios de c3. Para deshacer un commit ya publicado, conviene usar revert en lugar de reset.

cherry-pick: tomar un solo commit

git cherry-pick x7

Reaplica sobre main el cambio que x7 introdujo respecto a su commit padre y produce x7′ con el mismo contenido pero distinto id. Es la forma habitual de llevar una corrección concreta a una rama de publicación.

Terminal de práctica: escribir los comandos en el navegador

Un simulador de Git completamente en memoria (no es Git real y no se conecta a la red): admite los subcomandos habituales init / add / commit / branch / switch / merge / rebase / reset / revert / stash / tag / remote / push / pull, y el grafo de la derecha se actualiza en tiempo real. 10 niveles van de «la primera confirmación» a «resolver un conflicto de fusión». La práctica de comandos de Linux está enReferencia de comandos de Linux.

git-lab — bashTab para completar · ↑↓ historial · Ctrl+L para limpiar

Terminal de práctica de Git de Toolun: un Git en memoria con el que se puede experimentar libremente sin romper nada.

Escribir git help para ver los subcomandos admitidos; elegir un nivel a la derecha y seguir el objetivo: el grafo de commits se actualiza con cada comando.

user@toolun-lab:~$

Niveles de práctica 1/10

Inicializar un repositorio Git en ~/project, crear README.md y hacer commit de él (mensaje libre).

Grafo de commits (en directo)

Todavía no hay repositorio: tras git init, el grafo de commits aparecerá aquí.

Archivos ~

▸ project/