Git Diff详解：带有示例的完整指南

教程
Git

Git diff 是您查看代码存储库中变化的窗口。从本质上讲，它是一个命令，向您展示文件各种状态之间的差异，无论是将您当前的工作与已经暂存的内容进行比较，还是比较分支和提交之间的更改。可以将其视为 Git 回答“发生了什么变化？”这个问题的方式。运行 git diff 时，Git 逐行分析文件内容，识别添加、删除或修改的内容，并以标准化格式呈现这些信息，准确突出显示发生了什么变化以及在哪里发生了变化。

Git diff 帮助开发人员在提交之前提供修改清晰视图，以确保代码质量。在这里，我们将介绍如何有效使用这个基本命令，从基本比较到进阶技巧，以提高您的开发工作流程和团队协作。

先决条件

要跟随本教程，您应该熟悉以下 Git 概念：

  • 基本的 Git 工作流程（init、add、commit）
  • Git 仓库及其结构
  • 分支及其工作原理
  • 提交和提交历史
  • 暂存区（index）

如果您需要复习这些概念，可以参考以下资源：

你需要 在你的系统上安装Git以便跟随示例。所有命令都可以在终端或命令提示符中运行。

为什么Git Diff对开发人员至关重要

每个开发人员都需要知道他们的代码发生了什么变化，无论是独自工作还是在一个由数百人组成的团队中工作。没有git diff，你将不得不猜测你已经修改了哪些行，这将使故障排除和协作几乎不可能进行。

Git diff 是变更管理中必不可少的工具，通过有效的审查流程构建优质软件的基础。在检查变更时，git diff 提供了理解变更背后含义的上下文。

这种直接查看代码演变的能力帮助团队保持标准，防止错误进入生产环境。

随着项目复杂度的增加，git diff 凭借几个关键原因变得不可或缺：

  • 变更验证：确认即将提交的内容，避免意外包含调试代码或无关的更改
  • 知识传递 ：了解队友的工作内容，而不必读取整个文件
  • 冲突解决：在合并过程中准确识别变更冲突的位置和方式
  • 历史分析 ：追踪特定变更的引入时间，以便查找错误或了解功能演化
  • 针对性的代码审查：将注意力集中在实际更改的代码部分，节省时间并提高审查质量

要有效地使用git diff，有必要了解底层架构，使得这些比较成为可能——Git的“三树”模型。

Git的三树架构

要理解git diff，首先需要掌握Git的基本“三树”架构。尽管名字是这样，但这些并不是文件系统中的实际树，而是代码存在的三个不同状态。

把这些状态看作是 Git 同时跟踪的项目的三个不同版本：工作目录（您的实际文件）、暂存区（或索引，用于准备提交的更改）和仓库（存储在 .git 目录中的项目的提交历史）。

来源：Hashnode

工作目录包含您正在积极编辑的文件，这是您编写代码、进行更改和测试工作的地方。暂存区充当准备区，您可以在其中选择应包含在下一次提交中的更改。您可以将其视为装运前的装卸区，其中包裹（您的更改）在装运之前被组织好。

最后，仓库将您的项目的完整历史存储为一系列提交，即代码在特定时间点的快照，这些快照链接在一起形成历史链。

Git diff 通过比较这三种状态的各种组合来操作。当您运行 git diff 时，不带参数，它会将您的工作目录与暂存区进行比较，显示您已经做出但尚未暂存的更改。

使用 git diff --staged 比较暂存区和最后一次提交，显示将包含在您下一次提交中的内容。

使用git diff HEAD命令，直接比较您的工作目录和最后一次提交，显示所有未提交的更改，而不考虑暂存状态。

这些比较点构成了Git中所有diff操作的基础：

  • 工作目录 ↔ 暂存区：我做了哪些更改但尚未暂存？（git diff）
  • 暂存区 ↔ 代码仓库：我已经暂存了哪些更改将会在下一次提交时生效？（git diff --staged）
  • 工作目录 ↔ 代码仓库：我的工作文件与上次提交的总体差异是什么？（git diff HEAD）
  • 在提交之间：代码在历史上特定点之间如何演变？（git diff 提交1哈希 提交2哈希）

理解这个架构为您提供了使用 git diff 必需的思维模型，可以准确指出代码库中发生了什么变化、在哪里以及何时。

有了这种架构理解，我们现在可以探索如何在实践中使用 git diff 命令，以获取有关代码在这三个状态下演变的见解。

基本的 Git Diff 使用

让我们创建一个样本数据分析项目来演示git diff的实际操作。我们将建立一个包含Python脚本、CSV数据和文本文件的小型存储库，在本教程中我们将对其进行修改。

# 创建并初始化我们的项目
mkdir data-analysis-project
cd data-analysis-project
git init

# 创建初始文件
echo "# Data Analysis Project\nA sample project to demonstrate git diff functionality." > README.md
echo "import pandas as pd\n\ndef load_data(filename):\n return pd.read_csv(filename)\n\ndef analyze_data(data):\n return data.describe()" > analysis.py
echo "id,name,value\n1,alpha,10\n2,beta,20\n3,gamma,30" > data.csv
echo "DEBUG=False\nDATABASE_PATH=./data/" > config.txt
echo "def normalize_data(data):\n return (data - data.min()) / (data.max() - data.min())" > utils.py

# 进行第一次提交
git add .
git commit -m "Initial commit with basic project structure"

# 检查目录结构
> tree

.
├── README.md
├── analysis.py
├── config.txt
├── data.csv
└── utils.py

我们的项目现在有五个文件处于版本控制之下，为我们展示各种不同diff情况奠定了基础。随着我们的进展，我们将修改这些文件以展示git diff在不同情境下如何显示更改。

理解git diff的结果

当你运行git diff命令时，输出遵循一种标准化格式，旨在清晰地指示发生了什么更改。让我们修改我们的analysis.py文件以查看diff的实际效果：

# 使用新函数更新analysis.py
echo "import pandas as pd\n\ndef load_data(filename):\n return pd.read_csv(filename)\n\ndef analyze_data(data):\n return data.describe()\n\ndef visualize_data(data):\n return data.plot(kind='bar')" > analysis.py

现在让我们检查生成的git diff：

git diff

你将看到类似于以下内容的输出：

注意：要退出git diff输出，请在终端上按“q”键。

让我们分解这个输出：

  1. 头部（diff --git a/analysis.py b/analysis.py）显示正在比较的文件，即analysis.py
  2. 文件元数据（index db0e049..a7a7ab0 100644）显示之前和之后版本的内部 Git 标识符
  3. 文件标记（--- a/analysis.py和+++ b/analysis.py）表示“之前”和“之后”的文件
  4. 片段标题（@@ -5,3 +5,6 @@）显示受影响的行。这种符号可以解释为：
  • -5,3表示在原始文件中从第5行开始，显示差异的行数为3行
  • +5,6表示在修改后的文件中从第5行开始，显示差异的行数为6行
  • 这些数字的差异表明新增了3行

5. 内容有所更改，以+开头的行表示新增内容

在较大的文件中，git diff 将更改分组成“hunks”——包含更改内容的文件部分。每个hunk都有自己的标题，包含行号，帮助您在文件中定位更改。

比较工作目录和暂存区

运行git diff无参数比较您的工作目录（文件的当前状态）和暂存区（准备提交的更改）。这对于审查您已更改但尚未准备好提交的内容很有用。

让我们修改多个文件来演示：

# 更新 README.md
echo "# Data Analysis Project\nA sample project to demonstrate git diff functionality.\n\n## Installation\nRun \pip install -r requirements.txt" > README.md

# 更新 data.csv
echo "id,name,value\n1,alpha,10\n2,beta,20\n3,gamma,30\n4,delta,40" > data.csv

现在让我们只暂存 README.md 的更改：

git add README.md

运行git diff现在只会显示文件的未暂存更改以及上面的analysis.py文件：

这有助于您专注于尚未暂存的内容。如果要查看已暂存的内容：

git diff --staged # or git diff --cached (they're synonyms)

这将显示已暂存并准备提交的文件的更改。这种工作流对于构建干净、逻辑清晰的提交至关重要。您可以将有意义的工作部分暂存在一起，审查已暂存的差异以验证其是否是一致的更改单元，然后提交。

比较暂存区和上一次提交的内容

git diff --staged 命令会比较您的暂存区和最后一次提交。如果您现在运行 git commit，这将准确显示下一个提交中包含的内容。

让我们暂存 data.csv 的更改并检查已暂存的内容：

git add data.csv
git diff --staged

现在输出将显示对 README.md 和 data.csv 的更改，因为两者都已暂存。在提交之前进行这个审查步骤非常重要，它是您最后防线，防止提交不必要的更改。

常见的工作流程可能如下：

  1. 对多个文件进行更改
  2. 运行 git diff 来审查所有更改
  3. 使用git add <file>有选择地将逻辑组的更改暂存
  4. 运行git diff --staged以验证即将提交的内容
  5. 使用git commit -m "Your message"提交已暂存的更改
  6. 针对其他逻辑组的更改重复上述步骤

这种系统的方法有助于维护干净、有意义的提交历史，使您更容易理解项目的演变，并 pinpoint 问题可能出现的位置。随着经验的积累，这些 diff 命令将变得如同第二天性，成为您开发过程中不离不弃的伙伴。

在进入下一个阶段之前，让我们先进行提交：

# data.csv 和 README.md 将被提交
git commit -m "Modify data.csv and README.md files"

# 阶段并提交 analysis.py
git add analysis.py
git diff --staged  # Review the changes one more time
git commit -m "Add a new function to analysis.py"

中级 Git Diff 技巧

现在我们已经了解了 git diff 的基础知识，让我们探索一些更强大的技巧，以增强您跟踪和分析项目变更的能力。我们将继续使用我们的数据分析项目来演示这些中级概念。

在不同引用之间进行比较

Git 是围绕引用的概念构建的——指向代码特定状态的指针。这些引用包括分支、提交和标签。git diff 命令可以比较这两个引用之间的任何两个，以显示它们之间的变化。

让我们创建一个新分支来开发一个功能，并进行一些更改：

# 创建并切换到新分支
git checkout -b feature/advanced-analytics

# 使用新函数修改analysis.py文件
echo "import pandas as pd
import numpy as np

def load_data(filename):
   return pd.read_csv(filename)

def analyze_data(data):
   return data.describe()

def visualize_data(data):
   return data.plot(kind='bar')

def perform_advanced_analysis(data):
   """Performs advanced statistical analysis on the dataset"""
   results = {}
   results['correlation'] = data.corr()
   results['skew'] = data.skew()
   return results" > analysis.py

# 提交更改
git add analysis.py
git commit -m "Add advanced analysis function"

现在我们可以将我们的特性分支与主分支进行比较：

git diff main feature/advanced-analytics

这个命令显示两个分支之间的所有差异——每个已修改、添加或删除的文件。您将看到我们对analysis.py所做的更改，包括我们的新导入和函数（在终端中按回车多次，因为完整的差异在终端中被截断）。

要与特定提交进行比较，您可以使用提交哈希：

git log --oneline  # Find the commit hash you want to compare with

git diff 7b3105e  # Replace 7b3105e with the actual commit hash you want to compare

当：

  • 准备进行代码审查，看到特性分支中的所有更改时
  • 在合并之前查看同事分支将引入的更改
  • 了解代码库在发布或版本之间如何演变

比较特定文件

当处理大型存储库时，通常希望关注对特定文件或目录的更改，而不是查看所有差异。Git diff通过允许您指定路径使此操作变得简单。

让我们修改多个文件：

# 更新config.txt
echo "DEBUG=True
DATABASE_PATH=./data/
LOG_LEVEL=INFO" > config.txt

# 更新utils.py
echo "def normalize_data(data):
   return (data - data.min()) / (data.max() - data.min())

def clean_data(data):
   return data.dropna()" > utils.py

仅查看对config文件的更改：

git diff config.txt

或在分支之间比较特定文件：

# 比较main分支和feature/advanced-analytics分支之间的analysis.py文件
git diff main feature/advanced-analytics -- analysis.py

上述命令中的--帮助Git区分引用和文件路径。这在以下情况下特别有用：

  • 在具有许多文件但专注于特定组件的存储库中工作（这种情况经常发生）
  • 检查配置在不同分支之间的变化
  • 仅审查大量更改中最关键的文件

上下文差异选项

Git diff提供了几个选项来调整显示差异的方式，使得更容易集中注意力在有意义的更改上。

例如，在处理代码格式更改时，空白差异可能会掩盖重要的语义更改。让我们来演示一下格式更改：

# 对 analysis.py 进行空白更改
sed -i '' 's/    return/  return/g' analysis.py  # Reduce indentation

现在，与标准的 git diff 进行比较会显示空白更改（请注意 return 语句的错位）：

git diff analysis.py

# OUT:
--- a/analysis.py
+++ b/analysis.py
@@ -2,17 +2,17 @@ import pandas as pd
import numpy as np

def load_data(filename):
-    return pd.read_csv(filename)
+  return pd.read_csv(filename)

def analyze_data(data):
-    return data.describe()
+  return data.describe()

def visualize_data(data):
-    return data.plot(kind='bar')
+  return data.plot(kind='bar')

def perform_advanced_analysis(data):
    Performs advanced statistical analysis on the dataset
    results = {}
    results['correlation'] = data.corr()
    results['skew'] = data.skew()
-    return results
+  return results

但我们可以忽略空白更改（这不会显示任何更改，因为我们只删除了空白）：

git diff -w analysis.py  # or --ignore-all-space

另一个有用的选项是控制上下文行数 —— 显示在修改周围的未更改行：

git diff -U1 analysis.py  # Show only 1 line of context (default is 3)
git diff -U5 analysis.py  # Show 5 lines of context

在以下情况下，这些上下文选项尤为有价值：

  • 审查已经通过自动格式化的代码
  • 专注于功能更改而不是样式更改
  • 需要更多上下文来理解特定更改
  • 在处理大文件时，默认上下文会生成太多输出

通过掌握这些中级技巧，您将能更好地控制代码库中的变更审查和理解方式，使您的开发工作流更加高效，您的代码审查更加有效。

在继续进行高级 git diff 应用之前，让我们提交最新的更改：

git add .
git commit -m "Modify analysis.py, config.txt, and utils.py"

高级 Git Diff 应用

在我们对git diff中级技巧的理解基础上，让我们探索一些高级应用，这将使您的Git技能达到更高水平。这些高级技术在处理复杂代码库或与更大团队合作时特别有用。

使用外部diff工具

虽然Git的内置diff功能强大，但有时视觉diff工具能提供更清晰的查看，特别是对于复杂更改。Git允许您配置外部工具来增强您的diff体验。

让我们设置一个流行的视觉diff工具。我们以VSCode为例，但类似的配置也适用于Beyond Compare、Meld或KDiff3等工具：

# 配置Git使用VSCode作为diff工具（特定于项目）
git config diff.tool vscode
git config difftool.vscode.cmd "code --wait --diff \$LOCAL \$REMOTE"

# 要使用其他流行工具，您可以使用：
# 对于Beyond Compare（特定于项目）：
git config diff.tool bc3
git config difftool.bc3.path "/path/to/beyond/compare"

# 安装命令：
# 对于Beyond Compare：
# 在macOS上：brew install --cask beyond-compare
# 在Ubuntu上：sudo apt-get install beyond-compare
# 在Windows上：从https://www.scootersoftware.com/download.php下载

# 注意：要将这些设置应用到全局而不仅限于当前项目，
# 在每个命令中添加--global标志，例如：
# git config --global diff.tool vscode

现在，您可以使用以下命令而不是使用git diff：

git difftool main feature/advanced-analytics

这将打开您配置的可视化差异工具以显示更改。这是Beyond Compare 的外观：

可视化差异工具提供了几个优势：

  1. 并排比较，更容易看到上下文
  2. 语法高亮显示，与您的编辑器偏好对齐
  3. 在更改之间进行高级导航
  4. 在查看差异时直接编辑文件的能力

在审查大型更改或具有复杂结构的文件（如嵌套 JSON 或 XML）时，可视化差异工具可以显著提高理解和效率。

专门的差异命令

Git 提供了专门的差异命令，为特定用例提供更细粒度的控制。让我们探索其中一些强大的命令：

git diff-tree 检查树对象（目录）之间的差异：

# 获取最后两次提交的哈希值
LAST_COMMIT=$(git rev-parse HEAD)
PREV_COMMIT=$(git rev-parse HEAD~1)

# 显示最后一次提交的更改
git diff-tree --patch $PREV_COMMIT $LAST_COMMIT

git diff-index 比较工作目录与索引（暂存区）或一个树：

# 将工作目录与索引进行比较
git diff-index --patch HEAD

git diff-index对于脚本编写和自动化非常有用。它允许您以编程方式检查下一个提交中将包含哪些更改，这对于预提交钩子和验证脚本非常有价值。

例如，您可以在CI/CD流水线中使用它来验证某些文件是否已被修改，或者确保配置更改遵循特定模式，然后允许提交。

git diff-files显示工作目录中文件与索引之间的差异：

# 检查特定文件的差异
git diff-files --patch config.txt

这些专门的命令特别适用于：

  • 创建自定义Git工作流程和脚本
  • 调试Git内部问题
  • 执行针对仓库状态的有针对性分析
  • 构建与Git交互的自动化工具

分析代码历史

git diff最强大的应用之一是分析代码随时间的演变，这对于调试或理解特性开发至关重要。

让我们使用特殊的^!标记来检查一个特定的提交：

# 获取我们高级分析提交的哈希值
ANALYTICS_COMMIT=$(git log --oneline | grep "advanced analysis" | cut -d ' ' -f 1)

# 仅显示在该特定提交中引入的更改
git diff $ANALYTICS_COMMIT^!

^!语法是比较一个提交与其父提交的简写，精确显示该提交中发生的更改。

要追踪特定文件随时间的演变：

# 分析 analysis.py 在最近的3个提交中的变化
git log -p -3 analysis.py

在查找错误时，您可以使用git diff结合git bisect：

# 添加一个错误以模拟一个回归错误
echo "import pandas as pd
import numpy as np

def load_data(filename):
   # 错误：意外地返回 None 而不是数据
   pd.read_csv(filename)
   return None

def analyze_data(data):
   return data.describe()

def visualize_data(data):
   return data.plot(kind='bar')

def perform_advanced_analysis(data):
   results = {}
   results['correlation'] = data.corr()
   results['skew'] = data.skew()
   return results" > analysis.py

git add analysis.py
git commit -m "Update analysis.py with a hidden bug"

# 现在使用 git bisect 找出错误是如何引入的
git bisect start
git bisect bad  # Mark current commit as containing the bug
git bisect good main  # Mark the main branch as working correctly

# Git 将为您检出提交以供测试
# 一旦找到，您可以检查引入错误的确切更改
git diff HEAD^!

Git bisect 是一个强大的调试工具，通过对提交历史进行二分搜索来查找引入错误的提交。结合 git diff 使用，可以创建高效的工作流程：

1. 使用 git bisect start 命令开始二分查找过程

2. 使用 git bisect bad 命令标记当前提交为有问题的提交

3. 使用 git bisect good <commit-hash> 命令标记已知没有 bug 的提交

4. Git 会自动检出历史记录中间的一个提交供您测试。

5. 在测试当前提交后，告诉 git 测试结果：

  • 如果当前提交存在 bug: 使用 git bisect bad 命令
  • 如果当前提交不存在 bug: 使用 git bisect good 命令

6. Git会根据您的反馈（在每个git bisect bad/good命令后）继续检查不同的提交，每次缩小搜索范围。重复测试和标记过程，直到git确定第一个有问题的提交。

7. 一旦git找到有问题的提交，它将显示一个消息指示引入错误的提交。

8. 使用以下命令精确查看确定的提交中发生了什么更改：git diff HEAD^!

9. 此命令将准确显示引入错误的提交中修改的代码，让您能够把调试工作集中在这些特定的更改上。

10. 通过以下命令随时退出二分查找： git bisect reset 这会让你回到开始二分查找过程前所在的分支。

11. 你也可以通过以下命令自动化二分查找过程： git bisect run <test-script> 其中test-script是一个命令，对于好的提交返回0，对于坏的提交返回非零值。

这种工作流程极大地缩短了调试时间，特别是在具有许多提交且工作状态和错误状态之间有很多差异的大型代码库中。

这些历史分析技术对以下情况非常宝贵：

  • 找出错误是何时和为什么引入的
  • 了解特性或组件的演化
  • 审计更改以进行安全审查
  • 记录代码更改背后的决策过程

通过掌握这些高级的git diff应用，您将能够精确地浏览项目的历史，更有效地调试问题，并深入了解代码库的演变。

Git Diff 命令参考

Git diff 提供了广泛的选项，可定制其输出和行为，以满足特定情况的需求。以下是最常用参数的全面参考，可增强您的差异分析：

基本比较选项

  • git diff – 比较工作目录与暂存区
  • git diff --staged（或 --cached）- 比较暂存区与上次提交
  • git diff HEAD – 比较工作目录与上次提交
  • git diff <commit> – 比较工作目录与特定提交
  • git diff <commit1> <commit2> – 比较两个特定提交
  • git diff <branch1> <branch2> – 比较两个分支

路径限制

  • git diff -- <path> – 限制比较到特定文件或目录
  • git diff --stat – 显示更改摘要（更改的文件、插入、删除），对于大型差异非常有用
  • git diff --name-only – 仅显示更改文件的名称
  • git diff --name-status – 显示更改文件的名称和状态（已添加、已修改、已删除）

显示控制

  • git diff -w（或–ignore-all-space）- 忽略空格更改
  • git diff --ignore-space-change – 忽略空格数量的更改
  • git diff --color-words – 以彩色显示单词级别的差异
  • git diff --word-diff – 以不同的格式显示单词级别的差异
  • git diff -U<n> – 显示 n 行上下文内容（默认为 3）
  • git diff --no-prefix – 在差异输出中不显示 a/ 和 b/ 前缀

内容过滤

  • git diff --binary – 显示对二进制文件的更改
  • git diff -S<string> – 查找添加或删除指定字符串的更改
  • git diff -G<regex> – 查找匹配指定正则表达式模式的更改
  • git diff --pickaxe-all – 当使用 -S 或 -G 时，显示文件中的所有更改，而不仅仅是匹配的更改

格式选项

  • git diff --patch-with-stat – 显示补丁和统计摘要
  • git diff --compact-summary – 以紧凑的格式显示统计摘要
  • git diff --numstat – 以机器友好的格式显示统计信息
  • git diff --summary – 显示创建/删除摘要

这些选项可以结合起来，创建强大且有针对性的比较。例如，要查看特定文件中的单词级别更改，同时忽略空格：

git diff --color-words -w -- analysis.py

或者查找可能已添加或删除特定函数的所有位置：

git diff -S"def perform_advanced_analysis" main feature/advanced-analytics

了解这些选项可以帮助您过滤噪音，精确关注重要的更改，使您的代码审查和分析工作流更高效。无论您是在寻找错误、为拉取请求做准备，还是只是想了解发生了什么变化，正确的git diff选项都可以显著简化您的任务。

结论

在本文中，我们探讨了git diff作为一种多功能命令来查看代码更改。我们涵盖了比较工作文件与暂存更改的内容，检查分支和提交之间的差异，并使用专门的命令进行更深入的洞察。将git diff纳入工作流程有助于构建更干净的提交，及早发现问题，并促进更好的代码审查。

无论是独自工作还是团队合作，精通git diff都能让你不仅仅是编写代码，更能理解代码库随时间演变的方式。

要继续建设您的Git专业知识，请查阅这些宝贵资源：

这些资源将帮助您在您已经了解的git diff基础上继续学习，并将您的版本控制技能提升到更高水平。

Source:
https://www.datacamp.com/tutorial/git-diff-guide