Loogeking Hexo https://loogeking.github.io/ All rights reserved 2026, Loogeking 代码改变世界 Loogeking's Blog 2026-06-22T10:20:31.707Z Loogeking Welcome to Hexo! This is your very first post. Check documentation for more info. If you get any problems when using Hexo, you can find the answer in troubleshooting or you can ask me on GitHub.

Quick Start

Create a new post

$ hexo new "My New Post"

More info: Writing

Run server

$ hexo server

More info: Server

Generate static files

$ hexo generate

More info: Generating

Deploy to remote sites

$ hexo deploy

More info: Deployment

]]> https://loogeking.github.io/posts/hello-world/ 2026-06-22T10:20:31.707Z Welcome to Hexo! This is your very first post. Check documentation for]]> Hello World 2026-06-22T10:20:31.707Z Loogeking
]]> https://loogeking.github.io/posts/%E8%8A%9D%E5%8A%A0%E6%98%8C%E7%9A%84%E5%A4%A9%E6%B0%94%E6%9C%AA%E5%BF%85%E6%9C%89%E6%88%91%E5%BF%A7%E9%83%81/ 2026-06-22T10:13:53.000Z Here's something encrypted, password is required to continue reading. 芝加昌的天气未必有我忧郁 2026-06-22T10:20:31.707Z Loogeking Markdown 数学公式速查表（LaTeX 语法）

基础语法

类型写法效果
行内公式$公式$公式公式
块级公式$$公式$$独立一行居中

指数与上下标

描述写法效果
上标$a^b$aba**b
上标（多字符）$a^{bc}$abcabc
下标$a_b$aba**b
下标（多字符）$a_{bc}$abcabc
上下标组合$a_b^c$abcabc
指数函数$e^x$exe**x
指数函数$\exp(x)$exp⁡(x)exp(x)

对数

描述写法效果
自然对数$\ln(x)$ln⁡(x)ln(x)
常用对数$\log(x)$log⁡(x)log(x)
常用对数（10为底）$\log_{10}(x)$log⁡10(x)log10(x)
任意底数$\log_a(x)$log⁡a(x)loga(x)
以2为底$\log_2(x)$log⁡2(x)log2(x)
常用对数简写$\lg(x)$lg⁡(x)lg(x)（部分支持）

分数与根式

描述写法效果
分数$\frac{a}{b}$abb**a
内联分数$a/b$a/ba/b
平方根$\sqrt{x}$xx
立方根$\sqrt[3]{x}$x33x
n次方根$\sqrt[n]{x}$xnn**x
分数嵌套$\frac{\frac{a}{b}}{c}$abccba

运算符

描述写法效果
加+++
减-−−
乘$\times$××
点乘$\cdot$⋅⋅
除$\div$÷÷
正负$\pm$±±
负正$\mp$∓∓
求和$\sum_{i=1}^n$∑i=1n∑i=1n
求积$\prod_{i=1}^n$∏i=1n∏i=1n
积分$\int_{a}^{b}$∫ab∫a**b
二重积分$\iint$∬∬
三重积分$\iiint$∭∭
极限$\lim_{x \to 0}$lim⁡x→0limx→0

关系符号

描述写法效果
等于===
不等于$\neq$≠\=
约等于$\approx$≈≈
恒等于$\equiv$≡≡
大于$>$>>
小于$<$<<
大于等于$\geq$≥≥
小于等于$\leq$≤≤
远大于$\gg$≫≫
远小于$\ll$≪≪
属于$\in$∈∈
包含于$\subset$⊂⊂
包含$\supset$⊃⊃

希腊字母

写法效果写法效果
$\alpha$αα$\beta$ββ
$\gamma$γγ$\delta$δδ
$\epsilon$ϵϵ$\varepsilon$εε
$\zeta$ζζ$\eta$ηη
$\theta$θθ$\vartheta$ϑϑ
$\iota$ιι$\kappa$κκ
$\lambda$λλ$\mu$μμ
$\nu$νν$\xi$ξξ
$\pi$ππ$\rho$ρρ
$\sigma$σσ$\tau$ττ
$\phi$ϕϕ$\varphi$φφ
$\chi$χχ$\psi$ψψ
$\omega$ωω

大写： $\Gamma$ ΓΓ $\Delta$ ΔΔ $\Theta$ ΘΘ $\Lambda$ ΛΛ $\Pi$ ΠΠ $\Sigma$ ΣΣ $\Phi$ ΦΦ $\Psi$ ΨΨ $\Omega$ ΩΩ

括号与定界符

描述写法效果
小括号$(x)$(x)(x)
中括号$[x]$[x][x]
大括号$\{x\}${x}{x}
自适应括号$\left( \frac{x}{y} \right)$(xy)(y**x)
绝对值$\lvert x \rvert$∣x∣∣x∣
范数$\lVert x \rVert$∥x∥∥x∥
取整$\lfloor x \rfloor$⌊x⌋⌊x⌋
取顶$\lceil x \rceil$⌈x⌉⌈x⌉

矩阵与行列式

矩阵：

$$
\begin{matrix}
1 & 2 \\
3 & 4
\end{matrix}
$$

带括号矩阵：

$$
\begin{pmatrix}
1 & 2 \\
3 & 4
\end{pmatrix}
$$

行列式：

$$
\begin{vmatrix}
1 & 2 \\
3 & 4
\end{vmatrix}
$$

间距

写法效果说明
$a\,b$a ba**b小间距
$a\;b$a  ba**b中等间距
$a\quad b$aba**b大间距
$a\qquad b$aba**b两倍大间距
$a\!b$a ⁣ba**b负间距（紧贴）

综合示例

指数与对数组合：

$e^{\ln x} = x$
$\log_{2}(2^n) = n$

复杂公式：

$$
f(x) = \frac{1}{\sigma\sqrt{2\pi}} e^{-\frac{1}{2}\left(\frac{x-\mu}{\sigma}\right)^2}
$$

多行公式：

$$
\begin{aligned}
e^{i\pi} &= \cos\pi + i\sin\pi \\
&= -1 + 0 \\
&= -1
\end{aligned}
$$
]]> https://loogeking.github.io/posts/Markdown-%E6%95%B0%E5%AD%A6%E5%85%AC%E5%BC%8F%E9%80%9F%E6%9F%A5%E8%A1%A8/ 2026-06-21T00:40:52.000Z Markdown 数学公式速查表（LaTeX 语法）

基础语法

类型 HTML学习

第一章：HTML 基础概念

1.1 HTML 的定义与作用

HTML（超文本标记语言，Hypertext Markup Language）是构建网页的基石和骨架。它通过标签来定义网页的内容结构，就像建筑的蓝图一样。

核心作用：

  • 定义内容结构：组织文本、图片、链接等元素
  • 创建文档骨架：为CSS和JavaScript提供操作基础
  • 确保跨平台兼容：不同浏览器都能正确解析
  • 支持SEO优化：良好的HTML结构有利于搜索引擎索引

1.2 HTML 文档基本结构

<!DOCTYPE html>  <!-- 文档类型声明，告诉浏览器使用HTML5 -->
<html lang="zh-CN">  <!-- 根元素，lang属性指定语言 -->
<head>
    <!-- 头部：包含元数据和链接资源 -->
    <meta charset="UTF-8">  <!-- 字符编码，必须放在最前面 -->
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>页面标题</title>  <!-- 显示在浏览器标签页 -->
</head>
<body>
    <!-- 主体：所有可见内容都在这里 -->
    <h1>欢迎来到我的网站</h1>
    <p>这是一个段落。</p>
</body>
</html>

第二章：HTML 元素详解

2.1 元素组成结构

<标签名 属性名="属性值">内容</标签名>

元素类型：

类型示例特点
双标签元素<h1>标题</h1>有开始和结束标签
单标签元素<img src="img.jpg">自我闭合，无内容
空元素<br>, <hr>没有结束标签

2.2 常用基础元素

标题元素（h1-h6）

<h1>一级标题</h1>    <!-- 最重要的标题，通常页面只有一个 -->
<h2>二级标题</h2>    <!-- 节标题 -->
<h3>三级标题</h3>    <!-- 子节标题 -->
<h4>四级标题</h4>    <!-- 更小的分组 -->
<h5>五级标题</h5>
<h6>六级标题</h6>    <!-- 最低级别的标题 -->

最佳实践：

  • 保持标题的层级关系（不要从h1直接跳到h4）
  • h1通常用于页面主标题
  • 标题不仅为了样式，更为了语义结构

段落和容器

<!-- 段落：用于文本内容 -->
<p>这是一个段落。段落会自动换行并有默认的上下边距。</p>

<!-- div：通用容器，无语义 -->
<div class="container">
    <p>div是一个块级容器</p>
    <p>常用于布局和样式分组</p>
</div>

<!-- span：行内容器 -->
<p>这是一段<span class="highlight">强调</span>文本</p>

2.3 特殊字符（HTML实体）

字符实体编码说明
<<小于号（避免与标签冲突）
>>大于号
&&和号
""双引号
''单引号
`` 不换行空格
©©版权符号
®®注册商标
<p>使用 &lt;div&gt; 标签创建容器</p>
<p>版权所有 &copy; 2024 公司名称</p>

第三章：链接与资源

3.1 超链接（a标签）

<!-- 外部链接 -->
<a href="https://www.example.com" target="_blank">访问示例网站</a>

<!-- 内部链接 -->
<a href="#section2">跳转到第二节</a>

<!-- 下载链接 -->
<a href="file.pdf" download>下载PDF文件</a>

<!-- 邮件链接 -->
<a href="mailto:email@example.com">发送邮件</a>

<!-- 电话链接（移动端有效） -->
<a href="tel:+8613800138000">打电话</a>

target属性详解：

  • _blank：在新窗口/标签页打开
  • _self：在当前窗口打开（默认）
  • _parent：在父框架打开
  • _top：在顶层框架打开

3.2 路径类型

<!-- 绝对路径 -->
<img src="https://www.example.com/images/logo.png">
<a href="/about/index.html">关于我们</a>

<!-- 相对路径 -->
<img src="images/photo.jpg">           <!-- 同级目录的images文件夹 -->
<a href="../contact.html">联系我们</a>  <!-- 上一级目录 -->
<script src="./js/main.js"></script>   <!-- 当前目录的js文件夹 -->

<!-- 根相对路径 -->
<link href="/css/style.css">          <!-- 从网站根目录开始 -->

路径符号记忆：

  • /：根目录
  • ./：当前目录（可省略）
  • ../：上级目录
  • ../../：上两级目录

3.3 资源链接

<!-- 链接外部CSS -->
<link rel="stylesheet" href="styles.css" type="text/css">

<!-- 链接网站图标 -->
<link rel="icon" href="favicon.ico" type="image/x-icon">
<link rel="apple-touch-icon" href="apple-touch-icon.png">

<!-- 链接外部JavaScript -->
<script src="script.js" defer></script>
<!-- defer：HTML解析完成后执行 -->
<!-- async：下载完成后立即执行 -->

第四章：语义化HTML

4.1 为什么需要语义化？

语义化HTML的好处：

  • 更好的可访问性：屏幕阅读器能正确解读
  • SEO优化：搜索引擎理解内容结构
  • 代码可维护性：结构清晰，易于理解
  • 未来兼容性：适应新的浏览器和设备

4.2 主要语义化标签

页面结构标签

<body>
    <!-- 页眉：通常包含logo、导航等 -->
    <header>
        <nav>
            <ul>
                <li><a href="/">首页</a></li>
                <li><a href="/about">关于</a></li>
            </ul>
        </nav>
    </header>
    
    <!-- 主要内容区域 -->
    <main>
        <!-- 独立文章 -->
        <article>
            <h1>文章标题</h1>
            <p>文章内容...</p>
            
            <!-- 侧边内容 -->
            <aside>
                <h3>相关阅读</h3>
                <p>相关内容...</p>
            </aside>
        </article>
        
        <!-- 内容区块 -->
        <section>
            <h2>产品介绍</h2>
            <p>产品详情...</p>
        </section>
    </main>
    
    <!-- 页脚 -->
    <footer>
        <p>© 2024 公司名称</p>
        <address>
            联系地址：北京市朝阳区<br>
            电话：010-12345678
        </address>
    </footer>
</body>

文本语义化标签

<p>
    <strong>重要内容</strong>需要突出显示，
    <em>强调内容</em>表示语气重点，
    这是<mark>标记的文本</mark>，
    <small>小号字体</small>用于免责声明等，
    <del>原价：100元</del>
    <ins>现价：80元</ins>
</p>

<!-- 代码相关 -->
<pre><code>
function hello() {
    console.log("Hello World!");
}
</code></pre>

<p>按<kbd>Ctrl</kbd>+<kbd>S</kbd>保存</p>
<p>输出结果：<samp>保存成功</samp></p>

<!-- 引用 -->
<blockquote cite="https://example.com">
    <p>这是一个重要的引用。</p>
    <footer>— 作者名，<cite>作品名</cite></footer>
</blockquote>

<p>他说：<q>今天天气真好！</q></p>

<!-- 定义和缩写 -->
<p>
    <abbr title="HyperText Markup Language">HTML</abbr>
    是网页的基础。
</p>

<dl>
    <dt>HTML</dt>
    <dd>超文本标记语言</dd>
    
    <dt>CSS</dt>
    <dd>层叠样式表</dd>
</dl>

时间与联系方式

<!-- 时间 -->
<p>
    发布日期：<time datetime="2024-01-15">2024年1月15日</time><br>
    会议时间：<time datetime="2024-01-20T14:30">1月20日下午2:30</time>
</p>

<!-- 联系方式 -->
<address>
    作者：<a href="mailto:author@example.com">张三</a><br>
    地址：北京市海淀区<br>
    电话：<a href="tel:+8613800138000">13800138000</a>
</address>

4.3 语义化 vs 非语义化对比

不好的做法（已废弃）：

<!-- 已废弃的表现性标签 -->
<center>居中内容</center>
<font size="5" color="red">红色大字</font>
<big>大号字</big>
<strike>删除线</strike>

好的做法（语义化）：

<!-- 使用CSS控制样式，HTML关注结构 -->
<div class="text-center">居中内容</div>
<p class="highlight">重点内容</p>
<del>已删除的内容</del>

第五章：图像与多媒体

5.1 图像元素

<!-- 基础图片 -->
<img 
    src="images/photo.jpg" 
    alt="图片描述文字" 
    width="800" 
    height="600"
    loading="lazy"  <!-- 延迟加载 -->
>

<!-- 响应式图片 -->
<picture>
    <!-- 不同屏幕尺寸使用不同图片 -->
    <source media="(min-width: 1200px)" srcset="large.jpg">
    <source media="(min-width: 768px)" srcset="medium.jpg">
    <!-- 默认图片 -->
    <img src="small.jpg" alt="响应式图片">
</picture>

<!-- 带标题的图片 -->
<figure>
    <img src="chart.png" alt="数据图表">
    <figcaption>图1：2024年销售数据趋势图</figcaption>
</figure>

重要属性：

  • alt：替代文本，图片无法显示时显示，对无障碍访问和SEO至关重要
  • width/height：指定尺寸，避免布局偏移
  • loading="lazy"：图片进入视口时再加载
  • srcset：提供不同分辨率图片
  • sizes：指定图片显示尺寸

5.2 图片格式选择

格式特点适用场景
JPEG/JPG有损压缩，文件小照片、复杂图像
PNG无损压缩，支持透明图标、logo、需要透明的图片
GIF支持动画，256色简单动画、低色彩图像
WebP现代格式，压缩率高所有场景（需考虑兼容性）
SVG矢量格式，无限缩放图标、logo、简单图形
AVIF最新格式，极致压缩高性能网站

5.3 SVG（可缩放矢量图形）

<!-- 内联SVG -->
<svg width="100" height="100">
    <circle cx="50" cy="50" r="40" fill="blue" />
</svg>

<!-- 外部SVG文件 -->
<img src="logo.svg" alt="公司logo" width="200">

<!-- 使用symbol和use重用 -->
<svg style="display: none;">
    <symbol id="icon-star" viewBox="0 0 24 24">
        <path d="M12 2l3.09 6.26L22 9.27l-5 4.87 1.18 6.88L12 17.77l-6.18 3.25L7 14.14 2 9.27l6.91-1.01L12 2z"/>
    </symbol>
</svg>

<svg><use href="#icon-star"></use></svg>

SVG优势：

  • 无限缩放不失真
  • 可通过CSS控制样式
  • 文件体积小
  • 搜索引擎可索引
  • 可编辑和动画

5.4 音频和视频

<!-- 音频 -->
<audio controls preload="metadata">
    <source src="audio.mp3" type="audio/mpeg">
    <source src="audio.ogg" type="audio/ogg">
    <p>您的浏览器不支持音频播放。</p>
</audio>

<!-- 视频 -->
<video 
    controls 
    width="640" 
    poster="preview.jpg"
    preload="metadata"
>
    <source src="video.mp4" type="video/mp4">
    <source src="video.webm" type="video/webm">
    <track 
        src="subtitles.vtt" 
        kind="subtitles" 
        srclang="zh" 
        label="中文"
        default
    >
    <p>您的浏览器不支持视频播放。</p>
</video>

多媒体属性：

  • controls：显示播放控制界面
  • autoplay：自动播放（移动端有限制）
  • loop：循环播放
  • muted：静音
  • preload：预加载策略（none/metadata/auto）
  • playsinline：移动端内联播放

5.5 嵌入外部内容（iframe）

<!-- 嵌入地图 -->
<iframe 
    src="https://maps.google.com/maps?q=beijing&output=embed"
    width="600" 
    height="450"
    frameborder="0"
    allowfullscreen
    title="北京地图"
></iframe>

<!-- 嵌入YouTube视频 -->
<iframe 
    width="560" 
    height="315" 
    src="https://www.youtube.com/embed/视频ID"
    title="YouTube视频"
    frameborder="0" 
    allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture" 
    allowfullscreen
></iframe>

iframe安全注意事项：

  1. 使用 sandbox 属性限制权限
  2. 设置 title 属性保证可访问性
  3. 考虑使用 loading="lazy" 延迟加载
  4. 注意跨域安全问题

第六章：表单详解

6.1 表单基础结构

<form 
    action="/submit" 
    method="POST"
    enctype="multipart/form-data"
    novalidate  <!-- 禁用浏览器验证 -->
    target="_blank"  <!-- 在新窗口打开 -->
>
    <!-- 表单内容 -->
</form>

表单属性：

属性值说明
actionURL表单提交地址
methodGET/POST提交方法
enctypeapplication/x-www-form-urlencoded（默认） multipart/form-data（文件上传） text/plain编码类型
target_self/_blank/…打开方式
autocompleteon/off自动完成
novalidatenovalidate禁用验证

6.2 输入控件（input）

文本类输入

<!-- 文本输入 -->
<input 
    type="text" 
    id="username"
    name="username"
    placeholder="请输入用户名"
    required
    minlength="3"
    maxlength="20"
    pattern="[A-Za-z0-9]+"
    autocomplete="username"
    value="默认值"
    readonly  <!-- 只读 -->
    disabled  <!-- 禁用 -->
>

<!-- 密码 -->
<input type="password" name="password" required>

<!-- 邮箱 -->
<input type="email" name="email" multiple>  <!-- multiple支持多个邮箱 -->

<!-- 电话 -->
<input type="tel" name="phone" pattern="[0-9]{11}">

<!-- 网址 -->
<input type="url" name="website">

<!-- 搜索框 -->
<input type="search" name="keyword">

<!-- 多行文本 -->
<textarea 
    name="message" 
    rows="4" 
    cols="50"
    placeholder="请输入留言"
    wrap="hard"  <!-- 自动换行 -->
>默认内容</textarea>

选择类输入

<!-- 单选按钮 -->
<label>
    <input type="radio" name="gender" value="male" checked> 男
</label>
<label>
    <input type="radio" name="gender" value="female"> 女
</label>

<!-- 复选框 -->
<label>
    <input type="checkbox" name="hobby" value="reading"> 阅读
</label>
<label>
    <input type="checkbox" name="hobby" value="sports"> 运动
</label>

<!-- 下拉选择 -->
<select name="city" multiple size="4">  <!-- multiple多选 -->
    <option value="">请选择城市</option>
    <optgroup label="华北地区">
        <option value="beijing" selected>北京</option>
        <option value="tianjin">天津</option>
    </optgroup>
    <optgroup label="华东地区">
        <option value="shanghai">上海</option>
    </optgroup>
</select>

<!-- 数据列表 -->
<input list="browsers" name="browser">
<datalist id="browsers">
    <option value="Chrome">
    <option value="Firefox">
    <option value="Safari">
</datalist>

特殊输入类型

<!-- 数字 -->
<input 
    type="number" 
    name="age" 
    min="0" 
    max="120" 
    step="1"
>

<!-- 范围滑块 -->
<input 
    type="range" 
    name="volume" 
    min="0" 
    max="100" 
    step="10"
    list="volumemarks"
>
<datalist id="volumemarks">
    <option value="0" label="静音"></option>
    <option value="50" label="50%"></option>
    <option value="100" label="最大"></option>
</datalist>

<!-- 日期时间 -->
<input type="date" name="birthday">
<input type="time" name="meeting-time">
<input type="datetime-local" name="appointment">
<input type="month" name="month">
<input type="week" name="week">

<!-- 颜色选择 -->
<input type="color" name="favcolor" value="#ff0000">

<!-- 文件上传 -->
<input 
    type="file" 
    name="avatar" 
    accept="image/*"  <!-- 接受图片 -->
    multiple  <!-- 多文件 -->
    capture="camera"  <!-- 移动端直接拍照 -->
>

<!-- 隐藏字段 -->
<input type="hidden" name="user_id" value="123">

6.3 标签和分组

隐式关联

<!-- 推荐：简单结构 -->
<label>
    用户名：
    <input type="text" name="username">
</label>

<label>
    <input type="checkbox" name="agree"> 我同意条款
</label>

显式关联

<!-- 推荐：复杂布局 -->
<label for="email">邮箱地址：</label>
<input type="email" id="email" name="email">

<label for="subscribe">
    <input type="checkbox" id="subscribe" name="subscribe">
    订阅新闻
</label>

表单分组

<fieldset>
    <legend>个人信息</legend>  <!-- 分组标题 -->
    
    <div>
        <label for="name">姓名：</label>
        <input type="text" id="name" name="name">
    </div>
    
    <div>
        <label for="email">邮箱：</label>
        <input type="email" id="email" name="email">
    </div>
</fieldset>

<fieldset disabled>  <!-- 禁用整个分组 -->
    <legend>附加信息（可选）</legend>
    <!-- ... -->
</fieldset>

6.4 按钮

<!-- 提交按钮 -->
<button type="submit">提交表单</button>
<input type="submit" value="提交">

<!-- 重置按钮 -->
<button type="reset">重置</button>
<input type="reset" value="重置">

<!-- 普通按钮 -->
<button type="button" onclick="alert('点击!')">点击我</button>
<input type="button" value="普通按钮">

<!-- 图片按钮 -->
<input type="image" src="submit.png" alt="提交">

<!-- 带图标的按钮 -->
<button type="submit">
    <svg><!-- 图标 --></svg>
    提交
</button>

6.5 表单验证

<form id="myForm">
    <!-- 必填字段 -->
    <input type="text" required>
    
    <!-- 长度限制 -->
    <input type="text" minlength="6" maxlength="20">
    
    <!-- 数字范围 -->
    <input type="number" min="0" max="100" step="1">
    
    <!-- 模式匹配 -->
    <input type="text" pattern="[A-Za-z]{3,20}">
    
    <!-- 自定义验证 -->
    <input type="email" oninvalid="setCustomValidity('请输入有效邮箱')">
    
    <!-- 验证消息样式 -->
    <style>
        input:valid { border-color: green; }
        input:invalid { border-color: red; }
        input:focus:invalid { box-shadow: 0 0 5px red; }
    </style>
</form>

<!-- JavaScript验证 -->
<script>
document.getElementById('myForm').addEventListener('submit', function(e) {
    if (!this.checkValidity()) {
        e.preventDefault();
        // 显示自定义错误信息
    }
});
</script>

6.6 表单状态和反馈

/* 焦点状态 */
input:focus {
    outline: 2px solid blue;
    box-shadow: 0 0 5px rgba(0, 0, 255, 0.5);
}

/* 有效/无效状态 */
input:valid { background-color: #e8f5e8; }
input:invalid { background-color: #ffe6e6; }

/* 禁用状态 */
input:disabled {
    opacity: 0.5;
    cursor: not-allowed;
}

/* 只读状态 */
input:read-only {
    background-color: #f5f5f5;
    border-color: #ddd;
}

/* 占位符样式 */
input::placeholder {
    color: #999;
    font-style: italic;
}

第七章：表格

7.1 基础表格结构

<table border="1" cellspacing="0" cellpadding="8">
    <caption>学生成绩表</caption>  <!-- 表格标题 -->
    
    <!-- 表头 -->
    <thead>
        <tr>
            <th scope="col">学号</th>      <!-- 列标题 -->
            <th scope="col">姓名</th>
            <th scope="col">成绩</th>
        </tr>
    </thead>
    
    <!-- 表格主体 -->
    <tbody>
        <tr>
            <th scope="row">001</th>      <!-- 行标题 -->
            <td>张三</td>
            <td>95</td>
        </tr>
        <tr>
            <th scope="row">002</th>
            <td>李四</td>
            <td>88</td>
        </tr>
    </tbody>
    
    <!-- 表尾（可选） -->
    <tfoot>
        <tr>
            <td colspan="2">平均分</td>  <!-- 合并单元格 -->
            <td>91.5</td>
        </tr>
    </tfoot>
</table>

7.2 复杂表格示例

<table>
    <colgroup>
        <col span="2" style="background-color: #f0f0f0">
        <col style="background-color: #e0e0ff">
    </colgroup>
    
    <thead>
        <tr>
            <th rowspan="2">部门</th>      <!-- 垂直合并 -->
            <th colspan="3">2024年季度</th>  <!-- 水平合并 -->
        </tr>
        <tr>
            <th>Q1</th>
            <th>Q2</th>
            <th>Q3</th>
        </tr>
    </thead>
    
    <tbody>
        <tr>
            <th scope="rowgroup" rowspan="2">技术部</th>
            <td>100万</td>
            <td>120万</td>
            <td>150万</td>
        </tr>
        <tr>
            <td>同比+20%</td>
            <td>同比+25%</td>
            <td>同比+30%</td>
        </tr>
    </tbody>
</table>

7.3 表格属性详解

<table 
    border="1"          <!-- 边框 -->
    cellspacing="0"     <!-- 单元格间距 -->
    cellpadding="10"    <!-- 单元格内边距 -->
    width="100%"        <!-- 宽度 -->
    summary="销售数据表" <!-- 摘要（无障碍） -->
    role="grid"         <!-- ARIA角色 -->
>
    <!-- 列分组 -->
    <colgroup>
        <col width="20%">
        <col width="30%">
        <col width="50%">
    </colgroup>
    
    <!-- 行分组 -->
    <thead>...</thead>
    <tbody>...</tbody>
    <tfoot>...</tfoot>
</table>

7.4 表格最佳实践

  1. 语义化标记：使用thead、tbody、tfoot
  2. 添加scope属性：帮助屏幕阅读器
  3. 使用caption：描述表格内容
  4. 响应式设计：小屏幕时可滚动
  5. 适当合并单元格：但不要过度使用

第八章：元数据与SEO

8.1 基础元标签

<head>
    <!-- 字符编码（必须放在最前面） -->
    <meta charset="UTF-8">
    
    <!-- 视口设置（响应式必备） -->
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    
    <!-- 页面描述 -->
    <meta name="description" content="这是一个关于HTML学习的专业网站">
    
    <!-- 关键词（现代搜索引擎已不太重视） -->
    <meta name="keywords" content="HTML,CSS,JavaScript,前端开发">
    
    <!-- 作者 -->
    <meta name="author" content="你的名字">
    
    <!-- 版权 -->
    <meta name="copyright" content="© 2024 公司名称">
    
    <!-- 页面刷新/跳转 -->
    <meta http-equiv="refresh" content="5; url=https://example.com">
    
    <!-- 禁止搜索引擎索引 -->
    <meta name="robots" content="noindex, nofollow">
</head>

8.2 Open Graph协议（社交媒体分享）

<!-- Facebook、LinkedIn等 -->
<meta property="og:title" content="页面标题">
<meta property="og:description" content="页面描述">
<meta property="og:image" content="https://example.com/image.jpg">
<meta property="og:url" content="https://example.com/page.html">
<meta property="og:type" content="website">
<meta property="og:site_name" content="网站名称">
<meta property="og:locale" content="zh_CN">

<!-- 视频相关 -->
<meta property="og:video" content="https://example.com/video.mp4">
<meta property="og:video:type" content="video/mp4">
<meta property="og:video:width" content="1280">
<meta property="og:video:height" content="720">

8.3 Twitter Cards

<!-- Twitter专用 -->
<meta name="twitter:card" content="summary_large_image">
<meta name="twitter:site" content="@username">
<meta name="twitter:creator" content="@author">
<meta name="twitter:title" content="页面标题">
<meta name="twitter:description" content="页面描述">
<meta name="twitter:image" content="https://example.com/image.jpg">
<meta name="twitter:image:alt" content="图片描述">

8.4 其他重要元数据

<!-- 主题颜色（PWA） -->
<meta name="theme-color" content="#4285f4">

<!-- 移动端添加到主屏幕 -->
<meta name="apple-mobile-web-app-capable" content="yes">
<meta name="apple-mobile-web-app-status-bar-style" content="black">
<meta name="apple-mobile-web-app-title" content="App名称">
<link rel="apple-touch-icon" href="/icon-180.png">

<!-- 微软相关 -->
<meta name="application-name" content="应用名称">
<meta name="msapplication-TileColor" content="#2b5797">
<meta name="msapplication-config" content="/browserconfig.xml">

第九章：最佳实践与性能优化

9.1 语义化最佳实践

  1. 使用正确的HTML5语义标签
  2. 为图像添加有意义的alt文本
  3. 使用正确的标题层级（h1-h6）
  4. 为链接提供明确的描述文本
  5. 使用label关联表单元素

9.2 性能优化技巧

<!-- 延迟加载图片 -->
<img src="image.jpg" loading="lazy" alt="...">

<!-- 预加载重要资源 -->
<link rel="preload" href="critical.css" as="style">
<link rel="preload" href="hero.jpg" as="image">

<!-- 预连接关键域名 -->
<link rel="preconnect" href="https://fonts.googleapis.com">
<link rel="dns-prefetch" href="https://fonts.gstatic.com">

<!-- 使用现代图片格式 -->
<picture>
    <source srcset="image.avif" type="image/avif">
    <source srcset="image.webp" type="image/webp">
    <img src="image.jpg" alt="...">
</picture>

<!-- 脚本优化 -->
<script defer src="main.js"></script>
<script async src="analytics.js"></script>

9.3 可访问性（A11Y）

<!-- 语义化标签 -->
<nav aria-label="主导航">
    <ul>
        <li><a href="/" aria-current="page">首页</a></li>
    </ul>
</nav>

<!-- 表单可访问性 -->
<label for="search">搜索</label>
<input type="search" id="search" aria-describedby="search-help">
<p id="search-help">输入关键词进行搜索</p>

<!-- 图片描述 -->
<img src="chart.png" alt="2024年销售趋势图：1月100万，2月120万">

<!-- 隐藏内容（对屏幕阅读器可见） -->
<div class="visually-hidden">此内容仅对屏幕阅读器可见</div>
<style>
.visually-hidden {
    position: absolute;
    width: 1px;
    height: 1px;
    padding: 0;
    margin: -1px;
    overflow: hidden;
    clip: rect(0, 0, 0, 0);
    white-space: nowrap;
    border: 0;
}
</style>

9.4 验证工具

  1. W3C验证器：https://validator.w3.org/
  2. Lighthouse：Chrome开发者工具
  3. axe DevTools：可访问性检查
  4. HTMLHint：代码质量检查

第十章：实用代码片段

10.1 常用HTML模板

<!DOCTYPE html>
<html lang="zh-CN">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <meta name="description" content="页面描述">
    <meta name="keywords" content="关键词1,关键词2">
    <meta name="author" content="作者">
    
    <!-- Open Graph -->
    <meta property="og:title" content="页面标题">
    <meta property="og:description" content="页面描述">
    <meta property="og:image" content="图片URL">
    <meta property="og:url" content="页面URL">
    <meta property="og:type" content="website">
    
    <!-- 网站图标 -->
    <link rel="icon" href="/favicon.ico" type="image/x-icon">
    <link rel="apple-touch-icon" href="/apple-touch-icon.png">
    
    <!-- CSS -->
    <link rel="stylesheet" href="styles.css">
    
    <!-- 页面标题 -->
    <title>页面标题</title>
</head>
<body>
    <!-- 跳过导航链接（无障碍） -->
    <a href="#main" class="skip-link">跳过导航</a>
    
    <!-- 页眉 -->
    <header>
        <nav aria-label="主导航">
            <!-- 导航内容 -->
        </nav>
    </header>
    
    <!-- 主要内容 -->
    <main id="main">
        <!-- 页面内容 -->
    </main>
    
    <!-- 页脚 -->
    <footer>
        <!-- 页脚内容 -->
    </footer>
    
    <!-- JavaScript -->
    <script src="script.js" defer></script>
</body>
</html>

10.2 常见布局模式

<!-- 两栏布局 -->
<div class="container">
    <aside class="sidebar">
        <!-- 侧边栏内容 -->
    </aside>
    <main class="content">
        <!-- 主要内容 -->
    </main>
</div>

<!-- 卡片布局 -->
<div class="card-grid">
    <article class="card">
        <img src="image.jpg" alt="卡片图片">
        <h3>卡片标题</h3>
        <p>卡片描述内容</p>
        <a href="#">了解更多</a>
    </article>
    <!-- 更多卡片 -->
</div>

<!-- 响应式导航 -->
<nav class="navbar">
    <a href="/" class="logo">网站Logo</a>
    <button class="menu-toggle" aria-label="菜单">☰</button>
    <ul class="nav-menu">
        <li><a href="/">首页</a></li>
        <li><a href="/about">关于</a></li>
        <li><a href="/contact">联系</a></li>
    </ul>
</nav>

总结

关键要点回顾

  1. 语义化：使用正确的标签表达正确的含义
  2. 可访问性：确保所有人都能使用你的网站
  3. SEO优化：合理使用元标签和结构化数据
  4. 性能：优化图片、脚本和样式表
  5. 响应式：适应各种设备和屏幕尺寸
]]> https://loogeking.github.io/posts/HTML%E5%AD%A6%E4%B9%A0%E7%AC%94%E8%AE%B0/ 2026-06-21T00:29:58.000Z HTML学习

第一章：HTML 基础概念

1.1 HTML 的定义与作用

HTML（超文本标记语]]>

HTML学习笔记 2026-06-22T10:20:31.706Z Loogeking CSS学习笔记

1. CSS 基础概念

1.1 什么是CSS？

  • 定义：层叠样式表（Cascading Style Sheets）
  • 作用：用于描述HTML元素的显示样式，包括颜色、布局、字体等
  • 重要性：实现内容与表现的分离

1.2 CSS规则结构

selector {
  property: value;  /* 声明 */
  /* 更多声明 */
}
  • 选择器：定位要样式化的HTML元素
  • 声明块：包含一个或多个样式声明
  • 声明：由属性和值组成

1.3 CSS引入方式

方式语法优点缺点
内联<div style="color: red;">优先级高不易维护，破坏结构分离
内部<style>div {color: red;}</style>适合小项目增加HTML文件大小
外部<link rel="stylesheet" href="style.css">最佳实践，易维护需要额外HTTP请求

2. CSS选择器

2.1 基础选择器

/* 元素选择器 */
p { color: blue; }

/* 类选择器 */
.classname { color: red; }

/* ID选择器 */
#idname { color: green; }

/* 通用选择器 */
* { margin: 0; padding: 0; }

2.2 组合器

组合器语法描述
后代div p选择div内的所有p元素
子元素div > p只选择div的直接子元素p
相邻兄弟h1 + p选择紧接在h1后的p元素
后续兄弟h1 ~ p选择h1后的所有同级p元素

2.3 伪类选择器

/* 用户交互 */
:hover { background: yellow; }
:focus { border: 2px solid blue; }
:active { transform: scale(0.95); }

/* 表单状态 */
:checked { accent-color: green; }
:disabled { opacity: 0.5; }
:valid { border-color: green; }
:invalid { border-color: red; }

/* 结构伪类 */
:first-child { font-weight: bold; }
:nth-child(odd) { background: #f0f0f0; }
:last-child { margin-bottom: 0; }

2.4 伪元素

::before {
  content: "※ ";
  color: red;
}

::after {
  content: " ✓";
  color: green;
}

::first-letter {
  font-size: 2em;
  color: #900;
}

::selection {
  background: yellow;
  color: black;
}

2.5 选择器优先级

优先级从高到低：

  • 内联样式
  • ID选择器
  • class选择器
  • 元素选择器
  • 通用选择器
<head>
  <style>
    p {
      color: blue;       /* 元素选择器，优先级最低 */
    }
    .highlight {
      color: green !important;  /* !important 强制覆盖所有规则 */
    }
    #unique {
      color: purple;     /* ID选择器，优先级最高 */
    }
  </style>
</head>
<body>
  <p id="unique" class="highlight">This text</p>
</body>
  • 若没有 !important：ID选择器优先级最高 → 显示 purple
  • 加了 !important 后：强制覆盖所有规则 → 显示 green

⚠️ !important 会打破正常的优先级计算，非必要不建议使用，会增加后期维护难度。

3. HTML元素显示类型

3.1 对比总览

特性块元素 (Block)行内元素 (Inline)行内块元素 (Inline-block)
默认宽度父元素的100%内容宽度内容宽度
能否设置宽高可以不可以可以
垂直外边距有效无效有效
水平外边距有效有效有效
换行行为独占一行不换行不换行
排列方式垂直排列水平排列水平排列
包含关系可包含块/行内只能包含行内可包含块/行内

3.2 块元素 (Block Elements)

常见块元素

<div>, <p>, <h1>-<h6>, <ul>, <ol>, <li>, <section>, <article>, <nav>, <header>, <footer>

核心特性

/* 块元素的默认样式相当于 */
display: block;
width: 100%;      /* 默认占满父容器宽度 */
height: auto;     /* 高度由内容决定 */

示例代码

<div class="block-demo">
    <p>这是一个段落（块元素）</p>
    <div>这是一个div（块元素）</div>
    <h2>这是一个标题（块元素）</h2>
</div>
.block-demo p,
.block-demo div,
.block-demo h2 {
    background-color: lightblue;
    margin: 10px 0;   /* 垂直外边距有效 */
    padding: 10px;
    width: 300px;     /* 可以设置宽度 */
    height: 50px;     /* 可以设置高度 */
}

特性总结

  • 独占一行：自动换行，前后都有换行符
  • 可设置宽高：width 和 height 属性有效
  • 垂直外边距有效：上下 margin 会影响布局
  • 默认宽度100%：占满父容器的宽度

3.3 行内元素 (Inline Elements)

常见行内元素

<span>, <a>, <strong>, <em>, <b>, <i>, <label>

核心特性

/* 行内元素的默认样式相当于 */
display: inline;
width: auto;       /* 宽度由内容决定，不可设置 */
height: auto;      /* 高度由内容决定，不可设置 */

示例代码

<p>
    这是一个<span>行内元素</span>，
    <a href="#">链接也是行内元素</a>，
    <strong>加粗</strong>也是。
</p>
span, a, strong {
    background-color: lightgreen;
    margin: 20px 10px;  /* 只有水平外边距有效，垂直无效 */
    padding: 5px 10px;
    width: 100px;       /* 设置无效 */
    height: 50px;       /* 设置无效 */
    line-height: 2;     /* 行高有效 */
}

特性总结

  • 不换行：在同一行内显示
  • 不可设置宽高：width 和 height 属性无效
  • 垂直外边距无效：上下 margin 不影响布局
  • 水平排列：像文字一样从左到右排列

3.4 行内块元素 (Inline-block Elements)

如何创建行内块

<!-- 默认是行内块的元素 -->
<img>, <button>, <input>, <textarea>, <select>

<!-- 通过CSS转换 -->
<div class="inline-block">我是行内块</div>
.inline-block {
    display: inline-block;  /* 关键属性 */
}

示例代码

<div class="container">
    <div class="box">行内块 1</div>
    <div class="box">行内块 2</div>
    <div class="box">行内块 3</div>
</div>
.container {
    text-align: center;
}

.box {
    display: inline-block;
    width: 100px;
    height: 100px;
    margin: 10px;
    padding: 15px;
    background-color: coral;
    vertical-align: middle;  /* 控制垂直对齐 */
}

特性总结

  • 不换行：像行内元素一样水平排列
  • 可设置宽高：像块元素一样可以控制尺寸
  • 垂直外边距有效：完整的外边距控制
  • 有间隙问题：元素间会有默认空格间隙

4. CSS单位与计算函数

4.1 绝对单位

单位描述换算关系示例
px像素，固定大小单位1px = 1/96 英寸width: 100px
in英寸1in = 96pxwidth: 1in
cm厘米1cm ≈ 37.8pxwidth: 1cm
mm毫米1mm = 1/10 cmwidth: 10mm
pt点1pt = 1/72 英寸font-size: 12pt
pcPicas1pc = 1/6 英寸width: 1pc

4.2 相对单位

单位描述使用场景
%相对于父元素尺寸宽度、高度布局
em相对于当前元素字体大小组件内相对间距
rem相对于根元素字体大小全局字体、间距
vw视口宽度的1%响应式宽度
vh视口高度的1%全屏布局
vmin视口较小边的1%响应式正方形
vmax视口较大边的1%特殊响应式场景

em 与 rem 的区别

html { font-size: 16px; }

.parent {
    font-size: 20px;
    padding: 2em;   /* 2 × 20px = 40px，相对当前元素 */
}

.child {
    font-size: 2rem; /* 2 × 16px = 32px，相对根元素，不受父元素影响 */
}

4.3 calc() 函数

calc() 允许在样式中直接进行数学计算，动态确定属性值。

语法

property: calc(expression);

⚠️ 加法和减法运算符前后必须有空格，否则无效。

基本使用

.box {
  /* 视口宽度减去固定侧边栏 */
  width: calc(100vw - 200px);

  /* 50%宽度加上间距补偿 */
  width: calc(50% + 20px);

  /* 全屏高度减去头部 */
  height: calc(100vh - 60px);
}

响应式布局

/* 三列等宽，含间距 */
.col {
  width: calc((100% - 40px) / 3);
  margin-right: 20px;
}

.col:last-child {
  margin-right: 0;
}

流体字体公式

/* 在320px到1200px视口中，字体从16px线性变化到24px */
font-size: calc(16px + (24 - 16) * (100vw - 320px) / (1200 - 320));

使用技巧

/* ✅ 正确：运算符前后有空格 */
width: calc(100% - 20px);

/* ❌ 错误：缺少空格 */
width: calc(100%-20px);

/* 可以使用括号 */
height: calc((100vh - 80px) / 2);

/* 结合多种单位 */
padding: calc(2rem + 5vw);

4.4 其他计算函数

/* min()：取最小值 */
width: min(100%, 1200px);      /* 不超过1200px */

/* max()：取最大值 */
height: max(50vh, 300px);      /* 至少300px */

/* clamp()：限定范围 */
font-size: clamp(1rem, 2.5vw, 2rem);  /* 最小1rem，最大2rem，理想2.5vw */

💡 clamp(min, ideal, max) 是响应式设计中非常实用的函数，可以替代很多媒体查询。

5. 伪类与伪元素

5.1 核心概念

伪类伪元素
语法单冒号 :双冒号 ::
作用基于元素状态或位置进行选择创建虚拟元素，插入内容
示例:hover、:nth-child()::before、::after

5.2 用户动作伪类

伪类描述
:hover鼠标悬停时
:active元素被激活时（如点击按钮瞬间）
:focus元素获得焦点时
:focus-within元素自身或其后代获得焦点时

5.3 输入伪类

伪类描述
:enabled启用的表单元素
:disabled禁用的表单元素
:checked被选中的单选/复选框
:valid符合验证规则的输入字段
:invalid不符合验证规则的输入字段
:required带有 required 属性的必填字段
:optional非必填字段
:in-range值在指定范围内
:out-of-range值超出指定范围

5.4 位置伪类

伪类描述
:link未访问的链接
:visited已访问的链接
:any-link匹配任何带 href 的锚点
:targetURL 片段标识符的目标元素

5.5 树结构伪类

伪类描述
:root文档根元素（通常是 <html>）
:empty无子元素的元素
:first-child父元素下第一个子元素
:last-child父元素下最后一个子元素
:nth-child(n)父元素下第 n 个子元素
:nth-last-child(n)从末尾计第 n 个子元素
:only-child父元素下唯一的子元素
:first-of-type同类型兄弟元素中的第一个
:last-of-type同类型兄弟元素中的最后一个
:nth-of-type(n)同类型兄弟元素中的第 n 个
:only-of-type父元素中该类型的唯一元素

5.6 函数伪类

伪类描述特性
:is(选择器列表)匹配列表中任一选择器的元素继承列表中最高优先级
:where(选择器列表)同 :is优先级为 0
:has(选择器列表)包含指定子元素的父元素唯一能向上选择父元素的伪类
:not(选择器)不匹配指定选择器的元素—
/* :where 优先级为0，方便覆盖 */
:where(h1, h2, h3) {
  margin: 0;
  padding: 0;
}

/* :has 父选择器，选中包含h2的article */
article:has(h2) {
  border: 2px solid hotpink;
}

/* :not 排除法 */
p:not(.example) {
  color: blue;
}

5.7 伪元素

伪元素描述
::before在元素内容前插入装饰内容（需 content 属性）
::after在元素内容后插入装饰内容（需 content 属性）
::first-letter元素内容的首字母
::marker列表项的项目符号或编号
::selection用户选中的文本
/* 必须设置 content 属性，可以为空字符串 */
.badge::before {
  content: "※ ";
  color: red;
}

.done::after {
  content: " ✓";
  color: green;
}

/* 首字母下沉效果 */
p::first-letter {
  font-size: 2em;
  float: left;
  color: #900;
}

5.8 核心记忆点

  1. 伪类 单冒号 :，基于状态/位置
  2. 伪元素 双冒号 ::，创建虚拟元素
  3. :is() vs :where() → 功能相同，区别在于优先级
  4. :has() → 唯一能向上选择父元素的伪类
  5. ::before / ::after → 必须设置 content 属性

6. 盒模型

6.1 盒模型组成

┌─────────────────────────────┐
│          margin             │
│  ┌─────────────────────┐    │
│  │       border        │    │
│  │  ┌─────────────┐    │    │
│  │  │   padding   │    │    │
│  │  │  ┌───────┐  │    │    │
│  │  │  │content│  │    │    │
│  │  │  └───────┘  │    │    │
│  │  └─────────────┘    │    │
│  └─────────────────────┘    │
└─────────────────────────────┘
  • content：实际内容区域
  • padding：内边距，内容与边框之间的空间
  • border：边框
  • margin：外边距，元素与其他元素之间的空间

6.2 box-sizing属性

/* 默认值：content-box */
/* 实际宽度 = width + padding + border = 200 + 40 + 4 = 244px */
.default {
  box-sizing: content-box;
  width: 200px;
  padding: 20px;
  border: 2px solid;
}

/* 推荐使用：border-box */
/* 实际宽度 = width = 200px，padding 和 border 向内压缩 */
.better {
  box-sizing: border-box;
  width: 200px;
  padding: 20px;
  border: 2px solid;
}

/* 全局推荐写法 */
*, *::before, *::after {
  box-sizing: border-box;
}

推荐全局设置 border-box，所见即所得，避免计算实际宽度时出错。

6.3 边距塌陷

现象：相邻的垂直外边距会合并为两者中较大的那个，而不是相加。

/* 两个相邻div，期望间距40px，实际只有20px */
.box-a { margin-bottom: 20px; }
.box-b { margin-top: 20px; }

解决方案

/* 方案一：只设置单侧margin */
.box-a { margin-bottom: 20px; }
/* .box-b 不设置 margin-top */

/* 方案二：父元素创建BFC，防止与子元素塌陷 */
.parent {
  overflow: hidden;    /* 触发BFC */
}

/* 方案三：父元素添加padding或border隔断 */
.parent {
  padding-top: 1px;
}

7. 布局系统

7.1 显示类型

display: block;         /* 块级元素，独占一行 */
display: inline;        /* 行内元素，不独占一行 */
display: inline-block;  /* 行内块，不换行但可设宽高 */
display: flex;          /* 弹性布局 */
display: grid;          /* 网格布局 */
display: none;          /* 不显示，不占据空间 */

7.2 Flexbox（弹性盒子）

容器属性

.container {
  display: flex;

  /* 主轴方向 */
  flex-direction: row;            /* 默认，水平从左到右 */
  flex-direction: row-reverse;    /* 水平从右到左 */
  flex-direction: column;         /* 垂直从上到下 */
  flex-direction: column-reverse; /* 垂直从下到上 */

  /* 换行 */
  flex-wrap: nowrap;              /* 默认，不换行 */
  flex-wrap: wrap;                /* 换行 */

  /* 主轴对齐（水平方向） */
  justify-content: flex-start;    /* 默认，靠左 */
  justify-content: flex-end;      /* 靠右 */
  justify-content: center;        /* 居中 */
  justify-content: space-between; /* 两端对齐 */
  justify-content: space-around;  /* 每项两侧等距 */
  justify-content: space-evenly;  /* 每项之间等距 */

  /* 交叉轴对齐（垂直方向） */
  align-items: stretch;           /* 默认，拉伸填满 */
  align-items: flex-start;        /* 顶部对齐 */
  align-items: flex-end;          /* 底部对齐 */
  align-items: center;            /* 垂直居中 */
  align-items: baseline;          /* 基线对齐 */

  /* 多行对齐 */
  align-content: flex-start;
  align-content: center;
  align-content: space-between;

  /* 间距 */
  gap: 10px;                      /* 行列间距相同 */
  gap: 10px 20px;                 /* 行间距 列间距 */
}

项目属性

.item {
  order: 0;              /* 排列顺序，数值越小越靠前 */
  flex-grow: 0;          /* 放大比例，默认不放大 */
  flex-shrink: 1;        /* 缩小比例，默认可缩小 */
  flex-basis: auto;      /* 初始大小 */
  flex: 1;               /* 简写：flex-grow:1 flex-shrink:1 flex-basis:0 */
  align-self: center;    /* 单独设置该项的垂直对齐 */
}

实战：导航栏

.navbar {
  display: flex;
  justify-content: space-between;  /* logo左，菜单右 */
  align-items: center;             /* 垂直居中 */
  padding: 0 20px;
  height: 60px;
}

/* 垂直+水平居中 */
.center-box {
  display: flex;
  justify-content: center;
  align-items: center;
}

7.3 CSS Grid（网格布局）

容器属性

.container {
  display: grid;

  /* 定义列：3列等宽 + 1列固定200px */
  grid-template-columns: repeat(3, 1fr) 200px;

  /* 定义行 */
  grid-template-rows: 100px minmax(200px, auto);

  /* 命名区域 */
  grid-template-areas:
    "header header header"
    "sidebar main   main"
    "footer footer  footer";

  /* 间距 */
  gap: 10px;

  /* 对齐 */
  justify-items: stretch;    /* 单元格内水平对齐 */
  align-items: stretch;      /* 单元格内垂直对齐 */
}

项目属性

.item {
  grid-column: 1 / 3;        /* 从第1列线到第3列线 */
  grid-row: 2 / 4;           /* 从第2行线到第4行线 */
  grid-area: header;         /* 使用命名区域 */
  justify-self: center;      /* 单独设置水平对齐 */
  align-self: center;        /* 单独设置垂直对齐 */
}

实战：经典三栏布局

.layout {
  display: grid;
  grid-template-areas:
    "header  header  header"
    "sidebar main    main"
    "footer  footer  footer";
  grid-template-columns: 200px 1fr 1fr;
  grid-template-rows: 60px 1fr 60px;
  min-height: 100vh;
  gap: 10px;
}

.header  { grid-area: header; }
.sidebar { grid-area: sidebar; }
.main    { grid-area: main; }
.footer  { grid-area: footer; }

7.4 Flex vs Grid 如何选择

场景推荐方案原因
导航栏、工具栏Flex一维布局，元素间距灵活
页面整体骨架Grid二维布局，行列同时控制
卡片列表Grid等宽等高，自动换行
垂直+水平居中Flex语法最简洁
不规则布局Grid可跨行跨列

8. 定位

8.1 定位类型

/* 静态定位：默认值，不受top/left等影响 */
position: static;

/* 相对定位：相对于自身原始位置偏移，原空间仍保留 */
position: relative;
top: 10px;
left: 20px;

/* 绝对定位：相对于最近的非static祖先元素定位，脱离文档流 */
position: absolute;
top: 0;
right: 0;

/* 固定定位：相对于视口，滚动页面不移动 */
position: fixed;
bottom: 20px;
right: 20px;

/* 粘性定位：滚动到指定位置时固定 */
position: sticky;
top: 0;    /* 距离视口顶部0时开始固定 */

8.2 常用定位技巧

/* 子绝父相：子元素绝对定位，父元素相对定位作为参照 */
.parent {
  position: relative;
}
.child {
  position: absolute;
  top: 50%;
  left: 50%;
  transform: translate(-50%, -50%);  /* 绝对居中 */
}

/* 固定悬浮按钮 */
.float-btn {
  position: fixed;
  bottom: 30px;
  right: 30px;
  z-index: 100;
}

/* 粘性导航栏 */
.navbar {
  position: sticky;
  top: 0;
  z-index: 100;
  background: white;
}

8.3 z-index堆叠

.element {
  position: relative;   /* z-index 仅在非static定位时有效 */
  z-index: 10;          /* 数值越大越靠前 */
}

/* 常见z-index层级规范 */
.dropdown   { z-index: 100; }
.modal-mask { z-index: 200; }
.modal      { z-index: 300; }
.toast      { z-index: 400; }

9. 响应式设计

9.1 视口设置

<!-- 必须添加，否则移动端会按桌面宽度渲染 -->
<meta name="viewport" content="width=device-width, initial-scale=1.0">

9.2 媒体查询

/* 移动优先：先写小屏样式，再用min-width覆盖 */
.container {
  padding: 10px;
  width: 100%;
}

/* 平板：768px及以上 */
@media (min-width: 768px) {
  .container {
    padding: 20px;
    max-width: 720px;
    margin: 0 auto;
  }
}

/* 桌面：992px及以上 */
@media (min-width: 992px) {
  .container {
    padding: 30px;
    max-width: 960px;
  }
}

/* 大屏：1200px及以上 */
@media (min-width: 1200px) {
  .container {
    max-width: 1140px;
  }
}

9.3 系统偏好媒体查询

/* 暗色模式 */
@media (prefers-color-scheme: dark) {
  body {
    background: #121212;
    color: #ffffff;
  }
}

/* 用户偏好减少动画（无障碍） */
@media (prefers-reduced-motion: reduce) {
  * {
    animation-duration: 0.01ms !important;
    transition-duration: 0.01ms !important;
  }
}

/* 打印样式 */
@media print {
  .no-print { display: none; }
  body { font-size: 12pt; }
}

9.4 响应式常用技巧

/* 响应式图片 */
img {
  max-width: 100%;
  height: auto;
}

/* 响应式字体（clamp方案，无需媒体查询） */
h1 {
  font-size: clamp(1.5rem, 4vw, 3rem);
}

/* 响应式网格（自动换行，无需媒体查询） */
.grid {
  display: grid;
  grid-template-columns: repeat(auto-fit, minmax(250px, 1fr));
  gap: 20px;
}

10. 颜色与渐变

10.1 颜色表示法

/* 命名颜色 */
color: red;
color: transparent;

/* 十六进制 */
color: #ff0000;
color: #f00;          /* 缩写 */
color: #ff000080;     /* 带透明度（后两位为alpha） */

/* RGB / RGBA */
color: rgb(255, 0, 0);
color: rgba(255, 0, 0, 0.5);   /* 0为全透明，1为不透明 */

/* HSL / HSLA（更直观的颜色调整方式） */
color: hsl(0, 100%, 50%);      /* 色相0-360, 饱和度%, 亮度% */
color: hsla(0, 100%, 50%, 0.5);

/* 现代写法（CSS Color Level 4） */
color: rgb(255 0 0 / 50%);
color: hsl(0 100% 50% / 50%);

HSL 是调色最直观的方式：改变色相（H）换颜色，调饱和度（S）控制鲜艳程度，调亮度（L）控制深浅。

10.2 渐变

线性渐变

/* 方向：to right / to bottom / 角度 */
background: linear-gradient(to right, red, blue);
background: linear-gradient(45deg, red, orange, yellow);

/* 指定色标位置 */
background: linear-gradient(to right, red 0%, orange 30%, blue 100%);

径向渐变

/* 圆形渐变 */
background: radial-gradient(circle at center, red, blue);

/* 椭圆渐变 */
background: radial-gradient(ellipse at top, red, transparent);

重复渐变

/* 斑马条纹 */
background: repeating-linear-gradient(
  45deg,
  #f0f0f0,
  #f0f0f0 10px,
  #ffffff 10px,
  #ffffff 20px
);

实战：极光渐变背景

.aurora {
  background: linear-gradient(
    135deg,
    #667eea 0%,
    #764ba2 25%,
    #f093fb 50%,
    #4facfe 75%,
    #00f2fe 100%
  );
  background-size: 400% 400%;
  animation: aurora 8s ease infinite;
}

@keyframes aurora {
  0%   { background-position: 0% 50%; }
  50%  { background-position: 100% 50%; }
  100% { background-position: 0% 50%; }
}

11. 字体与排版

11.1 字体属性

body {
  font-family: "Helvetica Neue", Arial, sans-serif; /* 字体栈，从左到右依次回退 */
  font-size: 16px;          /* 大小 */
  font-weight: 400;         /* 粗细：100-900，400=normal，700=bold */
  font-style: normal;       /* 样式：normal | italic | oblique */
  line-height: 1.6;         /* 行高，推荐无单位写法 */
  letter-spacing: 0.5px;    /* 字符间距 */
  word-spacing: 2px;        /* 单词间距 */
  text-align: left;         /* 对齐：left | right | center | justify */
  text-transform: none;     /* 大小写：uppercase | lowercase | capitalize */
  text-decoration: none;    /* 装饰线：underline | line-through | none */
}

11.2 自定义字体

@font-face {
  font-family: 'CustomFont';
  src: url('font.woff2') format('woff2'),  /* 优先使用woff2，体积最小 */
       url('font.woff') format('woff');
  font-weight: normal;
  font-style: normal;
  font-display: swap;  /* 加载期间先显示系统字体，加载完成后替换 */
}

body {
  font-family: 'CustomFont', sans-serif;
}

11.3 文字效果

/* 文字阴影 */
text-shadow: 2px 2px 4px rgba(0, 0, 0, 0.5);

/* 多层阴影（描边效果） */
text-shadow:
  1px  1px 0 #000,
  -1px -1px 0 #000,
  1px -1px 0 #000,
  -1px  1px 0 #000;

/* 发光效果 */
text-shadow: 0 0 10px rgba(100, 200, 255, 0.8);

11.4 文字溢出处理

/* 单行省略 */
.ellipsis {
  overflow: hidden;
  text-overflow: ellipsis;
  white-space: nowrap;
}

/* 多行省略（3行） */
.ellipsis-multi {
  display: -webkit-box;
  -webkit-line-clamp: 3;
  -webkit-box-orient: vertical;
  overflow: hidden;
}

12. 动画与过渡

12.1 过渡效果（transition）

过渡用于在状态改变时（如 hover）产生平滑的动画效果。

/* 基本用法 */
.button {
  background: blue;
  transition: background 0.3s ease;
}

.button:hover {
  background: darkblue;
}

/* 多属性过渡 */
.card {
  transition:
    transform 0.3s ease,
    box-shadow 0.3s ease,
    background 0.5s cubic-bezier(0.68, -0.55, 0.265, 1.55);
}

.card:hover {
  transform: translateY(-4px);
  box-shadow: 0 10px 30px rgba(0, 0, 0, 0.2);
}

/* 过渡所有属性（性能较差，谨慎使用） */
.element {
  transition: all 0.3s ease;
}

常用缓动函数

值描述
ease默认，慢-快-慢
linear匀速
ease-in慢速开始
ease-out慢速结束
ease-in-out两端慢速
cubic-bezier(x1,y1,x2,y2)自定义贝塞尔曲线

12.2 关键帧动画（animation）

动画用于自动播放、循环或复杂多阶段的动效。

/* 定义关键帧 */
@keyframes slideIn {
  0% {
    opacity: 0;
    transform: translateX(-100%);
  }
  80% {
    transform: translateX(10px);  /* 轻微回弹 */
  }
  100% {
    opacity: 1;
    transform: translateX(0);
  }
}

/* 应用动画 */
.element {
  animation: slideIn 0.5s ease-out forwards;
}

animation 属性详解

.element {
  animation-name: slideIn;              /* 关键帧名称 */
  animation-duration: 0.5s;            /* 持续时间 */
  animation-timing-function: ease-out; /* 缓动函数 */
  animation-delay: 0.2s;               /* 延迟开始 */
  animation-iteration-count: infinite; /* 播放次数，infinite为无限 */
  animation-direction: alternate;      /* 方向：normal | reverse | alternate */
  animation-fill-mode: forwards;       /* 结束后保持最终状态 */
  animation-play-state: running;       /* running | paused */
}

/* 简写 */
.element {
  animation: slideIn 0.5s ease-out 0.2s 1 normal forwards running;
}

/* 多个动画 */
.element {
  animation:
    fadeIn 0.3s ease forwards,
    slideUp 0.5s ease 0.1s forwards;
}

12.3 常用动画示例

/* 淡入 */
@keyframes fadeIn {
  from { opacity: 0; }
  to   { opacity: 1; }
}

/* 向上滑入 */
@keyframes slideUp {
  from {
    opacity: 0;
    transform: translateY(30px);
  }
  to {
    opacity: 1;
    transform: translateY(0);
  }
}

/* 无限旋转（loading图标） */
@keyframes spin {
  from { transform: rotate(0deg); }
  to   { transform: rotate(360deg); }
}

.loading {
  animation: spin 1s linear infinite;
}

/* 心跳效果 */
@keyframes heartbeat {
  0%, 100% { transform: scale(1); }
  50%       { transform: scale(1.15); }
}

.heart {
  animation: heartbeat 1s ease-in-out infinite;
}

12.4 过渡 vs 动画

transitionanimation
触发方式需要状态改变（如hover）自动播放
关键帧只有起始和结束两帧可定义多个关键帧
循环不支持支持
适用场景交互反馈、状态切换加载动画、复杂动效

13. 高级特性

13.1 CSS变量（自定义属性）

/* 在 :root 定义全局变量 */
:root {
  --primary-color: #3498db;
  --secondary-color: #2ecc71;
  --danger-color: #e74c3c;
  --spacing-sm: 8px;
  --spacing-md: 16px;
  --spacing-lg: 24px;
  --font-main: 'Arial', sans-serif;
  --border-radius: 8px;
}

/* 使用变量 */
.button {
  background: var(--primary-color);
  padding: var(--spacing-sm) var(--spacing-md);
  border-radius: var(--border-radius);

  /* 设置回退值，变量不存在时使用 */
  color: var(--text-color, #333);
}

/* 结合calc使用 */
.card {
  margin: calc(var(--spacing-md) * 2);
}

/* 暗色模式切换 */
@media (prefers-color-scheme: dark) {
  :root {
    --primary-color: #1abc9c;
    --bg-color: #121212;
    --text-color: #ffffff;
  }
}

/* JS动态修改变量 */
/* document.documentElement.style.setProperty('--primary-color', '#e74c3c') */

13.2 滤镜效果

/* 单个滤镜 */
.blur      { filter: blur(5px); }
.bright    { filter: brightness(150%); }
.contrast  { filter: contrast(200%); }
.grayscale { filter: grayscale(100%); }
.sepia     { filter: sepia(100%); }
.hue       { filter: hue-rotate(90deg); }
.saturate  { filter: saturate(200%); }
.invert    { filter: invert(100%); }

/* 组合滤镜 */
.vintage {
  filter:
    sepia(50%)
    contrast(120%)
    brightness(90%)
    saturate(80%);
}

/* backdrop-filter：背景模糊（玻璃拟态效果） */
.glass-card {
  background: rgba(255, 255, 255, 0.1);
  backdrop-filter: blur(10px);
  -webkit-backdrop-filter: blur(10px);  /* Safari兼容 */
  border: 1px solid rgba(255, 255, 255, 0.2);
}

13.3 混合模式

/* 元素混合模式 */
.element {
  mix-blend-mode: multiply;   /* 正片叠底 */
  mix-blend-mode: screen;     /* 滤色 */
  mix-blend-mode: overlay;    /* 叠加 */
}

/* 背景混合模式 */
.element {
  background-image: url('photo.jpg'), linear-gradient(red, blue);
  background-blend-mode: multiply;
}

14. 现代CSS特性

14.1 容器查询

容器查询允许根据父容器的尺寸（而非视口）来改变样式，比媒体查询更灵活。

/* 第一步：定义容器 */
.card-wrapper {
  container-type: inline-size;
  container-name: card;       /* 命名，可选 */
}

/* 第二步：基于容器尺寸写样式 */
@container card (min-width: 400px) {
  .card {
    display: grid;
    grid-template-columns: 120px 1fr;
  }
}

@container card (min-width: 600px) {
  .card-title {
    font-size: 1.5rem;
  }
}

容器查询解决了组件复用中的痛点：同一个卡片组件在侧边栏（窄）和主内容区（宽）中可以自动呈现不同布局。

14.2 层叠层（@layer）

@layer 用于管理样式优先级，解决大型项目中样式覆盖混乱的问题。

/* 声明层的顺序，后面的层优先级更高 */
@layer reset, base, components, utilities;

@layer reset {
  * { margin: 0; padding: 0; box-sizing: border-box; }
}

@layer base {
  body { font-family: system-ui; line-height: 1.5; }
  a { color: inherit; }
}

@layer components {
  .button {
    padding: 0.5em 1em;
    border-radius: 4px;
    cursor: pointer;
  }
}

@layer utilities {
  .text-center { text-align: center; }
  .hidden { display: none; }
}

14.3 @supports 特性检测

/* 支持某特性时才应用样式 */
@supports (display: grid) {
  .container {
    display: grid;
    grid-template-columns: repeat(3, 1fr);
  }
}

/* 不支持时的回退方案 */
@supports not (display: grid) {
  .container {
    display: flex;
    flex-wrap: wrap;
  }
}

/* 检测多个特性 */
@supports (backdrop-filter: blur(10px)) or (-webkit-backdrop-filter: blur(10px)) {
  .glass {
    backdrop-filter: blur(10px);
    -webkit-backdrop-filter: blur(10px);
  }
}

14.4 子网格（subgrid）

.grid {
  display: grid;
  grid-template-columns: repeat(3, 1fr);
  gap: 20px;
}

/* 子元素继承父网格的轨道定义 */
.grid-item {
  display: grid;
  grid-column: span 2;
  grid-template-columns: subgrid;  /* 继承父网格的列定义 */
}

15. 可访问性与性能

15.1 隐藏内容

/* 视觉隐藏但屏幕阅读器可读（无障碍最佳实践） */
.sr-only {
  position: absolute;
  width: 1px;
  height: 1px;
  padding: 0;
  margin: -1px;
  overflow: hidden;
  clip: rect(0, 0, 0, 0);
  white-space: nowrap;
  border: 0;
}

/* 视觉隐藏且屏幕阅读器不可读 */
.hidden {
  display: none;
}

/* 仅视觉隐藏，保留空间 */
.invisible {
  visibility: hidden;
}

15.2 焦点样式

/* 自定义焦点样式（保证键盘用户可见） */
a:focus,
button:focus,
input:focus {
  outline: 2px solid #3498db;
  outline-offset: 2px;
}

/* 鼠标点击不显示焦点，键盘导航显示焦点 */
:focus:not(:focus-visible) {
  outline: none;
}

:focus-visible {
  outline: 3px dashed #2ecc71;
  outline-offset: 3px;
}

15.3 对比度要求

文本类型最低对比度标准
普通文本（小于18pt）4.5 : 1WCAG AA
大文本（18pt/24px以上）3 : 1WCAG AA
装饰性元素无要求—

15.4 渲染性能优化

/* 提示浏览器该属性即将变化，提前做优化 */
.animated {
  will-change: transform;     /* 仅在真正需要时使用，滥用会适得其反 */
}

/* 优先使用 transform 和 opacity 做动画（不触发重排重绘） */
/* 性能好 */
.good {
  transition: transform 0.3s ease, opacity 0.3s ease;
}

/* 性能差，触发重排 */
.bad {
  transition: width 0.3s ease, height 0.3s ease, top 0.3s ease;
}

/* 内容可见性：跳过屏幕外内容的渲染（长列表优化） */
.list-item {
  content-visibility: auto;
  contain-intrinsic-size: 0 200px;  /* 预估元素高度，防止滚动条跳动 */
}

15.5 加载优化

/* 字体加载策略 */
@font-face {
  font-family: 'CustomFont';
  src: url('font.woff2') format('woff2');
  font-display: swap;       /* 先用系统字体，加载完成后替换，避免字体闪烁 */
}

16. 调试技巧

16.1 调试样式

/* 给所有元素加边框，快速查看布局问题 */
* {
  outline: 1px solid red !important;
}

/* 调试网格背景 */
.debug-grid {
  background-image:
    repeating-linear-gradient(
      90deg,
      rgba(255, 0, 0, 0.1),
      rgba(255, 0, 0, 0.1) 1px,
      transparent 1px,
      transparent 20px
    ),
    repeating-linear-gradient(
      0deg,
      rgba(255, 0, 0, 0.1),
      rgba(255, 0, 0, 0.1) 1px,
      transparent 1px,
      transparent 20px
    );
}

16.2 常用调试方法

/* 查看元素实际尺寸 */
.debug {
  background: rgba(255, 0, 0, 0.2) !important;
  border: 1px solid red !important;
}

/* 空状态处理 */
.list:empty::after {
  content: "暂无数据";
  display: block;
  text-align: center;
  color: #999;
  padding: 40px;
}

/* 焦点包含调试 */
.form:focus-within {
  border-color: blue;
  box-shadow: 0 0 0 3px rgba(0, 0, 255, 0.1);
}

总结

知识体系速查

CSS 知识体系
├── 基础概念          → 规则结构、引入方式
├── 选择器            → 基础/组合器/伪类/伪元素/优先级
├── 显示类型          → block / inline / inline-block
├── 单位与函数        → px/rem/vw/vh + calc/clamp/min/max
├── 盒模型            → content/padding/border/margin + box-sizing
├── 布局系统          → Flex（一维）/ Grid（二维）
├── 定位              → static/relative/absolute/fixed/sticky
├── 响应式            → 媒体查询 + 移动优先
├── 颜色与渐变        → hex/rgb/hsl + linear/radial-gradient
├── 字体与排版        → font属性 + 溢出处理
├── 动画              → transition（交互）/ animation（自动）
├── 高级特性          → CSS变量 / 滤镜 / 混合模式
├── 现代CSS           → 容器查询 / @layer / @supports
├── 可访问性          → 焦点样式 / 对比度 / sr-only
├── 性能优化          → will-change / transform优先 / content-visibility
└── 调试              → outline调试法 / 空状态处理

常见问题速查

问题解决方案
边距塌陷只设单侧margin，或父元素触发BFC（overflow:hidden）
垂直居中display:flex + align-items:center + justify-content:center
浮动清除改用flex/grid，避免使用float
响应式图片max-width:100%; height:auto
字体闪烁font-display: swap
动画性能差只对 transform 和 opacity 做动画
文字超出截断单行用 text-overflow:ellipsis，多行用 -webkit-line-clamp
元素层级混乱规范化 z-index 值，建立层级体系
选择器优先级冲突降低选择器层级，使用 @layer 管理，避免 !important

学习建议

  1. 先理解，再记忆：CSS 属性很多，不需要全部背下来，理解原理后用到时查文档即可
  2. 多动手：每个知识点都亲自写一遍，比看十遍更有效
  3. 善用开发者工具：F12 是最好的 CSS 调试工具，实时修改样式即时预览
  4. 移动优先：写响应式样式时，养成从小屏开始的习惯
  5. 关注现代特性：容器查询、@layer、clamp() 等新特性正在成为主流

如有错误欢迎指正。

]]> https://loogeking.github.io/posts/CSS%E5%AD%A6%E4%B9%A0%E7%AC%94%E8%AE%B0/ 2026-06-21T00:26:23.000Z CSS学习笔记

1. CSS 基础概念

1.1 什么是CSS？

  • 定义：层叠样式表（Cascadin]]>
CSS学习笔记 2026-06-22T10:20:31.706Z Loogeking 基础爬虫教程

爬虫：通过一些手段（如Python的requests库）爬取网络中的一些数据

工具：Pycharm（可用其他编辑器平替如vscode），python3.12

一、核心概念

1.1、网络通信相关

1、URL（统一资源定位符）

URL 就是我们常说的"网址"，它是网络上每个资源的唯一地址。理解 URL 的组成对爬虫非常重要：

https://www.example.com:443/search?q=python&page=2#result
|协议|    |域名|         |端口| |路径|   |查询参数|    |锚点|
  • 协议：http 或 https（加密版本）
  • 域名：服务器地址
  • 路径：服务器上资源的位置
  • 查询参数：向服务器传递的额外信息（爬虫中经常需要构造这部分）

2、HTTP协议

HTTP 是浏览器与服务器之间通信的规则。爬虫本质上就是模拟浏览器向服务器发送 HTTP 请求，然后接收并解析响应。

3、请求方法

最常见的两种：

  • GET：从服务器获取数据，参数附在 URL 上（如搜索、翻页）
  • POST：向服务器提交数据，参数放在请求体中（如登录、表单提交）

4、请求头

请求头是随请求一起发送的附加信息，用来描述客户端的身份和能力。爬虫中最常用的字段：

  • User-Agent：标识客户端类型（浏览器/操作系统），很多网站会根据这个字段判断是否为爬虫
  • Referer：标识请求来源页面
  • Cookie：携带用户登录状态等信息

5、响应

服务器收到请求后返回的内容，主要包括：

组成部分说明requests 中的用法
状态码表示请求结果（200成功，404未找到，403禁止访问，500服务器错误）response.status_code
响应头服务器返回的附加信息（如内容类型、编码）response.headers
响应体返回的实际内容（HTML、JSON等）response.text / response.json()

1.2、数据格式相关

1、前端界面的组成

  • HTML：网页的结构骨架

    <div class="item">
        <h2 id="title">商品名称</h2>
        <span class="price">¥99.00</span>
        <a href="/detail/123">查看详情</a>
        <img src="image.jpg">
    </div>

    • 重点理解：

      • 标签：如 div、a、span
      • 属性：如 class、id、href、src
      • 嵌套关系：父子节点、兄弟节点

  • CSS：控制网页的样式和布局

    body{
    background-color: black;   //设置页面背景为黑色
    }

  • JS：实现网页的动态效果和交互功能

  • 资源文件：包括图片（jpg、png）、视频、音频、字体文件等

  • 服务器数据：网页上的数据通常存储在服务器端，通过 HTTP 请求返回给浏览器

2、网页源代码

  • 定义：服务器返回给浏览器的原始文本内容，通常是 HTML 文档

  • 查看方式

    • 通过鼠标右键可找到“查看网页源代码”的选项，点击即可
    • Ctrl+U快捷键

  • ==注意==：浏览器中“查看源代码”看到的是最初返回的 HTML，而“检查元素”看到的是浏览器执行 JavaScript 后生成的最终 DOM 结构。在一些动态网站中，这两者可能不同。

3、robots.txt 协议

这是网站根目录下的一个文件（如 https://www.example.com/robots.txt），声明了哪些页面允许爬取、哪些禁止爬取。虽然不具有强制力，但属于行业规范，建议遵守。

二、实战

2.1、百度热搜内容爬取

基础请求、请求头伪装、XPath 定位

1、确认目标网址

2、分析页面结构

  • 查看网页源代码（Ctrl+F搜索相关内容）

3、代码

"""
爬取网址：https://www.baidu.com
爬取要求：热搜内容
"""

import requests  # 发送请求
from lxml import etree  # 解析html


url = 'https://www.baidu.com'

# 请求头，被服务器读取，要符合读取要求才能给你发包，也就是所谓的请求成功
headers = {
    'user-agent':'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/138.0.0.0 Safari/537.36'
}
r = requests.get(url, headers=headers).content.decode('utf-8')
# print(r)  # 打印网页源代码，可以结合ctrl+f搜索关键字，看看是否获取成功
ret = etree.HTML(r)

# xpath表达式定位
li_list = ret.xpath('//ul[@class="s-hotsearch-content"]/li')
# print(len(li_list))  # 打印长度，看看是否获取成功
for li in li_list:
    text = li.xpath('.//span[@class="title-content-title"]/text()')[0]
    print(text)
结果展示：

image-20260515122326082.png

2.2、哲风壁纸图片爬取

文件下载（图片/视频）、条件判断、文件 IO

1、确认目标网址

2、分析页面结构

  • F12快捷键，定位图片位置获取url，再去网页源代码中搜索
    • image-20260515123944408.png
    • 发现存在，依旧直接写代码

3、代码

"""
os库用来新建文件夹
然后后面有判断语句是用来分辨动态壁纸和静态壁纸，分别写入文件
"""
import os
import requests
from lxml import etree

# 创建文件夹
if not os.path.exists('wallpaper'):
    os.mkdir('wallpaper')

# 确定爬取网址，并发出请求
url = 'https://haowallpaper.com/'
r = requests.get(url).content.decode('utf-8')
# print(r)

# 解析网页，获取数据
ret = etree.HTML(r)
div_list = ret.xpath('//div[@class="home-container"]/div')
# print(len(div_list))

n = 1
for div in div_list:
    wallpaper_url = div.xpath('./div[1]/img/@src')
    print(wallpaper_url)
    if wallpaper_url == []:
        wallpaper_url = div.xpath('./div[1]/video/@src')[0]
        with open(f'wallpaper/{n}.mp4', 'wb') as f:
            f.write(requests.get(wallpaper_url).content)
    else:
        with open(f'wallpaper/{n}.png', 'wb') as f:
            f.write(requests.get(wallpaper_url[0]).content)
    n += 1
结果展示：

image-20260515124306944.png

### 2.3、NBA球员数据抓取>抓包分析、查询参数构造、JSON 数据处理

1、确认目标网址

2、分析页面结构

  • image-20260515130808760.png

  • 没有，那就说明是动态网页，数据不在html中，而是以包的形式存在

  • 打开开发者工具，切换到网络监听，重新点击提交按钮

  • image-20260515130925214.png

  • 找到数据就可以写代码了

3、代码

import requests

def main():
    url = "https://data.zhibo8.cc/manage/public/app.php"
    params = {
        "_url": "/nba/player_conditions",
        "season": "2024",
        "random": "0.4268737407850992"
    }
    headers = {
        'user-agent':'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/139.0.0.0 Safari/537.36'
    }
    r = requests.get(url, params=params, headers=headers).json()
    lst = r['data']['data']['list']
    with open('NBA数据.csv', 'a', encoding='utf-8') as f:
        f.write('球员,球队,得分,场数,篮板,助攻,抢断,盖帽,先发,分钟,命中率,三分%,罚球%,前板,后板,失误,犯规\n')
        for i in lst:
            f.write(f'{i['球员']},{i['球队']},{i['得分']},{i['场数']},{i['篮板']},{i['助攻']},{i['抢断']},{i['盖帽']},{i['先发']},{i['分钟']},{i['命中率']},{i['三分%']},{i['罚球%']},{i['前板']},{i['后板']},{i['失误']},{i['犯规']}\n')


if __name__ == '__main__':
    main()
结果展示：

image-20260515131223189.png

2.4、华为商城数据爬取

POST 请求、请求体构造、Cookie/Token 携带

1、确认目标网址

2、分析页面结构

  • image-20260515132007238.png

  • 不是静态的，得抓包；通过翻页获取最新的包

  • image-20260515132052500.png

  • 包的分析和页面同理

3、代码

import requests
import json


headers = {
    "CsrfToken": "cy6HVAnxwXXJwOOFzHG4LuwwWx9hbDNCc4KX",
    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/148.0.0.0 Safari/537.36",
    "X-E2E-Trace": "e2eId=page#rn_searchResult#1#10cdbf9e48bcc4911b6e1fadf4121541;spanId=f36a4518a625a618b955fccd0f99189e",
    "X-Requested-With": "XMLHttpRequest",
}
cookies = {
    "perIdb": "401001097",
    "callAB": "1",
    "recommendflag": "0",
    "euid": "a8d0e83bf467a5a07fafb75460b4e7b6f3686c87b85959fc",
    "CSRF-TOKEN": "cy6HVAnxwXXJwOOFzHG4LuwwWx9hbDNCc4KX",
    "HWWAFSESTIME": "1778822159370",
    "HWWAFSESID": "b69f6346b172e3781a2",
    "showAds": "true",
    "deviceid": "17bc3e4c31f8e3469a387063eb57ee65",
    "TID": "17bc3e4c31f8e3469a387063eb57ee65",
    "cartId": "fbc39de996974e68a164a3f05c0190c9",
    "sdevid": "be101e2963cf2619e7b73b8617b9b4fd6a01292c",
    "referer": "https://www.vmall.com/product/comdetail/index.html?prdId=10086724171251&sbomCode=2601010586509",
    "device_data": "*2k48T5zCyEYUXMJWLUIh4AmmTSM46R9CmDlzTDSk04ltzymmNNMUVNbJcYdsYARE4EyLUIu6QeZZUH1Uj0jTmPx5DEw90RRJI1y2TFJZJZZMPQUI9E10RVUTUmjFZJaNV0xqxmlmmSGU2zTmjjN1NEy095adQZYRJRPd1AF9Bd4Q9oy0rMPJNNUiml0VSj3tum00wmPlZoAnnTj0UQZecSZOyJgE4ZlpUdjylVMPOZU2uu64K3qkDyikV0T348Fcyk1mvLMTNMcZZG1UlQUBQEFoyy1eMTOjWmXjDkSDFmmLJBH9p4NdUnGiDGZRbMQTPZnY4YpRRg9Qj0DUPJZM9Tx4uJmBUiiGzjUjjZZNNwVj3zzLaMLdPZPk4Y1lYk0J5zw1lPcZWSDTVmCDjkmZix41Z3kZabMUYcZF0jecxzPmLi4="
}
url = "https://openapi.vmall.com/mcp/v1/search/queryPrd"
data = {
    "tid": "17bc3e4c31f8e3469a387063eb57ee65",
    "sid": "b7a060f5481eb03d32c4ce2c1fc58f59a34509610ff3857b",
    "keyword": "手机",
    "pageNum": 2,
    "pageSize": 20,
    "searchSortField": 0,
    "searchSortType": "desc",
    "screenParams": "{}",
    "personalizeSearch": "2",
    "portal": "1",
    "lang": "zh-CN",
    "country": "CN",
    "searchFlag": "0",
    "brandType": 0
}
data = json.dumps(data, separators=(',', ':'))
response = requests.post(url, headers=headers, cookies=cookies, data=data)

print(response.json())
结果展示：

image-20260515132346945.png

三、总结

3.1、爬虫的基本流程

确定目标 URL
    ↓
分析页面结构（源代码 / F12 / 抓包）
    ↓
判断数据类型
    ├── 静态页面 → requests 获取 HTML → XPath / BeautifulSoup 解析
    └── 动态页面 → 开发者工具抓包 → 找到数据接口 → 请求 API 获取 JSON
    ↓
提取目标数据
    ↓
保存数据（txt / csv / 数据库）

3.2、四个案例回顾

案例数据类型请求方式解析方式核心知识点
百度热搜静态页面GETXPath基础请求、请求头伪装、XPath 定位
哲风壁纸静态页面GETXPath文件下载（图片/视频）、条件判断、文件 IO
NBA数据动态页面（API）GETJSON抓包分析、查询参数构造、JSON 数据处理
华为商城动态页面（API）POSTJSONPOST 请求、请求体构造、Cookie/Token 携带

3.3、进阶方向

如果你希望继续深入，可以探索以下方向：

方向说明
多页爬取通过循环构造翻页参数，批量爬取多页数据
并发爬取使用多线程 / 异步（aiohttp）提升爬取速度
数据持久化将数据存入 MySQL、MongoDB 等数据库
爬虫框架学习 Scrapy 框架，实现更工程化的爬虫项目
反爬对抗了解验证码、IP封禁、JS加密等反爬机制及应对方式
动态渲染使用 Selenium / Playwright 处理需要浏览器渲染的页面

⚠️ 免责声明：本文所有案例仅用于技术学习与交流目的。在实际使用爬虫时，请务必遵守目标网站的 robots.txt 协议及相关法律法规，合理控制请求频率，不对目标服务器造成过大压力，不将爬取的数据用于商业或非法用途。

]]> https://loogeking.github.io/posts/%E5%9F%BA%E7%A1%80%E7%88%AC%E8%99%AB/ 2026-06-20T13:45:33.000Z 基础爬虫教程

爬虫：通过一些手段（如Python的requests库）爬取网络中的一些数据

工具：Pycharm（可用其他编辑器平替如vscode），python3.12

]]> 基础爬虫 2026-06-22T10:20:31.707Z Loogeking JavaScript 学习笔记

1. JavaScript 基础概念

1.1 什么是 JavaScript？

  • 定义：一种轻量级、解释型的编程语言，是 Web 开发的三大核心技术之一
  • 运行环境：浏览器（前端）、Node.js（后端/工具链）
  • 特点：
    • 动态类型：变量类型在运行时确定
    • 单线程：基于事件循环处理异步任务
    • 原型继承：基于原型链实现面向对象
    • 函数是一等公民：函数可以作为参数、返回值、赋值给变量

1.2 JavaScript 在网页中的引入方式

<!-- 内联脚本 -->
<script>
  console.log('Hello World');
</script>

<!-- 外部脚本（推荐） -->
<script src="main.js"></script>

<!-- defer：HTML解析完成后执行，保持脚本顺序 -->
<script src="main.js" defer></script>

<!-- async：下载完成后立即执行，不保证顺序 -->
<script src="main.js" async></script>

推荐将 script 标签放在 body 底部，或使用 defer 属性，避免阻塞 HTML 解析。

1.3 输出与调试

// 控制台输出
console.log('普通信息');
console.warn('警告信息');
console.error('错误信息');
console.table([{ name: '张三', age: 18 }]);  // 表格形式输出
console.time('计时');
console.timeEnd('计时');                       // 输出耗时

// 弹窗（开发调试用，不建议在生产环境使用）
alert('提示');
confirm('确认？');   // 返回 true/false
prompt('请输入');    // 返回用户输入的字符串

2. 变量与数据类型

2.1 变量声明

// var：函数作用域，存在变量提升，不推荐使用
var name = '张三';

// let：块级作用域，可重新赋值，推荐使用
let age = 18;
age = 19;

// const：块级作用域，不可重新赋值，推荐优先使用
const PI = 3.14159;

三者对比

varletconst
作用域函数级块级块级
变量提升有无无
重复声明允许不允许不允许
重新赋值允许允许不允许
推荐程度不推荐推荐优先推荐

实际开发原则：默认使用 const，需要重新赋值时改用 let，避免使用 var。

2.2 数据类型

JavaScript 共有 8 种数据类型：

基本类型（7种）

// Number：整数和浮点数统一为 number 类型
let num = 42;
let float = 3.14;
let inf = Infinity;
let nan = NaN;            // Not a Number，但 typeof NaN === 'number'

// String
let str = '单引号';
let str2 = "双引号";
let str3 = `模板字符串`;

// Boolean
let bool = true;
let bool2 = false;

// Undefined：变量声明但未赋值
let undef;
console.log(undef);       // undefined

// Null：表示空值，需要主动赋值
let empty = null;

// Symbol：唯一标识符（ES6）
let sym = Symbol('描述');
let sym2 = Symbol('描述');
console.log(sym === sym2); // false，每个Symbol都是唯一的

// BigInt：任意精度整数（ES2020）
let big = 9007199254740991n;

引用类型（1种）

// Object：对象、数组、函数都属于引用类型
let obj = { name: '张三' };
let arr = [1, 2, 3];
let fn = function() {};

2.3 类型检测

// typeof：检测基本类型
typeof 42           // 'number'
typeof 'hello'      // 'string'
typeof true         // 'boolean'
typeof undefined    // 'undefined'
typeof null         // 'object'（历史遗留bug）
typeof {}           // 'object'
typeof []           // 'object'
typeof function(){} // 'function'

// instanceof：检测引用类型
[] instanceof Array         // true
{} instanceof Object        // true

// Array.isArray：专门检测数组
Array.isArray([])           // true
Array.isArray({})           // false

// Object.prototype.toString：最准确的类型检测
Object.prototype.toString.call(42)      // '[object Number]'
Object.prototype.toString.call([])      // '[object Array]'
Object.prototype.toString.call(null)    // '[object Null]'

2.4 类型转换

显式转换

// 转为数字
Number('42')        // 42
Number('abc')       // NaN
Number(true)        // 1
Number(false)       // 0
Number(null)        // 0
Number(undefined)   // NaN
parseInt('42px')    // 42（解析整数部分）
parseFloat('3.14rem') // 3.14

// 转为字符串
String(42)          // '42'
String(true)        // 'true'
String(null)        // 'null'
(42).toString()     // '42'
(255).toString(16)  // 'ff'（转为16进制）

// 转为布尔值
Boolean(0)          // false
Boolean('')         // false
Boolean(null)       // false
Boolean(undefined)  // false
Boolean(NaN)        // false
Boolean(false)      // false
// 以上6种为假值，其余都为 true

隐式转换（需要注意的坑）

// 字符串拼接
'5' + 3         // '53'（数字被转为字符串）
'5' - 3         // 2（字符串被转为数字）
'5' * '3'       // 15

// 宽松相等（==）会进行类型转换，推荐使用严格相等（===）
0 == false      // true
'' == false     // true
null == undefined // true
null == 0       // false

// 严格相等（===）不进行类型转换
0 === false     // false
1 === '1'       // false

3. 运算符

3.1 算术运算符

let a = 10, b = 3;

a + b   // 13，加法
a - b   // 7，减法
a * b   // 30，乘法
a / b   // 3.3333...，除法
a % b   // 1，取余
a ** b  // 1000，幂运算（ES7）

// 自增自减
let x = 5;
x++     // 先使用x（5），再自增，x变为6
++x     // 先自增，再使用x（7）
x--     // 先使用x（7），再自减，x变为6
--x     // 先自减，再使用x（5）

3.2 比较运算符

5 > 3       // true
5 < 3       // false
5 >= 5      // true
5 <= 4      // false
5 == '5'    // true（宽松相等，类型转换）
5 === '5'   // false（严格相等，类型不同）
5 != '5'    // false
5 !== '5'   // true

3.3 逻辑运算符

// && 与：两者都为真才返回真，返回第一个假值或最后一个值
true && true    // true
true && false   // false
'a' && 'b'      // 'b'
'' && 'b'       // ''（短路，返回第一个假值）

// || 或：有一个为真就返回真，返回第一个真值或最后一个值
true || false   // true
false || false  // false
'' || 'default' // 'default'（常用于设置默认值）

// ! 非
!true           // false
!0              // true

// ?? 空值合并运算符（ES2020）：只有 null 和 undefined 才触发
null ?? 'default'       // 'default'
undefined ?? 'default'  // 'default'
0 ?? 'default'          // 0（与 || 的区别：0不触发）
'' ?? 'default'         // ''

3.4 赋值运算符

let x = 10;
x += 5;     // x = x + 5 = 15
x -= 3;     // x = x - 3 = 12
x *= 2;     // x = x * 2 = 24
x /= 4;     // x = x / 4 = 6
x %= 4;     // x = x % 4 = 2
x **= 3;    // x = x ** 3 = 8
x ??= 'default'; // 仅当x为null或undefined时赋值
x ||= 'default'; // 仅当x为假值时赋值
x &&= 100;       // 仅当x为真值时赋值

3.5 其他运算符

// 三元运算符
let result = age >= 18 ? '成年' : '未成年';

// 可选链运算符（ES2020）：避免访问undefined/null的属性报错
let user = null;
user?.name          // undefined（不报错）
user?.address?.city // undefined（链式）
user?.getName?.()   // undefined（方法调用）

// 展开运算符
let arr = [1, 2, 3];
let arr2 = [...arr, 4, 5];  // [1, 2, 3, 4, 5]

let obj = { a: 1 };
let obj2 = { ...obj, b: 2 }; // { a: 1, b: 2 }

4. 流程控制

4.1 条件语句

// if...else if...else
let score = 85;

if (score >= 90) {
  console.log('优秀');
} else if (score >= 70) {
  console.log('良好');
} else if (score >= 60) {
  console.log('及格');
} else {
  console.log('不及格');
}

// switch（适用于多个固定值的判断）
let day = 3;
switch (day) {
  case 1:
    console.log('周一');
    break;
  case 2:
    console.log('周二');
    break;
  case 3:
  case 4:
    console.log('周三或周四');  // 多个case共用
    break;
  default:
    console.log('其他');
}

4.2 循环语句

// for 循环
for (let i = 0; i < 5; i++) {
  console.log(i);
}

// while 循环：先判断后执行
let i = 0;
while (i < 5) {
  console.log(i);
  i++;
}

// do...while 循环：先执行后判断，至少执行一次
let j = 0;
do {
  console.log(j);
  j++;
} while (j < 5);

// for...of：遍历可迭代对象（数组、字符串、Map、Set等）
let arr = [10, 20, 30];
for (let value of arr) {
  console.log(value);   // 10 20 30
}

// for...in：遍历对象的可枚举属性（键名）
let obj = { a: 1, b: 2, c: 3 };
for (let key in obj) {
  console.log(key, obj[key]);  // a 1  b 2  c 3
}

4.3 循环控制

// break：跳出当前循环
for (let i = 0; i < 10; i++) {
  if (i === 5) break;
  console.log(i);   // 输出 0 1 2 3 4
}

// continue：跳过本次迭代，继续下一次
for (let i = 0; i < 5; i++) {
  if (i === 2) continue;
  console.log(i);   // 输出 0 1 3 4
}

// 标签语句：用于多层嵌套循环中的跳出
outer: for (let i = 0; i < 3; i++) {
  for (let j = 0; j < 3; j++) {
    if (j === 1) break outer;  // 直接跳出外层循环
    console.log(i, j);
  }
}

4.4 异常处理

// try...catch...finally
try {
  let result = JSON.parse('invalid json');
} catch (error) {
  console.error(error.name);     // SyntaxError
  console.error(error.message);  // 具体错误信息
} finally {
  console.log('无论是否报错都会执行');
}

// 主动抛出错误
function divide(a, b) {
  if (b === 0) {
    throw new Error('除数不能为0');
  }
  return a / b;
}

// 自定义错误类型
class ValidationError extends Error {
  constructor(message) {
    super(message);
    this.name = 'ValidationError';
  }
}

try {
  throw new ValidationError('输入不合法');
} catch (error) {
  if (error instanceof ValidationError) {
    console.log('验证错误：', error.message);
  }
}

5. 函数

5.1 函数声明方式

// 函数声明（存在函数提升，可在声明前调用）
function greet(name) {
  return 'Hello, ' + name;
}

// 函数表达式（不存在提升）
const greet = function(name) {
  return 'Hello, ' + name;
};

// 箭头函数（ES6，没有自己的 this）
const greet = (name) => {
  return 'Hello, ' + name;
};

// 箭头函数简写（单行可省略 return 和花括号）
const greet = name => 'Hello, ' + name;

// 立即执行函数（IIFE）
(function() {
  console.log('立即执行');
})();

5.2 函数参数

// 默认参数（ES6）
function greet(name = '陌生人') {
  return 'Hello, ' + name;
}
greet()         // 'Hello, 陌生人'
greet('张三')   // 'Hello, 张三'

// 剩余参数（ES6）：收集多余的参数为数组
function sum(first, ...rest) {
  return rest.reduce((acc, val) => acc + val, first);
}
sum(1, 2, 3, 4)  // 10

// arguments 对象（非箭头函数中，包含所有参数）
function fn() {
  console.log(arguments);        // 类数组对象
  console.log([...arguments]);   // 转为真正的数组
}

// 解构参数
function createUser({ name, age = 18, role = 'user' }) {
  return { name, age, role };
}
createUser({ name: '张三', age: 25 });

5.3 作用域与闭包

// 全局作用域
let globalVar = '全局变量';

function outer() {
  // 函数作用域
  let outerVar = '外部变量';

  function inner() {
    // 块级作用域
    let innerVar = '内部变量';
    console.log(globalVar);   // 可以访问
    console.log(outerVar);    // 可以访问
  }

  inner();
  // console.log(innerVar);  // 报错，无法访问内部变量
}

// 闭包：函数记住了其定义时的词法环境
function makeCounter() {
  let count = 0;

  return {
    increment() { count++; },
    decrement() { count--; },
    getCount()  { return count; }
  };
}

const counter = makeCounter();
counter.increment();
counter.increment();
counter.getCount();  // 2
// count 变量被保护在闭包中，外部无法直接访问

5.4 this 关键字

// 普通函数中，this 由调用方式决定
const obj = {
  name: '张三',
  greet: function() {
    console.log(this.name);  // '张三'，this 指向 obj
  }
};

// 箭头函数没有自己的 this，继承外层作用域的 this
const obj2 = {
  name: '李四',
  greet: () => {
    console.log(this.name);  // undefined，this 指向外层（全局）
  },
  greetLater: function() {
    setTimeout(() => {
      console.log(this.name);  // '李四'，箭头函数继承了 greetLater 的 this
    }, 1000);
  }
};

// 显式绑定 this
function sayName() {
  console.log(this.name);
}

const user = { name: '王五' };

sayName.call(user);          // '王五'，立即调用，参数逐个传入
sayName.apply(user, []);     // '王五'，立即调用，参数以数组传入
const bound = sayName.bind(user);
bound();                     // '王五'，返回新函数，稍后调用

5.5 高阶函数

// 函数作为参数
function execute(fn, value) {
  return fn(value);
}
execute(x => x * 2, 5);  // 10

// 函数作为返回值
function multiplier(factor) {
  return num => num * factor;
}
const double = multiplier(2);
const triple = multiplier(3);
double(5);  // 10
triple(5);  // 15

// 函数柯里化
function curry(fn) {
  return function curried(...args) {
    if (args.length >= fn.length) {
      return fn(...args);
    }
    return (...more) => curried(...args, ...more);
  };
}

const add = (a, b, c) => a + b + c;
const curriedAdd = curry(add);
curriedAdd(1)(2)(3);  // 6
curriedAdd(1, 2)(3);  // 6

6. 数组

6.1 数组创建

// 字面量方式（推荐）
const arr = [1, 2, 3, 4, 5];

// 构造函数方式
const arr2 = new Array(3);        // [empty × 3]，长度为3的空数组
const arr3 = new Array(1, 2, 3);  // [1, 2, 3]

// Array.from：从类数组或可迭代对象创建
Array.from('hello');              // ['h', 'e', 'l', 'l', 'o']
Array.from({ length: 3 }, (_, i) => i + 1);  // [1, 2, 3]

// Array.of：从参数创建数组
Array.of(1, 2, 3);               // [1, 2, 3]

6.2 数组基本操作

const arr = [1, 2, 3, 4, 5];

// 访问元素
arr[0]          // 1
arr.at(-1)      // 5，at() 支持负索引（ES2022）

// 修改元素
arr[0] = 10;

// 获取长度
arr.length      // 5

// 检测是否为数组
Array.isArray(arr)  // true

6.3 增删操作

const arr = [1, 2, 3];

// 末尾操作
arr.push(4, 5);    // 末尾添加，返回新长度，arr = [1,2,3,4,5]
arr.pop();         // 末尾删除，返回被删除的元素，arr = [1,2,3,4]

// 开头操作
arr.unshift(0);    // 开头添加，返回新长度，arr = [0,1,2,3,4]
arr.shift();       // 开头删除，返回被删除的元素，arr = [1,2,3,4]

// splice：任意位置增删改（会修改原数组）
const arr2 = [1, 2, 3, 4, 5];
arr2.splice(1, 2);          // 从索引1开始删除2个，返回[2,3]，arr2=[1,4,5]
arr2.splice(1, 0, 10, 20);  // 从索引1插入，删除0个，arr2=[1,10,20,4,5]
arr2.splice(1, 1, 99);      // 从索引1替换1个，arr2=[1,99,20,4,5]

6.4 查找操作

const arr = [1, 2, 3, 2, 5];

arr.indexOf(2)          // 1，返回第一个匹配的索引，找不到返回-1
arr.lastIndexOf(2)      // 3，从后往前找
arr.includes(3)         // true，是否包含某元素

// find / findIndex：根据条件查找
const users = [
  { id: 1, name: '张三' },
  { id: 2, name: '李四' },
];
users.find(u => u.id === 2)       // { id: 2, name: '李四' }
users.findIndex(u => u.id === 2)  // 1

// findLast / findLastIndex（ES2023）：从末尾开始查找
arr.findLast(n => n < 4)          // 3
arr.findLastIndex(n => n < 4)     // 3

6.5 遍历操作

const arr = [1, 2, 3, 4, 5];

// forEach：遍历，无返回值
arr.forEach((item, index) => {
  console.log(index, item);
});

// map：映射，返回新数组
const doubled = arr.map(n => n * 2);      // [2, 4, 6, 8, 10]

// filter：过滤，返回满足条件的新数组
const evens = arr.filter(n => n % 2 === 0); // [2, 4]

// reduce：归并，将数组归结为单个值
const sum = arr.reduce((acc, n) => acc + n, 0);  // 15

// reduceRight：从右往左归并
const str = ['a', 'b', 'c'].reduceRight((acc, s) => acc + s, ''); // 'cba'

// every：是否所有元素都满足条件
arr.every(n => n > 0)   // true

// some：是否至少有一个元素满足条件
arr.some(n => n > 4)    // true

// flat：展平嵌套数组
[1, [2, [3, [4]]]].flat()     // [1, 2, [3, [4]]]，默认展开一层
[1, [2, [3, [4]]]].flat(Infinity)  // [1, 2, 3, 4]，完全展开

// flatMap：map后展开一层
[[1, 2], [3, 4]].flatMap(x => x)   // [1, 2, 3, 4]

6.6 排序与变换

const arr = [3, 1, 4, 1, 5, 9, 2, 6];

// sort：排序（默认按字符串Unicode排序，数字需要提供比较函数）
arr.sort((a, b) => a - b);   // 升序 [1, 1, 2, 3, 4, 5, 6, 9]
arr.sort((a, b) => b - a);   // 降序 [9, 6, 5, 4, 3, 2, 1, 1]

// reverse：反转（修改原数组）
[1, 2, 3].reverse();         // [3, 2, 1]

// slice：截取（不修改原数组）
const arr2 = [1, 2, 3, 4, 5];
arr2.slice(1, 3)    // [2, 3]，从索引1到3（不含3）
arr2.slice(-2)      // [4, 5]，最后两个元素
arr2.slice()        // [1, 2, 3, 4, 5]，浅拷贝整个数组

// concat：合并数组（不修改原数组）
[1, 2].concat([3, 4], [5, 6])  // [1, 2, 3, 4, 5, 6]

// join：数组转字符串
[1, 2, 3].join('-')   // '1-2-3'
[1, 2, 3].join('')    // '123'

// fill：填充
new Array(5).fill(0)              // [0, 0, 0, 0, 0]
[1, 2, 3, 4, 5].fill(0, 2, 4)   // [1, 2, 0, 0, 5]

6.7 数组解构

// 基本解构
const [a, b, c] = [1, 2, 3];
console.log(a, b, c);  // 1 2 3

// 跳过元素
const [first, , third] = [1, 2, 3];

// 默认值
const [x = 10, y = 20] = [5];
console.log(x, y);  // 5 20

// 剩余元素
const [head, ...tail] = [1, 2, 3, 4];
console.log(head, tail);  // 1 [2, 3, 4]

// 交换变量
let m = 1, n = 2;
[m, n] = [n, m];
console.log(m, n);  // 2 1

7. 对象

7.1 对象创建

// 字面量方式（推荐）
const user = {
  name: '张三',
  age: 18,
  greet() {
    return 'Hello, ' + this.name;
  }
};

// 构造函数方式
function User(name, age) {
  this.name = name;
  this.age = age;
}
const user2 = new User('李四', 20);

// Object.create：指定原型创建对象
const proto = { greet() { return 'Hello'; } };
const obj = Object.create(proto);

7.2 属性操作

const obj = { name: '张三', age: 18 };

// 读取属性
obj.name          // '张三'，点语法
obj['name']       // '张三'，方括号语法（适用于动态属性名）

const key = 'age';
obj[key]          // 18，动态属性名

// 添加/修改属性
obj.email = 'test@example.com';
obj['phone'] = '123456';

// 删除属性
delete obj.phone;

// 检测属性是否存在
'name' in obj                        // true，包含原型链
obj.hasOwnProperty('name')           // true，仅自身属性
Object.hasOwn(obj, 'name')           // true，ES2022推荐写法

// 属性简写（ES6）
const name = '张三';
const age = 18;
const user = { name, age };          // 等同于 { name: name, age: age }

// 计算属性名（ES6）
const prefix = 'user';
const config = {
  [prefix + 'Name']: '张三',         // userName: '张三'
  [`${prefix}Age`]: 18               // userAge: 18
};

7.3 对象遍历

const obj = { a: 1, b: 2, c: 3 };

// for...in：遍历所有可枚举属性（包含原型链，慎用）
for (let key in obj) {
  if (obj.hasOwnProperty(key)) {     // 过滤原型链属性
    console.log(key, obj[key]);
  }
}

// Object.keys：返回自身可枚举属性的键名数组
Object.keys(obj)      // ['a', 'b', 'c']

// Object.values：返回自身可枚举属性的值数组
Object.values(obj)    // [1, 2, 3]

// Object.entries：返回键值对数组
Object.entries(obj)   // [['a',1], ['b',2], ['c',3]]

// 配合 forEach 遍历
Object.entries(obj).forEach(([key, value]) => {
  console.log(key, value);
});

7.4 对象操作

// Object.assign：浅拷贝/合并对象
const target = { a: 1 };
const source = { b: 2, c: 3 };
Object.assign(target, source);       // { a:1, b:2, c:3 }，修改target

// 展开运算符合并（推荐）
const merged = { ...target, ...source, d: 4 };

// 浅拷贝
const copy = { ...obj };
const copy2 = Object.assign({}, obj);

// 深拷贝
const deep = JSON.parse(JSON.stringify(obj));   // 简单场景，不支持函数、undefined、循环引用
const deep2 = structuredClone(obj);             // 现代方案（ES2022）

// Object.freeze：冻结对象，不可修改
const frozen = Object.freeze({ x: 1 });
frozen.x = 2;        // 静默失败（严格模式下报错）
frozen.x             // 1

// Object.fromEntries：键值对数组转对象
Object.fromEntries([['a', 1], ['b', 2]]);       // { a: 1, b: 2 }
Object.fromEntries(new Map([['a', 1]]));         // { a: 1 }

7.5 对象解构

const user = { name: '张三', age: 18, city: '北京' };

// 基本解构
const { name, age } = user;

// 重命名
const { name: userName, age: userAge } = user;

// 默认值
const { name, role = 'user' } = user;

// 嵌套解构
const { address: { city, street } } = {
  address: { city: '北京', street: '长安街' }
};

// 剩余属性
const { name: n, ...rest } = user;
console.log(rest);   // { age: 18, city: '北京' }

// 函数参数解构
function display({ name, age = 18 }) {
  console.log(name, age);
}
display({ name: '张三' });

8. 字符串

8.1 字符串基本操作

const str = 'Hello World';

// 长度
str.length          // 11

// 访问字符
str[0]              // 'H'
str.at(-1)          // 'd'，支持负索引

// 大小写
str.toUpperCase()   // 'HELLO WORLD'
str.toLowerCase()   // 'hello world'

// 去除空白
'  hello  '.trim()        // 'hello'
'  hello  '.trimStart()   // 'hello  '
'  hello  '.trimEnd()     // '  hello'

// 填充（ES8）
'5'.padStart(3, '0')      // '005'
'5'.padEnd(3, '0')        // '500'

// 重复
'ab'.repeat(3)            // 'ababab'

8.2 字符串查找

const str = 'Hello World Hello';

str.indexOf('Hello')          // 0，返回第一个匹配的索引
str.lastIndexOf('Hello')      // 12，从后往前找
str.includes('World')         // true
str.startsWith('Hello')       // true
str.startsWith('World', 6)    // true，从索引6开始检测
str.endsWith('Hello')         // true
str.endsWith('World', 11)     // true，只检测前11个字符

8.3 字符串提取与替换

const str = 'Hello World';

// 提取
str.slice(0, 5)       // 'Hello'，支持负索引
str.slice(-5)         // 'World'
str.substring(6, 11)  // 'World'，不支持负索引

// 分割
'a,b,c'.split(',')    // ['a', 'b', 'c']
'abc'.split('')        // ['a', 'b', 'c']
'abc'.split('', 2)    // ['a', 'b']，限制数量

// 替换
str.replace('World', 'JS')      // 'Hello JS'，只替换第一个
str.replaceAll('Hello', 'Hi')   // 'Hi World Hi'，替换所有
str.replace(/Hello/g, 'Hi')     // 'Hi World Hi'，正则全局替换

8.4 模板字符串

const name = '张三';
const age = 18;

// 基本用法
const msg = `我叫${name}，今年${age}岁`;

// 支持表达式
const result = `${age >= 18 ? '成年' : '未成年'}`;

// 多行字符串
const html = `
  <div>
    <p>${name}</p>
  </div>
`;

// 标签模板
function highlight(strings, ...values) {
  return strings.reduce((result, str, i) => {
    return result + str + (values[i] ? `<mark>${values[i]}</mark>` : '');
  }, '');
}
const output = highlight`姓名：${name}，年龄：${age}`;

8.5 正则表达式基础

// 创建正则
const reg1 = /hello/i;           // 字面量，i 表示忽略大小写
const reg2 = new RegExp('hello', 'i');  // 构造函数

// 常用修饰符
// i：忽略大小写
// g：全局匹配
// m：多行匹配
// s：. 匹配换行符

// 常用方法
const str = 'Hello World 123';

/\d+/.test(str)              // true，测试是否匹配
str.match(/\d+/)             // ['123']，返回匹配结果
str.match(/[a-z]+/gi)        // ['Hello', 'World']，全局匹配
str.replace(/\d+/, '***')    // 'Hello World ***'

// 常用元字符
// .  匹配任意字符（除换行符）
// \d 匹配数字 [0-9]
// \w 匹配字母数字下划线 [a-zA-Z0-9_]
// \s 匹配空白字符
// ^  匹配开头
// $  匹配结尾
// *  0个或多个
// +  1个或多个
// ?  0个或1个
// {n,m} n到m个

9. Map 与 Set

9.1 Map

Map 是键值对集合，与普通对象的区别是：键可以是任意类型，且保持插入顺序。

// 创建
const map = new Map();
const map2 = new Map([['a', 1], ['b', 2]]);  // 从数组初始化

// 增删改查
map.set('name', '张三');
map.set(1, 'number key');     // 键可以是数字
map.set(true, 'bool key');    // 键可以是布尔值
map.set({}, 'object key');    // 键可以是对象

map.get('name')               // '张三'
map.has('name')               // true
map.delete('name')            // true
map.size                      // 元素数量
map.clear()                   // 清空

// 遍历
const m = new Map([['a', 1], ['b', 2], ['c', 3]]);
m.forEach((value, key) => console.log(key, value));
for (let [key, value] of m) { console.log(key, value); }
[...m.keys()]       // ['a', 'b', 'c']
[...m.values()]     // [1, 2, 3]
[...m.entries()]    // [['a',1], ['b',2], ['c',3]]

// Map 与 Object 互转
const obj = Object.fromEntries(m);       // Map 转 Object
const map3 = new Map(Object.entries(obj)); // Object 转 Map

9.2 Set

Set 是值的集合，所有值都是唯一的，不允许重复。

// 创建
const set = new Set();
const set2 = new Set([1, 2, 3, 2, 1]);  // 自动去重，set2 = {1, 2, 3}

// 增删查
set.add(1);
set.add(2);
set.add(1);    // 重复添加无效

set.has(1)     // true
set.delete(1)  // true
set.size       // 元素数量
set.clear()    // 清空

// 遍历
const s = new Set([1, 2, 3]);
s.forEach(value => console.log(value));
for (let value of s) { console.log(value); }
[...s]         // [1, 2, 3]，转为数组

// 数组去重（最常用场景）
const arr = [1, 2, 3, 2, 1, 3];
const unique = [...new Set(arr)];    // [1, 2, 3]

// 集合运算
const a = new Set([1, 2, 3, 4]);
const b = new Set([3, 4, 5, 6]);

// 并集
const union = new Set([...a, ...b]);               // {1,2,3,4,5,6}

// 交集
const intersection = new Set([...a].filter(x => b.has(x)));  // {3,4}

// 差集（a中有，b中没有）
const difference = new Set([...a].filter(x => !b.has(x)));   // {1,2}

9.3 WeakMap 与 WeakSet

// WeakMap：键必须是对象，不阻止垃圾回收
const wm = new WeakMap();
let obj = {};
wm.set(obj, '一些数据');
obj = null;  // obj 可以被垃圾回收，wm 中对应的条目也会消失

// 常见用途：存储私有数据、DOM节点关联数据
const privateData = new WeakMap();
class User {
  constructor(name) {
    privateData.set(this, { name });
  }
  getName() {
    return privateData.get(this).name;
  }
}

// WeakSet：值必须是对象，不阻止垃圾回收
const ws = new WeakSet();
let element = document.querySelector('div');
ws.add(element);
ws.has(element);  // true

10. 面向对象与原型

10.1 原型链

// 每个对象都有原型（__proto__），原型也是对象，形成原型链
const arr = [1, 2, 3];

// arr 的原型链：arr -> Array.prototype -> Object.prototype -> null
arr.__proto__ === Array.prototype           // true
Array.prototype.__proto__ === Object.prototype  // true
Object.prototype.__proto__ === null             // true

// 属性查找沿原型链向上
arr.push    // 在 Array.prototype 上找到
arr.toString  // 在 Object.prototype 上找到

10.2 构造函数

function Person(name, age) {
  this.name = name;
  this.age = age;
}

// 方法定义在原型上，所有实例共享，节省内存
Person.prototype.greet = function() {
  return `我叫${this.name}，今年${this.age}岁`;
};

// 静态方法
Person.create = function(name, age) {
  return new Person(name, age);
};

const p1 = new Person('张三', 18);
const p2 = new Person('李四', 20);

p1.greet()                     // '我叫张三，今年18岁'
p1 instanceof Person           // true
p1.constructor === Person      // true

10.3 Class 语法（ES6）

class Person {
  // 私有字段（ES2022）
  #id;

  // 静态属性
  static count = 0;

  constructor(name, age) {
    this.#id = Math.random();
    this.name = name;
    this.age = age;
    Person.count++;
  }

  // 实例方法
  greet() {
    return `我叫${this.name}，今年${this.age}岁`;
  }

  // 静态方法
  static create(name, age) {
    return new Person(name, age);
  }

  // getter
  get info() {
    return `${this.name}(${this.age})`;
  }

  // setter
  set info(val) {
    [this.name, this.age] = val.split(',');
  }
}

const p = new Person('张三', 18);
p.greet()       // '我叫张三，今年18岁'
p.info          // '张三(18)'
Person.count    // 1

10.4 继承

class Animal {
  constructor(name) {
    this.name = name;
  }

  speak() {
    return `${this.name}发出了声音`;
  }

  toString() {
    return `Animal(${this.name})`;
  }
}

class Dog extends Animal {
  constructor(name, breed) {
    super(name);          // 必须先调用super()，才能使用this
    this.breed = breed;
  }

  // 重写父类方法
  speak() {
    return `${this.name}汪汪叫`;
  }

  // 调用父类方法
  describe() {
    return `${super.speak()}，品种是${this.breed}`;
  }
}

const dog = new Dog('小黑', '拉布拉多');
dog.speak()              // '小黑汪汪叫'
dog.describe()           // '小黑发出了声音，品种是拉布拉多'
dog instanceof Dog       // true
dog instanceof Animal    // true

10.5 Mixin 模式

// JavaScript 只支持单继承，Mixin 可以实现类似多继承的效果
const Serializable = (superclass) => class extends superclass {
  serialize() {
    return JSON.stringify(this);
  }
  static deserialize(json) {
    return Object.assign(new this(), JSON.parse(json));
  }
};

const Validatable = (superclass) => class extends superclass {
  validate() {
    return Object.keys(this).every(key => this[key] !== null);
  }
};

class Base {
  constructor(data) {
    Object.assign(this, data);
  }
}

class User extends Serializable(Validatable(Base)) {
  constructor(data) {
    super(data);
  }
}

const user = new User({ name: '张三', age: 18 });
user.validate()     // true
user.serialize()    // '{"name":"张三","age":18}'

11. 异步编程

11.1 同步与异步

// 同步：代码按顺序执行，上一行执行完才执行下一行
console.log('第一行');
console.log('第二行');
console.log('第三行');
// 输出顺序：第一行 -> 第二行 -> 第三行

// 异步：不等待结果，继续执行后续代码
console.log('开始');
setTimeout(() => {
  console.log('异步任务');
}, 1000);
console.log('结束');
// 输出顺序：开始 -> 结束 -> 异步任务

11.2 回调函数

// 最基础的异步处理方式
function fetchData(callback) {
  setTimeout(() => {
    const data = { name: '张三' };
    callback(null, data);       // 约定：第一个参数为错误，第二个为数据
  }, 1000);
}

fetchData((error, data) => {
  if (error) {
    console.error(error);
    return;
  }
  console.log(data);
});

// 回调地狱：多层嵌套导致代码难以维护
fetchUser(id, (err, user) => {
  fetchOrders(user.id, (err, orders) => {
    fetchOrderDetail(orders[0].id, (err, detail) => {
      // 层层嵌套，难以维护
    });
  });
});

11.3 Promise

Promise 是对异步操作的封装，有三种状态：pending（进行中）、fulfilled（已成功）、rejected（已失败）。

// 创建 Promise
const promise = new Promise((resolve, reject) => {
  const success = true;
  if (success) {
    resolve('成功的数据');    // 变为 fulfilled 状态
  } else {
    reject(new Error('失败原因'));  // 变为 rejected 状态
  }
});

// 使用 Promise
promise
  .then(data => {
    console.log(data);        // '成功的数据'
    return '下一步的数据';    // 可以继续链式调用
  })
  .then(data => {
    console.log(data);        // '下一步的数据'
  })
  .catch(error => {
    console.error(error);     // 捕获任意一步的错误
  })
  .finally(() => {
    console.log('无论成败都执行');
  });

// 封装异步操作为 Promise
function delay(ms) {
  return new Promise(resolve => setTimeout(resolve, ms));
}

function fetchUser(id) {
  return new Promise((resolve, reject) => {
    setTimeout(() => {
      if (id > 0) {
        resolve({ id, name: '张三' });
      } else {
        reject(new Error('无效的ID'));
      }
    }, 1000);
  });
}

Promise 静态方法

// Promise.all：所有都成功才成功，有一个失败则失败
Promise.all([
  fetchUser(1),
  fetchUser(2),
  fetchUser(3)
]).then(([user1, user2, user3]) => {
  console.log(user1, user2, user3);
}).catch(error => {
  console.error('有一个请求失败', error);
});

// Promise.allSettled：等待所有完成，无论成功还是失败
Promise.allSettled([
  fetchUser(1),
  fetchUser(-1),
]).then(results => {
  results.forEach(result => {
    if (result.status === 'fulfilled') {
      console.log('成功', result.value);
    } else {
      console.log('失败', result.reason);
    }
  });
});

// Promise.race：谁先完成就用谁的结果
Promise.race([
  fetchUser(1),
  delay(500).then(() => { throw new Error('超时'); })
]).then(user => {
  console.log(user);
}).catch(error => {
  console.error(error);
});

// Promise.any：谁先成功就用谁的结果，全部失败才失败
Promise.any([
  Promise.reject(new Error('失败1')),
  fetchUser(1),
  fetchUser(2)
]).then(user => {
  console.log(user);  // 返回第一个成功的结果
});

11.4 async / await

async/await 是基于 Promise 的语法糖，让异步代码看起来像同步代码。

// async 函数始终返回 Promise
async function fetchUserData(id) {
  try {
    const user = await fetchUser(id);         // 等待 Promise 完成
    const orders = await fetchOrders(user.id); // 串行执行
    return { user, orders };
  } catch (error) {
    console.error('请求失败', error);
    throw error;   // 向上抛出，让调用者处理
  }
}

// 调用
fetchUserData(1).then(data => console.log(data));

// 并行执行（性能更好）
async function fetchAll() {
  // 错误写法：串行，总耗时 = 请求1 + 请求2
  const user1 = await fetchUser(1);
  const user2 = await fetchUser(2);

  // 正确写法：并行，总耗时 = max(请求1, 请求2)
  const [user1, user2] = await Promise.all([
    fetchUser(1),
    fetchUser(2)
  ]);
}

// 顶层 await（ES2022，在模块的顶层使用）
const data = await fetchUser(1);

11.5 事件循环

// JavaScript 是单线程的，通过事件循环处理异步任务
// 任务分为：宏任务（setTimeout、setInterval、I/O）
//           微任务（Promise.then、queueMicrotask、MutationObserver）
// 执行顺序：同步代码 -> 微任务队列 -> 宏任务队列

console.log('1');

setTimeout(() => console.log('2'), 0);   // 宏任务

Promise.resolve()
  .then(() => console.log('3'))           // 微任务
  .then(() => console.log('4'));          // 微任务

console.log('5');

// 输出顺序：1 -> 5 -> 3 -> 4 -> 2

12. DOM 操作

12.1 获取元素

// 通过选择器获取（推荐）
document.querySelector('.box')          // 返回第一个匹配元素
document.querySelectorAll('.item')      // 返回 NodeList（所有匹配）

// 传统方式
document.getElementById('app')
document.getElementsByClassName('box') // 返回 HTMLCollection（实时）
document.getElementsByTagName('div')

// 特殊元素
document.documentElement   // <html>
document.head              // <head>
document.body              // <body>

12.2 元素内容与属性

const el = document.querySelector('.box');

// 内容
el.textContent     // 纯文本内容（安全，推荐）
el.innerHTML       // HTML 内容（注意 XSS 风险）
el.innerText       // 可见文本（受 CSS 影响）

// 属性
el.getAttribute('href')            // 获取属性
el.setAttribute('href', '#')       // 设置属性
el.removeAttribute('disabled')     // 删除属性
el.hasAttribute('disabled')        // 是否有该属性

// data 属性
// <div data-user-id="123">
el.dataset.userId                  // '123'
el.dataset.userId = '456'          // 设置

// class 操作
el.classList.add('active')
el.classList.remove('active')
el.classList.toggle('active')      // 有则删除，无则添加
el.classList.contains('active')    // 是否包含
el.classList.replace('old', 'new') // 替换

12.3 样式操作

const el = document.querySelector('.box');

// 内联样式（直接修改 style 属性）
el.style.color = 'red';
el.style.backgroundColor = '#fff';   // 驼峰命名
el.style.cssText = 'color: red; font-size: 16px;';  // 批量设置

// 获取计算后的样式（只读，包含所有样式）
const styles = getComputedStyle(el);
styles.color          // 'rgb(255, 0, 0)'
styles.fontSize       // '16px'

// CSS 变量
el.style.setProperty('--color', 'red');
getComputedStyle(el).getPropertyValue('--color');

12.4 节点操作

// 创建节点
const div = document.createElement('div');
const text = document.createTextNode('文本节点');
const fragment = document.createDocumentFragment();  // 文档片段，批量插入用

// 插入节点
const parent = document.querySelector('.container');
const child = document.querySelector('.item');

parent.appendChild(div)                    // 末尾追加
parent.prepend(div)                        // 开头插入
parent.insertBefore(div, child)            // 在child之前插入
child.before(div)                          // 在child之前插入（更简洁）
child.after(div)                           // 在child之后插入
parent.replaceChild(div, child)            // 替换子节点
child.replaceWith(div)                     // 替换自身

// 删除节点
parent.removeChild(child)
child.remove()                             // 直接删除自身（推荐）

// 克隆节点
const clone = child.cloneNode(true)        // true 表示深克隆（包含子节点）

// 批量插入（性能优化）
const fragment2 = document.createDocumentFragment();
for (let i = 0; i < 100; i++) {
  const li = document.createElement('li');
  li.textContent = `第${i}项`;
  fragment2.appendChild(li);
}
document.querySelector('ul').appendChild(fragment2);  // 只触发一次重排

12.5 节点关系

const el = document.querySelector('.box');

// 父节点
el.parentNode
el.parentElement

// 子节点
el.childNodes           // 所有子节点（包含文本节点）
el.children             // 元素子节点（不含文本节点）
el.firstChild           // 第一个子节点（含文本节点）
el.firstElementChild    // 第一个元素子节点
el.lastChild
el.lastElementChild

// 兄弟节点
el.previousSibling
el.previousElementSibling
el.nextSibling
el.nextElementSibling

13. 事件

13.1 事件监听

const btn = document.querySelector('button');

// 添加事件监听（推荐）
btn.addEventListener('click', function(event) {
  console.log('点击了', event.target);
});

// 箭头函数（注意 this 指向）
btn.addEventListener('click', (event) => {
  console.log(event.target);
});

// 命名函数（可以移除）
function handleClick(event) {
  console.log('点击');
}
btn.addEventListener('click', handleClick);
btn.removeEventListener('click', handleClick);  // 移除事件

// 只触发一次
btn.addEventListener('click', handleClick, { once: true });

13.2 事件对象

document.querySelector('a').addEventListener('click', (event) => {
  event.preventDefault()          // 阻止默认行为（如链接跳转）
  event.stopPropagation()         // 阻止冒泡
  event.stopImmediatePropagation() // 阻止冒泡且阻止同元素的其他监听器

  event.target        // 触发事件的元素
  event.currentTarget // 绑定事件的元素
  event.type          // 事件类型，如 'click'
  event.timeStamp     // 事件触发时间

  // 鼠标事件
  event.clientX       // 相对于视口的坐标
  event.clientY
  event.pageX         // 相对于页面的坐标
  event.pageY
  event.button        // 0左键 1中键 2右键

  // 键盘事件
  event.key           // 按键名，如 'Enter'、'a'
  event.code          // 物理按键，如 'KeyA'
  event.ctrlKey       // 是否按下 Ctrl
  event.shiftKey      // 是否按下 Shift
  event.altKey        // 是否按下 Alt
});

13.3 事件冒泡与捕获

// 事件流：捕获阶段（从外到内）-> 目标阶段 -> 冒泡阶段（从内到外）
// addEventListener 第三个参数：false（冒泡，默认）/ true（捕获）

document.querySelector('.outer').addEventListener('click', () => {
  console.log('outer 冒泡');       // 后触发
}, false);

document.querySelector('.inner').addEventListener('click', () => {
  console.log('inner 冒泡');       // 先触发
}, false);

// 捕获阶段监听（先于冒泡触发）
document.querySelector('.outer').addEventListener('click', () => {
  console.log('outer 捕获');       // 最先触发
}, true);

13.4 事件委托

// 利用事件冒泡，将事件绑定在父元素上，处理所有子元素的事件
// 优点：减少事件监听器数量，支持动态添加的元素

const ul = document.querySelector('ul');

ul.addEventListener('click', (event) => {
  const li = event.target.closest('li');   // 找到最近的 li 祖先
  if (!li) return;                          // 点击的不是 li

  console.log('点击了', li.textContent);

  // 根据 data 属性区分不同操作
  const action = event.target.dataset.action;
  if (action === 'delete') {
    li.remove();
  } else if (action === 'edit') {
    li.contentEditable = true;
    li.focus();
  }
});

13.5 常用事件类型

// 鼠标事件
element.addEventListener('click', handler);
element.addEventListener('dblclick', handler);
element.addEventListener('mouseenter', handler);  // 不冒泡
element.addEventListener('mouseleave', handler);  // 不冒泡
element.addEventListener('mouseover', handler);   // 会冒泡
element.addEventListener('mouseout', handler);
element.addEventListener('mousemove', handler);
element.addEventListener('contextmenu', handler); // 右键菜单

// 键盘事件
document.addEventListener('keydown', handler);    // 按下
document.addEventListener('keyup', handler);      // 松开

// 表单事件
input.addEventListener('input', handler);         // 值改变时（实时）
input.addEventListener('change', handler);        // 失去焦点且值改变
input.addEventListener('focus', handler);
input.addEventListener('blur', handler);
form.addEventListener('submit', handler);
form.addEventListener('reset', handler);

// 窗口事件
window.addEventListener('load', handler);         // 页面完全加载
window.addEventListener('DOMContentLoaded', handler); // DOM 解析完成
window.addEventListener('resize', handler);       // 窗口大小改变
window.addEventListener('scroll', handler);       // 页面滚动

// 自定义事件
const event = new CustomEvent('myEvent', {
  detail: { name: '张三' },   // 传递自定义数据
  bubbles: true,               // 是否冒泡
});
element.dispatchEvent(event);
element.addEventListener('myEvent', e => console.log(e.detail));

14. 浏览器 API

14.1 存储

// localStorage：持久化存储，关闭浏览器不丢失
localStorage.setItem('key', 'value')
localStorage.getItem('key')             // 'value'
localStorage.removeItem('key')
localStorage.clear()

// 存储对象需要序列化
localStorage.setItem('user', JSON.stringify({ name: '张三' }))
const user = JSON.parse(localStorage.getItem('user'))

// sessionStorage：会话存储，关闭标签页即清除
sessionStorage.setItem('key', 'value')
sessionStorage.getItem('key')

// Cookie（简化版）
document.cookie = 'name=张三; max-age=3600; path=/'

14.2 定时器

// setTimeout：延迟执行一次
const timer = setTimeout(() => {
  console.log('1秒后执行');
}, 1000);

clearTimeout(timer);    // 取消定时器

// setInterval：重复执行
const interval = setInterval(() => {
  console.log('每秒执行');
}, 1000);

clearInterval(interval);  // 停止重复

// requestAnimationFrame：在下一帧执行（用于动画，性能优于setInterval）
function animate() {
  // 执行动画逻辑
  element.style.left = (parseInt(element.style.left) + 1) + 'px';

  if (parseInt(element.style.left) < 300) {
    requestAnimationFrame(animate);  // 继续下一帧
  }
}
requestAnimationFrame(animate);

14.3 网络请求

// fetch API（现代标准）
fetch('https://api.example.com/users')
  .then(response => {
    if (!response.ok) {
      throw new Error(`HTTP错误: ${response.status}`);
    }
    return response.json();
  })
  .then(data => console.log(data))
  .catch(error => console.error(error));

// async/await 写法（推荐）
async function fetchData(url) {
  try {
    const response = await fetch(url, {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
        'Authorization': 'Bearer token123'
      },
      body: JSON.stringify({ name: '张三' })
    });

    if (!response.ok) {
      throw new Error(`HTTP错误: ${response.status}`);
    }

    return await response.json();
  } catch (error) {
    console.error('请求失败', error);
    throw error;
  }
}

// 封装通用请求函数
async function request(url, options = {}) {
  const defaultOptions = {
    headers: { 'Content-Type': 'application/json' },
  };

  const response = await fetch(url, { ...defaultOptions, ...options });

  if (!response.ok) {
    const error = new Error('请求失败');
    error.status = response.status;
    throw error;
  }

  return response.json();
}

// 使用
const users = await request('/api/users');
const newUser = await request('/api/users', {
  method: 'POST',
  body: JSON.stringify({ name: '张三' })
});

14.4 URL 与路由

// URL 解析
const url = new URL('https://example.com/search?q=hello&page=2#result');
url.protocol    // 'https:'
url.hostname    // 'example.com'
url.pathname    // '/search'
url.search      // '?q=hello&page=2'
url.hash        // '#result'

// URLSearchParams：操作查询参数
const params = new URLSearchParams('q=hello&page=2');
params.get('q')           // 'hello'
params.set('page', '3')
params.append('sort', 'asc')
params.delete('q')
params.toString()         // 'page=3&sort=asc'

// History API
window.history.pushState({ page: 2 }, '', '/page/2')   // 添加历史记录
window.history.replaceState({ page: 2 }, '', '/page/2') // 替换当前记录
window.history.back()     // 后退
window.history.forward()  // 前进
window.history.go(-2)     // 后退2步

// popstate 事件（前进/后退时触发）
window.addEventListener('popstate', (event) => {
  console.log('历史状态', event.state);
});

15. 模块化

15.1 ES Module（ESM）

// 导出（named export）
export const PI = 3.14159;
export function add(a, b) { return a + b; }
export class User { /* ... */ }

// 默认导出（每个模块只能有一个）
export default class App { /* ... */ }

// 统一导出
const name = '张三';
const age = 18;
export { name, age };
export { name as userName };   // 重命名导出

// 导入
import App from './App.js';                    // 导入默认导出
import { add, PI } from './utils.js';          // 导入命名导出
import { add as sum } from './utils.js';       // 重命名导入
import * as utils from './utils.js';           // 导入所有
import App, { add, PI } from './module.js';    // 混合导入

// 动态导入（返回 Promise，按需加载）
const module = await import('./heavy-module.js');
module.default();
module.someExport();

// 懒加载示例
button.addEventListener('click', async () => {
  const { Chart } = await import('./chart.js');
  new Chart(data);
});

15.2 模块设计原则

// 单一职责：每个模块只做一件事
// utils/format.js
export function formatDate(date) {
  return new Intl.DateTimeFormat('zh-CN').format(date);
}

export function formatPrice(price) {
  return `¥${price.toFixed(2)}`;
}

// 避免循环依赖
// a.js 导入 b.js，b.js 又导入 a.js，会导致部分导出为 undefined

// 统一出口（barrel 模式）
// utils/index.js
export { formatDate, formatPrice } from './format.js';
export { request } from './request.js';
export { storage } from './storage.js';

// 使用时只需从一处导入
import { formatDate, request } from './utils/index.js';

16. 常用内置对象

16.1 Math

Math.PI           // 3.141592653589793
Math.abs(-5)      // 5，绝对值
Math.ceil(4.1)    // 5，向上取整
Math.floor(4.9)   // 4，向下取整
Math.round(4.5)   // 5，四舍五入
Math.max(1, 2, 3) // 3
Math.min(1, 2, 3) // 1
Math.pow(2, 10)   // 1024，幂运算
Math.sqrt(16)     // 4，平方根
Math.random()     // [0, 1) 的随机数

// 常用公式
// 指定范围的随机整数
Math.floor(Math.random() * (max - min + 1)) + min

// 数组最大值
Math.max(...[1, 2, 3, 4, 5])   // 5

16.2 Date

// 创建日期
const now = new Date();
const date = new Date('2024-01-01');
const date2 = new Date(2024, 0, 1);  // 月份从0开始
const timestamp = Date.now();         // 当前时间戳（毫秒）

// 获取日期信息
now.getFullYear()     // 年
now.getMonth()        // 月（0-11）
now.getDate()         // 日
now.getDay()          // 星期（0-6，0为周日）
now.getHours()        // 时
now.getMinutes()      // 分
now.getSeconds()      // 秒
now.getTime()         // 时间戳

// 格式化（推荐使用 Intl.DateTimeFormat）
const formatter = new Intl.DateTimeFormat('zh-CN', {
  year: 'numeric',
  month: '2-digit',
  day: '2-digit',
  hour: '2-digit',
  minute: '2-digit',
});
formatter.format(now)   // '2024/01/01 12:00'

// 时间差计算
const start = new Date('2024-01-01');
const end = new Date('2024-12-31');
const diffMs = end - start;                          // 毫秒差
const diffDays = Math.floor(diffMs / 86400000);      // 天数差

16.3 JSON

// 序列化：对象转 JSON 字符串
const obj = { name: '张三', age: 18, hobbies: ['读书', '编程'] };
JSON.stringify(obj)
// '{"name":"张三","age":18,"hobbies":["读书","编程"]}'

JSON.stringify(obj, null, 2)          // 格式化输出，缩进2个空格
JSON.stringify(obj, ['name', 'age'])  // 只包含指定字段

// 注意：以下值会被忽略或转换
JSON.stringify({ fn: function(){}, undef: undefined, sym: Symbol() })
// '{}'，函数、undefined、Symbol 会被忽略

// 反序列化：JSON 字符串转对象
JSON.parse('{"name":"张三","age":18}')

// 安全解析
function safeParseJSON(str, fallback = null) {
  try {
    return JSON.parse(str);
  } catch {
    return fallback;
  }
}

17. 代码规范与实践建议

17.1 命名规范

// 变量和函数：小驼峰
let userName = '张三';
function getUserInfo() {}

// 类和构造函数：大驼峰
class UserService {}
function Person() {}

// 常量：全大写下划线分隔
const MAX_RETRY_COUNT = 3;
const API_BASE_URL = 'https://api.example.com';

// 私有属性/方法：下划线前缀（约定）或 # 前缀（ES2022私有字段）
class MyClass {
  #privateField = 0;
  _legacyPrivate = 0;   // 旧约定，仍可从外部访问
}

// 布尔值：is/has/can 前缀
let isLoading = false;
let hasPermission = true;
let canEdit = false;

17.2 常见最佳实践

// 使用严格相等
if (value === null) {}   // 而不是 value == null（除非有意利用类型转换）

// 提前返回，减少嵌套
function process(user) {
  if (!user) return null;          // 提前返回
  if (!user.name) return null;
  return user.name.toUpperCase();  // 主逻辑清晰
}

// 避免魔法数字
const MAX_ITEMS = 10;              // 有意义的常量名
if (items.length > MAX_ITEMS) {}  // 而不是 items.length > 10

// 善用解构
const { name, age } = user;
const [first, ...rest] = arr;

// 使用可选链避免报错
const city = user?.address?.city ?? '未知';

// 函数单一职责
function validateEmail(email) { /* 只负责验证 */ }
function sendEmail(email, content) { /* 只负责发送 */ }

// 避免副作用
// 纯函数：相同输入始终产生相同输出，不修改外部状态
function add(a, b) { return a + b; }  // 纯函数

// 有副作用的函数
let total = 0;
function addToTotal(n) { total += n; }  // 修改了外部状态

17.3 性能注意事项

// 避免在循环中进行 DOM 操作
// 错误写法
for (let i = 0; i < 1000; i++) {
  document.querySelector('.list').innerHTML += `<li>${i}</li>`;
}

// 正确写法：使用文档片段批量操作
const fragment = document.createDocumentFragment();
for (let i = 0; i < 1000; i++) {
  const li = document.createElement('li');
  li.textContent = i;
  fragment.appendChild(li);
}
document.querySelector('.list').appendChild(fragment);

// 防抖（debounce）：连续触发时，只执行最后一次
function debounce(fn, delay) {
  let timer = null;
  return function(...args) {
    clearTimeout(timer);
    timer = setTimeout(() => fn.apply(this, args), delay);
  };
}

// 使用场景：搜索框输入、窗口resize
const handleSearch = debounce((event) => {
  console.log('搜索：', event.target.value);
}, 500);
input.addEventListener('input', handleSearch);

// 节流（throttle）：规定时间内只执行一次
function throttle(fn, interval) {
  let lastTime = 0;
  return function(...args) {
    const now = Date.now();
    if (now - lastTime >= interval) {
      lastTime = now;
      fn.apply(this, args);
    }
  };
}

// 使用场景：页面滚动、鼠标移动
const handleScroll = throttle(() => {
  console.log('滚动位置：', window.scrollY);
}, 100);
window.addEventListener('scroll', handleScroll);

总结

知识体系速查

JavaScript 知识体系
├── 基础概念          → 引入方式、输出调试
├── 变量与类型        → var/let/const、8种数据类型、类型转换
├── 运算符            → 算术/比较/逻辑/可选链/展开
├── 流程控制          → if/switch/for/while/try-catch
├── 函数              → 声明方式、参数、作用域、闭包、this、高阶函数
├── 数组              → 增删查改、遍历方法、解构
├── 对象              → 创建、属性操作、遍历、解构
├── 字符串            → 常用方法、模板字符串、正则基础
├── Map 与 Set        → 用途、API、WeakMap/WeakSet
├── 面向对象          → 原型链、构造函数、Class、继承、Mixin
├── 异步编程          → 回调、Promise、async/await、事件循环
├── DOM 操作          → 获取元素、内容属性、节点操作、节点关系
├── 事件              → 监听、事件对象、冒泡捕获、事件委托
├── 浏览器 API        → 存储、定时器、fetch、URL/History
├── 模块化            → ESM 导入导出、动态导入、设计原则
├── 内置对象          → Math、Date、JSON
└── 最佳实践          → 命名规范、代码风格、防抖节流

常见问题速查

问题解决方案
变量提升导致的 bug使用 let/const 替代 var
this 指向错误箭头函数、bind()、或提前保存 this
深浅拷贝混淆简单场景用 structuredClone()，复杂场景用第三方库
回调地狱改用 Promise 或 async/await
类型判断不准确使用 Object.prototype.toString.call()
异步并行性能差使用 Promise.all() 并行执行
频繁 DOM 操作卡顿使用文档片段批量操作，或虚拟 DOM 框架
事件监听内存泄漏及时 removeEventListener，或使用 once 选项
高频事件性能问题防抖（debounce）或节流（throttle）
访问 null/undefined 属性报错使用可选链运算符（?.）
]]> https://loogeking.github.io/posts/JavaScript%E5%AD%A6%E4%B9%A0%E7%AC%94%E8%AE%B0/ 2026-06-20T13:42:16.000Z JavaScript 学习笔记

1. JavaScript 基础概念

1.1 什么是 JavaScript？

    ]]>
JavaScript学习笔记 2026-06-22T10:20:31.706Z Loogeking 从零搭建 VSCode C++ 算法刷题环境（含 LeetCode 插件 + Git 工作流）

适合人群：准备考研机试、刷 LeetCode、面试算法题的同学
目标：在 VSCode 里一键写题、一键运行、一键提交、一键 push 到 GitHub
系统：Windows（Mac/Linux 同理，仅个别命令不同）

一、环境总览

我们要搭建的环境包含：

  • VSCode（编辑器）
  • MinGW-w64 / g++（C++ 编译器）
  • Code Runner（一键运行）
  • LeetCode 插件（在 VSCode 里刷力扣）
  • Git + GitHub（版本管理 + 题解仓库）
  • 代码片段 Snippets（一键生成题解模板）

完成后，写一道算法题的完整流程是：

打开 LeetCode 插件 → 选题 → 写代码 → 本地运行测试 → 提交力扣 → git push

二、安装 VSCode 与 C++ 编译器

1. 安装 VSCode

官网下载：https://code.visualstudio.com/

2. 安装 C++ 编译器（MinGW-w64）

推荐用 MSYS2 安装，最干净稳定：

  1. 下载 MSYS2：https://www.msys2.org/

  2. 安装后，打开 MSYS2 MINGW64 终端，执行：

    pacman -S mingw-w64-x86_64-gcc

  3. 把以下路径加入系统环境变量 Path：

    C:\msys64\mingw64\bin

  4. 验证安装：

    g++ --version

    能输出版本号即成功，例如：

    g++.exe (x86_64-posix-seh-rev0, Built by MinGW-Builds project) 16.1.0

三、必装 VSCode 插件

插件作者作用
C/C++MicrosoftC++ 语法高亮、智能提示、调试
Code RunnerJun Han一键运行代码
LeetCodeshengchen liu在 VSCode 内刷力扣
Error LensAlexander行内显示错误信息
GitLensGitKraken增强 Git 体验
Material Icon ThemePhilipp Kief美化文件图标（可选）
Chinese (Simplified)Microsoft中文界面（按需）

安装方式：Ctrl + Shift + X 打开扩展商店，搜索名称即可。

四、配置 settings.json

打开命令面板：Ctrl + Shift + P → 输入 Open User Settings (JSON)

粘贴以下配置（请把 leetcode.workspaceFolder 改成自己的仓库路径）：

{
    // ===== Code Runner =====
    "code-runner.runInTerminal": true,
    "code-runner.saveFileBeforeRun": true,
    "code-runner.clearPreviousOutput": true,
    "code-runner.ignoreSelection": true,
    "code-runner.executorMap": {
        "cpp": "cd $dir && g++ -std=c++17 -O2 $fileName -o $fileNameWithoutExt && $dir$fileNameWithoutExt"
    },

    // ===== LeetCode =====
    "leetcode.endpoint": "leetcode-cn",
    "leetcode.defaultLanguage": "cpp",
    "leetcode.workspaceFolder": "D:/code/algorithm-solutions",
    "leetcode.filePath": {
        "default": {
            "folder": "problems/leetcode",
            "filename": "${id}-${kebab-case-name}.${ext}"
        }
    },
    "leetcode.hint.commandShortcut": false,
    "leetcode.hint.configWebviewMarkdown": false,

    // ===== 编辑体验 =====
    "files.autoSave": "afterDelay",
    "editor.fontSize": 15,
    "editor.tabSize": 4,
    "editor.formatOnSave": true,
    "editor.minimap.enabled": false,
    "editor.cursorBlinking": "smooth",
    "editor.smoothScrolling": true,
    "editor.bracketPairColorization.enabled": true,
    "terminal.integrated.fontSize": 14,
    "workbench.iconTheme": "material-icon-theme"
}

关键配置说明

配置作用
runInTerminal在终端运行，支持 cin 输入
saveFileBeforeRun运行前自动保存
executorMap.cpp使用 C++17 编译并开启 O2 优化
leetcode.workspaceFolderLeetCode 插件下载题目时的存放位置
formatOnSave保存时自动格式化代码

五、配置 LeetCode 插件

1. 切换为力扣中国站

Ctrl + Shift + P → 输入：

LeetCode: Switch Endpoint

选择 leetcode.cn。

Ctrl + Shift + P → 输入：

LeetCode: Sign in

选 LeetCode Cookie，然后：

  1. 浏览器登录 https://leetcode.cn
  2. 按 F12 → Application → Cookies → https://leetcode.cn
  3. 复制以下两个字段的 Value：
    • LEETCODE_SESSION
    • csrftoken
  4. 粘贴到 VSCode 提示框中

登录成功后，VSCode 左下角会显示用户名。

3. 设置默认语言为 C++

LeetCode: Switch Default Language → cpp

六、常用 LeetCode 命令

命令作用
LeetCode: Show Problem打开一道题
LeetCode: Test用样例本地测试
LeetCode: Submit提交到力扣
LeetCode: Pick One随机来一题
LeetCode: Sign in / out登录登出

也可以直接在左侧 LeetCode 面板里右键题目，选 Show / Test / Submit。

七、配置代码片段（一键生成题解模板）

Ctrl + Shift + P → 输入 Snippets: Configure Snippets → 选择 cpp.json：

{
    "LeetCode Template": {
        "prefix": "lc",
        "body": [
            "/*",
            " * 难度：${1:简单}",
            " * 分类：${2:数组 / 哈希表}",
            " *",
            " * ────────────────────────────────────────",
            " * 【题目大意】",
            " * ${3:题目描述}",
            " *",
            " * 【解题思路】",
            " * ${4:思路}",
            " *",
            " * 【复杂度】",
            " * 时间复杂度：O(${5:n})",
            " * 空间复杂度：O(${6:1})",
            " *",
            " * 【易错点 / 收获】",
            " * - ${7:易错点}",
            " * ────────────────────────────────────────",
            " */",
            "$0"
        ],
        "description": "LeetCode 题解模板"
    }
}

使用方式：在 .cpp 文件里输入 lc，按 Tab 即可自动生成模板，逐项填写。

八、题解模板示例

下面是按模板写完的一道题，可作为参考：

/*
 * @lc app=leetcode.cn id=9 lang=cpp
 *
 * [9] 回文数
 *
 * 难度：简单
 * 分类：数学 / 双指针
 *
 * ────────────────────────────────────────
 * 【题目大意】
 * 给一个整数 x，判断是否为回文整数。
 *
 * 【解题思路】
 * 1. 负数 / 末位为 0 且非 0 的数：一定不是回文
 * 2. 反转后半部分数字，当 x <= revertedNumber 时停止
 * 3. 偶数位：x == revertedNumber
 *    奇数位：x == revertedNumber / 10
 *
 * 【复杂度】
 * 时间复杂度：O(log10(x))
 * 空间复杂度：O(1)
 *
 * 【易错点 / 收获】
 * - 不要把整个数全反转，可能溢出
 * - 注意末位为 0 的特殊情况
 * ────────────────────────────────────────
 */

// @lc code=start
class Solution {
public:
    bool isPalindrome(int x) {
        if (x < 0 || (x % 10 == 0 && x != 0)) return false;

        int revertedNumber = 0;
        while (x > revertedNumber) {
            revertedNumber = revertedNumber * 10 + x % 10;
            x /= 10;
        }
        return x == revertedNumber || x == revertedNumber / 10;
    }
};
// @lc code=end

九、推荐的仓库目录结构

algorithm-solutions/
├── README.md
├── .gitignore
├── problems/
│   ├── leetcode/           # LeetCode 插件自动下载到这
│   ├── array/
│   ├── string/
│   ├── linked_list/
│   ├── stack_queue/
│   ├── tree/
│   ├── dp/
│   └── binary_search/
├── notes/                  # 知识点笔记、复杂度总结、错题
└── templates/              # 自己整理的算法模板（DFS/BFS/二分等）

.gitignore 推荐内容

# VSCode
.vscode/

# 编译产物
*.exe
*.out
*.o
*.obj
a.out

# 系统
.DS_Store
Thumbs.db

十、Git 工作流（每天刷完题就提交）

第一次配置

git config --global user.name "your-name"
git config --global user.email "your-email@example.com"

日常流程

git add .
git commit -m "solve: leetcode 9 回文数"
git push

推荐的 Commit Message 规范

类型用途示例
solve:新解题solve: leetcode 1 两数之和
fix:修复旧题fix: leetcode 9 修复溢出问题
note:添加笔记note: 二分查找模板整理
docs:修改文档docs: 更新 README

十一、常用 VSCode 快捷键

快捷键作用
Ctrl + ~打开/关闭终端
Ctrl + Alt + N运行当前文件（Code Runner）
Ctrl + S保存
Ctrl + /注释当前行
Alt + ↑ / ↓上下移动整行
Shift + Alt + ↓向下复制当前行
Ctrl + D选中下一个相同的词
Ctrl + Shift + K删除当前行
Ctrl + P快速查找文件
Ctrl + Shift + P命令面板（万能）
F12跳转到定义
Alt + ←回到上一个位置

十二、完整刷题工作流

  1. 打开 VSCode → 左侧 LeetCode 图标

  2. 选题 → 右键 Show Problem

  3. 输入 lc → Tab 生成模板，写题目大意 + 思路

  4. 写代码（// @lc code=start 和 // @lc code=end 之间）

  5. 本地跑：Ctrl + Alt + N 或 LeetCode: Test

  6. 提交：LeetCode: Submit

  7. 通过后补全 “易错点 / 收获”

  8. 提交到 GitHub：

    git add .
    git commit -m "solve: leetcode 题号 题名"
    git push

十三、写在最后

很多人刷题没坚持下来，根本原因不是不会做题，而是：

  • 环境太麻烦，每次写题前先折腾半天
  • 没有记录，做完就忘
  • 没有产出，看不到自己的进步

而这一套环境帮你解决了三件事：

  • 写题流畅：一键运行、一键提交
  • 沉淀记录：每道题都有思路、复杂度、易错点
  • 持续可见：GitHub 上的每日提交就是你最好的简历

配置只是开始，每天能写下去才是真正的关键。

祝你我刷题愉快，早日上岸

]]> https://loogeking.github.io/posts/vscode%E9%85%8D%E7%BD%AEC-%E5%88%B7%E9%A2%98%E7%8E%AF%E5%A2%83/ 2026-06-20T13:34:49.000Z 从零搭建 VSCode C++ 算法刷题环境（含 LeetCode 插件 + Git 工作流）

适合人群：准备考研机试、刷 LeetCode、面试算法题的同学
目标：在 VSCode 里一键写题、一键运行、一键提交、一键]]>

vscode配置C++刷题环境 2026-06-22T10:20:31.707Z Loogeking 四六级怎么才能过？备考策略全攻略

本文总结自刘晓燕老师的四六级焚决视频，适合考前冲刺阶段阅读。
视频链接：25四六级考前冲刺-焚诀

写在前面

四六级说难不难，说简单也不简单。

很多人挂科不是因为英语太差，而是不知道怎么分配时间，不知道先做哪题、放弃哪题，结果把时间全押在低性价比的题上，高分题反而没时间做。

四六级本质上是一场时间管理考试，你需要的不只是英语能力，还要有清晰的应试策略。

本文会从写作、听力、阅读、翻译四个模块，给你一套可以直接用的备考思路。

核心原则

在进入各模块之前，先记住这五条总原则：

  1. 先做高性价比题型，后做低性价比题型
  2. 先拿看得见的分，不在难题上死磕
  3. 写作和翻译，以"表达清楚"为第一目标
  4. 听力和阅读，以"定位关键词"为核心方法
  5. 时间不够时，及时止损，果断蒙题

一、写作（建议用时 25min）

官方给写作的时间是 30min，但建议你控制在 25min 以内，挤出来的 5min 用于听力预读，后面会讲为什么。

文章结构

写作不需要多花哨，三段式搞定：

段落内容
首段一句话概括背景 + 一句话表明观点
中间段多举例子，支撑你的观点
尾段总结观点 + 提出措施/展望

结构清晰，阅卷老师一眼就知道你在说什么，印象分自然不会低。

写作两大重点

1. 把长难句拆成简单句

很多同学写作分低，不是因为词汇量不够，而是硬写长句，结果语法错误一堆，反而拉低分数。

与其写一个错误的长句，不如写两个正确的短句。

示例：

  • 难句写法（容易出错）：The importance of environmental protection, which has been widely discussed in recent years, cannot be ignored.
  • 简单句写法（稳妥得分）：Environmental protection is very important. Many people have discussed this topic in recent years.

意思一样，后者出错概率更低，得分反而更稳。

2. 多用逻辑连接词

连接词能让文章看起来有逻辑、有层次，是提分的捷径。

关系常用连接词
平行and, not only…but also…, similarly, likewise, at the same time
转折but, however, nevertheless, on the contrary, by contrast, whereas
选择or, alternatively, whether…or…
因果so, therefore, thus, consequently, as a result
递进besides, furthermore, moreover, additionally, in addition

关于模板的问题

网上流传很多四六级万能模板，比如：

“Nowadays, with the rapid development of society, more and more people are paying attention to…”

这类模板千万别直接背。

原因很简单：阅卷老师一天要看几千份卷子，这种开头他闭着眼睛都能背出来，不但不加分，可能还会让他产生审美疲劳，影响对你整篇文章的评价。

但这不意味着什么都不准备。正确的做法是：

不背整篇模板，但要提前准备结构框架、常用句型和高频过渡表达。

比如"如何引出问题"、“如何举例”、“如何总结”，这些可以提前想好表达方式，考场上直接套用，既不雷同，又节省思考时间。

二、听力（建议用时 30min）

听力差的同学，问题往往不是"听不懂"，而是"没带着问题听"。

核心策略：一定要预读！

这也是为什么写作要从 30min 压缩到 25min —— 省出来的 5min 就是用来预读听力题目的。

预读的时候，重点圈出：

  • 专有名词（人名、地名、机构名）
  • 数字、时间、比例
  • 关键名词（题目的核心词）

带着这些关键词去听，你的定位会准确很多，不容易被干扰项带偏。

听力答题技巧

1. 优先选与原文表达一致的选项

四六级听力很多题目，答案就藏在原文里，原词复现。
听到什么，优先考虑选什么。

2. 注意转折和因果

但原词复现不是万能的。
四六级听力经常在转折后出答案，比如：

“He thought the plan was great, but he finally decided to give it up.”

这道题如果问"他对这个计划的态度是什么"，答案是放弃，而不是"觉得很好"。

所以听的时候，对 but、however、although、yet 这类转折词要高度警觉，转折后的内容往往才是答案。

3. 注意同义替换

选项里的表达不一定和原文一模一样，命题人会故意换一种说法。
比如原文说 “The store is not open”，选项可能写成 “The store is closed”。
要养成"听意思"而不是"听原词"的习惯。

三、阅读（建议用时 35min + 剩余时间）

阅读分三个题型，做题顺序很重要：

传统阅读 → 长篇阅读 → 选词填空

传统阅读（建议用时 20min）

分值高，性价比最高，优先做。

做题步骤：

第一步：快速把握文章结构

读首段、各段首句、尾段首尾句，大概知道文章在讲什么。

第二步：先看题干，带关键词回文定位

不要通篇读完再做题，那样时间完全不够。
先看题目，找到题干里的关键词（专有名词、数字、时间优先），再回到原文定位。

第三步：找到答案句及其上下句，和选项匹配

把答案句和前后各一句一起看，这样能避免断章取义。
实在看不懂，就看哪个选项和原文重复的词最多。

长篇阅读（建议用时 15min）

长篇阅读难度大、耗时长，尽力就好，不必追求全对。

定位优先级（从高到低）：

  1. 标题关键词（但标题词全篇都有，只能用来排除，不能直接定位）
  2. 专有名词（时间、地点、人名、数字）
  3. 普通名词（能在原文中直接找到的具体词）
  4. 极端词（比较级、最高级，比如 “the most”、“better than”）

⚠️ 不要用形容词和副词定位，这两类词最容易被同义替换，容易被坑。

选词填空（剩余时间完成）

0.5 分一个，性价比最低，放到最后做。

如果前面题目做顺了还有时间，就认真做；
如果时间已经不多，快速浏览语境，凭语感选，或者直接蒙，不要在这里死磕。

四、翻译（建议用时 25min）

翻译是很多人最头疼的部分，遇到不会的词就卡住。
其实翻译有三个实用技巧，可以帮你绕过大多数难题：

技巧一：上位词替换

不会某个词，就用它的"上级概念"代替。

原词替换词
教授老师（teacher）
地铁交通工具（transportation）
春节节日（festival）

意思不会差太多，但至少不会空着。

技巧二：用会的词解释不会的词

遇到专有名词或文化词，直接用描述性的方式翻译。

示例：

  • 京杭大运河 → A famous canal connecting Beijing and Hangzhou
  • 豆腐 → A traditional Chinese food made from soybeans

这种方法很实用，阅卷老师能看懂意思，照样给分。

技巧三：大词写好，小词不纠结

翻译时，核心词（大词）写准确，修饰词（小词）写不出来也影响不大。

示例：

他是一位敬业的教授。

  • "敬业"是大词，要想办法表达：dedicated、hardworking、devoted to his work
  • "教授"如果实在不确定，写 teacher 或者 person 也可以

不要为了小词卡住，把整句话的逻辑主干忘了写。

翻译底层逻辑

先搭主谓宾主干，再补定状时地等修饰成分。

很多同学翻译分低，不是词汇量问题，而是句子没有主语、谓语，或者时态乱用。
只要主干清晰、时态基本正确，词汇不够精准也不会扣太多分。

总结

模块建议用时核心策略
写作25min三段式结构，简单句 + 连接词，不背万能模板
听力30min提前预读，圈专有名词，注意转折和同义替换
传统阅读20min先看题干，带关键词定位，从高性价比开始做
长篇阅读15min专有名词优先定位，不追求全对
选词填空剩余时间最后做，实在没时间直接蒙
翻译25min上位词替换，解释不会的词，先搭主干

四六级没有捷径，但有方法。
用对策略，把时间花在刀刃上，过线不是难事。

祝你考试顺利。

]]> https://loogeking.github.io/posts/%E5%9B%9B%E5%85%AD%E7%BA%A7%E8%8B%B1%E8%AF%AD%E6%8A%80%E5%B7%A7/ 2026-06-20T13:27:55.000Z 四六级怎么才能过？备考策略全攻略

本文总结自刘晓燕老师的四六级焚决视频，适合考前冲刺阶段阅读。
视频链接：25四]]>

四六级英语技巧 2026-06-22T10:20:31.707Z Loogeking Python 学习笔记

一、Python 简介

1.1 什么是 Python？

Python 是一种高级、通用、解释型的编程语言，由 Guido van Rossum 于 1991 年创建。它以简洁、易读的语法著称，是目前全球最流行的编程语言之一。

1.2 Python 的特点

  • 语法简洁：接近自然语言，代码可读性极高
  • 跨平台：支持 Windows、macOS、Linux 等操作系统
  • 解释型语言：无需编译，逐行解释执行
  • 动态类型：变量类型在运行时确定，无需显式声明
  • 丰富的生态：拥有庞大的标准库和第三方库

1.3 主要应用领域

领域代表框架/库
Web 开发Django、Flask、FastAPI
数据科学NumPy、Pandas、Matplotlib
机器学习TensorFlow、PyTorch、scikit-learn
自动化脚本os、shutil、subprocess
网络爬虫Requests、BeautifulSoup、Scrapy
嵌入式系统MicroPython

1.4 Python 2 与 Python 3

Python 2 已于 2020 年正式停止维护，当前所有新项目均应使用 Python 3。两者在语法上存在不兼容之处，本笔记所有内容均基于 Python 3.10+。

二、环境配置

2.1 安装 Python

Windows

  1. 访问 https://www.python.org/downloads/ 下载安装包
  2. 安装时勾选 Add Python to PATH（必须勾选，否则命令行无法识别 python 命令）
  3. 验证安装：
python --version

macOS

# 使用 Homebrew 安装（推荐）
brew install python3

# 验证安装
python3 --version

Linux（Ubuntu/Debian）

sudo apt update
sudo apt install python3 python3-pip

2.2 虚拟环境

虚拟环境是 Python 项目的隔离空间，用于避免不同项目之间的依赖冲突。每个项目都应该使用独立的虚拟环境。

# 创建虚拟环境
python -m venv myenv

# 激活虚拟环境
# Windows
myenv\Scripts\activate

# macOS / Linux
source myenv/bin/activate

# 退出虚拟环境
deactivate

激活后，命令行提示符前会出现 (myenv) 字样，表示当前处于虚拟环境中。此时安装的所有包只作用于该环境，不影响系统全局。

2.3 包管理（pip）

# 安装包
pip install requests

# 安装指定版本
pip install requests==2.28.0

# 升级包
pip install --upgrade requests

# 卸载包
pip uninstall requests

# 查看已安装的所有包
pip list

# 导出当前环境的依赖列表
pip freeze > requirements.txt

# 根据依赖列表安装（用于复现他人环境）
pip install -r requirements.txt

requirements.txt 是协作开发中共享依赖信息的标准方式，提交项目时应一并上传。

三、基础语法

3.1 注释

# 这是单行注释

"""
这是多行注释（文档字符串）
通常用于函数、类、模块的说明文档
"""

'''
也可以用单引号的三引号
'''

3.2 代码结构规范

Python 使用缩进来表示代码块，而不是花括号。缩进不正确会直接导致程序报错。

# 正确：使用4个空格缩进（PEP8 标准）
if True:
    print("正确")

# 错误：缩进不一致
if True:
    print("这行是4空格")
      print("这行是6空格")  # IndentationError

3.3 导入模块

# 导入整个模块
import os
import math

# 导入模块中的指定内容
from datetime import datetime
from os.path import join, exists

# 导入并重命名（常用于名称较长的库）
import numpy as np
import pandas as pd

# 主程序入口（重要）
if __name__ == '__main__':
    main()

if __name__ == '__main__' 的作用：当该文件被直接运行时执行其中的代码，当被其他文件导入时不执行。这是 Python 模块化开发的基本规范。

3.4 变量与命名规范

# 变量赋值（无需声明类型）
name = "张三"
age = 18
score = 95.5
is_student = True

# 多重赋值
x = y = z = 0

# 解包赋值
a, b, c = 1, 2, 3

# 命名规范（遵循 PEP8）
user_name = "张三"       # 变量、函数：小写字母 + 下划线（snake_case）
MAX_SIZE = 100           # 常量：全大写 + 下划线
class UserInfo:          # 类名：大驼峰（CamelCase）
    pass

3.5 基本输入输出

# 输出
print("Hello, World!")
print("姓名:", "张三", "年龄:", 18)    # 多个值用空格分隔
print("第一行", end="")               # end 参数控制结尾字符，默认为换行
print("同一行")

# f-string 格式化输出（Python 3.6+，推荐）
name = "张三"
age = 18
print(f"我叫 {name}，今年 {age} 岁")
print(f"π 保留两位小数：{3.14159:.2f}")
print(f"数字补零：{age:05d}")          # 00018

# 输入（返回值始终是字符串）
name = input("请输入你的名字：")
age = int(input("请输入你的年龄："))   # 需要手动转换类型

四、数据类型

4.1 基本数据类型概览

Python 共有以下基本数据类型：

类型关键字示例是否可变
整数int42、-10否
浮点数float3.14、-2.5否
复数complex3+4j否
布尔值boolTrue、False否
字符串str"hello"否
空值NoneTypeNone否

4.2 整数（int）

x = 10
y = -5
large_num = 1_000_000      # 下划线分隔，增强可读性，等同于 1000000

# 不同进制的整数字面量
binary = 0b1010             # 二进制，值为 10
octal = 0o12                # 八进制，值为 10
hexadecimal = 0xFF          # 十六进制，值为 255

# Python 的整数精度没有上限
big = 10 ** 100             # 可以表示任意大的整数

4.3 浮点数（float）

a = 3.14
b = -2.5
c = 2.0
scientific = 1.23e-4        # 科学计数法，等同于 0.000123

# 浮点数精度问题（重要）
print(0.1 + 0.2)            # 0.30000000000000004，不是 0.3
print(0.1 + 0.2 == 0.3)    # False

# 解决方案：使用 round() 或 decimal 模块
print(round(0.1 + 0.2, 1) == 0.3)  # True

from decimal import Decimal
print(Decimal("0.1") + Decimal("0.2"))  # 0.3，精确计算

浮点数精度问题是所有编程语言的通病，根源在于计算机用二进制表示小数时存在精度损失。涉及金融计算时应使用 decimal 模块。

4.4 布尔值（bool）

is_valid = True
is_empty = False

# bool 是 int 的子类，True 等同于 1，False 等同于 0
print(True + True)    # 2
print(True * 5)       # 5

# 假值（以下所有值在布尔上下文中视为 False）
bool(False)           # False
bool(0)               # False
bool(0.0)             # False
bool(None)            # False
bool("")              # False（空字符串）
bool([])              # False（空列表）
bool({})              # False（空字典）
bool(())              # False（空元组）
bool(set())           # False（空集合）

# 其余所有值都为 True
bool(1)               # True
bool(-1)              # True
bool("0")             # True（非空字符串）
bool([0])             # True（非空列表）

4.5 空值（None）

result = None         # 表示"没有值"或"空"

# 常见用途：
# 1. 函数无返回值时默认返回 None
def do_something():
    print("执行")
print(do_something())  # None

# 2. 作为变量的初始值
data = None
if some_condition:
    data = fetch_data()

# 判断是否为 None，必须用 is，不能用 ==
if result is None:
    print("没有结果")
if result is not None:
    print("有结果")

4.6 类型检查与转换

# type()：返回变量的类型
print(type(42))         # <class 'int'>
print(type(3.14))       # <class 'float'>
print(type("hello"))    # <class 'str'>
print(type(True))       # <class 'bool'>
print(type(None))       # <class 'NoneType'>

# isinstance()：检查是否是某个类型（推荐，支持继承）
print(isinstance(42, int))           # True
print(isinstance(True, int))         # True（bool 是 int 的子类）
print(isinstance(3.14, (int, float))) # True（检查多个类型）

# 类型转换
int("123")          # 123
int(3.9)            # 3（直接截断，不是四舍五入）
float("3.14")       # 3.14
str(100)            # "100"
bool(0)             # False
list("abc")         # ['a', 'b', 'c']
tuple([1, 2, 3])    # (1, 2, 3)

# 注意：无法转换的情况会报 ValueError
int("abc")          # ValueError: invalid literal for int()

4.7 可变与不可变类型

这是 Python 中一个非常重要的概念，直接影响函数传参、赋值等行为。

# 不可变类型：int、float、bool、str、tuple
# 对不可变类型的"修改"实际上是创建了新对象
x = 10
print(id(x))    # 假设地址为 140000
x = 20
print(id(x))    # 地址改变了，x 指向了新对象

s = "hello"
# s[0] = "H"   # TypeError，字符串不可原地修改
s = "Hello"     # 实际上是创建了新字符串

# 可变类型：list、dict、set
# 对可变类型的修改在原地进行，对象地址不变
lst = [1, 2, 3]
print(id(lst))  # 假设地址为 200000
lst.append(4)
print(id(lst))  # 地址不变，但内容变了

# 函数传参的影响
def modify(data):
    data.append(99)    # 修改的是原列表

my_list = [1, 2, 3]
modify(my_list)
print(my_list)         # [1, 2, 3, 99]，原列表被修改

def modify_int(num):
    num = 100          # 只是让局部变量 num 指向新对象

my_num = 10
modify_int(my_num)
print(my_num)          # 10，原值不变

五、字符串

5.1 字符串创建

s1 = '单引号'
s2 = "双引号"
s3 = """多行
字符串"""

# 原始字符串：反斜杠不转义，常用于正则表达式和文件路径
path = r"C:\Users\Name\Documents"
pattern = r"\d+\.\d+"

# 字节字符串
b = b"hello"          # bytes 类型，用于处理二进制数据

5.2 字符串索引与切片

text = "Hello, Python!"

# 索引（从 0 开始，支持负索引）
print(text[0])        # 'H'
print(text[-1])       # '!'
print(text[7])        # 'P'

# 切片 [start:end:step]
# start 包含，end 不包含
print(text[0:5])      # 'Hello'
print(text[7:])       # 'Python!'
print(text[:5])       # 'Hello'
print(text[::2])      # 'Hlo yhn'（每隔一个取一个）
print(text[::-1])     # '!nohtyP ,olleH'（反转字符串）

5.3 字符串常用方法

s = "  Hello, World!  "

# 大小写
s.upper()             # "  HELLO, WORLD!  "
s.lower()             # "  hello, world!  "
s.title()             # "  Hello, World!  "（每个单词首字母大写）
s.swapcase()          # "  hELLO, wORLD!  "

# 去除空白
s.strip()             # "Hello, World!"（去除两侧）
s.lstrip()            # "Hello, World!  "（去除左侧）
s.rstrip()            # "  Hello, World!"（去除右侧）

# 查找
s.find("World")       # 返回第一次出现的索引，找不到返回 -1
s.rfind("o")          # 从右往左找，返回索引
s.index("World")      # 与 find 类似，但找不到时抛出 ValueError
s.count("l")          # 统计出现次数

# 判断
"123".isdigit()       # True，是否全为数字
"abc".isalpha()       # True，是否全为字母
"abc123".isalnum()    # True，是否全为字母或数字
"   ".isspace()       # True，是否全为空白
"hello".islower()     # True
"HELLO".isupper()     # True
"Hello".startswith("He")   # True
"Hello".endswith("lo")     # True

# 替换
s.replace("World", "Python")   # 替换所有匹配的子字符串

# 分割与连接
"a,b,c".split(",")    # ['a', 'b', 'c']
"a  b  c".split()     # ['a', 'b', 'c']（无参数时按空白分割）
"-".join(["a", "b", "c"])  # "a-b-c"

# 填充
"5".zfill(4)          # "0005"，用0补全左侧
"hi".center(10, "*")  # "****hi****"
"hi".ljust(10, "-")   # "hi--------"
"hi".rjust(10, "-")   # "--------hi"

5.4 字符串格式化

name = "张三"
age = 18
score = 95.678

# f-string（Python 3.6+，推荐）
print(f"我叫{name}，今年{age}岁")
print(f"成绩：{score:.2f}")           # 保留两位小数：95.68
print(f"年龄补零：{age:05d}")         # 00018
print(f"左对齐：{name:<10}")          # "张三        "
print(f"右对齐：{name:>10}")          # "        张三"
print(f"居中：{name:^10}")            # "    张三    "
print(f"表达式：{age * 2}")           # 支持任意表达式

# format() 方法
print("{}今年{}岁".format(name, age))
print("{name}今年{age}岁".format(name="李四", age=20))

# % 格式化（旧式，了解即可）
print("%s今年%d岁" % (name, age))

5.5 转义字符

print("换行：第一行\n第二行")
print("制表符：姓名\t年龄")
print("反斜杠：C:\\Users\\Name")
print("单引号：I\'m fine")
print("双引号：He said \"Hello\"")

# Unicode 转义
print("\u4e2d\u6587")    # 中文
print("\n".join(["a", "b", "c"]))  # 用换行符连接

六、数字与数学运算

6.1 算术运算符

a, b = 10, 3

print(a + b)    # 13，加法
print(a - b)    # 7，减法
print(a * b)    # 30，乘法
print(a / b)    # 3.3333...，真除法（结果始终是浮点数）
print(a // b)   # 3，整除（向下取整）
print(a % b)    # 1，取余
print(a ** b)   # 1000，幂运算

# 注意整除的行为
print(7 // 2)   # 3
print(-7 // 2)  # -4（向下取整，不是向零取整）
print(7 % -2)   # -1（结果的符号与除数相同）

# divmod：同时返回商和余数
print(divmod(10, 3))   # (3, 1)

6.2 赋值运算符

x = 10
x += 5     # x = 15
x -= 3     # x = 12
x *= 2     # x = 24
x /= 4     # x = 6.0
x //= 2    # x = 3.0
x %= 2     # x = 1.0
x **= 3    # x = 1.0

6.3 比较与逻辑运算符

# 比较运算符（返回布尔值）
print(5 == 5)    # True
print(5 != 3)    # True
print(5 > 3)     # True
print(5 >= 5)    # True

# Python 支持链式比较
x = 5
print(0 < x < 10)     # True，等同于 0 < x and x < 10
print(1 < 2 < 3 < 4)  # True

# 身份比较（比较的是内存地址，不是值）
a = [1, 2, 3]
b = [1, 2, 3]
c = a

print(a == b)    # True（值相等）
print(a is b)    # False（不是同一个对象）
print(a is c)    # True（同一个对象）

# None 的判断必须用 is
result = None
print(result is None)       # True（正确）
print(result == None)       # True（不推荐，可能被重载）

# 逻辑运算符
print(True and False)   # False
print(True or False)    # True
print(not True)         # False

# 短路求值：and 遇到假值停止，or 遇到真值停止
print(0 and 1/0)        # 0，不会执行 1/0
print(1 or 1/0)         # 1，不会执行 1/0

# 利用 or 设置默认值
name = "" or "匿名用户"  # "匿名用户"

6.4 math 模块

import math

# 常量
print(math.pi)          # 3.141592653589793
print(math.e)           # 2.718281828459045
print(math.inf)         # 正无穷大
print(math.nan)         # NaN

# 常用函数
print(abs(-5))          # 5，绝对值（内置函数）
print(round(3.14159, 2)) # 3.14，四舍五入
print(math.sqrt(16))    # 4.0，平方根
print(math.ceil(3.2))   # 4，向上取整
print(math.floor(3.8))  # 3，向下取整
print(math.trunc(-3.8)) # -3，向零取整

# round() 的银行家舍入
print(round(0.5))       # 0（四舍六入五成双）
print(round(1.5))       # 2
print(round(2.5))       # 2

# 幂与对数
print(math.pow(2, 10))  # 1024.0
print(math.log(math.e)) # 1.0，自然对数
print(math.log10(100))  # 2.0，以10为底
print(math.log2(8))     # 3.0，以2为底

# 最大值最小值（内置函数）
print(max(1, 5, 3))     # 5
print(min(1, 5, 3))     # 1
print(sum([1, 2, 3, 4])) # 10

6.5 进制转换

# 十进制转其他进制（返回字符串）
print(bin(10))          # '0b1010'
print(oct(10))          # '0o12'
print(hex(255))         # '0xff'

# 去掉前缀
print(bin(10)[2:])      # '1010'
print(format(10, 'b'))  # '1010'
print(format(255, 'x')) # 'ff'
print(format(255, 'X')) # 'FF'
print(format(255, '08b')) # '11111111'（8位，不足补零）

# 其他进制转十进制
print(int("1010", 2))   # 10
print(int("ff", 16))    # 255
print(int("12", 8))     # 10

七、流程控制

7.1 条件语句

score = 85

# 基本 if...elif...else
if score >= 90:
    grade = "A"
elif score >= 80:
    grade = "B"
elif score >= 70:
    grade = "C"
elif score >= 60:
    grade = "D"
else:
    grade = "F"

print(grade)   # B

# 条件表达式（三元运算符）
age = 20
status = "成年" if age >= 18 else "未成年"

# 嵌套条件
age = 25
has_license = True

if age >= 18:
    if has_license:
        print("可以开车")
    else:
        print("需要先考驾照")
else:
    print("年龄不够")

# match 语句（Python 3.10+，类似 switch）
command = "quit"
match command:
    case "start":
        print("启动")
    case "stop":
        print("停止")
    case "quit" | "exit":  # 多个值用 | 分隔
        print("退出")
    case _:                # 默认分支
        print("未知命令")

7.2 for 循环

# 遍历列表
fruits = ["apple", "banana", "cherry"]
for fruit in fruits:
    print(fruit)

# 遍历字符串
for char in "Python":
    print(char, end=" ")   # P y t h o n

# range() 函数
for i in range(5):          # 0, 1, 2, 3, 4
    print(i)

for i in range(2, 8):       # 2, 3, 4, 5, 6, 7
    print(i)

for i in range(0, 10, 2):   # 0, 2, 4, 6, 8
    print(i)

for i in range(10, 0, -1):  # 10, 9, ..., 1
    print(i)

# enumerate()：同时获取索引和值
for index, value in enumerate(fruits):
    print(f"第{index}个：{value}")

# enumerate 可以指定起始索引
for index, value in enumerate(fruits, start=1):
    print(f"第{index}个：{value}")   # 从1开始

# zip()：并行遍历多个序列
names = ["张三", "李四", "王五"]
scores = [90, 85, 78]
for name, score in zip(names, scores):
    print(f"{name}：{score}分")

# 遍历字典
person = {"name": "张三", "age": 18, "city": "北京"}
for key in person:              # 遍历键
    print(key)
for value in person.values():   # 遍历值
    print(value)
for key, value in person.items():  # 遍历键值对
    print(f"{key}: {value}")

# for...else：循环正常结束时执行 else（没有被 break 打断）
for i in range(5):
    print(i)
else:
    print("循环正常结束")

# 查找质数（for...else 的经典用法）
for num in range(2, 20):
    for i in range(2, int(num**0.5) + 1):
        if num % i == 0:
            break
    else:
        print(f"{num} 是质数")

7.3 while 循环

# 基本 while 循环
count = 0
while count < 5:
    print(count)
    count += 1

# while True + break：用于需要至少执行一次的场景
while True:
    user_input = input("输入 q 退出：")
    if user_input == 'q':
        break
    print(f"你输入了：{user_input}")

# while...else：与 for...else 相同，未被 break 打断时执行 else
count = 0
while count < 5:
    count += 1
else:
    print("while 循环结束")

7.4 循环控制语句

# break：立即终止整个循环
for i in range(10):
    if i == 5:
        break
    print(i)   # 输出 0 1 2 3 4

# continue：跳过本次迭代，继续下一次
for i in range(5):
    if i == 2:
        continue
    print(i)   # 输出 0 1 3 4

# pass：占位符，语法上需要语句但逻辑上不需要时使用
for i in range(5):
    if i == 2:
        pass    # 暂时什么都不做
    else:
        print(i)

# 嵌套循环中跳出外层（Python 没有 goto，可以用标志变量或函数代替）
found = False
for i in range(5):
    for j in range(5):
        if i == 2 and j == 3:
            found = True
            break
    if found:
        break
print(f"找到了 i={i}, j={j}")

7.5 推导式

推导式是 Python 中非常重要的语法特性，可以用简洁的方式创建列表、字典、集合。

# 列表推导式
# 基本格式：[表达式 for 变量 in 可迭代对象 if 条件]
squares = [x**2 for x in range(10)]
print(squares)   # [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

# 带条件过滤
even_squares = [x**2 for x in range(10) if x % 2 == 0]
print(even_squares)   # [0, 4, 16, 36, 64]

# 嵌套推导式（展平二维列表）
matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
flat = [num for row in matrix for num in row]
print(flat)   # [1, 2, 3, 4, 5, 6, 7, 8, 9]

# 字典推导式
squares_dict = {x: x**2 for x in range(5)}
print(squares_dict)   # {0: 0, 1: 1, 2: 4, 3: 9, 4: 16}

# 反转键值对
original = {"a": 1, "b": 2, "c": 3}
reversed_dict = {v: k for k, v in original.items()}
print(reversed_dict)  # {1: "a", 2: "b", 3: "c"}

# 集合推导式
unique_chars = {char.lower() for char in "Hello World" if char != " "}
print(unique_chars)   # {'h', 'e', 'l', 'o', 'w', 'r', 'd'}

# 生成器表达式（不立即生成列表，节省内存）
# 处理大量数据时使用
gen = (x**2 for x in range(1000000))
print(next(gen))      # 0，按需生成，不占用大量内存
print(sum(x**2 for x in range(100)))  # 直接在函数中使用

八、函数

8.1 函数定义与调用

# 基本函数定义
def greet():
    """函数的文档字符串，描述函数的作用"""
    print("Hello, World!")

greet()   # 调用函数

# 带参数的函数
def greet_person(name):
    print(f"Hello, {name}!")

greet_person("张三")

# 带返回值的函数
def add(a, b):
    return a + b

result = add(3, 5)
print(result)   # 8

# 返回多个值（实际上返回的是元组）
def get_min_max(numbers):
    return min(numbers), max(numbers)

minimum, maximum = get_min_max([3, 1, 4, 1, 5, 9])
print(f"最小值：{minimum}，最大值：{maximum}")

# 没有 return 语句的函数默认返回 None
def no_return():
    print("执行了")

print(no_return())   # None

8.2 函数参数

# 位置参数：按顺序传入
def power(base, exponent):
    return base ** exponent

print(power(2, 3))    # 8

# 关键字参数：通过参数名传入，顺序可以不同
print(power(exponent=3, base=2))   # 8

# 默认参数：调用时可以不传该参数
def greet(name, greeting="你好"):
    print(f"{greeting}，{name}！")

greet("张三")              # 你好，张三！
greet("李四", "早上好")    # 早上好，李四！

# 注意：默认参数不能使用可变对象（常见陷阱）
# 错误写法
def append_to(element, to=[]):
    to.append(element)
    return to

print(append_to(1))   # [1]
print(append_to(2))   # [1, 2]，不是 [2]，因为默认列表只创建一次

# 正确写法
def append_to(element, to=None):
    if to is None:
        to = []
    to.append(element)
    return to

# 可变位置参数（*args）：收集多余的位置参数为元组
def sum_all(*args):
    print(type(args))   # <class 'tuple'>
    return sum(args)

print(sum_all(1, 2, 3))         # 6
print(sum_all(1, 2, 3, 4, 5))   # 15

# 可变关键字参数（**kwargs）：收集多余的关键字参数为字典
def print_info(**kwargs):
    print(type(kwargs))   # <class 'dict'>
    for key, value in kwargs.items():
        print(f"{key}: {value}")

print_info(name="张三", age=18, city="北京")

# 参数顺序规则：位置参数 -> *args -> 默认参数 -> **kwargs
def complex_function(a, b, *args, option=True, **kwargs):
    print(f"a={a}, b={b}")
    print(f"args={args}")
    print(f"option={option}")
    print(f"kwargs={kwargs}")

complex_function(1, 2, 3, 4, option=False, x=10, y=20)
# a=1, b=2
# args=(3, 4)
# option=False
# kwargs={'x': 10, 'y': 20}

# 强制关键字参数（* 后面的参数只能以关键字方式传入）
def create_user(name, *, age, city):
    return {"name": name, "age": age, "city": city}

create_user("张三", age=18, city="北京")   # 正确
# create_user("张三", 18, "北京")          # TypeError

8.3 作用域

# LEGB 规则：Python 查找变量的顺序
# Local（局部）-> Enclosing（外层函数）-> Global（全局）-> Built-in（内置）

x = "全局变量"

def outer():
    x = "外层变量"

    def inner():
        x = "局部变量"
        print(x)   # 局部变量

    inner()
    print(x)   # 外层变量

outer()
print(x)   # 全局变量

# global 关键字：在函数内修改全局变量
count = 0

def increment():
    global count
    count += 1

increment()
increment()
print(count)   # 2

# nonlocal 关键字：在内层函数中修改外层函数的变量
def make_counter():
    count = 0

    def increment():
        nonlocal count
        count += 1
        return count

    return increment

counter = make_counter()
print(counter())   # 1
print(counter())   # 2
print(counter())   # 3

8.4 闭包

闭包是指内层函数记住了其定义时所在的外层作用域的变量，即使外层函数已经执行完毕。

def make_multiplier(factor):
    # factor 是外层函数的局部变量
    def multiplier(x):
        return x * factor   # 内层函数记住了 factor
    return multiplier

double = make_multiplier(2)
triple = make_multiplier(3)

print(double(5))   # 10
print(triple(5))   # 15

# double 和 triple 是两个不同的闭包，各自记住了不同的 factor

# 闭包的实际用途：数据封装
def make_counter(start=0):
    count = start

    def increment(step=1):
        nonlocal count
        count += step
        return count

    def reset():
        nonlocal count
        count = start

    def get():
        return count

    return increment, reset, get

inc, reset, get = make_counter(10)
print(inc())      # 11
print(inc(5))     # 16
print(get())      # 16
reset()
print(get())      # 10

# 常见陷阱：循环中的闭包
# 错误示例
funcs = []
for i in range(3):
    funcs.append(lambda: i)

print([f() for f in funcs])   # [2, 2, 2]，所有函数共享同一个 i

# 正确写法：用默认参数捕获当前值
funcs = []
for i in range(3):
    funcs.append(lambda x=i: x)

print([f() for f in funcs])   # [0, 1, 2]

8.5 装饰器

装饰器本质上是一个接受函数作为参数、返回新函数的高阶函数，用于在不修改原函数的前提下扩展其功能。

# 基本装饰器
def timer(func):
    import time
    def wrapper(*args, **kwargs):
        start = time.time()
        result = func(*args, **kwargs)
        elapsed = time.time() - start
        print(f"{func.__name__} 耗时：{elapsed:.4f}秒")
        return result
    return wrapper

@timer
def slow_function():
    import time
    time.sleep(1)

slow_function()   # slow_function 耗时：1.0001秒

# 等同于：
# slow_function = timer(slow_function)

# 保留原函数信息（使用 functools.wraps）
import functools

def timer(func):
    @functools.wraps(func)   # 保留 func 的 __name__、__doc__ 等属性
    def wrapper(*args, **kwargs):
        import time
        start = time.time()
        result = func(*args, **kwargs)
        elapsed = time.time() - start
        print(f"{func.__name__} 耗时：{elapsed:.4f}秒")
        return result
    return wrapper

# 带参数的装饰器
def repeat(n):
    def decorator(func):
        @functools.wraps(func)
        def wrapper(*args, **kwargs):
            for _ in range(n):
                result = func(*args, **kwargs)
            return result
        return wrapper
    return decorator

@repeat(3)
def say_hello():
    print("Hello!")

say_hello()   # 打印3次 Hello!

# 多个装饰器叠加（从下往上应用）
@timer
@repeat(3)
def greet(name):
    print(f"Hello, {name}!")

# 等同于：greet = timer(repeat(3)(greet))

# 类装饰器
class Singleton:
    """单例模式装饰器"""
    def __init__(self, cls):
        self._cls = cls
        self._instance = None

    def __call__(self, *args, **kwargs):
        if self._instance is None:
            self._instance = self._cls(*args, **kwargs)
        return self._instance

@Singleton
class DatabaseConnection:
    def __init__(self):
        print("创建数据库连接")

db1 = DatabaseConnection()   # 创建数据库连接
db2 = DatabaseConnection()   # 不再打印
print(db1 is db2)            # True

8.6 Lambda 函数

# lambda 函数：匿名函数，适合简单的单行逻辑
square = lambda x: x ** 2
print(square(5))   # 25

add = lambda a, b: a + b
print(add(3, 4))   # 7

# 常用于排序的 key 参数
students = [
    {"name": "张三", "score": 85},
    {"name": "李四", "score": 92},
    {"name": "王五", "score": 78},
]

# 按成绩升序
sorted_students = sorted(students, key=lambda s: s["score"])

# 按成绩降序
sorted_students = sorted(students, key=lambda s: s["score"], reverse=True)

# 多键排序（先按成绩降序，成绩相同按名字升序）
sorted_students = sorted(students, key=lambda s: (-s["score"], s["name"]))

# 配合 map()、filter()
numbers = [1, 2, 3, 4, 5]
doubled = list(map(lambda x: x * 2, numbers))        # [2, 4, 6, 8, 10]
evens = list(filter(lambda x: x % 2 == 0, numbers))  # [2, 4]

8.7 生成器

生成器是一种特殊的迭代器，使用 yield 关键字逐个产出值，不会一次性将所有数据加载到内存中。

# 生成器函数
def count_up_to(n):
    count = 1
    while count <= n:
        yield count    # 暂停并产出值，下次调用从这里继续
        count += 1

gen = count_up_to(5)
print(next(gen))   # 1
print(next(gen))   # 2
print(next(gen))   # 3

for num in count_up_to(5):
    print(num)     # 1 2 3 4 5

# 生成器 vs 列表
# 列表：一次性生成所有数据，占用大量内存
all_squares = [x**2 for x in range(1000000)]   # 占用约 8MB 内存

# 生成器：按需产出，几乎不占内存
gen_squares = (x**2 for x in range(1000000))   # 几乎不占内存
print(next(gen_squares))   # 0

# 实际应用：逐行读取大文件
def read_large_file(filepath):
    with open(filepath, "r", encoding="utf-8") as f:
        for line in f:
            yield line.strip()

for line in read_large_file("large_file.txt"):
    process(line)   # 每次只处理一行，内存占用极低

# yield from：委托给另一个可迭代对象
def chain(*iterables):
    for iterable in iterables:
        yield from iterable

for item in chain([1, 2], [3, 4], [5, 6]):
    print(item)   # 1 2 3 4 5 6

九、数据结构

9.1 列表（List）

# 创建列表
empty = []
numbers = [1, 2, 3, 4, 5]
mixed = [1, "hello", 3.14, True, None]
nested = [[1, 2], [3, 4], [5, 6]]

# 通过函数创建
list_from_range = list(range(5))     # [0, 1, 2, 3, 4]
list_from_str = list("hello")        # ['h', 'e', 'l', 'l', 'o']

# 索引与切片
lst = [10, 20, 30, 40, 50]
print(lst[0])        # 10
print(lst[-1])       # 50
print(lst[1:4])      # [20, 30, 40]
print(lst[::-1])     # [50, 40, 30, 20, 10]

# 增删改
lst.append(60)                    # 末尾添加：[10,20,30,40,50,60]
lst.insert(2, 25)                 # 索引2处插入：[10,20,25,30,40,50,60]
lst.extend([70, 80])              # 末尾添加多个元素
lst.remove(25)                    # 删除第一个值为25的元素
popped = lst.pop()                # 删除并返回最后一个元素
popped2 = lst.pop(0)              # 删除并返回索引0的元素
del lst[1:3]                      # 删除切片范围内的元素
lst[0] = 99                       # 修改元素
lst[1:3] = [100, 200]             # 修改切片

# 查找
lst = [3, 1, 4, 1, 5, 9, 2, 6]
print(lst.index(4))               # 2，返回第一个匹配的索引
print(lst.count(1))               # 2，统计出现次数
print(1 in lst)                   # True，是否包含

# 排序
lst.sort()                        # 原地升序排序
lst.sort(reverse=True)            # 原地降序排序
lst.sort(key=lambda x: abs(x))   # 按绝对值排序

new_lst = sorted(lst)             # 返回新列表，不修改原列表
lst.reverse()                     # 原地反转

# 其他
lst.clear()                       # 清空列表
copy = lst.copy()                 # 浅拷贝

# 深拷贝（嵌套列表时使用）
import copy
deep = copy.deepcopy(nested)

9.2 元组（Tuple）

元组与列表的最大区别是不可变，一旦创建就不能修改。

# 创建元组
empty = ()
single = (1,)                # 单元素元组，逗号必须有
numbers = (1, 2, 3, 4, 5)
mixed = (1, "hello", 3.14)

# 不加括号也是元组
t = 1, 2, 3
print(type(t))   # <class 'tuple'>

# 元组不可修改
# numbers[0] = 10   # TypeError

# 元组解包
point = (10, 20)
x, y = point
print(x, y)   # 10 20

# 扩展解包
first, *middle, last = (1, 2, 3, 4, 5)
print(first)    # 1
print(middle)   # [2, 3, 4]
print(last)     # 5

# 交换变量
a, b = 1, 2
a, b = b, a    # 利用元组解包
print(a, b)    # 2 1

# 元组的用途
# 1. 函数返回多个值
def get_info():
    return "张三", 18, "北京"

name, age, city = get_info()

# 2. 作为字典的键（列表不能作为键，因为列表不可哈希）
d = {(0, 0): "原点", (1, 0): "x轴上的点"}

# 3. 保护数据不被修改
WEEKDAYS = ("周一", "周二", "周三", "周四", "周五", "周六", "周日")

9.3 字典（Dictionary）

# 创建字典
empty = {}
person = {"name": "张三", "age": 18, "city": "北京"}
d = dict(name="李四", age=20)

# 访问
print(person["name"])               # "张三"，键不存在时抛出 KeyError
print(person.get("name"))           # "张三"
print(person.get("phone"))          # None，键不存在返回 None
print(person.get("phone", "未知"))  # "未知"，键不存在返回默认值

# 增删改
person["email"] = "test@test.com"   # 添加新键值对
person["age"] = 19                  # 修改值
person.update({"city": "上海", "job": "工程师"})  # 批量更新
del person["email"]                 # 删除键值对
value = person.pop("city")          # 删除并返回值，键不存在时抛出 KeyError
value = person.pop("xx", None)      # 键不存在时返回默认值
key, val = person.popitem()         # 删除并返回最后插入的键值对

# 遍历
for key in person:                  # 遍历键
    print(key)
for value in person.values():       # 遍历值
    print(value)
for key, value in person.items():   # 遍历键值对（最常用）
    print(f"{key}: {value}")

# 常用操作
print("name" in person)             # True，检查键是否存在
print("张三" in person.values())    # True，检查值是否存在
print(len(person))                  # 键值对数量
keys = list(person.keys())          # 转为列表

# setdefault：键不存在时设置默认值并返回，存在时直接返回
person.setdefault("score", 0)

# 合并字典
d1 = {"a": 1, "b": 2}
d2 = {"b": 3, "c": 4}

merged = {**d1, **d2}              # {"a":1, "b":3, "c":4}，d2 覆盖 d1
merged = d1 | d2                   # Python 3.9+，同上

# 字典推导式
squares = {x: x**2 for x in range(5)}
filtered = {k: v for k, v in person.items() if v is not None}

9.4 集合（Set）

# 创建集合（集合中所有元素唯一）
empty = set()                         # 空集合，不能用 {}（那是空字典）
s = {1, 2, 3, 4, 5}
s_from_list = set([1, 2, 2, 3, 3])  # {1, 2, 3}，自动去重

# 增删
s.add(6)                # 添加元素
s.remove(1)             # 删除元素，不存在时抛出 KeyError
s.discard(100)          # 删除元素，不存在时不报错（推荐）
s.pop()                 # 随机删除并返回一个元素
s.clear()               # 清空

# 集合运算
A = {1, 2, 3, 4, 5}
B = {4, 5, 6, 7, 8}

A | B                   # 并集：{1,2,3,4,5,6,7,8}
A.union(B)              # 同上

A & B                   # 交集：{4,5}
A.intersection(B)       # 同上

A - B                   # 差集（A中有，B中没有）：{1,2,3}
A.difference(B)         # 同上

A ^ B                   # 对称差（只在一个集合中出现的元素）：{1,2,3,6,7,8}
A.symmetric_difference(B)  # 同上

# 子集与超集
{1, 2}.issubset({1, 2, 3})     # True，{1,2} 是 {1,2,3} 的子集
{1, 2, 3}.issuperset({1, 2})   # True
{1, 2}.isdisjoint({3, 4})      # True，两个集合没有交集

# 最常用场景：列表去重
lst = [1, 2, 3, 2, 1, 3, 4]
unique = list(set(lst))   # [1, 2, 3, 4]（顺序不保证）

# 检查元素是否存在（比列表快得多，O(1) vs O(n)）
valid_choices = {"yes", "no", "maybe"}
user_input = "yes"
if user_input in valid_choices:
    print("有效输入")

9.5 collections 模块

from collections import defaultdict, Counter, deque, OrderedDict, namedtuple

# defaultdict：访问不存在的键时自动创建默认值
word_count = defaultdict(int)      # 默认值为 0
for word in "hello world hello".split():
    word_count[word] += 1          # 无需先判断键是否存在
print(dict(word_count))            # {'hello': 2, 'world': 1}

grouped = defaultdict(list)
for name, dept in [("张三", "技术"), ("李四", "产品"), ("王五", "技术")]:
    grouped[dept].append(name)
print(dict(grouped))   # {'技术': ['张三', '王五'], '产品': ['李四']}

# Counter：计数器
words = ["apple", "banana", "apple", "orange", "banana", "apple"]
c = Counter(words)
print(c)                    # Counter({'apple': 3, 'banana': 2, 'orange': 1})
print(c.most_common(2))     # [('apple', 3), ('banana', 2)]
print(c["apple"])           # 3
print(c["grape"])           # 0，不存在时返回0而不报错

# 计数器运算
c1 = Counter({"a": 3, "b": 2})
c2 = Counter({"a": 1, "c": 4})
print(c1 + c2)              # Counter({'c': 4, 'a': 4, 'b': 2})
print(c1 - c2)              # Counter({'b': 2, 'a': 2})

# deque：双端队列，头尾操作都是 O(1)
dq = deque([1, 2, 3])
dq.append(4)                # 右端添加
dq.appendleft(0)            # 左端添加
dq.pop()                    # 右端删除
dq.popleft()                # 左端删除
dq.rotate(1)                # 向右旋转1位

# 固定大小的队列（保留最近 N 个）
recent = deque(maxlen=3)
for i in range(5):
    recent.append(i)
print(list(recent))         # [2, 3, 4]

# namedtuple：命名元组（轻量级数据类）
Point = namedtuple("Point", ["x", "y"])
p = Point(10, 20)
print(p.x, p.y)             # 10 20
print(p[0], p[1])           # 10 20（支持索引访问）
x, y = p                    # 支持解包

Person = namedtuple("Person", ["name", "age", "city"])
alice = Person("Alice", 25, "北京")
print(alice._asdict())      # OrderedDict，转为字典
bob = alice._replace(name="Bob")  # 创建修改了部分字段的新实例

十、面向对象编程

10.1 类与对象基础

class Dog:
    # 类属性：所有实例共享
    species = "Canis familiaris"
    count = 0

    # 构造方法：创建实例时自动调用
    def __init__(self, name, age):
        # 实例属性：每个实例独有
        self.name = name
        self.age = age
        Dog.count += 1    # 修改类属性

    # 实例方法：第一个参数必须是 self
    def bark(self):
        return f"{self.name} 汪汪叫！"

    def get_info(self):
        return f"{self.name}，{self.age} 岁"

    # 类方法：第一个参数是类本身（cls）
    @classmethod
    def get_count(cls):
        return f"共有 {cls.count} 只狗"

    # 静态方法：与类和实例都没有关联
    @staticmethod
    def is_adult(age):
        return age >= 2

# 创建实例
dog1 = Dog("小黑", 3)
dog2 = Dog("大白", 1)

# 访问属性和方法
print(dog1.name)           # 小黑
print(dog1.bark())         # 小黑 汪汪叫！
print(Dog.species)         # Canis familiaris
print(dog1.species)        # 实例也可以访问类属性
print(Dog.get_count())     # 共有 2 只狗
print(Dog.is_adult(3))     # True

# 动态添加属性
dog1.color = "黑色"
print(dog1.color)          # 黑色
print(hasattr(dog2, "color"))  # False，dog2 没有这个属性

# 删除属性
del dog1.color

10.2 继承

class Animal:
    def __init__(self, name, sound):
        self.name = name
        self.sound = sound

    def speak(self):
        return f"{self.name} 说 {self.sound}"

    def move(self):
        return f"{self.name} 在移动"

    def __str__(self):
        return f"Animal({self.name})"

class Dog(Animal):
    def __init__(self, name, breed):
        super().__init__(name, "汪汪")   # 调用父类的 __init__
        self.breed = breed

    # 重写父类方法
    def speak(self):
        return f"{self.name}（{self.breed}）大声地叫：{self.sound}！"

    # 新增方法
    def fetch(self):
        return f"{self.name} 去捡球了"

class Cat(Animal):
    def __init__(self, name, is_indoor=True):
        super().__init__(name, "喵喵")
        self.is_indoor = is_indoor

    def speak(self):
        prefix = "家猫" if self.is_indoor else "野猫"
        return f"{prefix} {self.name}：{self.sound}"

dog = Dog("小黑", "拉布拉多")
cat = Cat("小花")

print(dog.speak())     # 小黑（拉布拉多）大声地叫：汪汪！
print(cat.speak())     # 家猫 小花：喵喵
print(dog.move())      # 小黑 在移动（继承自 Animal）

# 类型检查
print(isinstance(dog, Dog))     # True
print(isinstance(dog, Animal))  # True（dog 也是 Animal）
print(issubclass(Dog, Animal))  # True

# 多继承
class Flyable:
    def fly(self):
        return "我会飞"

class Swimmable:
    def swim(self):
        return "我会游泳"

class Duck(Animal, Flyable, Swimmable):
    def __init__(self, name):
        super().__init__(name, "嘎嘎")

duck = Duck("唐老鸭")
print(duck.speak())   # 唐老鸭 说 嘎嘎
print(duck.fly())     # 我会飞
print(duck.swim())    # 我会游泳

# 查看方法解析顺序（MRO）
print(Duck.__mro__)

10.3 封装

class BankAccount:
    def __init__(self, owner, balance=0):
        self.owner = owner
        self._balance = balance      # 单下划线：约定为保护属性，不应从外部访问
        self.__log = []              # 双下划线：名称改写，外部无法直接访问

    def deposit(self, amount):
        if amount <= 0:
            raise ValueError("存款金额必须大于0")
        self._balance += amount
        self.__log.append(f"存入 {amount}")

    def withdraw(self, amount):
        if amount <= 0:
            raise ValueError("取款金额必须大于0")
        if amount > self._balance:
            raise ValueError("余额不足")
        self._balance -= amount
        self.__log.append(f"取出 {amount}")

    def get_balance(self):
        return self._balance

    def get_log(self):
        return self.__log.copy()   # 返回副本，防止外部修改

account = BankAccount("张三", 1000)
account.deposit(500)
account.withdraw(200)
print(account.get_balance())   # 1300
print(account.get_log())       # ['存入 500', '取出 200']

# 双下划线的名称改写
# print(account.__log)         # AttributeError
print(account._BankAccount__log)  # 可以访问，但不应该这么做

10.4 属性（property）

class Person:
    def __init__(self, name, age):
        self._name = name
        self._age = age

    @property
    def name(self):
        """姓名"""
        return self._name

    @name.setter
    def name(self, value):
        if not isinstance(value, str) or not value.strip():
            raise ValueError("姓名必须是非空字符串")
        self._name = value.strip()

    @property
    def age(self):
        """年龄"""
        return self._age

    @age.setter
    def age(self, value):
        if not isinstance(value, int) or not (0 <= value <= 150):
            raise ValueError("年龄必须是0到150之间的整数")
        self._age = value

    @property
    def is_adult(self):
        """是否成年（只读属性，没有 setter）"""
        return self._age >= 18

p = Person("张三", 17)
print(p.name)         # 张三（通过 getter 访问）
p.name = "李四"       # 通过 setter 修改
p.age = 25
print(p.is_adult)     # True

# p.is_adult = True  # AttributeError，没有 setter

10.5 特殊方法（魔法方法）

class Vector:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    # 字符串表示
    def __str__(self):
        """给用户看的字符串，print() 调用"""
        return f"Vector({self.x}, {self.y})"

    def __repr__(self):
        """给开发者看的字符串，调试时使用"""
        return f"Vector(x={self.x}, y={self.y})"

    # 算术运算
    def __add__(self, other):
        return Vector(self.x + other.x, self.y + other.y)

    def __sub__(self, other):
        return Vector(self.x - other.x, self.y - other.y)

    def __mul__(self, scalar):
        return Vector(self.x * scalar, self.y * scalar)

    def __rmul__(self, scalar):
        """支持 scalar * vector 的写法"""
        return self.__mul__(scalar)

    def __neg__(self):
        """取反：-vector"""
        return Vector(-self.x, -self.y)

    # 比较运算
    def __eq__(self, other):
        return self.x == other.x and self.y == other.y

    def __abs__(self):
        """abs() 函数支持"""
        import math
        return math.sqrt(self.x**2 + self.y**2)

    # 容器行为
    def __len__(self):
        return 2

    def __getitem__(self, index):
        if index == 0:
            return self.x
        elif index == 1:
            return self.y
        raise IndexError(f"Vector 索引超出范围：{index}")

    def __iter__(self):
        yield self.x
        yield self.y

    def __contains__(self, item):
        return item in (self.x, self.y)

    # 上下文管理器
    def __enter__(self):
        print("进入上下文")
        return self

    def __exit__(self, exc_type, exc_val, exc_tb):
        print("退出上下文")
        return False   # 不抑制异常

v1 = Vector(3, 4)
v2 = Vector(1, 2)

print(v1)              # Vector(3, 4)
print(v1 + v2)         # Vector(4, 6)
print(v1 * 2)          # Vector(6, 8)
print(2 * v1)          # Vector(6, 8)
print(abs(v1))         # 5.0
print(v1[0])           # 3
print(3 in v1)         # True
print(list(v1))        # [3, 4]

with v1 as v:
    print(v)           # Vector(3, 4)

10.6 抽象基类

from abc import ABC, abstractmethod

class Shape(ABC):
    """抽象基类：不能直接实例化，强制子类实现指定方法"""

    @abstractmethod
    def area(self):
        """计算面积"""
        pass

    @abstractmethod
    def perimeter(self):
        """计算周长"""
        pass

    # 非抽象方法：子类继承，不需要重写
    def describe(self):
        return (f"面积：{self.area():.2f}，"
                f"周长：{self.perimeter():.2f}")

class Rectangle(Shape):
    def __init__(self, width, height):
        self.width = width
        self.height = height

    def area(self):
        return self.width * self.height

    def perimeter(self):
        return 2 * (self.width + self.height)

class Circle(Shape):
    def __init__(self, radius):
        self.radius = radius

    def area(self):
        import math
        return math.pi * self.radius ** 2

    def perimeter(self):
        import math
        return 2 * math.pi * self.radius

# Shape()   # TypeError，不能实例化抽象基类

rect = Rectangle(3, 4)
circle = Circle(5)

print(rect.describe())     # 面积：12.00，周长：14.00
print(circle.describe())   # 面积：78.54，周长：31.42

# 多态：用统一的接口处理不同类型
shapes = [Rectangle(3, 4), Circle(5), Rectangle(6, 2)]
total_area = sum(shape.area() for shape in shapes)
print(f"总面积：{total_area:.2f}")

十一、异常处理

11.1 异常的概念

异常是程序运行时发生的错误。Python 中所有异常都是类，都继承自 BaseException。程序发生异常时，如果没有处理，程序会立即终止并打印错误信息。

# 不处理异常时，程序直接终止
print(1 / 0)   # ZeroDivisionError: division by zero

11.2 基本异常处理

# 基本结构
try:
    # 可能发生异常的代码
    result = 10 / 0
except ZeroDivisionError:
    # 发生指定异常时执行
    print("不能除以零")

# 捕获异常信息
try:
    result = int("abc")
except ValueError as e:
    print(f"发生错误：{e}")
    print(f"错误类型：{type(e).__name__}")

# 捕获多种异常
try:
    num = int(input("输入数字："))
    result = 10 / num
except ValueError:
    print("输入的不是有效数字")
except ZeroDivisionError:
    print("不能除以零")
except Exception as e:
    # Exception 是大多数异常的基类，可以捕获上面没列出的其他异常
    print(f"发生未知错误：{e}")

# 用元组同时捕获多种异常
try:
    pass
except (ValueError, TypeError) as e:
    print(f"值或类型错误：{e}")

# else：没有发生异常时执行
try:
    result = 10 / 2
except ZeroDivisionError:
    print("除零错误")
else:
    print(f"计算成功，结果是：{result}")   # 5.0

# finally：无论是否发生异常都会执行（常用于释放资源）
try:
    f = open("data.txt", "r")
    content = f.read()
except FileNotFoundError:
    print("文件不存在")
finally:
    print("执行完毕")   # 无论是否出错都会打印

11.3 主动抛出异常

# raise：主动抛出异常
def validate_age(age):
    if not isinstance(age, int):
        raise TypeError(f"年龄必须是整数，收到了 {type(age).__name__}")
    if age < 0 or age > 150:
        raise ValueError(f"年龄必须在 0 到 150 之间，收到了 {age}")
    return True

try:
    validate_age(-5)
except ValueError as e:
    print(f"验证失败：{e}")

# raise 不带参数：在 except 块中重新抛出当前异常
try:
    result = int("abc")
except ValueError:
    print("记录日志：发生了 ValueError")
    raise   # 重新抛出，让上层处理

# raise...from：异常链，指明因果关系
try:
    int("abc")
except ValueError as e:
    raise RuntimeError("数据处理失败") from e

11.4 自定义异常

# 自定义异常类，继承自 Exception
class AppError(Exception):
    """应用的基础异常类"""
    pass

class ValidationError(AppError):
    """数据验证异常"""
    def __init__(self, field, message):
        self.field = field
        self.message = message
        super().__init__(f"字段 '{field}' 验证失败：{message}")

class NetworkError(AppError):
    """网络请求异常"""
    def __init__(self, url, status_code):
        self.url = url
        self.status_code = status_code
        super().__init__(f"请求 {url} 失败，状态码：{status_code}")

# 使用自定义异常
def validate_user(data):
    if not data.get("name"):
        raise ValidationError("name", "姓名不能为空")
    if not isinstance(data.get("age"), int):
        raise ValidationError("age", "年龄必须是整数")
    if data["age"] < 0:
        raise ValidationError("age", "年龄不能为负数")

try:
    validate_user({"name": "", "age": 18})
except ValidationError as e:
    print(f"验证错误：{e}")
    print(f"问题字段：{e.field}")
except AppError as e:
    print(f"应用错误：{e}")

11.5 常见内置异常

# TypeError：类型错误
"hello" + 5           # TypeError

# ValueError：值错误（类型正确但值不合法）
int("abc")            # ValueError

# IndexError：索引超出范围
[1, 2, 3][10]         # IndexError

# KeyError：字典键不存在
{"a": 1}["b"]         # KeyError

# AttributeError：属性不存在
"hello".non_exist()   # AttributeError

# NameError：变量未定义
print(undefined_var)  # NameError

# FileNotFoundError：文件不存在
open("no_such_file.txt")  # FileNotFoundError

# ZeroDivisionError：除以零
10 / 0                # ZeroDivisionError

# RecursionError：递归深度超限
def f(): return f()
f()                   # RecursionError

# OverflowError：数值超出范围
import math
math.exp(1000)        # OverflowError

# StopIteration：迭代器耗尽
it = iter([1])
next(it)              # 1
next(it)              # StopIteration

11.6 上下文管理器

# with 语句自动管理资源（文件、锁、连接等）
# 进入 with 块时调用 __enter__，退出时调用 __exit__

# 文件操作（最常见的用法）
with open("example.txt", "w", encoding="utf-8") as f:
    f.write("第一行\n")
    f.write("第二行\n")
# 退出 with 块后文件自动关闭，无论是否发生异常

# 同时管理多个资源
with open("input.txt", "r") as fin, open("output.txt", "w") as fout:
    fout.write(fin.read())

# 自定义上下文管理器（实现 __enter__ 和 __exit__）
class Timer:
    def __init__(self, name):
        self.name = name

    def __enter__(self):
        import time
        self.start = time.time()
        print(f"开始计时：{self.name}")
        return self   # 返回值赋给 as 后的变量

    def __exit__(self, exc_type, exc_val, exc_tb):
        import time
        elapsed = time.time() - self.start
        print(f"结束计时：{self.name}，耗时 {elapsed:.4f} 秒")
        # 返回 True 表示抑制异常，False 表示正常传播异常
        return False

with Timer("数据处理") as t:
    import time
    time.sleep(0.5)

# 用 contextlib 简化自定义上下文管理器
from contextlib import contextmanager

@contextmanager
def timer(name):
    import time
    start = time.time()
    print(f"开始：{name}")
    try:
        yield             # yield 之前是 __enter__，之后是 __exit__
    finally:
        elapsed = time.time() - start
        print(f"结束：{name}，耗时 {elapsed:.4f} 秒")

with timer("任务"):
    import time
    time.sleep(0.5)

十二、文件操作

12.1 文件读写基础

# 文件打开模式
# "r"  读取（默认）
# "w"  写入（覆盖）
# "a"  追加
# "rb" 二进制读取
# "wb" 二进制写入
# "r+" 读写
# "x"  创建（文件已存在则报错）

# 写入文件
with open("example.txt", "w", encoding="utf-8") as f:
    f.write("第一行\n")
    f.write("第二行\n")
    f.writelines(["第三行\n", "第四行\n"])  # 写入多行

# 读取文件
with open("example.txt", "r", encoding="utf-8") as f:
    content = f.read()          # 读取全部内容（字符串）
    print(content)

with open("example.txt", "r", encoding="utf-8") as f:
    first_line = f.readline()   # 读取一行（包含换行符）
    print(first_line)

with open("example.txt", "r", encoding="utf-8") as f:
    lines = f.readlines()       # 读取所有行（列表）
    print(lines)

# 逐行读取（推荐，内存效率最高）
with open("example.txt", "r", encoding="utf-8") as f:
    for line in f:
        print(line.strip())     # strip() 去除换行符

# 追加内容
with open("example.txt", "a", encoding="utf-8") as f:
    f.write("第五行\n")

12.2 文件与路径操作

import os
from pathlib import Path   # 推荐使用 pathlib（Python 3.6+）

# pathlib 的面向对象路径操作
p = Path("data/example.txt")

print(p.name)           # example.txt（文件名）
print(p.stem)           # example（不含扩展名）
print(p.suffix)         # .txt（扩展名）
print(p.parent)         # data（父目录）
print(p.absolute())     # 绝对路径

# 路径拼接（不用字符串拼接，避免跨平台问题）
base = Path("data")
full = base / "subdir" / "file.txt"   # data/subdir/file.txt

# 文件检查
p.exists()              # 是否存在
p.is_file()             # 是否是文件
p.is_dir()              # 是否是目录

# 目录操作
Path("new_dir").mkdir(parents=True, exist_ok=True)   # 创建目录（含父目录）
p.unlink()              # 删除文件
Path("empty_dir").rmdir()  # 删除空目录

# 遍历目录
for item in Path(".").iterdir():
    print(item)

# 查找文件（glob 模式）
for py_file in Path(".").glob("*.py"):      # 当前目录的 .py 文件
    print(py_file)

for py_file in Path(".").rglob("*.py"):     # 递归查找所有 .py 文件
    print(py_file)

# 读写文件（pathlib 提供的简便方法）
p = Path("example.txt")
p.write_text("内容", encoding="utf-8")
content = p.read_text(encoding="utf-8")
p.write_bytes(b"binary data")
data = p.read_bytes()

# 文件重命名和移动
p.rename("new_name.txt")
p.replace("another_dir/file.txt")   # 移动文件

12.3 JSON 文件操作

import json

data = {
    "name": "张三",
    "age": 18,
    "hobbies": ["读书", "编程"],
    "address": {"city": "北京", "district": "海淀"}
}

# 写入 JSON 文件
with open("data.json", "w", encoding="utf-8") as f:
    json.dump(data, f, ensure_ascii=False, indent=2)
    # ensure_ascii=False：允许非 ASCII 字符（如中文）直接写入
    # indent=2：格式化缩进，便于阅读

# 读取 JSON 文件
with open("data.json", "r", encoding="utf-8") as f:
    loaded = json.load(f)

print(loaded["name"])          # 张三
print(loaded["hobbies"])       # ['读书', '编程']

# 字符串与 JSON 互转
json_str = json.dumps(data, ensure_ascii=False)   # dict 转 JSON 字符串
parsed = json.loads(json_str)                      # JSON 字符串转 dict

# 安全读取（防止文件损坏）
def load_json_safe(filepath, default=None):
    try:
        with open(filepath, "r", encoding="utf-8") as f:
            return json.load(f)
    except (FileNotFoundError, json.JSONDecodeError):
        return default

12.4 CSV 文件操作

import csv

# 写入 CSV
students = [
    ["姓名", "年龄", "成绩"],
    ["张三", 18, 90],
    ["李四", 20, 85],
    ["王五", 19, 92],
]

with open("students.csv", "w", encoding="utf-8-sig", newline="") as f:
    # utf-8-sig：解决 Excel 打开 CSV 中文乱码问题
    # newline=""：防止写入多余空行
    writer = csv.writer(f)
    writer.writerows(students)

# 读取 CSV
with open("students.csv", "r", encoding="utf-8-sig") as f:
    reader = csv.reader(f)
    for row in reader:
        print(row)

# 使用 DictReader/DictWriter（以字典形式读写，更直观）
records = [
    {"姓名": "张三", "年龄": 18, "成绩": 90},
    {"姓名": "李四", "年龄": 20, "成绩": 85},
]

with open("students.csv", "w", encoding="utf-8-sig", newline="") as f:
    writer = csv.DictWriter(f, fieldnames=["姓名", "年龄", "成绩"])
    writer.writeheader()     # 写入表头
    writer.writerows(records)

with open("students.csv", "r", encoding="utf-8-sig") as f:
    reader = csv.DictReader(f)
    for row in reader:
        print(row["姓名"], row["成绩"])

十三、标准库

13.1 os 与 sys

import os
import sys

# os：操作系统接口
print(os.name)                    # 操作系统名称（nt/posix）
print(os.getcwd())                # 当前工作目录
os.chdir("/tmp")                  # 切换目录
print(os.listdir("."))            # 列出目录内容
os.makedirs("a/b/c", exist_ok=True)  # 递归创建目录
os.remove("file.txt")            # 删除文件
os.rename("old.txt", "new.txt")  # 重命名

# 环境变量
print(os.environ.get("PATH"))    # 读取环境变量
os.environ["MY_VAR"] = "hello"  # 设置环境变量

# 执行系统命令（不推荐用于复杂场景，推荐使用 subprocess）
os.system("echo hello")

# sys：Python 解释器相关
print(sys.version)               # Python 版本
print(sys.platform)              # 平台（win32/linux/darwin）
print(sys.argv)                  # 命令行参数列表，argv[0] 是脚本名
print(sys.path)                  # 模块搜索路径
sys.exit(0)                      # 退出程序，0 表示正常退出

13.2 datetime

from datetime import datetime, date, time, timedelta

# 获取当前时间
now = datetime.now()             # 本地时间
today = date.today()             # 今天日期

# 创建指定时间
dt = datetime(2024, 1, 15, 10, 30, 0)
d = date(2024, 1, 15)

# 获取时间各部分
print(now.year, now.month, now.day)
print(now.hour, now.minute, now.second)
print(now.weekday())             # 0=周一，6=周日

# 时间差（timedelta）
delta = timedelta(days=7, hours=3)
next_week = now + delta
yesterday = today - timedelta(days=1)

# 计算两个时间之间的差值
start = datetime(2024, 1, 1)
end = datetime(2024, 12, 31)
diff = end - start
print(diff.days)                 # 365

# 格式化输出
print(now.strftime("%Y-%m-%d %H:%M:%S"))   # 2024-01-15 10:30:00
print(now.strftime("%Y年%m月%d日"))         # 2024年01月15日

# 常用格式符
# %Y 四位年份  %m 月份  %d 日期
# %H 24小时   %I 12小时  %M 分钟  %S 秒
# %A 英文星期  %a 缩写星期  %p AM/PM

# 字符串转时间
dt = datetime.strptime("2024-01-15", "%Y-%m-%d")
dt = datetime.strptime("2024/01/15 10:30", "%Y/%m/%d %H:%M")

# 时间戳
timestamp = now.timestamp()          # 转为 Unix 时间戳
dt = datetime.fromtimestamp(timestamp)  # 时间戳转 datetime

13.3 re（正则表达式）

import re

text = "我的邮箱是 alice@example.com，电话是 138-1234-5678"

# 常用函数
# re.match()：从字符串开头匹配
# re.search()：在字符串中搜索第一个匹配
# re.findall()：找到所有匹配，返回列表
# re.finditer()：找到所有匹配，返回迭代器
# re.sub()：替换
# re.split()：分割

# search：找到第一个匹配
match = re.search(r'\w+@\w+\.\w+', text)
if match:
    print(match.group())    # alice@example.com
    print(match.start())    # 匹配的起始位置
    print(match.end())      # 匹配的结束位置

# findall：找到所有匹配
phones = re.findall(r'\d{3}-\d{4}-\d{4}', text)
print(phones)               # ['138-1234-5678']

# sub：替换
new_text = re.sub(r'\d{3}-\d{4}-\d{4}', '***-****-****', text)
print(new_text)

# 分组
pattern = r'(\w+)@(\w+)\.(\w+)'
match = re.search(pattern, text)
if match:
    print(match.group(0))   # 完整匹配：alice@example.com
    print(match.group(1))   # 第一组：alice
    print(match.group(2))   # 第二组：example
    print(match.group(3))   # 第三组：com

# 命名分组
pattern = r'(?P<user>\w+)@(?P<domain>\w+)\.(?P<tld>\w+)'
match = re.search(pattern, text)
if match:
    print(match.group("user"))    # alice
    print(match.group("domain")) # example

# 编译正则（多次使用时提升性能）
email_pattern = re.compile(r'\w+@\w+\.\w+', re.IGNORECASE)
result = email_pattern.findall(text)

# 常用元字符速查
"""
.   匹配任意字符（除换行符）
^   匹配字符串开头
$   匹配字符串结尾
*   0 个或多个
+   1 个或多个
?   0 个或 1 个
{n} 恰好 n 个
{n,m} n 到 m 个
[]  字符集合
[^] 取反字符集合
|   或
()  分组
\d  数字 [0-9]
\D  非数字
\w  字母数字下划线 [a-zA-Z0-9_]
\W  非 \w
\s  空白字符
\S  非空白字符
"""

13.4 itertools 与 functools

import itertools
import functools

# itertools：高效迭代工具

# chain：连接多个可迭代对象
for item in itertools.chain([1, 2], [3, 4], [5, 6]):
    print(item)    # 1 2 3 4 5 6

# product：笛卡尔积
for pair in itertools.product([1, 2], ['a', 'b']):
    print(pair)    # (1,'a') (1,'b') (2,'a') (2,'b')

# combinations：组合
for c in itertools.combinations([1, 2, 3], 2):
    print(c)       # (1,2) (1,3) (2,3)

# permutations：排列
for p in itertools.permutations([1, 2, 3], 2):
    print(p)       # (1,2) (1,3) (2,1) ...

# groupby：分组
data = [("A", 1), ("A", 2), ("B", 3), ("B", 4)]
for key, group in itertools.groupby(data, key=lambda x: x[0]):
    print(key, list(group))

# islice：切片迭代器（不需要加载全部数据）
for item in itertools.islice(range(100), 5, 10):
    print(item)    # 5 6 7 8 9

# functools：高阶函数工具

# reduce：归并
total = functools.reduce(lambda acc, x: acc + x, [1, 2, 3, 4, 5])
print(total)       # 15

# partial：偏函数（固定部分参数）
def power(base, exponent):
    return base ** exponent

square = functools.partial(power, exponent=2)
cube = functools.partial(power, exponent=3)
print(square(5))   # 25
print(cube(3))     # 27

# lru_cache：缓存函数结果（记忆化）
@functools.lru_cache(maxsize=128)
def fibonacci(n):
    if n < 2:
        return n
    return fibonacci(n - 1) + fibonacci(n - 2)

print(fibonacci(50))   # 瞬间返回，没有缓存则会极慢

# cache（Python 3.9+，等同于 lru_cache(maxsize=None)）
@functools.cache
def factorial(n):
    return 1 if n == 0 else n * factorial(n - 1)

十四、模块化与包

14.1 模块

# 一个 .py 文件就是一个模块

# math_utils.py
"""数学工具模块"""

PI = 3.14159

def circle_area(radius):
    """计算圆的面积"""
    return PI * radius ** 2

def circle_perimeter(radius):
    """计算圆的周长"""
    return 2 * PI * radius

# 只有直接运行时才执行
if __name__ == "__main__":
    print(circle_area(5))

# 在其他文件中导入
import math_utils
print(math_utils.circle_area(5))

from math_utils import circle_area, PI
print(circle_area(5))

from math_utils import circle_area as area
print(area(5))

14.2 包

# 包是包含 __init__.py 的目录

# 目录结构：
# my_package/
#   __init__.py
#   utils/
#       __init__.py
#       string_utils.py
#       math_utils.py
#   models/
#       __init__.py
#       user.py

# my_package/__init__.py
from .utils.string_utils import format_name
from .utils.math_utils import circle_area
from .models.user import User

# 使用包
import my_package
my_package.format_name("zhang san")

from my_package.utils import string_utils
string_utils.format_name("zhang san")

from my_package.models.user import User
user = User("张三", 18)

14.3 虚拟环境与项目结构

推荐的项目结构：

my_project/
├── venv/                  # 虚拟环境（不提交到版本控制）
├── src/                   # 源代码
│   └── my_project/
│       ├── __init__.py
│       ├── main.py
│       ├── config.py
│       ├── models/
│       │   ├── __init__.py
│       │   └── user.py
│       └── utils/
│           ├── __init__.py
│           └── helpers.py
├── tests/                 # 测试代码
│   ├── __init__.py
│   └── test_user.py
├── requirements.txt       # 依赖列表
├── README.md              # 项目说明
└── .gitignore             # Git 忽略文件

十五、常用算法实现

15.1 排序算法

# 冒泡排序：O(n²)
def bubble_sort(arr):
    n = len(arr)
    for i in range(n):
        swapped = False
        for j in range(0, n - i - 1):
            if arr[j] > arr[j + 1]:
                arr[j], arr[j + 1] = arr[j + 1], arr[j]
                swapped = True
        if not swapped:
            break   # 如果一轮没有交换，说明已经有序
    return arr

# 插入排序：O(n²)，小数据量或接近有序时效果好
def insertion_sort(arr):
    for i in range(1, len(arr)):
        key = arr[i]
        j = i - 1
        while j >= 0 and arr[j] > key:
            arr[j + 1] = arr[j]
            j -= 1
        arr[j + 1] = key
    return arr

# 快速排序：平均 O(n log n)
def quick_sort(arr):
    if len(arr) <= 1:
        return arr
    pivot = arr[len(arr) // 2]
    left = [x for x in arr if x < pivot]
    middle = [x for x in arr if x == pivot]
    right = [x for x in arr if x > pivot]
    return quick_sort(left) + middle + quick_sort(right)

# 归并排序：O(n log n)，稳定排序
def merge_sort(arr):
    if len(arr) <= 1:
        return arr
    mid = len(arr) // 2
    left = merge_sort(arr[:mid])
    right = merge_sort(arr[mid:])
    return merge(left, right)

def merge(left, right):
    result = []
    i = j = 0
    while i < len(left) and j < len(right):
        if left[i] <= right[j]:
            result.append(left[i])
            i += 1
        else:
            result.append(right[j])
            j += 1
    result.extend(left[i:])
    result.extend(right[j:])
    return result

# Python 内置排序（TimSort，O(n log n)，稳定）
arr = [5, 2, 8, 1, 9]
sorted_arr = sorted(arr)              # 返回新列表
arr.sort()                            # 原地排序
arr.sort(key=lambda x: -x)           # 按相反数排序（降序）
arr.sort(key=abs)                     # 按绝对值排序

15.2 搜索算法

# 线性搜索：O(n)
def linear_search(arr, target):
    for i, item in enumerate(arr):
        if item == target:
            return i
    return -1

# 二分搜索：O(log n)，要求数组已排序
def binary_search(arr, target):
    left, right = 0, len(arr) - 1
    while left <= right:
        mid = (left + right) // 2
        if arr[mid] == target:
            return mid
        elif arr[mid] < target:
            left = mid + 1
        else:
            right = mid - 1
    return -1

# 使用标准库的二分搜索
import bisect

arr = [1, 3, 5, 7, 9, 11]
print(bisect.bisect_left(arr, 7))    # 3，目标值应插入的左侧位置
print(bisect.bisect_right(arr, 7))   # 4，目标值应插入的右侧位置
bisect.insort(arr, 6)                # 插入6并保持有序
print(arr)                           # [1, 3, 5, 6, 7, 9, 11]

15.3 递归

# 递归的两个要素：
# 1. 基本情况（终止条件）
# 2. 递归情况（问题规模缩小）

# 阶乘
def factorial(n):
    if n == 0:          # 基本情况
        return 1
    return n * factorial(n - 1)   # 递归情况

# 斐波那契数列（朴素递归，有大量重复计算）
def fib(n):
    if n < 2:
        return n
    return fib(n - 1) + fib(n - 2)

# 优化：记忆化递归
from functools import lru_cache

@lru_cache(maxsize=None)
def fib(n):
    if n < 2:
        return n
    return fib(n - 1) + fib(n - 2)

# 优化：动态规划（迭代版本，性能更好）
def fib_dp(n):
    if n < 2:
        return n
    a, b = 0, 1
    for _ in range(2, n + 1):
        a, b = b, a + b
    return b

# 二叉树的递归遍历
class TreeNode:
    def __init__(self, val=0, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right

def inorder(root):
    """中序遍历：左-根-右"""
    if root is None:
        return []
    return inorder(root.left) + [root.val] + inorder(root.right)

def preorder(root):
    """前序遍历：根-左-右"""
    if root is None:
        return []
    return [root.val] + preorder(root.left) + preorder(root.right)

十六、代码规范与调试

16.1 PEP8 规范要点

# 缩进：4个空格（不使用Tab）
def good_function():
    if True:
        pass

# 行长度：不超过79个字符
# 过长时使用括号换行
result = (first_value
          + second_value
          + third_value)

# 空行：顶层函数和类之间空2行，方法之间空1行
class MyClass:

    def method_one(self):
        pass

    def method_two(self):
        pass


def top_level_function():
    pass

# 导入顺序：标准库 -> 第三方库 -> 本地模块，每组之间空一行
import os
import sys

import requests
import numpy as np

from my_module import my_function

# 命名
variable_name = 1           # 变量：snake_case
CONSTANT_NAME = 2           # 常量：全大写
def function_name(): pass   # 函数：snake_case
class ClassName: pass       # 类：CamelCase

# 空格
x = 1                       # 赋值两侧各一个空格
y = x + 1                   # 运算符两侧各一个空格
lst[1:2]                    # 切片中冒号两侧不加空格
def f(x, y=1): pass        # 默认参数等号两侧不加空格
f(x=1, y=2)                # 关键字参数等号两侧不加空格

16.2 类型提示

# Python 3.5+ 支持类型提示（不影响运行，用于提升可读性和 IDE 支持）

# 基本类型
def greet(name: str) -> str:
    return f"Hello, {name}"

def add(a: int, b: int) -> int:
    return a + b

def get_ratio(total: int, part: int) -> float:
    return part / total

# 复合类型（Python 3.9+ 可以直接用 list、dict 等）
def process(items: list[int]) -> dict[str, int]:
    return {"sum": sum(items), "count": len(items)}

# Python 3.8 及之前需要从 typing 导入
from typing import List, Dict, Tuple, Optional, Union

def old_style(items: List[int]) -> Dict[str, int]:
    return {"sum": sum(items)}

# Optional：可以是某类型或 None
def find_user(user_id: int) -> Optional[str]:
    if user_id == 1:
        return "张三"
    return None

# Union：可以是多种类型之一
def parse(value: Union[str, int]) -> str:
    return str(value)

# 类的类型提示
class User:
    def __init__(self, name: str, age: int) -> None:
        self.name = name
        self.age = age

    def get_info(self) -> str:
        return f"{self.name}，{self.age}岁"

16.3 调试技巧

# print 调试（最基础）
print(f"DEBUG: value={value}, type={type(value)}")

# assert：断言（测试时使用）
def divide(a, b):
    assert b != 0, f"除数不能为0，收到 b={b}"
    return a / b

# logging：日志记录（推荐用于正式项目）
import logging

# 配置日志
logging.basicConfig(
    level=logging.DEBUG,
    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
    handlers=[
        logging.StreamHandler(),            # 输出到控制台
        logging.FileHandler("app.log"),     # 输出到文件
    ]
)

logger = logging.getLogger(__name__)

logger.debug("调试信息，开发时使用")
logger.info("一般信息")
logger.warning("警告，不影响运行")
logger.error("错误，影响部分功能")
logger.critical("严重错误，程序无法继续")

# pdb：Python 内置调试器
import pdb

def buggy_function(data):
    pdb.set_trace()    # 在此处暂停，进入交互式调试
    result = data * 2  # 可以单步执行、查看变量
    return result

# pdb 常用命令：
# n（next）：执行下一行
# s（step）：进入函数
# c（continue）：继续执行
# p variable：打印变量
# l（list）：显示当前代码
# q（quit）：退出调试

# Python 3.7+ 可以用 breakpoint() 代替 pdb.set_trace()
def buggy_function(data):
    breakpoint()
    return data * 2

16.4 单元测试

import unittest

# 被测试的函数
def add(a, b):
    return a + b

def divide(a, b):
    if b == 0:
        raise ZeroDivisionError("除数不能为0")
    return a / b

# 测试类
class TestMathFunctions(unittest.TestCase):

    def setUp(self):
        """每个测试方法执行前调用"""
        self.numbers = [1, 2, 3, 4, 5]

    def tearDown(self):
        """每个测试方法执行后调用"""
        pass

    def test_add_positive(self):
        self.assertEqual(add(2, 3), 5)
        self.assertEqual(add(0, 0), 0)

    def test_add_negative(self):
        self.assertEqual(add(-1, -2), -3)
        self.assertEqual(add(-1, 1), 0)

    def test_divide_normal(self):
        self.assertEqual(divide(10, 2), 5)
        self.assertAlmostEqual(divide(1, 3), 0.333, places=3)

    def test_divide_by_zero(self):
        with self.assertRaises(ZeroDivisionError):
            divide(10, 0)

    def test_add_is_not_multiply(self):
        self.assertNotEqual(add(2, 3), 6)

    def test_result_type(self):
        self.assertIsInstance(add(1, 2), int)

# 运行测试
if __name__ == "__main__":
    unittest.main()

# 命令行运行：python -m unittest test_module.py
# 运行并显示详情：python -m unittest -v test_module.py

总结

知识体系速查

Python 知识体系
├── 环境配置          → 安装、虚拟环境、pip
├── 基础语法          → 注释、缩进、导入、变量命名、输入输出
├── 数据类型          → int/float/bool/str/None、类型检查与转换、可变与不可变
├── 字符串            → 索引切片、常用方法、格式化、转义字符
├── 数字运算          → 算术运算符、math模块、进制转换
├── 流程控制          → if/elif/else、match、for、while、推导式
├── 函数              → 定义、参数类型、作用域、闭包、装饰器、lambda、生成器
├── 数据结构          → list、tuple、dict、set、collections模块
├── 面向对象          → 类与对象、继承、封装、property、魔法方法、抽象基类
├── 异常处理          → try/except/else/finally、自定义异常、上下文管理器
├── 文件操作          → 读写、pathlib、JSON、CSV
├── 标准库            → os/sys、datetime、re、itertools、functools
├── 模块化            → 模块、包、项目结构
├── 算法              → 排序、搜索、递归
└── 工程实践          → PEP8、类型提示、日志、调试、单元测试

常见问题速查

问题解决方案
浮点数精度问题使用 decimal 模块，或 round() 处理显示
可变默认参数陷阱默认参数使用 None，函数内判断后再创建
循环中的闭包陷阱用默认参数 lambda x=i: x 捕获当前值
浅拷贝与深拷贝混淆嵌套结构用 copy.deepcopy()，简单结构用 .copy()
修改列表时遍历列表遍历副本 for item in lst.copy(): 或用推导式过滤
大文件内存溢出使用生成器逐行处理
字典键不存在使用 .get(key, default) 或 defaultdict
字符串拼接性能差使用 "".join(list) 代替 +=
递归层数过深改用迭代，或 sys.setrecursionlimit() 调整限制
中文文件乱码指定 encoding="utf-8"，CSV 用 utf-8-sig
]]> https://loogeking.github.io/posts/Python%E5%AD%A6%E4%B9%A0%E7%AC%94%E8%AE%B0/ 2026-06-20T10:53:38.000Z Python 学习笔记

一、Python 简介

1.1 什么是 Python？

Python 是一种高级、通用、解释型]]>

Python学习笔记 2026-06-22T10:20:31.707Z Loogeking 第一章 计算机网络和因特网

1.1 什么是因特网

1.1.1 具体构成描述

端系统

因特网连接了全球数十亿计算设备，这些设备统称为主机（Host） 或端系统（End System） 。端系统包括传统的桌面计算机、服务器，也包括智能手机、平板、电视、游戏机、汽车、家用电器等非传统设备。端系统持续接入因特网的趋势催生了物联网（IoT，Internet of Things） 的概念。

端系统通过通信链路（Communication Link） 和分组交换机（Packet Switch） 彼此连接。

通信链路

不同的通信链路由不同的物理媒体构成，包括同轴电缆、铜线、光纤和无线电频谱等。不同链路的传输速率不同，链路的传输速率以 bit/s（bps）为单位。

分组与分组交换机

当一个端系统向另一个端系统发送数据时，发送端系统将数据分段，并为每段加上首部字节，形成分组（Packet） 。分组通过网络传输，在目的端系统处被重新组装还原为原始数据。

分组交换机从它的一条入通信链路接收到达的分组，并从它的一条出通信链路转发该分组。分组交换机主要有两类：

  • 路由器（Router） ：通常用于网络核心
  • 链路层交换机（Link-layer Switch） ：通常用于接入网

从发送端系统到接收端系统，一个分组所经历的一系列通信链路和分组交换机称为通过该网络的路径（Route / Path） 。

ISP

端系统通过因特网服务提供商（ISP，Internet Service Provider） 接入因特网。ISP 包括住宅 ISP（如电信、联通）、企业 ISP、大学 ISP，也包括在机场、咖啡馆等地提供 WiFi 接入的 ISP，以及提供移动接入的蜂窝数据 ISP。

每个 ISP 本身就是一个由分组交换机和通信链路组成的网络。各个 ISP 之间也必须互联，低层 ISP 通过高层 ISP 互联，高层 ISP 之间彼此互联。每个 ISP 网络是独立管理的，运行着 IP 协议，遵从一定的命名和地址规则。

协议

因特网中的端系统、分组交换机以及其他部件都需要运行一系列协议（Protocol） 。协议控制着因特网中信息的接收和发送。

TCP（Transmission Control Protocol，传输控制协议） 和IP（Internet Protocol，网际协议） 是因特网中两个最重要的协议，合称 TCP/IP。IP 协议规定了在路由器和端系统之间发送和接收的分组格式。

因特网的主要协议统称为因特网标准（Internet Standard） ，由IETF（Internet Engineering Task Force，因特网工程任务组） 研发。IETF 的标准文档称为 RFC（Request For Comment，请求评论） 。RFC 文档往往技术性很强，内容详尽，目前已有近 9000 份。此外，IEEE 802 LAN/MAN 标准委员会负责制定以太网和 WiFi 的标准。

1.1.2 服务描述

从另一个角度看，因特网是为应用程序提供服务的基础设施。

因特网应用程序包括电子邮件、Web 冲浪、社交网络、即时通信、VoIP、视频流、地图等，这些应用程序涉及多个相互交换数据的端系统，称为分布式应用程序（Distributed Application） 。

端系统上的应用程序如何指示因特网向另一个端系统上的应用程序交付数据？与因特网相连的端系统提供了一个套接字接口（Socket Interface） ，该接口规定了运行在一个端系统上的程序请求因特网基础设施向运行在另一个端系统上的特定程序交付数据的方式。因特网套接字接口是一套发送程序必须遵循的规则集合，以使因特网能够将数据交付给目的地。

1.1.3 什么是协议

人类活动中存在大量类似协议的东西。例如，当你向别人询问时间时，存在一套约定俗成的礼貌用语，双方都遵守这套规则，对话才能顺利进行。

网络协议类似于人类协议，只不过交换报文和采取动作的实体是硬件或软件组件。因特网中所有通信活动都由协议控制。

协议（Protocol）的定义：
协议定义了在两个或多个通信实体之间交换的报文的格式和顺序，以及报文发送和/或接收一条报文或其他事件所采取的动作。

1.2 网络边缘

1.2.1 接入网

接入网（Access Network） 是指将端系统物理连接到其边缘路由器（Edge Router） 的网络。边缘路由器是端系统到任何其他远程端系统的路径上的第一台路由器。

家庭接入：DSL

DSL（Digital Subscriber Line，数字用户线） 利用电话公司已有的本地电话基础设施（双绞铜线）来提供宽带因特网接入。

家庭的 DSL 调制解调器使用现有的电话线（双绞铜线）与电话公司的本地中心局（CO，Central Office）中的DSLAM（数字用户线接入复用器） 交换数据。家庭的 DSL 调制解调器将数字数据转换为高频音调，以便在电话线上传输给 CO。来自许多家庭的模拟信号在 DSLAM 处被转换回数字形式。

DSL 标准定义了多种传输速率，包括下行（从 CO 到家庭）和上行（从家庭到 CO）方向。由于下行和上行速率不同，该接入方式是非对称的，这也是"不对称数字用户线（ADSL）"名称的由来。

DSL 利用电话线同时承载数据和传统电话信号：

  • 高速下行：频率 > 50 kHz
  • 中速上行：频率 > 4 kHz
  • 普通双向电话：0~4 kHz

这种分频使得在同一条双绞线上，数据和电话通话可以同时传输互不干扰。

家庭接入：电缆因特网接入

电缆因特网接入（Cable Internet Access） 利用有线电视公司现有的有线电视基础设施。

由于这种系统同时使用了光纤和同轴电缆，所以常被称为HFC（Hybrid Fiber-Coaxial，混合光纤同轴） 。电缆因特网接入需要在家庭中安装电缆调制解调器（Cable Modem） 。在电缆头端（headend），CMTS（电缆调制解调器端接系统） 将来自许多下行家庭中的电缆调制解调器发送的模拟信号转换回数字形式。

电缆因特网接入是共享广播媒体：头端发送的每个分组被传送到每条家庭链路上，家庭发送的每个分组也被传送到头端。这意味着若干用户同时下载一个视频文件，每个用户实际接收到的下行速率将显著低于总电缆下行速率。由于上行信道也是共享的，需要一个分布式多路访问协议来协调传输、避免冲突。

家庭接入：FTTH

FTTH（Fiber To The Home，光纤到户） ：从 CO 直接到家庭提供光纤路径。

FTTH 可以提供比 DSL 和电缆高得多的因特网速率，达到 Gbps 量级。FTTH 技术有多种方案，最简单的称为直接光纤（每户一根光纤），更常见的方案是让从 CO 出发的每根光纤为多个家庭所共享，直到光纤距离家庭比较近时才分开成每户独占的光纤：

  • AON（Active Optical Network，主动光网络） ：本质上是交换以太网
  • PON（Passive Optical Network，被动光网络） ：使用无源光纤分路器（Splitter），每户安装 ONU（光网络单元），连接到 CO 处的 OLT（光线路终端）

企业及家庭接入：以太网和 WiFi

以太网（Ethernet） 使用双绞铜线连接到以太网交换机，再通过交换机连接到更大的因特网。

WiFi（无线局域网，WLAN） ：基于 IEEE 802.11 标准，用户在几十米范围内通过无线方式连接到接入点（AP，Access Point） ，接入点通过有线以太网连接到企业网络，再通过有线以太网连接到因特网。

广域无线接入：3G/4G/5G

蜂窝网络（Cellular Network） ：通过与移动电话相同的无线基础设施，在用户与附近基站之间发送和接收分组。基站由蜂窝网络提供商管理，用户只需在基站几十公里范围内即可接入因特网。4G LTE（Long-Term Evolution）已可提供超过 10 Mbps 的下载速率，5G 进一步大幅提升带宽并降低时延。

1.2.2 物理媒体

物理媒体分为两类：

  • 导引型媒体（Guided Media） ：信号沿固体媒体传播，如光缆、双绞铜线、同轴电缆
  • 非导引型媒体（Unguided Media） ：信号在大气和外层空间中传播，如无线局域网、数字卫星信道

双绞铜线

最廉价、使用最广泛的导引型传输媒体。两根铜线以规则的螺旋状排列，以减少邻近双绞线的电气干扰。通常多根双绞线被捆绑在一起构成电缆。

  • UTP（无屏蔽双绞线） ：常用于局域网
  • 现代以太网（Cat 6a）可达 10 Gbps

同轴电缆

由两个同心铜导体构成，绝缘性好。常见于有线电视系统。可作为导引型共享媒体，多个端系统直接连接到电缆。

光纤

传导光脉冲，每个脉冲表示一个比特。

  • 支持极高的比特率：数十至数百 Gbps
  • 不受电磁干扰
  • 长距离传输衰减极低（100 km 衰减仅 0.2 dB/km）
  • 很难被窃听，安全性高
  • 缺点：光学器件（发射器、接收器、交换机）造价较高

适合长距离导引型传输媒体，是越洋海底光缆的首选。

陆地无线电信道

无线电信道承载电磁频谱中的信号，不需要安装物理线缆，可以穿透建筑物，能提供到移动用户的连接，也能远距离传播。

无线信道受环境影响较大，包括路径衰减、多路径衰落（障碍物反射）、干扰等。

卫星无线电信道

一颗通信卫星连接地球上的两个或多个微波发射器/接收器（地面站）。

  • 同步卫星（GEO，Geostationary Earth Orbit） ：固定在地球赤道上空约 36000 km 处，信号传播时延约 280ms（单向），带宽可达 Mbps 至 Gbps 量级，用于 DSL 基础设施无法覆盖的地区
  • 低轨卫星（LEO，Low Earth Orbit） ：距地面数百至数千公里，时延更小，如 Starlink（SpaceX）项目已提供商业服务

1.3 网络核心

1.3.1 分组交换

在分组交换网络中，端系统之间交换的报文（Message） 可以包含协议设计者所希望包含的任何东西。报文在发送方被分成较小的数据块，称为分组（Packet） 。在源和目的地之间，每个分组都通过通信链路和分组交换机传送。

存储转发传输

大多数分组交换机在链路的输入端使用存储转发传输（Store-and-Forward Transmission） 机制：交换机必须接收到整个分组，才能开始向输出链路传输该分组的第一个比特。

端到端时延分析：

设分组长度为 L bits，链路传输速率为 R bps，则将一个分组从源主机传输到目的主机（经过 N 段链路，即 N−1 台路由器）的存储转发时延为：

dend−end=N⋅LR

这里忽略了传播时延和排队时延。

排队时延和分组丢失

每台分组交换机有多条链路与之相连，对于每条链路，该交换机有一个输出缓存（Output Buffer） ，也称输出队列（Output Queue） ，存储路由器准备发往那条链路的分组。

如果到达的分组需要通过某条链路传输，但该链路正忙于传输另一个分组，到达的分组就必须在输出缓存中等待，产生排队时延（Queuing Delay） 。排队时延是可变的，取决于网络的拥塞程度。

由于缓存空间是有限的，如果缓存已满，到达的分组或已在队列中的分组将被丢弃，即发生分组丢失（Packet Loss，丢包） 。

转发表和路由选择协议

路由器如何决定将分组转发到哪条链路？

在因特网中，每个端系统有一个称为 IP 地址的地址。当源端系统发送分组时，它在分组的首部包含了目的端系统的 IP 地址。当分组到达网络中的某路由器时，路由器检查分组的目的 IP 地址，查询转发表（Forwarding Table） ，找到对应的出链路，将分组转发过去。

转发表并不是由网络管理员手动配置的，而是由路由选择协议（Routing Protocol） 自动设置的。路由选择协议可以确定从每台路由器到每个目的地的最短路径，并用结果配置路由器中的转发表。

1.3.2 电路交换

在电路交换网络中，在端系统通信期间，网络沿路径为两端系统之间的通信预留了所需的资源（缓存、链路传输速率）。在分组交换网络中，这些资源是不预留的，每个报文段按需使用链路资源，因此可能需要等待（排队）。

电话网是电路交换网络的典型例子。在发送方与接收方能够传输信息之前，网络必须在两者之间建立一条连接。当网络建立了这条专用连接之后，它也在整条路径的每条链路上预留了一个恒定的传输速率，发送方可以以保证的恒定速率向接收方传输数据。

多路复用

链路中的电路是通过频分多路复用（FDM，Frequency-Division Multiplexing） 或时分多路复用（TDM，Time-Division Multiplexing） 来实现的。

FDM（频分多路复用） ：链路的频谱由跨越该链路的所有连接共享。在连接期间，每条连接专用一个频段。FM 广播电台使用 88 MHz~108 MHz 的频谱，每个电台分配一个特定频段，各电台互不干扰；电话网的 FDM 通常为每条连接分配 4 kHz 频段。

TDM（时分多路复用） ：对于 TDM 链路，时间被划分为固定期限的帧，每个帧被划分为固定数量的时隙。当网络跨越一条链路建立一条连接时，网络在每个帧中为该连接指定一个时隙，这个时隙专用于该连接。

分组交换 vs 电路交换

电路交换的缺点：预留的资源在空闲时（如通话停顿时）会被浪费。

分组交换更高效的例子： 设链路速率 1 Mbps，每个用户活跃时需要 100 kbps，但每个用户只有 10% 的时间是活跃的。

  • 电路交换：最多支持 1000kbps / 100kbps = 10 个用户同时使用
  • 分组交换：若有 35 个用户，某一时刻超过 10 个用户同时活跃的概率极小（约 0.0004），实际上可以同时支持 35 个用户，效率远高于电路交换

分组交换的缺点：不能保证端到端的性能，对实时应用（如视频会议）不够友好。

分组交换更适合突发性数据传输；电路交换适合需要保证稳定传输速率的场景。

1.3.3 网络的网络

端系统通过接入 ISP 与因特网相连，接入 ISP 再以某种复杂的网络层次结构彼此互联。

网络结构的演化：

  • 网络结构 1：一个全球中转 ISP，所有接入 ISP 均与其互联。不现实，单点垄断。
  • 网络结构 2：多个全球中转 ISP 相互竞争，接入 ISP 选择其中一个（或多个）连接。
  • 网络结构 3：在接入 ISP 和全球中转 ISP 之间增加区域 ISP（Regional ISP） ，形成多层次结构。
  • 网络结构 4：在结构 3 的基础上增加存在点（PoP，Points of Presence） 、多宿（Multi-Homing） 、对等互联（Peering） 和因特网交换点（IXP，Internet Exchange Point） 。
  • 网络结构 5：在结构 4 的基础上增加内容提供商网络（Content Provider Network） ，如谷歌在全球运营自己的专用数据中心网络，尽量绕过高层 ISP，降低费用并对服务有更多控制。

核心概念：

  • PoP：ISP 网络中的路由器群，供客户 ISP 接入提供商 ISP 的点
  • 多宿：接入 ISP 同时连接两个或多个提供商 ISP，避免单点故障
  • 对等互联：相邻同层级 ISP 之间直接互联，流量免费交换，无需经过上层 ISP
  • IXP：第三方公司运营的设施，多个 ISP 在此对等互联，降低流量交换成本

1.4 分组交换网中的时延、丢包和吞吐量

1.4.1 分组交换网中的时延概述

分组从一个节点（主机或路由器）出发，经过一系列路由器，到达目的节点，沿途会经历多种类型的时延。

在每个节点处，分组经历的时延称为节点总时延（Total Nodal Delay） ：

dnodal=dproc+dqueue+dtrans+dprop

节点处理时延 dproc

检查分组首部和决定将分组导向何处所需要的时间，还包括检查比特级别差错所需时间。高速路由器的处理时延通常在微秒（μs）量级甚至更低。处理之后，路由器将分组引导至通往下一路由器的链路之前的队列。

排队时延 dqueue

分组在队列中等待传输所花费的时间。实际的排队时延可以是毫秒到微秒量级。排队时延取决于先于该分组到达且正在排队的分组数量。

若队列为空且当前链路空闲，则排队时延为 0；若流量很大，排队时延可能很长。

传输时延 dtrans

将分组的所有比特推出到链路所需的时间。设分组长度为 L bits，链路传输速率为 R bps，则传输时延为 L/R 。

注意： 传输时延与链路长度和传播速度无关，仅与分组长度和链路速率有关。

传播时延 dprop

一个比特从链路起点传播到链路终点所需的时间。传播速度取决于物理媒体，大约为 2×108 m/s（光速的 2/3 左右）。

dprop=ds

其中 d 为链路物理长度， s 为信号传播速度。

传输时延 vs 传播时延的类比： 把分组比作车队，把链路比作公路。传输时延是车队从收费站全部通过所需时间，传播时延是从收费站到下一收费站的行驶时间，两者是完全不同的概念。

1.4.2 排队时延和流量强度

排队时延因情况而异，通常用统计测量值（如平均排队时延、排队时延的方差、超过某一特定值的排队时延的概率）来表征。

设 a 为分组到达队列的平均速率（pkt/s）， R 为传输速率（bps）， L 为分组长度（bits），定义流量强度（Traffic Intensity） ：

ρ=LaR
  • ρ<1 ：队列长度稳定，平均排队时延较小
  • ρ→1 ：平均排队时延趋向无穷大
  • ρ>1 ：到达速率超过服务速率，队列无限增长，排队时延趋向无穷

黄金设计原则： 不能将流量强度设计得等于或大于 1。

实际上，即使 ρ<1 ，排队时延也与流量到达的具体方式（周期性或突发性）有密切关系。

1.4.3 端到端时延

假设在源主机和目的主机之间有 N−1 台路由器（ N 段链路），忽略排队时延，每段链路处理时延、传输时延和传播时延相同，则端到端时延为：

dend−end=N(dproc+dtrans+dprop)

Traceroute（路由追踪）工具：

Traceroute 向目的地发送多个特殊的分组，路径上每台路由器收到特殊分组后向源端回送一个短报文，源端即可计算出到每个路由器的往返时延（RTT），以此确定路径和各段时延。

具体原理（详见第 4 章 ICMP 部分）：利用 TTL 字段，从 TTL=1 开始逐渐增加，路由器发现 TTL 超时时会返回 ICMP 报文，其中含有路由器的 IP 地址和名称，从而探测路径上每一跳。

1.4.4 计算机网络中的吞吐量

瞬时吞吐量（Instantaneous Throughput） ：在任何瞬间，主机 B 接收到文件的速率（bps）。

平均吞吐量（Average Throughput） ：若主机 B 在时间 T 秒内接收到 F bits，则平均吞吐量为 F/T bps。

瓶颈链路（Bottleneck Link）：

在由多段链路串联的路径上，端到端的吞吐量由路径上速率最慢的链路决定，该链路称为瓶颈链路。

吞吐量=min(R1,R2,…,RN)

实际因特网中，瓶颈链路通常是接入网链路（即最后一公里），而非核心网链路。但当许多流同时经过同一条核心链路时，该链路也可能成为瓶颈。

1.5 协议层次及其服务模型

1.5.1 分层体系结构

为什么分层？

网络协议设计十分复杂。分层提供了一种结构化方式来讨论系统组件，且模块化使得系统的组件可以独立更新——某层的协议改变时，只要该层向上层提供的服务不变，系统其余部分无需改动。

分层的缺点：层与层之间可能存在功能冗余（如差错恢复在多层实现），且一层可能需要另一层才有的信息。

协议栈

各层所有协议加在一起称为协议栈（Protocol Stack） 。因特网的协议栈由五层构成。

因特网协议栈（五层）

层次名称协议数据单元功能
5应用层报文（Message）网络应用及应用层协议
4传输层报文段（Segment）进程间数据传输
3网络层数据报（Datagram）主机间数据报路由
2链路层帧（Frame）相邻网络节点间数据传输
1物理层比特（Bit）在链路上传输比特

各层详述：

应用层： 网络应用程序及其协议驻留的地方。因特网的应用层包括许多协议，例如 HTTP（Web 文档请求和传送）、SMTP（电子邮件报文的传输）、FTP（文件传输）、DNS（域名解析）。应用层协议分布在多个端系统上，某个端系统中的应用程序使用该层协议与另一个端系统中的应用程序交换报文（Message） 。

传输层： 因特网的传输层在应用程序端点之间传送应用层报文。有两个传输协议：TCP 和 UDP。TCP 向应用层提供面向连接的服务，保证应用层报文的交付和按序交付，同时提供拥塞控制机制，在网络拥塞时限制传输速率。UDP 提供无连接服务，不提供可靠性保障，也没有拥塞控制。传输层的分组称为报文段（Segment） 。

网络层： 负责将称为数据报（Datagram） 的网络层分组从一台主机移动到另一台主机。源主机中的因特网传输层协议（TCP 或 UDP）向网络层递交传输层报文段和目的地址，就像寄快递时将包裹和目的地址交给快递员一样。网络层包括著名的 IP 协议，它定义了数据报中各字段以及端系统和路由器如何作用于这些字段的规则，以及路由选择协议，它确定数据报从源到目的地所采取的路由。

链路层： 网络层将数据报传递给链路层，链路层沿着路径将数据报传递给下一个节点。链路层的服务取决于应用于该链路的特定链路层协议，例如，某些链路层协议提供可靠传输（从发送节点经一条链路到接收节点）。注意，这里的可靠传输服务不同于 TCP 的可靠传输服务，TCP 提供的是从一个端系统到另一个端系统的可靠性。链路层分组称为帧（Frame） 。

物理层： 链路层的任务是将整个帧从一个网络元素移动到相邻网络元素，而物理层的任务是将帧中一个一个的比特从一个节点移动到下一个节点。该层的协议与链路有关，也与链路的实际传输媒体有关（双绞铜线、光纤等）。

OSI 参考模型（七层）

在五层因特网协议栈被广泛采用之前，OSI（Open Systems Interconnection，开放系统互联）参考模型由 ISO 提出，包含七层：

层次名称
7应用层
6表示层
5会话层
4传输层
3网络层
2链路层
1物理层

比五层模型多出的两层：

表示层： 使通信的应用程序能够解释交换数据的含义，包括数据压缩、数据加密和数据描述（使应用程序不必担心数据在计算机内部的表示/存储格式）。

会话层： 提供数据交换的定界和同步功能，包括建立检查点和恢复方案。

因特网的五层协议栈并未明确提供表示层和会话层的功能，如果应用程序需要这些功能，由应用程序开发者自行实现。

1.5.2 封装

下图描述了数据从应用层到物理层的封装（Encapsulation） 过程，以及在接收方的解封装过程。

发送主机                    路由器                   接收主机
[应用层 报文 M]
[传输层 Ht | M ]
[网络层 Hn | Ht | M ]      [网络层 Hn | Ht | M ]
[链路层 Hl | Hn | Ht | M ] [链路层 Hl | Hn | Ht | M ]    ...
[物理层 bits]              [物理层 bits]

每一层将来自上一层的分组作为载荷（Payload） ，在其前面（有时也在其后面）附加上本层的首部字段（Header） ，形成本层的分组，传递给下一层。这一过程就是封装。

在中间路由器处，由于路由器工作在网络层，它只需将分组解封装到网络层，查看 IP 地址，决定输出链路，然后重新封装成链路层帧向下传输。路由器不需要查看运输层和应用层信息。

1.6 面对攻击的网络

网络安全是贯穿全书的重要主题，这里先总体介绍常见的攻击类型。

恶意软件

恶意软件（Malware） ：能够进入并危害设备的软件，包括删除文件、安装间谍软件、发动 DDoS 攻击等。恶意软件通常具有自我复制能力：一旦感染一个宿主，就会试图感染更多主机。

  • 病毒（Virus） ：需要某种形式的用户交互才能感染设备，例如打开包含恶意代码的邮件附件
  • 蠕虫（Worm） ：无需用户明显交互即可进入设备，例如利用网络漏洞自动传播

僵尸网络

被恶意软件控制的受感染主机集合称为僵尸网络（Botnet） ，可被攻击者用于发送垃圾邮件、发动 DDoS 攻击等。

拒绝服务攻击

DoS（Denial-of-Service，拒绝服务）攻击：使合法用户无法使用网络、主机或其他基础设施。大多数 DoS 攻击分为三类：

  • 弱点攻击：向目标主机上运行的易受攻击的应用程序或操作系统发送精心制作的报文，使主机崩溃
  • 带宽洪泛：向目标主机发送大量分组，使目标主机的接入链路拥塞，合法用户的分组无法到达
  • 连接洪泛：在目标主机上建立大量 TCP 连接，耗尽资源，使其无法接受合法连接

DDoS（Distributed DoS，分布式 DoS 攻击） ：利用僵尸网络中大量受控主机同时向目标发起攻击，使流量洪泛难以过滤。单一来源的 DoS 攻击可以被检测并封锁，而来自数千个地址的 DDoS 攻击则更难防御。

分组嗅探

许多接入技术（如广播以太网、WiFi）是共享媒体，在此类网络中，被动地记录经过的所有分组副本的接收方称为分组嗅探器（Packet Sniffer） 。嗅探器可以捕获密码、个人信息、商业秘密等敏感数据。

防御手段：对分组内容进行加密。

IP 欺骗

将任意源地址放入分组称为 IP 欺骗（IP Spoofing） 。这使得接收方无法确认发送方的真实身份，也无法回复。更严重的情况下，攻击者伪装成合法用户，注入虚假数据到连接中。

防御手段：端点鉴别（End-point Authentication） ——验证报文确实来自其声称的来源，详见第 8 章。

1.7 计算机网络和因特网的历史（概览）

时期事件
1960s 以前电路交换的电话网是主导通信网络
1961~1972分组交换技术的萌芽：Leonard Kleinrock 的排队论文（1961），ARPANET 诞生（1969），第一台 NCP 实现，首封电子邮件（1972）
1972~1980网络互联与专有网络的增殖：ALOHAnet，Telenet，Cyclades，以太网，TCP/IP 雏形
1980~1990新协议和网络大爆发：BITNET, CSNET, NSFNET，DNS，TCP/IP 成为 ARPANET 标准（1983）
1990~2000因特网商业化、Web 诞生：ARPANET 退役（1991），Tim Berners-Lee 发明 WWW，浏览器 Mosaic（1993），ISP 商业化，拨号接入，电子商务兴起
2000 至今宽带接入、WiFi 普及，P2P 应用，社交网络，智能手机，云计算，物联网，5G，AI

本章小结

本章从宏观角度介绍了计算机网络和因特网的基本概念，是全书的概述。主要内容包括：

  1. 因特网的组成：端系统、通信链路、分组交换机（路由器和链路层交换机）、ISP 层次结构、协议（TCP/IP）和标准（RFC/IETF）

  2. 接入网：DSL、电缆（HFC）、FTTH、以太网、WiFi、蜂窝网络；物理媒体：双绞铜线、同轴电缆、光纤、无线电信道、卫星信道

  3. 网络核心：分组交换（存储转发、排队时延、转发表）vs 电路交换（FDM、TDM）；ISP 互联的层次结构（IXP、对等互联、多宿）

  4. 时延、丢包和吞吐量：处理时延、排队时延、传输时延、传播时延；流量强度 ρ=La/R ；瓶颈链路决定吞吐量

  5. 协议分层：五层因特网协议栈（应用层、传输层、网络层、链路层、物理层）；封装与解封装；OSI 七层模型

  6. 网络安全威胁：恶意软件（病毒、蠕虫）、DoS/DDoS、分组嗅探、IP 欺骗

第二章 应用层

2.1 应用层协议原理

2.1.1 网络应用程序体系结构

在开发网络应用程序之前，首先需要确定应用程序的整体架构。应用程序体系结构（Application Architecture）由应用程序开发者设计，规定了如何在各种端系统上组织应用程序。现代网络应用程序主要采用两种体系结构：

客户-服务器体系结构

在客户-服务器（Client-Server）体系结构中，有一个总是打开的主机称为服务器（Server） ，它服务于来自许多其他称为客户（Client） 的主机的请求。

服务器的特点：

  • 具有固定的、周知的 IP 地址
  • 总是处于运行状态，随时等待客户请求
  • 客户之间不直接通信，所有通信都经过服务器

典型应用：Web、FTP、Telnet、电子邮件。

由于单台服务器无法独自应对大量客户请求，配备大量主机的数据中心（Data Center） 常被用于创建强大的虚拟服务器。大型数据中心可拥有数十万台服务器，必须供电并进行维护，运营成本极高。

P2P 体系结构

在P2P（Peer-to-Peer）体系结构中，应用程序在间歇性连接的主机对（称为对等方）之间直接通信，对中央专用服务器的依赖很少甚至没有。

P2P 的突出特性是自扩展性（Self-Scalability） ：每个对等方既是内容的消费者，也是内容的分发者。例如在 P2P 文件共享应用中，虽然每个对等方都会请求文件（产生工作负荷），但每个对等方也同时向其他对等方分发文件（分担工作负荷），因此系统整体能力随用户数量增长而自动扩展。

P2P 应用的挑战：

  • 安全性：开放结构难以控制
  • 激励机制：如何促使用户共享资源
  • ISP 友好性：P2P 流量通常是非对称的，给 ISP 带来压力

典型应用：BitTorrent、Skype（早期）。

2.1.2 进程通信

操作系统术语中，进行通信的实际上是进程（Process） 而非程序。在两个不同端系统上的进程，通过跨越计算机网络交换报文（Message） 来相互通信。

客户和服务器进程

对于每对通信进程，通常将两个进程之一标识为客户（Client） ，另一个标识为服务器（Server） ：

发起通信（即在会话开始时发起联系）的进程称为客户，在会话开始时等待联系的进程称为服务器。

在 P2P 应用中，一个进程可能在某段时间内是客户，在另一段时间内是服务器，角色不是固定的。

进程与计算机网络之间的接口

进程通过套接字（Socket） 向网络发送报文和从网络接收报文。套接字是应用层与传输层之间的接口，也称为应用程序编程接口（API，Application Programming Interface）。

套接字类比：进程好比一座房子，套接字好比房子的门。发送进程将报文推出门（套接字），传输基础设施将报文传输到接收进程的门口，接收进程从门（套接字）取入报文。

应用程序开发者对套接字的传输层一侧几乎没有控制权，能做的选择主要是：

  1. 选择传输层协议（TCP 或 UDP）
  2. 设定少量传输层参数（如缓存大小、报文段大小等）

进程寻址

为了使一个端系统上的进程能向另一个端系统上的进程发送分组，需要两部分信息：

  1. 主机的地址（IP 地址） ：32 位，用于标识主机
  2. 主机中进程的标识符（端口号） ：16 位，用于标识主机上的特定进程（套接字）

周知端口号举例：Web 服务器 80，邮件服务器 25，FTP 服务器 21，DNS 服务器 53。

2.1.3 可供应用程序使用的传输服务

应用程序开发者可以选择传输层协议，在选择时需要考虑传输服务的四个维度：

可靠数据传输

某些应用（如文件传输、Web 事务、电子邮件）要求数据完整无误地到达目的地，不容忍任何数据丢失。若传输协议提供这种可靠数据传输（Reliable Data Transfer） 服务，发送进程只需将数据交给套接字，就能确保数据完整到达接收进程。

另一些应用（如实时音视频、在线游戏）是容忍丢失的（Loss-tolerant） ，少量数据丢失只会造成轻微的质量下降，可以接受。

吞吐量

传输协议能以某种特定的速率提供有保证的可用吞吐量：

  • 带宽敏感应用（Bandwidth-sensitive Application） ：对吞吐量有最低需求，如视频会议需要至少某一速率，否则无法正常使用
  • 弹性应用（Elastic Application） ：能够根据可用带宽灵活调整，如电子邮件、文件传输，能用多少带宽就用多少

定时

传输协议可以提供定时保证，如发送方发送的每个比特到达接收方套接字的时间不超过 100ms。这对于实时交互应用（如网络电话、多人在线游戏、视频会议）是必要的，而对于非实时应用则无关紧要。

安全性

传输协议可以为应用程序提供安全服务，包括：对发送数据加密、对接收数据解密、数据完整性保护、端点鉴别等。

2.1.4 因特网提供的传输服务

因特网（TCP/IP 网络）为应用程序提供两种传输层协议：TCP 和 UDP。

TCP 服务

面向连接（Connection-Oriented） ：在应用层报文开始流动之前，TCP 让客户和服务器互换传输层控制信息（三次握手），建立 TCP 连接。连接是全双工的，通信结束后必须拆除连接。

可靠数据传输（Reliable Data Transfer） ：通信进程可以依靠 TCP 无差错、按顺序交付所有发送的数据，没有字节的丢失和冗余。

拥塞控制（Congestion Control） ：当网络出现拥塞时，TCP 会抑制发送进程的发送速率。这是面向整个因特网的一种服务，对通信双方未必有利，但对网络整体有益。

TCP 不提供：定时保证、最低带宽保证、安全性保证。

UDP 服务

UDP 是一种轻量级传输协议，提供最小服务：

  • 无连接：通信前无需握手
  • 不可靠数据传输：不保证报文到达，也不保证到达顺序
  • 无拥塞控制：发送方可以以任意速率发送

为什么需要 UDP？

  • 对某些实时应用（如网络电话、实时视频），少量数据丢失可以容忍，但不能容忍额外时延
  • 应用程序希望自己控制发送速率和重传逻辑，而不受 TCP 拥塞控制的约束
  • 无连接建立，避免 TCP 握手引入的时延（DNS 使用 UDP 的原因之一）
  • 无连接状态，服务器可支持更多并发客户

SSL（Secure Sockets Layer）

TCP 和 UDP 都不提供加密。SSL（安全套接字层） 不是第三种传输协议，而是对 TCP 的增强，在应用层实现。应用程序使用 SSL 库，SSL 对数据加密后再交给 TCP 套接字传输。SSL 有自己的套接字 API，类似于 TCP 套接字 API。现在 SSL 已被TLS（Transport Layer Security） 取代。

常见应用与传输协议对照：

应用应用层协议传输层协议
电子邮件SMTPTCP
远程终端访问TelnetTCP
WebHTTPTCP
文件传输FTPTCP
流式多媒体HTTP（如 YouTube）TCP
网络电话SIP、RTP 等UDP 或 TCP
域名解析DNSUDP

2.1.5 应用层协议

应用层协议（Application-Layer Protocol） 定义了运行在不同端系统上的应用程序进程如何相互传递报文，具体包括：

  • 报文类型：请求报文和响应报文
  • 各种报文类型的语法：报文中各字段及其如何描述
  • 字段的语义：各字段中信息的含义
  • 进程何时以及如何发送报文，以及对报文进行响应的规则

有些应用层协议由 RFC 规定，是公开的（如 HTTP）；有些是专用的（如 Skype 早期的协议）。

需要注意区分网络应用（Network Application） 和应用层协议（Application-Layer Protocol） ：

  • 网络应用是用户使用的完整系统，如 Web 包括浏览器、服务器、HTML 格式等
  • 应用层协议只是网络应用的一部分，Web 的应用层协议是 HTTP

2.2 Web 和 HTTP

2.2.1 HTTP 概述

WWW（World Wide Web，万维网） 是最广为人知的因特网应用，也是推动因特网商业化的核心驱动力。

Web 页面（Web Page） 由对象构成。一个对象（Object） 是一个文件，例如 HTML 文件、JPEG 图像、JavaScript 文件、视频片段等，每个对象用一个 URL（Uniform Resource Locator，统一资源定位符） 寻址。URL 由两部分组成：存放对象的服务器主机名和对象的路径名。

多数 Web 页面由一个基本 HTML 文件和若干引用对象构成，基本 HTML 文件通过 URL 引用其他对象。

HTTP（HyperText Transfer Protocol，超文本传输协议） 是 Web 应用层协议的核心。HTTP 由一个客户程序和一个服务器程序构成，分别运行在不同端系统上，通过交换 HTTP 报文进行通话。HTTP 定义了这些报文的结构以及客户和服务器如何交换这些报文。

HTTP 使用 TCP 作为传输层协议：客户发起 TCP 连接，一旦连接建立，客户和服务器就可以通过套接字接口访问 TCP。

HTTP 是无状态协议（Stateless Protocol） ：服务器不保存关于客户的任何信息。同一客户在短短几秒内请求同一对象两次，服务器并不知道之前已经响应过该客户，会再次响应。这简化了服务器设计，允许同时服务数千个 TCP 连接。

2.2.2 非持续连接和持续连接

非持续连接（HTTP/1.0）

非持续连接（Non-Persistent Connection） ：每个请求/响应对经过一个单独的 TCP 连接发送。

步骤（以请求一个包含 10 个 JPEG 对象的 HTML 文件为例）：

  1. 客户发起 TCP 连接（SYN）
  2. 服务器确认并回复（SYNACK）
  3. 客户发送 HTTP GET 请求（ACK + 请求）
  4. 服务器传送包含 HTML 文件的 HTTP 响应报文，关闭 TCP 连接
  5. 客户收到响应，解析 HTML，发现 10 个 JPEG 对象的引用
  6. 对每个 JPEG 重复步骤 1~4

响应时间分析：

定义 RTT（Round-Trip Time，往返时间） ：一个短分组从客户到服务器再返回客户所花费的时间，包括分组传播时延、排队时延和处理时延。

每个对象的响应时间 = 2 RTT + 文件传输时间：

  • 第 1 个 RTT：建立 TCP 连接（三次握手的前两次）
  • 第 2 个 RTT：HTTP 请求和响应的前几个字节
  • 文件传输时间：传输对象本身

非持续连接的缺点：

  • 每个对象需要建立新的 TCP 连接，每次需要 2 RTT 开销
  • 每条 TCP 连接都要在客户和服务器分配 TCP 缓冲区和 TCP 变量，消耗资源
  • 浏览器通常并行建立多个 TCP 连接来弥补串行的低效，但并行连接数有限

持续连接（HTTP/1.1 默认）

持续连接（Persistent Connection） ：所有的请求及其响应经同一个 TCP 连接发送。

服务器在发送响应后保持 TCP 连接打开，后续请求和响应通过同一连接传输。如果一条连接经过一定时间（超时间隔）没有被使用，服务器就关闭该连接。

流水线（Pipelining） ：客户端遇到一个引用对象就立即发送该对象的请求，不必等待上一个请求的响应，从而进一步减少时延。HTTP/1.1 默认使用带有流水线的持续连接。

2.2.3 HTTP 报文格式

HTTP 请求报文

GET /somedir/page.html HTTP/1.1\r\n
Host: www.someschool.edu\r\n
Connection: close\r\n
User-agent: Mozilla/5.0\r\n
Accept-language: fr\r\n
\r\n

HTTP 请求报文完全由 ASCII 文本书写，每行以回车符（\r）和换行符（\n）结束。

请求报文结构：

  • 请求行（Request Line） ：第一行，包含三个字段——方法字段、URL 字段和 HTTP 版本字段
  • 首部行（Header Lines） ：后续各行，每行一个首部字段
  • 空行：首部行结束的标志
  • 实体体（Entity Body） ：GET 方法的实体体为空，POST 方法的实体体包含用户在表单中输入的内容

常用首部字段：

首部字段说明
Host指定对象所在的主机，HTTP/1.1 要求必须包含，用于 Web 代理缓存
Connectionclose 表示发送完响应后关闭连接（非持续）
User-agent浏览器类型，服务器可据此发送不同版本的对象
Accept-language用户优先使用的语言，服务器可据此返回对应语言版本

HTTP 方法：

方法说明
GET请求指定 URL 的对象，实体体为空
POST提交表单数据，数据放在实体体中
HEAD类似 GET，但服务器响应不含对象，常用于调试
PUT上传实体体中的对象到指定 URL 路径，用于 Web 发布工具
DELETE允许用户或应用程序删除 Web 服务器上的对象

GET vs POST： 使用 GET 方法时也可以在 URL 中传递表单数据（如 www.somesite.com/animalsearch?monkey&banana，? 后为用户输入），但 URL 有长度限制且不够安全；POST 方法将数据放在实体体中，更安全且无长度限制。

HTTP 响应报文

HTTP/1.1 200 OK\r\n
Connection: close\r\n
Date: Tue, 18 Aug 2015 15:44:04 GMT\r\n
Server: Apache/2.2.3 (CentOS)\r\n
Last-Modified: Tue, 18 Aug 2015 15:11:03 GMT\r\n
Content-Length: 6821\r\n
Content-Type: text/html\r\n
\r\n
(data data data data data ...)

响应报文结构：

  • 状态行（Status Line） ：第一行，包含 HTTP 版本、状态码和对应短语
  • 首部行（Header Lines） ：后续各行
  • 实体体（Entity Body） ：请求对象本身（最重要的部分）

常用首部字段：

首部字段说明
Connection: close发送完响应后关闭 TCP 连接
Date服务器产生并发送该响应报文的日期和时间（不是对象创建或修改的时间）
Server服务器类型，类似于请求报文中的 User-agent
Last-Modified对象创建或最后修改的日期和时间，对缓存至关重要
Content-Length被发送对象的字节数
Content-Type实体体中对象的类型（如 text/html, image/jpeg）

常见 HTTP 状态码：

状态码短语说明
200OK请求成功，信息在响应报文中返回
301Moved Permanently请求的对象已被永久转移，新 URL 定义在 Location 首部行，客户端会自动重定向
304Not Modified用于条件 GET，对象未修改，客户端使用缓存副本
400Bad Request服务器不能理解该请求，通用差错代码
404Not Found请求的对象不存在于服务器上
505HTTP Version Not Supported服务器不支持请求报文使用的 HTTP 版本

HTTP 是无状态的，但 Web 站点通常希望能识别用户，限制用户访问，或记录用户行为（购物车、推荐系统等）。Cookie 技术允许站点对用户进行跟踪。

Cookie 的四个组件：

  1. HTTP 响应报文中的 Set-cookie 首部行（服务器→客户）
  2. HTTP 请求报文中的 cookie 首部行（客户→服务器）
  3. 用户端系统中保存的 cookie 文件（由浏览器管理）
  4. Web 站点的后端数据库

Cookie 工作过程：

  1. 用户首次访问 Web 站点，站点为其创建唯一识别码（如 1678），并将含有 Set-cookie: 1678 的响应报文发给用户
  2. 用户浏览器收到响应后，在其 cookie 文件中添加一行记录（包含服务器主机名和识别码）
  3. 此后用户每次向该服务器发送 HTTP 请求，浏览器自动在请求中附加 cookie: 1678
  4. 服务器通过识别码在数据库中查找用户信息，实现个性化服务

Cookie 的隐私问题： Cookie 可以被用于构建用户档案，结合用户提供的账户信息（如邮件地址），可以精准识别用户身份，形成大量隐私信息。这也是 Cookie 受到广泛争议的原因，欧盟 GDPR 等法规对 Cookie 使用有严格限制。

2.2.5 Web 缓存

Web 缓存（Web Cache） 也称代理服务器（Proxy Server） ，是能够代表初始 Web 服务器来满足 HTTP 请求的网络实体。Web 缓存有自己的磁盘存储空间，在其中保存最近请求过的对象副本。

Web 缓存工作过程：

  1. 浏览器建立与 Web 缓存器的 TCP 连接，向其发送 HTTP 请求
  2. Web 缓存器检查本地是否存储了该对象的副本
    • 若有：直接返回缓存副本，无需联系初始服务器
    • 若没有：Web 缓存器向初始服务器发起 TCP 连接，请求该对象，收到后保存副本，再返回给客户

Web 缓存器既是服务器（对发出请求的浏览器而言）又是客户（对初始服务器而言）。

Web 缓存的好处：

  1. 减少响应时间：缓存通常部署在用户附近（如同一 LAN），传输速度更快
  2. 减少接入链路流量：减少了机构内网到因特网的接入链路上的流量，降低带宽费用
  3. 减轻原始服务器负担

通过计算理解缓存的价值：

设机构接入链路速率为 1.5 Mbps，平均对象大小 100 KB，平均请求速率 15 req/s，因特网时延约 2s。

流量强度 ρ=LaR=100000×8×151500000=0.8 ，接入链路排队时延较高。

若升级接入链路至 10 Mbps：费用高昂。

若安装 Web 缓存器，设命中率 40%：40% 的请求由缓存直接响应（时延极短），60% 的请求需经过接入链路，但接入链路流量降低为 60%，流量强度大幅下降，端到端时延也大幅降低，且成本远低于升级链路。

条件 GET

Web 缓存器保存的对象可能过期（初始服务器上的对象已更新），需要一种机制来验证缓存是否为最新版本，这就是条件 GET（Conditional GET） 。

条件 GET 的标志：

  • 请求报文使用 GET 方法
  • 请求报文包含 If-Modified-Since 首部行

工作流程：

  1. Web 缓存器第一次请求对象，收到响应，其中含 Last-Modified: Wed, 9 Sep 2015 09:23:24，缓存器将对象连同该日期一起存储
  2. 一周后，又有客户请求同一对象，缓存器向初始服务器发起条件 GET：If-Modified-Since: Wed, 9 Sep 2015 09:23:24
  3. 若对象未修改，服务器返回 304 Not Modified，响应报文实体体为空，节省带宽；若对象已修改，服务器返回新对象和新的 Last-Modified

2.2.6 HTTP/2

HTTP/2 于 2015 年标准化（RFC 7540），目标是减少在同一服务器上请求多个对象时的感知时延。

HTTP/1.1 的问题：HOL 阻塞

HTTP/1.1 使用持续连接和流水线，但仍存在HOL（Head-of-Line）阻塞问题：假设一个 Web 页面包含一个大视频文件和若干小图片，服务器按请求顺序处理，若视频文件排在队首，后面的小图片必须等待，即使小图片可以很快传完。

为绕过 HOL 阻塞，浏览器打开多个并行 TCP 连接（通常最多 6 个），但这也导致每个连接的拥塞窗口较小，总带宽利用率不高。

HTTP/2 的改进

帧（Framing）机制： HTTP/2 将每个报文分割成若干小的帧（Frame） ，来自不同响应的帧可以交错（Interleave） 发送，在接收端再重新组装。这样大文件的帧和小图片的帧可以交替发送，小图片不再被大文件阻塞，解决了 HOL 阻塞问题。

二进制编码： HTTP/2 使用二进制格式而非 HTTP/1.1 的 ASCII 文本格式，解析更高效，占用空间更小。

请求优先级： 客户端可以为不同对象指定优先级，让服务器优先发送高优先级对象的帧。

服务器推送（Server Push）： 服务器可以主动向客户端推送对象，无需等待客户端请求。例如服务器在发送 HTML 文件的同时，主动推送 HTML 中引用的 CSS 和 JS 文件，减少往返次数。

首部压缩（HPACK）： 对 HTTP 首部进行压缩，减少开销（HTTP 首部在每次请求中重复发送，如 Cookie 等字段可能很长）。

HTTP/3

HTTP/3 基于 QUIC 协议（运行在 UDP 之上），进一步解决 HTTP/2 中仍存在的问题：

  • HTTP/2 在单条 TCP 连接上多路复用，但 TCP 的可靠传输机制导致一旦某个 TCP 报文段丢失，所有流都必须等待重传（TCP 层面的 HOL 阻塞），HTTP/2 的帧交错也无济于事
  • QUIC 在 UDP 基础上实现了独立的流，每个流的丢包恢复互不影响
  • QUIC 内置 TLS，将加密和连接建立合并，实现 0-RTT 或 1-RTT 连接建立

2.3 电子邮件

2.3.1 电子邮件系统概述

因特网电子邮件系统有三个主要组成部分：用户代理（User Agent） 、邮件服务器（Mail Server） 和简单邮件传输协议（SMTP） 。

用户代理： 允许用户阅读、回复、转发、保存和撰写报文，如 Outlook、Thunderbird、Gmail 网页界面等。

邮件服务器： 电子邮件基础设施的核心。每个接收方在某个邮件服务器上有一个邮箱（Mailbox） ，存放该用户的入站报文。邮件服务器还有报文队列（Message Queue） ，存放待发送的邮件。

邮件发送过程（Alice 发给 Bob）：

  1. Alice 通过用户代理撰写报文并发送
  2. Alice 的用户代理将报文发送到 Alice 的邮件服务器，放入报文队列
  3. Alice 邮件服务器的 SMTP 客户端，发起到 Bob 邮件服务器的 TCP 连接
  4. 经 SMTP 握手后，SMTP 客户端将 Alice 的报文发送到 Bob 的邮件服务器
  5. Bob 的邮件服务器将报文放入 Bob 的邮箱
  6. Bob 通过用户代理读取报文

若 Alice 的邮件服务器无法连接 Bob 的邮件服务器，报文保存在 Alice 的报文队列中，稍后再试（通常每 30 分钟重试一次，若几天内仍失败则通知 Alice）。

2.3.2 SMTP

SMTP（Simple Mail Transfer Protocol，简单邮件传输协议） 是因特网电子邮件的核心应用层协议，使用 TCP 可靠数据传输，端口 25。

SMTP 有两个方面：运行在发送方邮件服务器的客户端和运行在接收方邮件服务器的服务器端。每台邮件服务器都同时运行 SMTP 的客户端和服务器端。

SMTP 通信过程

SMTP 通信分为三个阶段：

握手阶段（SMTP 握手）：

  • 客户端建立 TCP 连接（端口 25）
  • 服务器发送 220 ready 欢迎报文
  • 客户端发送 HELO 或 EHLO 命令，表明身份

传输阶段：

  • MAIL FROM:<alice@crepes.fr> — 发送方地址
  • RCPT TO:<bob@hamburger.edu> — 接收方地址
  • DATA — 准备传输报文体
  • 服务器回复 354 Start mail input
  • 客户端发送报文内容，最后一行为 .（单独一行，表示结束）
  • 服务器回复 250 OK

关闭阶段：

  • QUIT — 客户端请求关闭

SMTP 的一条 TCP 连接可以传输多封邮件（持续连接），一旦都传送完毕，客户端发 QUIT 关闭连接。

SMTP 与 HTTP 的比较

比较维度HTTPSMTP
协议类型拉协议（Pull，客户拉取服务器内容）推协议（Push，客户将报文推送到服务器）
报文格式首部行 + 实体体（二者独立）首部行 + 实体体（放在同一报文中）
字符集不限要求所有报文（含附件）必须是 7 位 ASCII 格式
多对象处理每个对象封装在独立响应报文中多个对象放在同一报文中发送

MIME（Multipurpose Internet Mail Extensions，多用途因特网邮件扩展）： 由于 SMTP 要求 7 位 ASCII，对于二进制数据（图片、音频等），需要通过 MIME 将二进制数据编码为 ASCII 格式（Base64 等），在首部添加额外字段（如 Content-Type、Content-Transfer-Encoding）说明数据类型和编码方式，接收方再解码还原。

邮件报文格式

RFC 5322 定义了电子邮件报文的格式，由首部行和报文体组成：

From: alice@crepes.fr
To: bob@hamburger.edu
Subject: Searching for the meaning of life.

报文体（ASCII 格式）

首部行与报文体之间有一个空行。From、To 是必需的，Subject 等是可选的。

注意：这里的首部行是邮件报文本身的首部，不同于 SMTP 命令中的 MAIL FROM 和 RCPT TO（后者是 SMTP 握手命令，用于建立 SMTP 连接，类似信封上的地址；前者是报文内容，类似信件内容本身）。

2.3.3 邮件访问协议

Alice 的用户代理将邮件推送到 Alice 的邮件服务器使用 SMTP。但 Bob 读取邮件是拉取操作——Bob 的用户代理从 Bob 的邮件服务器取邮件，这不能用 SMTP（SMTP 是推协议），需要使用邮件访问协议。

POP3

POP3（Post Office Protocol Version 3，第三版邮局协议） 极其简单，功能有限。

POP3 工作在三个阶段：

  1. 特许（Authorization）阶段：用户代理发送用户名和口令认证身份
  2. 事务处理阶段：用户代理取回报文，可以做标记、删除、获取统计等
  3. 更新阶段：客户端发出 QUIT 命令，服务器删除被标记为删除的报文

POP3 的"下载并删除"模式：用户在一台机器上取走邮件后，其他机器就无法再访问同一封邮件，不适合多设备用户。

IMAP

IMAP（Internet Mail Access Protocol，因特网邮件访问协议） 具有比 POP3 多得多的功能，也复杂得多。

IMAP 的核心特性：

  • 邮件保存在服务器上，用户可以在任意设备访问所有邮件
  • 允许用户创建文件夹，将邮件移入不同文件夹管理
  • 维护 IMAP 会话中的用户状态信息（如文件夹结构）
  • 允许用户代理只获取报文的某些部分（如只取首部，在低速连接时避免下载大附件）

基于 Web 的电子邮件（HTTP）

Gmail、Outlook 等 Web 邮件服务，用户通过浏览器（HTTP）与邮件服务器交互：

  • 用户代理（浏览器）→ Alice 的邮件服务器：使用 HTTP（而非 SMTP）
  • Alice 的邮件服务器 → Bob 的邮件服务器：使用 SMTP
  • Bob 的邮件服务器 → Bob 的浏览器：使用 HTTP（而非 POP3/IMAP）

2.4 DNS：因特网的目录服务

2.4.1 DNS 提供的服务

人类习惯使用便于记忆的主机名（如 www.google.com），而路由器处理固定长度的 IP 地址（如 142.250.74.46）更方便。DNS（Domain Name System，域名系统） 负责将主机名翻译为 IP 地址。

DNS 是：

  1. 一个由分层 DNS 服务器（运行 BIND 软件的 UNIX 机器）实现的分布式数据库
  2. 一个允许主机查询分布式数据库的应用层协议

DNS 使用 UDP 作为传输层协议，端口 53。DNS 通常由其他应用层协议（HTTP、SMTP）调用，在用户进行网络访问前自动完成域名解析，对用户透明。

DNS 提供的其他服务：

  • 主机别名（Host Aliasing） ：一个主机可以有一个规范主机名（Canonical Hostname） （如 relay1.west-coast.enterprise.com）和一个或多个别名（Alias） （如 enterprise.com、www.enterprise.com）。DNS 可以将别名解析为规范主机名及其 IP 地址。

  • 邮件服务器别名（Mail Server Aliasing） ：同样支持邮件服务器的别名解析，使邮件服务器和 Web 服务器可以使用同一别名（如 yahoo.com），但有不同的规范主机名。MX 记录允许一个公司的邮件服务器和 Web 服务器拥有相同的主机名（别名）。

  • 负载分配（Load Distribution） ：DNS 可以将一个主机名对应多个 IP 地址（多台服务器），在响应 DNS 查询时轮转（Rotate） 这些地址的顺序，从而将流量分散到不同服务器，实现负载均衡。

2.4.2 DNS 工作原理

分布式层次数据库

DNS 采用分布式、层次化的设计，主要原因是：集中式设计存在单点故障、流量瓶颈、远距离时延大、难以维护和扩展等问题，不适合因特网规模。

DNS 服务器大致分为三种类型，构成层次结构：

根 DNS 服务器（Root DNS Server）
         ↓
顶级域 DNS 服务器（TLD DNS Server）
（如 .com, .org, .net, .edu, .gov, .cn 等）
         ↓
权威 DNS 服务器（Authoritative DNS Server）
（各组织自己维护）

根 DNS 服务器： 全球有 13 组根服务器（标记为 A 到 M），实际上每组由多台服务器通过 IP 任播（Anycast）组成，加起来超过 1000 台。根服务器提供 TLD 服务器的 IP 地址。

顶级域（TLD）DNS 服务器： 负责 .com、.org、.net、.edu 等通用顶级域和 .cn、.uk、.fr 等国家顶级域。例如 Verisign 公司维护 .com 的 TLD 服务器。TLD 服务器提供权威 DNS 服务器的 IP 地址。

权威 DNS 服务器： 每个在因特网上可以公共访问的组织必须提供公共可访问的 DNS 记录，这些记录存储在权威 DNS 服务器上，将主机名映射到 IP 地址。组织可以自建权威 DNS 服务器，也可以付费使用服务提供商的权威 DNS 服务器。

本地 DNS 服务器（Local DNS Server）： 严格来说不属于 DNS 层次结构，但至关重要。每个 ISP（家庭 ISP、企业、大学等）都有一个本地 DNS 服务器（也称默认名字服务器）。主机的第一个 DNS 查询发往本地 DNS 服务器，本地 DNS 服务器起代理作用，将查询转发到 DNS 层次结构中，并将结果返回给主机。

DNS 查询过程

迭代查询（Iterative Query）（常见方式）：

以主机 cis.poly.edu 查询 gaia.cs.umass.edu 的 IP 地址为例：

  1. 主机向本地 DNS 服务器（dns.poly.edu）发送查询
  2. 本地 DNS 服务器向根 DNS 服务器查询，根服务器返回 .edu TLD 服务器地址
  3. 本地 DNS 服务器向 TLD 服务器查询，TLD 服务器返回 dns.umass.edu（权威服务器）地址
  4. 本地 DNS 服务器向 dns.umass.edu 查询，获得 gaia.cs.umass.edu 的 IP 地址
  5. 本地 DNS 服务器将 IP 地址返回给发起查询的主机

整个过程共发送了 8 条 DNS 报文（4 次查询 + 4 次响应）。

递归查询（Recursive Query）：

主机将解析任务完全交给本地 DNS 服务器，本地服务器再向根服务器递归查询，根服务器向 TLD 服务器递归查询，以此类推，结果沿原路返回。实践中根服务器不倾向于做递归查询，通常使用迭代方式。

DNS 缓存

DNS 缓存（DNS Caching） 是 DNS 的一个重要特性，用于改善时延性能并减少因特网上 DNS 报文数量。

工作原理：在一次查询过程中，当某个 DNS 服务器收到一个 DNS 回答时，它能将其中的信息缓存在本地存储器中。下次收到相同查询时直接从缓存中返回，无需再次查询上级服务器。

缓存有 TTL（Time To Live，生存时间） ：通常为 2 天。TTL 过期后缓存条目被删除，再次查询时需重新向权威服务器查询。

本地 DNS 服务器会缓存 TLD 服务器的地址，因此在实际中根 DNS 服务器被绕过的情况很常见，根服务器的实际压力远小于理论值。

2.4.3 DNS 记录和报文

资源记录（RR）

DNS 分布式数据库存储了资源记录（Resource Record，RR） ，提供主机名到 IP 地址的映射。每条 RR 是一个四元组：

(Name, Value, Type, TTL)

TTL 决定该记录在缓存中的生存时间。Name 和 Value 的含义取决于 Type：

TypeNameValue说明
A主机名IPv4 地址标准主机名到 IP 的映射，如 (relay1.bar.foo.com, 145.37.93.126, A)
AAAA主机名IPv6 地址IPv6 版本的 A 记录
NS域（如 foo.com）该域的权威 DNS 服务器主机名用于路由 DNS 查询，如 (foo.com, dns.foo.com, NS)
CNAME别名主机名对应的规范主机名如 (foo.com, relay1.bar.foo.com, CNAME)
MX别名对应的邮件服务器规范主机名允许邮件服务器有别名，如 (foo.com, mail.bar.foo.com, MX)

注意： NS 记录和 A 记录通常成对出现。当 TLD 服务器告知权威服务器的主机名（NS 记录）时，通常同时附带该主机名对应的 IP 地址（A 记录），这条附带的 A 记录称为粘合记录（Glue Record） ，避免再发起一次额外查询。

DNS 报文格式

DNS 查询报文和回答报文的格式完全相同，共有以下字段：

首部区域（12 字节）：

字段大小说明
标识符（ID）16 bits标识该查询，回答报文使用相同标识符，使客户端能匹配请求和响应
标志（Flags）16 bits包含多个标志位，如查询/回答标志（0=查询，1=回答）、权威标志、递归期望标志、递归可用标志
问题数16 bits
回答 RR 数16 bits
权威 RR 数16 bits
附加 RR 数16 bits

问题区域： 包含正在查询的名字（如 gaia.cs.umass.edu）和查询类型（如 A、MX）

回答区域： 包含对最初查询名字的 RR，可以有多条 RR（一个主机名对应多个 IP 地址）

权威区域： 包含其他权威服务器的记录

附加区域： 包含有帮助的其他记录（如 NS 记录对应的 A 记录）

在 DNS 数据库中插入记录

当新注册一个域名（如 networkutopia.com）时：

  1. 向域名注册机构（Registrar，如 GoDaddy、阿里云等）提供权威 DNS 服务器的主机名和 IP 地址
  2. 注册机构在 .com TLD 服务器中插入两条 RR：
    • (networkutopia.com, dns1.networkutopia.com, NS)
    • (dns1.networkutopia.com, 212.212.212.1, A)
  3. 在自己的权威 DNS 服务器上添加：
    • (www.networkutopia.com, 212.212.212.1, A) — Web 服务器
    • (networkutopia.com, mail.networkutopia.com, MX) — 邮件服务器

DNS 安全

DNS 面临安全威胁：

  • DNS 欺骗/缓存中毒（Cache Poisoning） ：攻击者向 DNS 服务器注入伪造的 RR，使主机被导向恶意 IP 地址
  • DDoS 攻击：向根服务器发动带宽洪泛攻击（历史上发生过，但被过滤和 Anycast 技术缓解）
  • DNS 放大攻击：利用 DNS 协议的非对称性（小查询→大响应），以 UDP 欺骗发动 DDoS

DNSSEC（DNS Security Extensions） 通过数字签名对 DNS 记录进行认证，防止欺骗和缓存中毒，但部署进展较慢。

2.5 P2P 文件分发

2.5.1 P2P 体系结构的扩展性

在客户-服务器体系结构中，服务器必须向每个对等方发送文件的一份副本，服务器的总体发送时间随用户数量线性增长。而在 P2P 体系结构中，每个对等方收到文件后也可以向其他对等方分发，系统总体分发能力随用户数增加而增长。

分发时间分析：

设文件大小为 F bits，对等方数量为 N ，服务器上传速率为 us ，每个对等方 i 的上传速率为 ui ，下载速率为 di 。

客户-服务器最小分发时间：

Dcs=max(NFus,Fdmin)

随 N 线性增长。

P2P 最小分发时间：

DP2P=max(Fus,Fdmin,NFus+∑i=1Nui)
  • 第一项：服务器至少要发出一份完整文件
  • 第二项：最慢的对等方限制了最小时间
  • 第三项：系统总共需要分发 NF bits，总上传能力为 us+∑ui

P2P 的分发时间随 N 增长非常缓慢，甚至趋于稳定，具有优秀的可扩展性。

2.5.2 BitTorrent

BitTorrent 是目前最广泛使用的 P2P 文件分发协议。

基本概念

  • 洪流（Torrent） ：参与特定文件分发的所有对等方的集合
  • 块（Chunk） ：文件被分成固定大小的数据块，通常为 256 KB
  • 追踪器（Tracker） ：追踪参与洪流的对等方，当新对等方加入时，追踪器随机选择一组对等方（如 50 个）的地址列表提供给新加入者

对等方加入洪流后，从邻居对等方处获取块，同时也向其他对等方分发块，当获得完整文件后可以选择继续留在洪流中（利他）或离开（自私）。

请求块策略：最稀缺优先

Alice 对哪些块发出请求？使用最稀缺优先（Rarest First） 策略：

优先请求在自己邻居中副本数量最少的块。这样可以让最稀缺的块尽快得到更多副本，均衡各块的分布，避免某些块因对等方离开而完全消失。

发送块策略：阻塞机制

Alice 优先向谁发送块？BitTorrent 使用一种"以牙还牙（Tit-for-Tat）"的机制：

Alice 持续测量从每个邻居处收到数据的速率，选出当前向自己提供数据速率最高的前 4 个邻居（称为"疏通（Unchoke）"），向这 4 个邻居发送块；对其他邻居实行阻塞（Choke） ，不向其发送任何块。

Alice 每 30 秒随机选择一个额外的邻居，向其发送块，称为乐观疏通（Optimistic Unchoking） 。这个随机选择的邻居可能比当前 4 个邻居速率更快，从而逐渐替换进前 4 名，使系统动态找到最优伙伴。

这种机制的效果：能够提供较快速率的对等方往往能从其他提供较快速率的对等方处获取数据，实现互利合作，而"搭便车"（只下载不上传）的对等方会发现难以获得数据。

2.6 视频流和内容分发网络

2.6.1 因特网视频

视频的特点：

  • 视频是图像序列，通常以恒定速率显示（如 24、30、60 帧/秒）
  • 每帧图像是由像素（Pixel） 组成的阵列，每个像素用若干比特表示颜色和亮度
  • 视频可以被压缩：利用帧内冗余（空间冗余）和帧间冗余（时间冗余）
  • 常用编码格式：H.264、H.265（HEVC）、AV1；封装格式：MP4、MKV 等
  • CBR（恒定比特率） ：固定速率编码
  • VBR（可变比特率） ：根据画面复杂度动态调整码率，更高效

视频是当前因特网流量的最大来源，YouTube、Netflix 等平台消耗了大量带宽。

流式视频（Streaming Video）的挑战： 不同用户的带宽差异巨大（从几百 Kbps 到数百 Mbps），且同一用户的可用带宽也随时间变化。简单地以固定码率流式传输效果很差。

2.6.2 HTTP 流和 DASH

早期 HTTP 流： 视频文件存储在 HTTP 服务器上，客户端与服务器建立 TCP 连接，发送 HTTP GET 请求，服务器以尽可能快的速度发送视频文件。客户端收到一定数量字节后开始播放，同时在后台继续下载缓冲。

问题：所有客户不管带宽如何，都接收到相同的固定编码版本，对于低带宽用户造成频繁卡顿。

DASH（Dynamic Adaptive Streaming over HTTP，经 HTTP 的动态自适应流）：

视频被编码为多个不同比特率的版本（如 300 Kbps、1 Mbps、3 Mbps、8 Mbps），每个版本又被分成若干块（Chunk） （通常几秒长），每个块单独存储在 HTTP 服务器上。

服务器同时提供一个告示文件（Manifest File） ，记录不同版本的 URL 和比特率信息。

DASH 工作流程：

  1. 客户端首先请求并下载告示文件，了解有哪些版本可选
  2. 客户端周期性地测量当前可用带宽（通过观察下载速率）
  3. 根据带宽自适应地选择合适版本的块发起 GET 请求：带宽充足时请求高质量版本，带宽不足时请求低质量版本
  4. 维护一定大小的播放缓冲区，确保流畅播放

DASH 的核心是智能客户端：由客户端决定"何时请求块"、“请求哪个质量的块”、“从哪里请求块（可以是不同的 CDN 服务器）”，服务器无需了解客户端的网络状况。

2.6.3 内容分发网络

视频流媒体提供商面临一个问题：如何将内容分发给全球数百万并发用户？

方案 1：单一大型数据中心

问题：单点故障风险、到远距离用户时延大、热门视频通过同一接入链路反复传输浪费带宽。

方案 2：内容分发网络（CDN，Content Distribution Network）

CDN 管理分布在多个地理位置的服务器，在这些服务器中存储视频（及其他 Web 内容）的副本，并将用户请求引导至能提供最佳服务的 CDN 服务器。CDN 可以是公司自建的（如谷歌的 GGC），也可以是第三方提供的（如 Akamai、Cloudflare、AWS CloudFront）。

CDN 服务器部署策略

深入（Enter Deep）策略：

  • 将 CDN 服务器深入部署到全球各地的接入 ISP 中
  • 靠近终端用户，减少时延，改善用户体验
  • 代价：服务器数量多（数千台），维护管理复杂

邀请做客（Bring Home）策略：

  • 在少数关键位置（通常靠近 IXP）建立大型服务器集群（PoP）
  • 接入 ISP 需要将流量送到最近的 PoP
  • 代价：服务器数量少，维护成本低，但时延相对较高

Akamai 采用深入策略，Limelight 采用邀请做客策略。大型内容提供商（如 Google、Netflix）自建 CDN，采用混合策略。

CDN 如何将用户请求引导到合适的服务器

CDN 主要通过 DNS 重定向实现：

以用户访问 video.netcinema.com 为例（CDN 服务商为 KingCDN）：

  1. 用户 DNS 查询 video.netcinema.com
  2. 本地 DNS 服务器向 NetCinema 的权威 DNS 服务器查询
  3. NetCinema 的权威服务器返回 KingCDN 某主机名（如 a1105.kingcdn.com）的 CNAME 记录
  4. 本地 DNS 服务器转而查询 KingCDN 的 DNS 系统
  5. KingCDN 的 DNS 系统返回某个合适的 CDN 服务器的 IP 地址
  6. 本地 DNS 服务器将该 IP 地址返回给用户
  7. 用户直接向该 CDN 服务器发起 HTTP 请求获取视频

KingCDN 的 DNS 系统如何选择"合适的"服务器？CDN 集群选择策略（Cluster Selection Strategy）：

  • 地理位置最近：选择地理位置（按 IP 地址估计）离用户最近的集群，简单但不精确（地理最近不等于网络最近）
  • 实时网络测量：CDN 定期向本地 DNS 服务器发送探测包，测量各集群到各地区的时延和丢包率，选择实时网络性能最好的集群
  • 混合策略：结合地理位置和实时测量

Netflix 案例

Netflix 使用亚马逊云（AWS）处理注册、登录、支付、内容推荐等业务，但视频内容分发使用自建的 CDN（Open Connect）。

Netflix 在夜间低峰期，主动将热门视频推送（预置，Push）到 ISP 内部的 Open Connect 服务器，而非被动等待用户请求后再从远端服务器获取。这种主动预置策略利用低峰期带宽，大幅减少了高峰期的网络负载。

2.7 套接字编程：生成网络应用

网络应用由一对程序构成——客户程序和服务器程序，分别运行在不同端系统上，通过套接字通信。

2.7.1 UDP 套接字编程

UDP 是无连接的，发送数据前无需建立连接，每个分组独立处理。发送方在每个分组中附上目的主机的 IP 地址和端口号，网络根据这两个信息将分组路由到正确目的地。

UDP 客户端（Python 示例逻辑）：

创建套接字（socket, SOCK_DGRAM）
读取用户输入
将数据发送到（服务器IP, 服务器端口）
接收服务器返回的数据
打印结果
关闭套接字

UDP 服务器端（Python 示例逻辑）：

创建套接字（socket, SOCK_DGRAM）
绑定到特定端口（bind）
循环：
    接收数据和客户端地址（recvfrom）
    处理数据
    将结果发送回客户端地址（sendto）

关键点：

  • 使用 recvfrom() 接收数据时，同时获得发送方地址（IP + 端口），以便回复
  • UDP 不保证分组到达，也不保证到达顺序
  • UDP 报文可能比 TCP 报文段有更大的不确定性

2.7.2 TCP 套接字编程

TCP 是面向连接的，通信前需要建立连接。服务器必须事先准备好接受连接请求。

服务器有两种套接字：

  • 欢迎套接字（Welcome Socket） ：持续监听新的连接请求，类似前台接待，端口固定（如 80）
  • 连接套接字（Connection Socket） ：为每个连接的客户单独创建，用于实际数据传输，端口由系统随机分配

TCP 客户端（Python 示例逻辑）：

创建套接字（socket, SOCK_STREAM）
发起连接（connect 到服务器IP和端口，触发三次握手）
发送数据（send）
接收数据（recv）
关闭套接字

TCP 服务器端（Python 示例逻辑）：

创建欢迎套接字（socket, SOCK_STREAM）
绑定到特定端口（bind）
监听（listen）
循环：
    接受连接（accept，阻塞等待，返回连接套接字和客户端地址）
    在连接套接字上接收数据（recv）
    处理数据
    在连接套接字上发送结果（send）
    关闭连接套接字

关键点：

  • connect() 触发 TCP 三次握手，连接建立后才能传数据
  • accept() 在欢迎套接字上等待，返回新的连接套接字，可为每个连接创建一个线程/进程
  • TCP 提供字节流服务，数据可能被分片，接收方可能需要多次 recv() 才能获得完整数据
  • send() 和 recv() 都通过套接字与 TCP 缓冲区交互，实际发送和接收由 TCP 控制

本章小结

本章从应用层角度介绍了因特网应用的原理和主要协议，主要内容包括：

  1. 应用层体系结构：客户-服务器体系结构（服务器固定地址、总是开机）和 P2P 体系结构（自扩展性）；进程通过套接字（API）与网络交互，使用 IP 地址 + 端口号寻址

  2. 传输层服务选择：可靠数据传输、吞吐量、定时、安全性四个维度；TCP（面向连接、可靠、拥塞控制）vs UDP（无连接、不可靠、低开销）

  3. HTTP：无状态拉协议；非持续（HTTP/1.0，每个对象 2RTT）vs 持续连接（HTTP/1.1，流水线）；请求/响应报文格式；Cookie（用户跟踪）；Web 缓存和条件 GET；HTTP/2（帧、多路复用、服务器推送、首部压缩）；HTTP/3（基于 QUIC/UDP）

  4. 电子邮件：用户代理、邮件服务器、SMTP（推协议、TCP 端口 25、7 位 ASCII、持续连接）；POP3 vs IMAP vs HTTP 方式访问邮件

  5. DNS：分布式层次数据库（根、TLD、权威、本地 DNS 服务器）；迭代查询和递归查询；DNS 缓存（TTL）；资源记录类型（A、NS、CNAME、MX）；DNS 报文格式；DNSSEC

  6. P2P 文件分发：P2P 的自扩展性；BitTorrent（洪流、块、追踪器、最稀缺优先请求、以牙还牙发送机制、乐观疏通）

  7. 视频流和 CDN：DASH（多版本、分块、智能客户端自适应选择）；CDN（深入 vs 邀请做客部署策略；DNS 重定向选择服务器；Netflix 主动预置策略）

  8. 套接字编程：UDP 套接字（无连接，recvfrom/sendto）；TCP 套接字（面向连接，欢迎套接字 + 连接套接字，connect/accept/send/recv）

第三章 传输层

3.1 概述和传输层服务

3.1.1 传输层和网络层的关系

传输层协议为运行在不同主机上的应用进程提供逻辑通信（Logical Communication） ：从应用程序的角度看，两台主机好像是直接相连的，而实际上这两台主机可能位于地球的两端，中间经过无数路由器和各种类型的链路。

传输层 vs 网络层：

  • 网络层：提供主机之间的逻辑通信
  • 传输层：提供进程之间的逻辑通信

传输层协议运行在端系统中，而非路由器中。发送方传输层将应用进程的报文转换为传输层分组（报文段，Segment），然后交给网络层；接收方传输层从网络层取出报文段，将数据交付给正确的应用进程。

家庭类比： 设 Alice 家和 Bob 家各有 12 个孩子互相通信。每家有一个"家庭代理"负责收发信件——将孩子写的信统一送到邮局（类似多路复用），并将邮局送来的信分发给各个孩子（类似多路分解）。这里"孩子"是应用进程，"信件"是应用层报文，"家庭代理"是传输层协议，"邮政服务"是网络层。

传输层能提供什么，不能提供什么：

传输层的服务受限于网络层的服务模型。如果网络层协议不能为主机间的通信提供时延或带宽保证，传输层协议也无法为进程间通信提供这些保证。

但是传输层可以扩展网络层的服务：例如即使底层网络层协议是不可靠的（如 IP），传输层也可以通过差错恢复机制提供可靠数据传输服务；传输层还可以提供加密服务，即使网络层不提供。

3.1.2 因特网传输层概述

因特网提供两种截然不同的传输层协议：

UDP（User Datagram Protocol）：

  • 不可靠、无连接服务
  • 仅提供多路复用/多路分解和简单的差错检测
  • 对应用程序的数据发送几乎不加控制

TCP（Transmission Control Protocol）：

  • 可靠、面向连接服务
  • 提供可靠数据传输、拥塞控制、流量控制
  • 在 IP 不可靠服务的基础上建立可靠信道

因特网网络层协议是 IP（Internet Protocol） ，提供尽力而为交付服务（Best-Effort Delivery Service） ：IP 尽力在通信主机之间交付报文段，但不做任何保证——不保证报文段的交付，不保证顺序交付，不保证数据完整性。因此 IP 是不可靠服务（Unreliable Service） 。

将主机间交付扩展到进程间交付称为传输层的多路复用与多路分解，这是 UDP 和 TCP 都必须提供的最基本服务。

3.2 多路复用与多路分解

3.2.1 基本概念

多路分解（Demultiplexing）： 将传输层收到的报文段中的数据，交付给正确的套接字（即正确的应用进程）的工作。

多路复用（Multiplexing）： 在源主机，从不同套接字收集数据块，并为每个数据块封装首部信息（用于分解），生成报文段传递给网络层的工作。

端口号（Port Number）：

  • 16 位整数，范围 0~65535
  • 周知端口号（Well-Known Port Numbers） ：0~1023，保留给特定应用（HTTP: 80，HTTPS: 443，FTP: 21，SMTP: 25，DNS: 53）
  • 临时端口号（Ephemeral Port） ：1024~65535，由操作系统动态分配给客户端套接字

传输层报文段首部中包含源端口号和目的端口号字段，接收方通过目的端口号（以及其他信息）将报文段交付到正确的套接字。

3.2.2 无连接的多路复用与多路分解（UDP）

UDP 套接字由二元组唯一标识：

(目的 IP 地址, 目的端口号)

如果两个 UDP 报文段有不同的源 IP 地址和/或源端口号，但具有相同的目的 IP 地址和目的端口号，那么这两个报文段将通过相同的套接字被导向相同的目的进程。

源端口号的作用： 作为"返回地址"。接收方使用源端口号和源 IP 地址构造响应报文并发回。

3.2.3 面向连接的多路复用与多路分解（TCP）

TCP 套接字由四元组唯一标识：

(源 IP 地址, 源端口号, 目的 IP 地址, 目的端口号)

两个具有不同源 IP 地址或源端口号的 TCP 报文段，即使目的 IP 地址和目的端口号相同，也会被导向不同的套接字（不同的连接）。

这就是为什么服务器可以同时处理来自多个客户的请求：每个客户连接对应一个独立的连接套接字，由四元组区分。

与 UDP 的对比：

特点UDPTCP
套接字标识二元组（目的IP, 目的端口）四元组（源IP, 源端口, 目的IP, 目的端口）
连接关系无连接，同一目的可复用套接字面向连接，每个连接独立套接字
并发处理一个套接字处理所有来源的报文每个客户连接有独立套接字

Web 服务器与 TCP 套接字： 高性能 Web 服务器通常只使用一个进程，为每个新的客户连接创建一个新的线程（而非进程），每个线程有自己的连接套接字。非持续 HTTP 的每个请求-响应都有自己的 TCP 连接和套接字（连接关闭后套接字销毁），而持续 HTTP 在整个持续连接期间使用同一套接字。

3.3 无连接传输：UDP

3.3.1 UDP 概述

UDP 几乎没有在 IP 之上增加什么：仅增加了多路复用/多路分解功能和简单的差错检测。UDP 从应用进程取数据，附加源/目的端口号等少量首部字段，直接传给网络层。

为什么使用 UDP？

  1. 应用层能更好地控制发送时间和速率： UDP 没有拥塞控制，发送方可以以任意速率发送，适合需要精确控制的实时应用（如实时视频、在线游戏）

  2. 无需建立连接： TCP 的三次握手引入额外时延，UDP 无此开销。DNS 使用 UDP，若用 TCP 则每次域名查询都需要握手，时延倍增

  3. 无连接状态： TCP 在端系统维护连接状态（缓冲区、拥塞控制变量、序号与确认号等），UDP 不维护任何连接状态，同样的服务器硬件可以支持更多并发 UDP 客户

  4. 分组首部开销小： TCP 首部 20 字节，UDP 首部仅 8 字节，对于小报文，TCP 首部开销占比显著

使用 UDP 的典型应用：

应用类型应用传输协议
实时多媒体网络电话、视频会议UDP（通常）
流式媒体YouTube（早期）UDP 或 TCP
域名解析DNSUDP
网络管理SNMPUDP
路由选择RIPUDP

UDP 上的可靠传输： 使用 UDP 并不意味着完全放弃可靠性。应用程序可以在应用层自行实现可靠性机制（重传、确认、序号等），同时避开 TCP 拥塞控制的限制。例如早期的 HTTP/3（基于 QUIC/UDP）就是这种思路。

3.3.2 UDP 报文段结构

UDP 报文段由 RFC 768 定义，结构如下：

 0              15 16             31
+----------------+----------------+
|   源端口号      |   目的端口号    |   首部
+----------------+----------------+
|    长度         |    检验和       |
+----------------+----------------+
|                                 |
|         数据（应用数据）          |   数据
|                                 |
+---------------------------------+
字段大小说明
源端口号16 bits发送方端口号
目的端口号16 bits接收方端口号，用于多路分解
长度16 bitsUDP 报文段的总长度（首部 + 数据），最小值为 8（仅首部）
检验和16 bits差错检测
数据可变应用层数据

UDP 首部仅 8 字节，非常精简。

3.3.3 UDP 检验和

目的： 检测 UDP 报文段在传输过程中是否出现比特差错（翻转）。

发送方计算检验和：

将报文段（加上伪首部：源IP、目的IP、协议号、UDP长度）中所有 16 比特字相加，将所得结果的进位（溢出）回卷到结果上，然后对结果取反码（每位取反）得到检验和，填入检验和字段。

接收方验证：

将收到的所有 16 比特字（含检验和字段）相加，若结果为全 1（1111111111111111），则无差错；若有任何一个 0 位，则说明报文段已受损。

为什么在 UDP 中提供检验和，而不完全依赖链路层？

  • 不能保证所有链路都提供差错检测（某些链路层协议不提供）
  • 即使链路层提供了差错检测，报文段在路由器内存中存储时也可能引入差错

这体现了端到端原则（End-to-End Principle） ：只有在端系统处实现某功能，才能在整个系统层面上保证该功能的正确性，中间节点的处理不能替代端到端的保障。

UDP 检验和的局限： 只能检测差错，不能纠正。UDP 对检测到差错的报文段，要么丢弃，要么连同警告一起交给应用程序，具体行为取决于实现。

3.4 可靠数据传输原理

可靠数据传输（Reliable Data Transfer，rdt）是传输层最重要的问题之一。上层应用调用 rdt_send()，希望数据能可靠地到达接收方；接收方调用 rdt_rcv()，将正确接收的数据通过 deliver_data() 交给上层。然而底层信道可能是不可靠的——这就是问题所在。

我们通过逐步构建协议来理解可靠传输的设计思路，使用有限状态机（FSM，Finite State Machine） 描述协议。

3.4.1 构建可靠数据传输协议

rdt 1.0：完全可靠的信道

假设底层信道完全可靠，不会出现比特差错和分组丢失。

在此假设下，发送方和接收方的 FSM 极其简单：

  • 发送方：等待上层调用 → 打包并发送分组
  • 接收方：等待下层调用 → 解包并交付给上层

无需任何差错恢复机制，这是理想情况。

rdt 2.0：产生比特差错的信道

假设底层信道可能翻转分组中的比特，但不丢失分组。

差错检测： 使用检验和检测比特差错。

接收方反馈： 引入控制报文——肯定确认（ACK，Acknowledgement） 和否定确认（NAK，Negative Acknowledgement） 。接收方收到正确分组回复 ACK，收到错误分组回复 NAK。

发送方重传： 发送方收到 NAK 后重传分组，收到 ACK 则发送下一个分组。

rdt 2.0 是停等协议（Stop-and-Wait Protocol） ：发送方发出一个分组后，在收到接收方的确认之前不会发送新数据。

rdt 2.0 的致命缺陷： ACK/NAK 报文本身也可能受损！发送方收到受损的反馈报文时，不知道接收方是否正确收到了分组，无法判断应该重传还是发送新分组。

rdt 2.1：处理受损的 ACK/NAK

解决方案： 发送方对每个分组添加序号（Sequence Number） ，接收方根据序号判断收到的是新分组还是重传分组。

停等协议只需要两个序号（0 和 1）即可区分当前分组和重传分组。

发送方 FSM（4 个状态）：

  • 等待上层调用发送序号 0 的分组
  • 等待对序号 0 分组的 ACK 或 NAK
  • 等待上层调用发送序号 1 的分组
  • 等待对序号 1 分组的 ACK 或 NAK

若收到受损 ACK/NAK 或 NAK，重传当前分组；若收到正确 ACK，发送下一个分组。

接收方 FSM（2 个状态）：

  • 等待序号 0 的分组：若正确收到序号 0 的分组，回复 ACK 并移至等待序号 1；若收到序号 1 的分组（重复），回复 ACK（告知发送方已收到）；若收到受损分组，回复 NAK
  • 等待序号 1 的分组：对称处理

rdt 2.2：无 NAK 的协议

改进： 去掉 NAK，只使用 ACK。接收方不发送 NAK，而是对最后正确收到的分组发送 ACK，ACK 中包含该分组的序号。

发送方收到冗余 ACK（Duplicate ACK） （对同一序号的两次 ACK）时，效果等同于收到 NAK——重传当前分组。这为后续 TCP 的快速重传奠定了基础。

rdt 3.0：产生差错和丢包的信道

假设底层信道既可能翻转比特，又可能丢失分组（包括数据分组和 ACK 分组）。

解决丢包： 发送方等待"合理"的时间后，若未收到 ACK 则重传分组。需要引入定时器（Timer） 。

关键问题： 如何确定"合理"的等待时间？太短则频繁不必要的重传，太长则对丢包响应迟缓。实践中选择一个合理的超时值，并接受可能出现的不必要重传（冗余分组）。

接收方通过序号识别冗余分组，对冗余分组也回复 ACK（不能丢弃不理，否则发送方会一直重传）。

由于序号在 0 和 1 之间交替，rdt 3.0 也称为交替比特协议（Alternating-Bit Protocol） 。

rdt 3.0 的性能问题：

rdt 3.0 虽然正确，但性能极差。以发送方发送 1000 Mbps 链路，传播时延 15ms，分组大小 8000 bits 为例：

dtrans=LR=8000109=0.008 ms 发送方利用率=L/RRTT+L/R=0.00830.008≈0.00027

发送方利用率仅为 0.027%！大部分时间发送方都在空等 ACK，链路严重浪费。问题根源在于停等协议的串行性。

3.4.2 流水线可靠数据传输协议

流水线（Pipelining）： 允许发送方在收到 ACK 之前发送多个分组，无需等待确认，如同"填满管道"。

流水线技术对可靠数据传输协议的影响：

  • 必须增大序号范围（不再只需 0 和 1）
  • 发送方和接收方都需要缓存多个分组
  • 需要解决流水线中差错恢复的问题

处理流水线差错恢复的两种基本方法：回退 N 步（GBN） 和选择重传（SR） 。

3.4.3 回退 N 步（GBN）

滑动窗口协议： 发送方维护一个大小为 N 的发送窗口（Window） ，允许最多 N 个已发送但未确认的分组同时存在于"管道"中。

发送方窗口示意：
|已确认|  已发送未确认（窗口内）  |未发送|
        base            nextseqnum
        |<-----------N---------->|
  • base：最小未确认分组的序号
  • nextseqnum：下一个待发送分组的序号
  • 窗口大小 N ：限制已发送未确认的分组数量

序号空间： 若使用 k 位表示序号，则序号范围为 [0,2k−1] ，GBN 的窗口大小最大为 2k−1 （不能等于 2k ，否则无法区分新分组和重传分组）。

GBN 发送方的事件处理：

  • 上层调用： 若窗口未满，创建分组并发送，更新 nextseqnum；若窗口已满，拒绝数据（返回上层）或缓存
  • 收到 ACK(n)： 使用累积确认（Cumulative Acknowledgement） ，表示序号 n 及之前的所有分组均已正确接收，将 base 移至 n+1 ，若 base == nextseqnum 则停止定时器，否则重启定时器
  • 超时： 重传所有已发送但未确认的分组（序号从 base 到 nextseqnum-1），定时器针对的是最老的未确认分组

GBN 接收方的事件处理：

接收方非常简单，只维护一个变量：期望的下一个序号 expectedseqnum。

  • 收到序号为 expectedseqnum 的正确分组： 回复 ACK(expectedseqnum)，expectedseqnum 加 1，将数据交付上层
  • 其他所有情况（失序分组、受损分组）： 丢弃分组，回复 ACK(expectedseqnum - 1)（即最后正确接收的分组的序号）

GBN 的问题： 一旦一个分组出错，后续窗口内的所有分组都会被丢弃并重传，在差错率较高时，大量不必要的重传严重浪费带宽。

3.4.4 选择重传（SR）

选择重传（Selective Repeat） 通过让发送方只重传那些已经出错（或丢失）的分组来避免不必要的重传。

SR 发送方：

  • 为每个未确认分组维护独立的逻辑定时器
  • 窗口大小为 N ，可以有多个已发送未确认分组
  • 每个分组单独确认（非累积）
  • 若某分组超时，只重传该分组
  • 收到 ACK(n)，若 n 在窗口内，标记为已收到；若 n==base ，将窗口向前移至最小未确认序号处

SR 接收方：

  • 窗口大小也为 N ，维护一个接收窗口
  • 接收方对正确接收的分组逐一回复 ACK，即使是失序的
  • 失序但在窗口内的分组被缓存，等待缺失分组到达后再按序交付上层
  • 窗口左边界以下的分组（已交付）的 ACK 也需要回复（否则发送方会重传）
接收方窗口示意：
|已交付|  已收到未交付（等待缺失）  |期望接收|
        rcv_base
        |<-----------N---------->|

SR 的序号空间限制：

窗口大小≤序号空间大小2

即 N≤2k−1 （ k 为序号位数）。

为什么有此限制？ 若窗口大小过大，接收方无法区分新分组和重传分组。以 4 个序号（0,1,2,3）为例：若窗口大小为 3，发送方发送分组 0,1,2，接收方全部收到并回复 ACK，但 ACK 全部丢失。发送方超时重传 0,1,2，此时接收方正在等待 3,0,1（窗口已移动），它会误以为重传的 0 是新的序号 0 分组而接受——发生错误。若窗口大小为 2，则不会出现此问题。

GBN 与 SR 对比总结：

比较维度GBNSR
发送窗口大小最大 2k−1 最大 2k−1
接收窗口大小1 N
确认方式累积确认逐一确认
差错处理重传窗口内所有未确认分组只重传出错分组
接收方缓存不需要需要缓存失序分组
适用场景差错率低时效率高差错率高时效率高

3.5 面向连接的传输：TCP

3.5.1 TCP 连接

TCP 是面向连接（Connection-Oriented） 的：在一个进程向另一个进程发送数据之前，两个进程必须先相互"握手"，即交换若干预备报文段，以确认参数，建立连接。

TCP 连接的特点：

  • 全双工（Full-Duplex） ：TCP 连接建立后，数据可以在两个方向上同时流动
  • 点对点（Point-to-Point） ：单一发送方与单一接收方之间的连接，TCP 不支持多播
  • 不提供媒体类型：TCP 是字节流服务，对上层数据不加解释

TCP 连接的组成： 一个 TCP 连接包括：与该连接相关的发送缓存（Send Buffer） 、接收缓存（Receive Buffer） 和一些变量。TCP 连接的"实体"驻留在端系统中，中间路由器对 TCP 连接一无所知。

最大报文段长度（MSS，Maximum Segment Size）： TCP 每次能发送的应用数据最大字节数（不含 TCP 首部）。MSS 通常根据最大传输单元（MTU，Maximum Transmission Unit） 确定（典型以太网 MTU 为 1500 字节，典型 MSS 为 1460 字节 = 1500 - 20（IP首部）- 20（TCP首部））。

3.5.2 TCP 报文段结构

 0         7 8        15 16       23 24       31
+------------+-----------+-----------+-----------+
|   源端口号（16 bits）   |   目的端口号（16 bits）  |
+----------------------------------------------------+
|              序号（Sequence Number，32 bits）        |
+----------------------------------------------------+
|              确认号（Acknowledgement Number，32 bits）|
+--------+--------+--------+-----+---------+--------+
|首部长度 |  保留   | C E U A P R S F|  接收窗口（16 bits）|
|（4bits）|（3bits）| W C R C S S Y I|                   |
+--------+--------+---+----+-----+---------+--------+
|         检验和（16 bits）       |  紧急数据指针（16 bits）|
+----------------------------------------------------+
|                选项（可变长度）                        |
+----------------------------------------------------+
|                数据（可变长度）                        |
+----------------------------------------------------+

各字段说明：

字段大小说明
源端口号16 bits用于多路复用/分解
目的端口号16 bits用于多路复用/分解
序号32 bits该报文段数据部分第一个字节在字节流中的编号
确认号32 bits接收方期望从发送方收到的下一个字节的序号（累积确认）
首部长度4 bits以 32 位字为单位的 TCP 首部长度，因选项字段可变，通常为 5（即 20 字节）
标志位6 bitsURG（紧急）、ACK（确认有效）、PSH（推送）、RST（重置）、SYN（同步）、FIN（终止）
接收窗口16 bits流量控制，接收方告知发送方自己愿意接受的字节数
检验和16 bits差错检测（覆盖首部和数据）
紧急数据指针16 bitsURG 标志置位时指向紧急数据末尾
选项可变用于协商 MSS、时间戳、窗口扩大因子等

序号和确认号详解：

TCP 将数据视为无结构的字节流，序号是字节流中的字节编号，而不是分组编号。

序号： 报文段的序号是该报文段数据部分第一个字节的字节流编号。例如，数据流共 500000 字节，MSS 为 1000 字节，则第一个报文段序号为 0，第二个为 1000，第三个为 2000，以此类推。

初始序号（ISN，Initial Sequence Number）： 不从 0 开始，而是随机选取，以减少网络中残留的旧报文段被误认为当前连接报文段的可能性。

确认号： 接收方期望从发送方收到的下一个字节的序号。TCP 使用累积确认——确认号 x 表示序号小于 x 的所有字节均已正确收到。

示例： Host A 发送 0~535 字节的数据（序号 0，长 536 字节），Host B 收到后回复 ACK，确认号为 536（即期望收到序号 536 的字节）。

失序报文段的处理： TCP RFC 没有规定接收方必须丢弃失序报文段，实际实现通常缓存失序报文段，等待缺失部分到达后再按序交付（类似 SR）。

3.5.3 往返时间的估计与超时

TCP 使用超时重传机制，超时间隔的设置至关重要：太短会导致频繁不必要重传，太长会降低对丢包的响应速度。

SampleRTT 与 EstimatedRTT

SampleRTT： 从报文段发出到收到 ACK 的时间测量值。TCP 在任意时刻只为一个已发送未确认的报文段测量 SampleRTT（不为重传报文段测量，避免 Karn 问题）。SampleRTT 会随网络拥塞程度的变化而波动。

EstimatedRTT（指数加权移动平均，EWMA）：

EstimatedRTT=(1−α)⋅EstimatedRTT+α⋅SampleRTT

RFC 6298 推荐 α=0.125 。EWMA 给近期样本更高权重，能跟踪 RTT 的变化趋势，同时平滑随机波动。

DevRTT：RTT 偏差

单纯用 EstimatedRTT 确定超时间隔不够，还需要考虑 RTT 的波动幅度：

DevRTT=(1−β)⋅DevRTT+β⋅|SampleRTT−EstimatedRTT|

RFC 6298 推荐 β=0.25 。

超时间隔（TimeoutInterval）

TimeoutInterval=EstimatedRTT+4⋅DevRTT
  • EstimatedRTT ：基准值
  • 4⋅DevRTT ：安全边界，RTT 波动越大，超时间隔越长

初始值 TimeoutInterval 设为 1 秒。若发生超时，下次超时间隔翻倍（指数退避），收到新 ACK 后用公式重新计算。

3.5.4 可靠数据传输

TCP 在 IP 的不可靠服务之上建立可靠数据传输服务，综合使用了以下机制：

  • 检验和： 检测比特差错
  • 序号和确认号： 检测丢包和失序
  • 定时器和超时重传： 处理丢包
  • 累积确认： 确认所有已收到的连续字节
  • 流水线： 提高利用率

TCP 发送方的三个主要事件

事件 1：应用层数据到来

  • 封装成 TCP 报文段，分配序号（NextSeqNum）
  • 若定时器未运行，启动定时器
  • 将报文段传给 IP 层

事件 2：定时器超时

  • 重传引起超时的报文段（序号最小的未确认报文段）
  • 重启定时器

事件 3：收到 ACK

  • 若 ACK 确认号 > SendBase（最小未确认序号），更新 SendBase
  • 若仍有未确认报文段，重启定时器

几种有趣的情况

情况 1：ACK 丢失

A 发送报文段（序号 92，8字节），B 正确收到但 ACK 丢失。A 超时后重传。B 收到重复报文段，回复 ACK 100（忽略重复数据）。最终 A 收到 ACK 100，正常继续。

情况 2：ACK 累积确认

A 发送两个报文段（序号 92，序号 100），第一个 ACK 丢失，但第二个 ACK（确认号 120）正常到达。由于累积确认，A 知道序号 120 以前的所有字节均已收到，两个报文段都被确认，无需重传。

情况 3：超时间隔太短

A 发送报文段（序号 92），超时间隔过短，在 ACK 到达之前就超时重传。A 重传时 B 收到冗余报文段（若原始报文段已到达）。B 再次回复 ACK 100，A 最终正常。

快速重传（Fast Retransmit）

超时触发的重传存在问题：超时间隔可能较长（尤其是超时翻倍后），在超时前会有较长等待时间。

冗余 ACK（Duplicate ACK） 可以在超时之前检测丢包：接收方收到失序报文段时，立即回复冗余 ACK（重复确认最后正确收到的按序字节）。

快速重传规则： 若发送方收到同一数据的 3 个冗余 ACK（加上原始 ACK 共 4 个相同的 ACK），则认为该报文段之后的报文段已丢失，在定时器超时之前立即重传。

选择 3 个冗余 ACK 的原因：到达的 3 个冗余 ACK 表明至少有 3 个后续报文段到达了接收方，而对应序号的报文段确实缺失，这是一个较强的丢包信号。

TCP 是 GBN 还是 SR？

TCP 结合了两者：

  • TCP 的累积确认类似于 GBN
  • TCP 的接收缓存失序报文段类似于 SR（GBN 接收方丢弃失序报文段）
  • TCP 的快速重传只重传一个分组（最小序号的未确认报文段）类似于 SR

TCP 是两者的混合体，具体行为还受到其他机制（如选择确认 SACK 选项）的影响。

3.5.5 流量控制

流量控制（Flow Control）： 防止发送方发送速度过快，超出接收方缓冲区的处理能力，导致缓冲区溢出。

TCP 通过接收窗口（Receive Window，rwnd） 提供流量控制。接收方在每个 TCP 报文段的接收窗口字段中，告知发送方自己当前可用的缓冲区空间大小。

rwnd=RcvBuffer−[LastByteRcvd−LastByteRead]

发送方的约束：

LastByteSent−LastByteAcked≤rwnd

即发送方保证未确认的数据量（在管道中的数据）不超过接收方的可用缓冲区大小。

零窗口问题（Zero Window Deadlock）：

当 rwnd = 0 时，发送方停止发送数据。若接收方的缓冲区再次有空间（应用程序读取了数据），接收方通过 ACK 通知发送方，但如果此 ACK 丢失，双方会陷入死锁（发送方等待非零 rwnd，接收方等待数据）。

解决方案： 当 rwnd = 0 时，发送方继续发送只含 1 字节数据的报文段（探测报文段），以触发接收方回复 ACK（其中包含新的 rwnd 值），避免死锁。

注意区分流量控制和拥塞控制：

  • 流量控制：防止发送方淹没接收方，由接收方通过 rwnd 控制
  • 拥塞控制：防止发送方淹没网络，由 TCP 拥塞控制机制（cwnd）控制

发送方实际的未确认数据量受两者中较小的限制：

LastByteSent−LastByteAcked≤min(cwnd,rwnd)

3.5.6 TCP 连接管理

三次握手（Three-Way Handshake）

目的： 双方相互告知初始序号，分配缓冲区，建立连接状态。

过程：

第一步（SYN）： 客户端向服务器发送 SYN 报文段：

  • SYN 标志位 = 1
  • 随机选择客户端初始序号 client_isn，seq = client_isn
  • 不含应用层数据

第二步（SYNACK）： 服务器收到 SYN，分配 TCP 缓冲区和变量，向客户端发送 SYNACK 报文段：

  • SYN = 1，ACK = 1
  • 随机选择服务器初始序号 server_isn，seq = server_isn
  • ack = client_isn + 1（确认已收到客户端 SYN）

第三步（ACK）： 客户端收到 SYNACK，分配缓冲区和变量，向服务器发送 ACK 报文段：

  • SYN = 0，ACK = 1
  • seq = client_isn + 1
  • ack = server_isn + 1
  • 可以携带应用层数据（连接已建立）

握手完成，连接建立。SYN 和 SYNACK 报文段不含数据，但各消耗一个序号。

为什么需要三次握手而不是两次？

两次握手无法避免"已失效的连接请求报文段"问题：若客户端发出的旧连接请求（已超时）延迟到达服务器，服务器会认为这是一个新的连接请求，分配资源并回复，但客户端不会理会，造成服务器资源浪费。三次握手要求客户端确认，可以避免这种情况。

四次挥手（连接终止）

TCP 连接的任意一方都可以终止连接。以客户端主动关闭为例：

第一步（FIN）： 客户端发送 FIN 报文段（FIN = 1），进入 FIN_WAIT_1 状态

第二步（ACK）： 服务器收到 FIN，发送 ACK，进入 CLOSE_WAIT 状态。客户端收到 ACK，进入 FIN_WAIT_2 状态（此时服务器到客户端方向的连接仍然开放，服务器可以继续发送数据）

第三步（FIN）： 服务器完成数据发送，发送 FIN 报文段，进入 LAST_ACK 状态

第四步（ACK）： 客户端收到 FIN，发送 ACK，进入 TIME_WAIT 状态，等待 2MSL（Maximum Segment Lifetime，最大报文段寿命） 时间后关闭。服务器收到 ACK 后关闭连接。

TIME_WAIT 的作用：

  1. 确保最后的 ACK 能到达服务器：若最后的 ACK 丢失，服务器会重传 FIN，客户端在 TIME_WAIT 期间可以再次回复 ACK
  2. 让网络中残留的旧报文段过期消失，防止被新连接误认

连接状态图（TCP 状态机） ：TCP 在连接建立、数据传输和连接终止过程中经历多个状态（CLOSED、LISTEN、SYN_SENT、SYN_RCVD、ESTABLISHED、FIN_WAIT_1、FIN_WAIT_2、CLOSE_WAIT、LAST_ACK、TIME_WAIT），状态转换由收到的报文和超时事件触发。

SYN 洪泛攻击（SYN Flood Attack）： 攻击者伪造源 IP 地址，向服务器发送大量 SYN 报文段。服务器为每个 SYN 分配资源（缓冲区和变量）并回复 SYNACK，但由于源 IP 是伪造的，ACK 永远不会到来，服务器的资源被大量半开连接（Half-Open Connection）耗尽，无法处理合法连接——这是一种典型的 DoS 攻击。

SYN Cookie（防御机制）：

  1. 服务器收到 SYN 时，不分配资源，而是用源/目的 IP、端口和其他信息计算出一个特殊的初始序号（SYN Cookie） ，发送 SYNACK（其中 seq = SYN Cookie）
  2. 服务器之后不保存任何关于该连接的信息（不分配资源）
  3. 若客户端是合法的，它会回复 ACK，ACK 中的确认号为 SYN Cookie + 1
  4. 服务器收到 ACK 后，验证确认号是否合法（重新计算 SYN Cookie 并比较），若合法则分配资源，建立连接
  5. 攻击者发出大量伪造 SYN，服务器不为其分配任何资源，攻击无效

3.6 拥塞控制原理

3.6.1 拥塞的原因与代价

拥塞（Congestion）： 太多源同时发送太多数据，网络来不及处理，导致分组丢失（路由器缓存溢出）和排队时延增大。

拥塞控制和流量控制是不同的概念——流量控制是点对点的（防止发送方淹没接收方），拥塞控制是全局的（防止发送方淹没网络）。

拥塞的代价（通过简化场景分析）：

场景 1：两个发送方，一台无限缓存路由器，无重传

随着发送速率接近链路容量 R/2 ，排队时延趋向无穷大——这是拥塞的第一个代价：大排队时延。

场景 2：两个发送方，一台有限缓存路由器，有重传

  • 若发送方能完美知道路由器何时空闲（不可能），吞吐量可以达到 R/2
  • 现实中发送方会超时重传，导致部分带宽用于传输重复分组——拥塞的第二个代价：需要重传，降低了有效吞吐量
  • 若分组未丢失但时延较大，发送方过早重传，网络中有重复分组同时传输，进一步浪费带宽

场景 3：四个发送方，多台有限缓存路由器

出现更严重的问题：当拥塞加剧时，分组在某个中间路由器处被丢弃，此前路由器为该分组消耗的传输资源全部浪费——拥塞的第三个代价：分组被丢弃时，上游路由器已消耗的传输资源全部白费。

3.6.2 拥塞控制方法

端到端拥塞控制（End-to-End Congestion Control）：

网络层不提供拥塞的显式支持，端系统根据观察到的网络行为（丢包、时延）自行推断拥塞程度并调整发送速率。TCP 使用此方法。

网络辅助的拥塞控制（Network-Assisted Congestion Control）：

路由器向发送方或接收方提供明确的拥塞反馈信息：

  • 简单地设置一个比特位指示链路拥塞（如 SNA、DECnet）
  • 明确告知发送方应使用的速率

显式拥塞通知（ECN，Explicit Congestion Notification）：

ECN 是 TCP/IP 中网络辅助拥塞控制的实现（RFC 3168）：

  • 路由器在接近拥塞时，将 IP 数据报首部中的 ECN 标志位置位（而不是直接丢弃分组）
  • 接收方收到带 ECN 标志的报文段后，在响应 ACK 中设置 ECE（ECN-Echo）标志通知发送方
  • 发送方如同收到丢包信号一样，降低拥塞窗口，并在下一个报文段中设置 CWR（Congestion Window Reduced）标志告知接收方

ECN 的优势：在丢包发生之前就通知发送方，避免了重传的延迟和带宽浪费。

3.7 TCP 拥塞控制

3.7.1 经典 TCP 拥塞控制

TCP 让每个发送方根据所感知到的网络拥塞程度来限制发送速率。

拥塞窗口（cwnd，Congestion Window）： 发送方维护的变量，限制发送方向网络中注入数据的速率。

发送方实际的已发送未确认数据量：

LastByteSent−LastByteAcked≤min(cwnd,rwnd)

为简化讨论，设接收方缓冲区足够大（rwnd 不是限制），则发送速率约为：

发送速率≈cwndRTT bytes/sec

TCP 如何感知拥塞？

  • 丢包事件：超时或收到 3 个冗余 ACK，视为拥塞信号
  • 非丢包事件：收到 ACK，表明报文段已成功到达，网络未拥塞，可适当增大 cwnd

TCP 拥塞控制的指导方针：

  • 丢包事件时，减小 cwnd
  • 收到 ACK 时（未丢包），增大 cwnd
  • 带宽探测：TCP 持续尝试增大发送速率，直到丢包，然后减小，再尝试增大——持续探测可用带宽

慢启动（Slow Start）

初始： cwnd = 1 MSS，发送速率约为 MSS/RTT（非常慢，这也是"慢启动"名称的由来，尽管增长速度实际上很快）。

每收到一个 ACK： cwnd 增加 1 MSS。

效果：每经过一个 RTT，cwnd 翻倍（指数增长）。

何时结束慢启动？

  • 超时： 将 ssthresh（慢启动阈值）设为 cwnd/2，cwnd 重置为 1 MSS，重新进入慢启动
  • cwnd 达到 ssthresh： 进入拥塞避免阶段（线性增长）
  • 收到 3 个冗余 ACK： 将 ssthresh 设为 cwnd/2，cwnd 设为 ssthresh + 3 MSS，进入快速恢复

拥塞避免（Congestion Avoidance）

进入拥塞避免时，cwnd 约为上次丢包时的一半，此时需要更谨慎地增大 cwnd。

每个 RTT 将 cwnd 增加 1 MSS（线性增长），具体实现：每收到一个 ACK，cwnd 增加 MSS2cwnd （即每个 RTT 增加约 1 个 MSS）。

何时结束拥塞避免？

  • 超时： ssthresh = cwnd/2，cwnd = 1 MSS，进入慢启动
  • 收到 3 个冗余 ACK： ssthresh = cwnd/2，cwnd = ssthresh + 3 MSS，进入快速恢复

快速恢复（Fast Recovery）

仅 TCP Reno 有此阶段（TCP Tahoe 没有）。

进入快速恢复时，cwnd = ssthresh + 3 MSS（3 是因为收到了 3 个冗余 ACK，表明有 3 个报文段已被接收方收到，可以暂时将它们"移出"窗口）。

每收到一个新的冗余 ACK： cwnd 增加 1 MSS（快速恢复期间 cwnd 可能继续增长）。

收到新 ACK（非冗余）： 表明丢失的报文段已被重传并确认，cwnd 设为 ssthresh（不是再加 3 MSS），进入拥塞避免。

超时： ssthresh = cwnd/2，cwnd = 1 MSS，进入慢启动。

TCP Tahoe vs TCP Reno：

事件TCP TahoeTCP Reno
超时ssthresh=cwnd/2，cwnd=1，慢启动ssthresh=cwnd/2，cwnd=1，慢启动
3 个冗余 ACKssthresh=cwnd/2，cwnd=1，慢启动ssthresh=cwnd/2，cwnd=ssthresh+3，快速恢复

Reno 对 3 个冗余 ACK 的响应更温和，因为 3 个冗余 ACK 意味着虽然有分组丢失，但网络仍在运转（后续分组还在到达接收方），不需要像超时那样激烈地减小 cwnd。

TCP 拥塞控制总结（状态转换）

            超时
慢启动 ──────────────────────────────────→ 慢启动
  │    cwnd达到ssthresh                    （cwnd=1,ssthresh=cwnd/2）
  └─────────────────────→ 拥塞避免
                              │  超时
                              ├──────────→ 慢启动
                              │  3个冗余ACK
                              └──────────→ 快速恢复
                                              │  超时
                                              ├──→ 慢启动
                                              │  新ACK
                                              └──→ 拥塞避免

3.7.2 TCP 拥塞控制：宏观视角（AIMD）

忽略慢启动（当 ssthresh 足够大时），TCP 拥塞控制在拥塞避免阶段的行为可以描述为：

AIMD（Additive Increase Multiplicative Decrease，加性增乘性减）：

  • 加性增（AI）： 每个 RTT 将 cwnd 增加 1 MSS（线性增加），探索可用带宽
  • 乘性减（MD）： 检测到丢包时，将 cwnd 减半（乘性减少）

cwnd 随时间的变化呈现出"锯齿形（Sawtooth）"：缓慢线性增加，遇到拥塞信号后快速减半，如此循环。

TCP 吞吐量的近似公式：

设丢包时的窗口大小为 W ，则 TCP 吞吐量在 W/2 到 W 之间线性变化，平均吞吐量约为：

吞吐量―=0.75⋅WRTT

更精确的分析（考虑丢包率 L ）：

吞吐量―=1.22⋅MSSRTT⋅L

丢包率越低，吞吐量越高；RTT 越小，吞吐量越高。这也解释了为什么长肥网络（Long Fat Network，高带宽延迟积）上 TCP 的性能较差。

3.7.3 公平性

公平性目标： 若 K 条 TCP 连接共享一条瓶颈链路（容量 R ），理想情况下每条连接的平均速率约为 R/K 。

AIMD 机制的公平性：

可以通过图示分析证明，AIMD 算法能使多条 TCP 连接逐渐收敛到公平点（每条连接获得等份带宽）。

具体来说，若两条连接的带宽之和为 R （位于效率线上），当两条连接都未达到公平点时，AIMD 的加性增会使它们沿 45° 方向移动（同等增加），遇到拥塞后乘性减使它们向原点方向移动，如此反复，两条连接的速率最终收敛于公平分配点。

影响公平性的因素：

  • 并行 TCP 连接： 一个应用打开多个并行 TCP 连接（如浏览器），获得的带宽是单个 TCP 连接的倍数，从而占据更多共享带宽，对其他应用不公平
  • UDP 流： UDP 没有拥塞控制，会挤占 TCP 的带宽，从网络整体角度看是不公平的
  • RTT 不同： RTT 小的 TCP 连接能更快地增大 cwnd，在竞争中占据更多带宽

3.7.4 QUIC：基于 UDP 的快速传输

QUIC（Quick UDP Internet Connections） 是由 Google 开发的应用层协议，现已标准化（RFC 9000），用于 HTTP/3。

QUIC 的设计动机：

HTTP/2 运行在 TCP 之上，虽然在应用层实现了多路复用（多个 HTTP 请求共享一个 TCP 连接），但 TCP 层面的可靠传输是针对整个字节流的——一旦某个 TCP 报文段丢失，整个 TCP 连接中的所有 HTTP 请求都会被阻塞（TCP 层面的 HOL 阻塞），直到丢失报文段被重传。

QUIC 的主要特性：

面向连接与安全： QUIC 的握手同时完成连接建立和加密协商（基于 TLS 1.3），仅需 1 RTT（甚至 0 RTT，若与同一服务器有过连接记录）即可建立安全连接，而 TCP + TLS 需要至少 3 RTT。

流： QUIC 连接内有多个独立的流（Stream） ，每个 HTTP 请求对应一个 QUIC 流。各流相互独立，一个流的丢包不影响其他流的数据交付，从根本上解决了 HOL 阻塞问题。

可靠性与拥塞控制： QUIC 在自身实现了类似 TCP 的可靠传输（序号、确认、重传）和拥塞控制，但以流为粒度管理，而不是对整个连接统一管理。

连接迁移： QUIC 连接用连接 ID 标识，而不是 IP 地址 + 端口四元组，因此当客户端 IP 地址改变（如从 WiFi 切换到蜂窝网络）时，QUIC 连接可以无缝迁移，不需要重新建立连接。

QUIC vs TCP + TLS + HTTP/2：

特性TCP + TLS + HTTP/2QUIC + HTTP/3
连接建立3 RTT（TCP 1 RTT + TLS 2 RTT）1 RTT（0 RTT 可能）
HOL 阻塞存在（TCP 层面）无（流独立）
头部阻塞范围整个 TCP 连接单个 QUIC 流
传输层TCPUDP
安全性TLS（额外层）内置 TLS 1.3
连接迁移不支持支持（连接 ID）

本章小结

本章详细介绍了传输层的原理和协议，主要内容包括：

  1. 传输层基础： 传输层提供进程间（而非主机间）的逻辑通信；多路复用（发送方）和多路分解（接收方）通过端口号实现；UDP 用二元组（目的IP, 目的端口）标识套接字，TCP 用四元组标识

  2. UDP： 无连接、不可靠、无拥塞控制；8 字节精简首部；检验和提供基本差错检测；适合实时应用、DNS 等对时延敏感的场景

  3. 可靠数据传输原理： 从 rdt 1.0 到 rdt 3.0 逐步引入检验和、ACK/NAK、序号、超时重传等机制；停等协议的低效性；流水线协议（GBN 和 SR）的比较

  4. TCP： 面向连接、全双工、字节流；报文段结构（序号、确认号、标志位、接收窗口等）；RTT 估计（EWMA）和超时间隔计算；可靠数据传输（超时重传、快速重传）；流量控制（rwnd，防止淹没接收方）；三次握手和四次挥手；SYN Cookie 防御 SYN 洪泛

  5. 拥塞控制原理： 拥塞的代价（时延、重传、上游资源浪费）；端到端拥塞控制 vs 网络辅助拥塞控制；ECN

  6. TCP 拥塞控制： 慢启动（指数增长）→ 拥塞避免（线性增长）→ 快速恢复（仅 Reno）；AIMD 的锯齿形行为；TCP Tahoe vs TCP Reno；吞吐量近似公式；公平性分析

  7. QUIC： 基于 UDP 的传输协议；1 RTT 连接建立（含 TLS）；多流并行无 HOL 阻塞；连接迁移；HTTP/3 的基础

第四章 网络层：数据平面

4.1 网络层概述

4.1.1 转发和路由选择：数据平面和控制平面

网络层的作用是将分组从发送主机移动到接收主机，为此需要两种重要的网络层功能：

转发（Forwarding）：
当一个分组到达路由器的某条输入链路时，路由器必须将该分组移动到适当的输出链路。转发是在数据平面中实现的本地动作，是网络层功能的具体执行，发生在纳秒时间尺度上，通常用硬件实现。

路由选择（Routing）：
当分组从发送方流向接收方时，网络层必须决定这些分组所采用的路由或路径。计算这些路径的算法称为路由选择算法（Routing Algorithm） 。路由选择是在控制平面中实现的全局动作，发生在秒级时间尺度上，通常用软件实现。

转发表（Forwarding Table）：
路由器通过检查到达分组首部字段的值，再用该值在转发表中进行索引，找到对应的输出链路接口。转发表是连接数据平面和控制平面的关键数据结构。

4.1.2 控制平面：传统方法与 SDN 方法

传统方法（每台路由器控制）：

每台路由器中都有一个路由选择组件，不同路由器中的路由选择组件相互通信（通过路由选择协议报文），共同计算转发表。OSPF、BGP 等协议采用此方法。

路由器 A ←───路由选择协议报文───→ 路由器 B
[路由选择组件]                    [路由选择组件]
[转发表]                          [转发表]
[数据平面]                        [数据平面]

SDN 方法（软件定义网络，Software-Defined Networking）：

由远程控制器（Remote Controller） 统一计算并分发转发表，路由器本身只负责转发，不参与路由选择计算。控制平面在路由器外部实现，逻辑集中。

      [远程控制器]
      /           \
     /             \
路由器 A           路由器 B
[转发表]←─控制器─→[转发表]
[数据平面]        [数据平面]

SDN 的优势：灵活性高、便于管理、网络可编程，已在数据中心和广域网中广泛应用。

4.1.3 网络服务模型

因特网的网络层服务模型：尽力而为（Best-Effort）

IP 协议提供尽力而为的服务，不保证：

  • 分组的成功交付
  • 分组交付的顺序
  • 端到端时延
  • 最低带宽

这种"不保证"的设计是刻意为之的：简单的网络层允许在各种链路技术上运行，将可靠性等复杂功能推给端系统（传输层）处理，这也是因特网能够大规模扩展的原因之一。

4.2 路由器工作原理

路由器的体系结构分为四个组成部分：

         输入端口          交换结构         输出端口
线路端接─→链路层─→查找转发─→
线路端接─→链路层─→查找转发─→  交换结构  ─→链路层─→线路端接
线路端接─→链路层─→查找转发─→
                               ↑
                          路由选择处理器
                         （控制平面，软件）

4.2.1 输入端口处理和基于目的地的转发

输入端口在路由器的最左侧，执行以下功能（从左到右）：

  1. 线路端接（Line Termination）： 物理层功能，接收比特流
  2. 数据链路处理（Link Layer Processing）： 链路层功能，处理帧
  3. 查找、转发、排队（Lookup, Forwarding, Queuing）： 核心功能——查询转发表，决定输出端口

基于目的地的转发（Destination-Based Forwarding）：

路由器根据分组目的 IP 地址查找转发表，确定输出端口。

最长前缀匹配（Longest Prefix Match）：

转发表中的条目采用地址前缀形式。当一个目的地址匹配多个表项时，路由器选择最长（最具体）的匹配前缀对应的输出端口。

示例：

前缀输出链路接口
11001000 00010111 000100
11001000 00010111 000110001
11001000 00010111 000112
其他3

目的地址 11001000 00010111 00011000 10101010：

  • 匹配前缀 0（20 位匹配）
  • 匹配前缀 1（24 位匹配）
  • 匹配前缀 2（21 位匹配）
  • 最长匹配为前缀 1，输出接口 1

为什么用最长前缀匹配而不是精确匹配？

IP 地址空间有 232 个地址，精确匹配表需要 40 亿个条目，无法存储。前缀聚合（路由聚合）大幅减少转发表规模，用于组织层次化的 IP 地址空间。

实现： 最长前缀匹配通常用三态内容可寻址存储器（TCAM，Ternary Content Addressable Memory） 实现，可以在一个时钟周期内完成查找，速度极快。TCAM 每个存储单元可以存储 0、1 或"无关（don’t care）"三种状态。

4.2.2 交换结构

交换结构（Switching Fabric）将输入端口连接到输出端口，是路由器的核心。

交换速率： 分组从输入端口传输到输出端口的速率。通常希望交换速率是输入/输出线路速率的 N 倍（ N 为端口数），以避免成为瓶颈。

经内存交换（Switching via Memory）

最早的路由器使用此方法。输入端口收到分组后产生中断，路由选择处理器将分组拷贝到内存，查找转发表，再拷贝到输出端口缓存。

输入端口 ─→ 内存（系统总线）─→ 输出端口

缺点： 受内存带宽限制，每个分组需要两次内存访问（读和写），速度较慢。现代某些路由器（如 Cisco Catalyst 8500）用共享内存实现，但本质类似。

经总线交换（Switching via a Bus）

输入端口直接通过共享总线将分组传送到输出端口，不需要路由选择处理器介入（使用预先计算好的标签）。

输入端口 ─→ 共享总线 ─→ 输出端口

缺点： 每次只有一个分组可以通过总线，总线带宽成为瓶颈。适合接入路由器和企业级路由器（Cisco 5600 可达 32 Gbps）。

经互联网络交换（Switching via an Interconnection Network）

使用纵横式交换机（Crossbar Switch） 或更复杂的多级互联网络，克服总线带宽瓶颈。

纵横式交换机有 2N 条总线（ N 条水平， N 条垂直），可以同时并行转发多个分组（只要它们的输出端口不同）。

输入1 ─────────────────┐
输入2 ──────────┐      │
输入3 ──┐       │      │
        ↓       ↓      ↓
        输出3   输出2  输出1

优点： 非阻塞（Non-Blocking），多个分组可以同时交换；可以扩展为多级网络，进一步提升容量（Cisco CRS 使用多级 Crossbar，达到 Tbps 级别）。

4.2.3 输出端口处理

输出端口从交换结构取出分组，执行必要的链路层和物理层处理，然后将分组发送到输出链路。

当分组到达速率超过链路传输速率时，需要将分组放入输出端口的缓存队列等待传输。分组调度器（Packet Scheduler） 决定队列中哪个分组先被传输。

4.2.4 排队

排队发生在输入端口和输出端口，是分组时延和丢包的根本原因。

输入排队

若交换结构不够快，输入端口可能发生排队。

线头阻塞（HOL Blocking，Head-of-Line Blocking）：

即使输出端口空闲，排在队列后面的分组也可能因为前面的分组在等待（其目标输出端口被占用）而无法前进。这是输入排队的特有问题。

输入队列：[分组A→输出1][分组B→输出2]
         [分组C→输出1]  ←─ C 被 A 阻塞，即使输出2空闲

即使在交换结构速率为输入线路速率 N 倍的情况下，HOL 阻塞也会使吞吐量限制在约 58%。

输出排队

当多个分组在同一时刻经交换结构到达同一输出端口时，这些分组需要排队等待。

分组丢失（丢包）： 当输出缓存满时，新到达的分组或队列中的分组将被丢弃。

缓存大小的设计：

  • 早期 RFC 建议：缓存大小 = RTT × 链路容量（如 RTT=250ms，C=10Gbps，则缓存=2.5Gbit）
  • 现代观点：考虑大量并发 TCP 连接时，缓存大小可以显著减小： RTT⋅CN （ N 为 TCP 连接数）
  • 过大的缓存反而有害：导致极大的排队时延，称为缓冲区膨胀（Bufferbloat） 问题

主动队列管理（AQM，Active Queue Management）：

不等缓存满才丢包，而是在缓存未满时就主动随机丢弃或标记分组，给发送方提前发出拥塞信号。

RED（Random Early Detection，随机早期检测）： 当平均队列长度超过最小阈值时，以一定概率随机丢弃分组；超过最大阈值时丢弃所有分组。CoDel 是更现代的 AQM 算法，直接以排队时延为指标。

4.2.5 分组调度

调度（Scheduling）： 决定排在输出端口队列中的哪个分组下一个被传输。

FIFO 调度（First-In-First-Out）

按到达顺序传输，先到先服务。最简单，无法区分流量优先级。

尾丢弃（Tail Drop）： 缓存满时丢弃新到达的分组（FIFO 的默认策略）。

优先级排队（Priority Queuing）

将分组分为多个优先级类（Priority Class） ，高优先级类的分组总是先于低优先级类传输。

  • 抢占式优先级（Preemptive Priority）： 高优先级分组可以打断低优先级分组的传输（链路层一般不抢占，等当前分组传完）
  • 非抢占式优先级（Non-Preemptive Priority）： 当前正在传输的分组传完后，从最高优先级非空队列取分组

问题： 低优先级队列可能长期得不到服务（饥饿，Starvation）。

循环排队和加权公平排队

循环排队（Round Robin，RR）：

轮流从多个类的队列中各取一个分组传输。每个类获得相同的服务机会，无饥饿问题，但不支持不同权重。

加权公平排队（WFQ，Weighted Fair Queuing）：

循环排队的推广，每个类有一个权重（Weight） ，按权重比例分配服务时间（即带宽）。若类 i 的权重为 wi ，则该类获得的带宽比例为：

wi∑jwj

WFQ 在每个类权重相同时退化为普通循环排队。WFQ 是实现区分服务（Differentiated Services） 的重要机制，可以保证每个类的最小带宽。

4.3 网际协议：IPv4、寻址、IPv6 及其他

4.3.1 IPv4 数据报格式

IPv4 数据报结构如下：

 0         7 8        15 16       23 24       31
+----------+-----------+-----------+-----------+
|  版本(4) |首部长度(4)|  服务类型(8)  | 数据报长度(16)    |
+----------+-----------+-----------+-----------+
|      标识(16)        | 标志(3)  |    片偏移(13)      |
+----------+-----------+-----------+-----------+
|  寿命TTL(8) |  协议(8) |      首部检验和(16)         |
+----------+-----------+-----------+-----------+
|                   源 IP 地址(32)                     |
+----------------------------------------------------+
|                  目的 IP 地址(32)                    |
+----------------------------------------------------+
|                   选项（可变）                        |
+----------------------------------------------------+
|                   数据（可变）                        |
+----------------------------------------------------+

各字段说明：

字段大小说明
版本号4 bitsIP 协议版本（IPv4 为 4）
首部长度4 bits以 32 位字（4字节）为单位，无选项时为 5（即 20 字节）
服务类型（TOS / DSCP+ECN）8 bits区分不同类型的 IP 数据报（实时、高吞吐量等）；低 2 位为 ECN 位
数据报长度16 bits整个 IP 数据报的总字节数（首部 + 数据），最大 65535 字节
标识16 bits用于 IP 分片，同一数据报的所有片具有相同标识
标志3 bits最低位 MF（More Fragments）：1 表示后面还有片；中间位 DF（Don’t Fragment）：1 表示不允许分片
片偏移13 bits该片在原始数据报中的偏移，以 8 字节为单位
寿命（TTL）8 bits每经过一台路由器减 1，减为 0 时丢弃该数据报，并向源主机发 ICMP 报文；防止数据报在网络中无限循环
协议8 bits指示数据部分应交给哪个传输层协议（6=TCP，17=UDP，1=ICMP，89=OSPF）
首部检验和16 bits仅对 IP 首部进行差错检测（不含数据），每台路由器都需重新计算（TTL 每跳改变）
源 IP 地址32 bits
目的 IP 地址32 bits
选项可变允许扩展 IP 首部，如记录路由、时间戳等；很少使用，路由器处理选项会降低速度
数据可变通常是传输层报文段（TCP 或 UDP），也可以是 ICMP 报文等

IPv4 首部固定部分为 20 字节。 TCP 报文段封装在 IP 数据报中，总开销至少 40 字节（20 字节 IP 首部 + 20 字节 TCP 首部）。

4.3.2 IPv4 数据报分片

分片（Fragmentation）的原因：

不同链路层协议的 MTU（最大传输单元）不同（以太网 1500 字节，某些广域网链路 576 字节）。当 IP 数据报长度超过链路 MTU 时，路由器必须将其分成若干较小的片（Fragment）再传输。

重组（Reassembly）：

IPv4 在目的主机处重组分片，而不是在中间路由器处，这简化了路由器设计（不需要维护重组状态）。

分片过程：

设原始数据报数据部分 4000 字节（总长 4020 字节），MTU = 1500 字节：

  • 首部 20 字节，每片数据最多 1480 字节（1500 - 20），必须是 8 字节的整数倍，取 1480
  • 片 1：数据 1480 字节，偏移 0，MF=1（后面还有片）
  • 片 2：数据 1480 字节，偏移 185（= 1480/8），MF=1
  • 片 3：数据 1040 字节，偏移 370（= 2960/8），MF=0（最后一片）

重组依据： 接收方根据标识字段（相同标识属于同一数据报）、片偏移字段（确定各片在原始数据报中的位置）和 MF 标志（确定是否为最后一片）完成重组。

IPv6 不支持分片： IPv6 要求中间路由器不进行分片，发送方负责路径 MTU 发现（Path MTU Discovery），确保发送的数据报不超过路径上最小的 MTU。

4.3.3 IPv4 编址

接口与 IP 地址

IP 地址在技术上是与接口（Interface） 关联的，而不是与主机或路由器关联的。每个接口有一个 IP 地址（通常）。

  • 一台主机通常只有一个接口，因此只有一个 IP 地址
  • 一台路由器有多个接口，因此有多个 IP 地址

IP 地址是 32 位（IPv4），通常用点分十进制表示法（Dotted-Decimal Notation） 书写，每 8 位为一组，用十进制表示，共 4 组，用点分隔，如 192.168.1.1。

子网

子网（Subnet）的定义： 能够彼此物理连通，无需路由器介入即可直接通信的设备集合。也称为 IP 网络（IP Network） 或网络（Network） 。

同一子网内的所有接口的 IP 地址具有相同的网络部分（Network Prefix） 。

子网掩码（Subnet Mask）： 用于标识 IP 地址的哪部分是网络前缀，哪部分是主机部分。如 /24（CIDR 表示法）表示前 24 位为网络部分，后 8 位为主机部分，即有 28−2=254 个可用主机地址。

子网识别方法： 分离主机（路由器）的接口，每个孤立的端部形成一个子网。

CIDR（无类别域间路由）

CIDR（Classless InterDomain Routing，无类别域间路由） 是现代 IP 地址分配的基础，将 IP 地址分为任意长度的前缀：

a.b.c.d/x

其中 x 是前缀长度（Prefix Length） ，表示 IP 地址中网络部分的比特数。

地址聚合（Route Aggregation / Supernetting）： 将多个连续的子网地址聚合为一个更短的前缀，减少路由表规模。例如，四个 /24 网络可以聚合为一个 /22 网络。

地址分类（历史，已废弃）：

在 CIDR 之前，IP 地址按类分配：

类别前缀位网络数量每网络主机数
A 类0xxxxxxx（前 1 位固定）12816,777,214
B 类10xxxxxx（前 2 位固定）16,38465,534
C 类110xxxxx（前 3 位固定）2,097,152254

分类编址导致地址浪费严重（一个 B 类网络分配给只需要几百个地址的组织），CIDR 解决了这个问题。

获取 IP 地址

DHCP（Dynamic Host Configuration Protocol，动态主机配置协议）：

DHCP 允许主机自动从服务器获取 IP 地址（以及子网掩码、默认网关、DNS 服务器等信息），是一种即插即用（Plug-and-Play） 协议。

DHCP 是客户-服务器协议，使用 UDP（客户端 68 端口，服务器 67 端口）。

DHCP 四步过程（DORA）：

1. DHCP 发现（DHCP Discover）：

  • 客户端广播（目的地址 255.255.255.255，源地址 0.0.0.0）DHCP 发现报文
  • 本地网络中所有设备收到，但只有 DHCP 服务器响应

2. DHCP 提供（DHCP Offer）：

  • DHCP 服务器广播 DHCP 提供报文（因为客户端还没有 IP 地址）
  • 包含：推荐的 IP 地址、子网掩码、IP 地址租用期、服务器 ID

3. DHCP 请求（DHCP Request）：

  • 客户端收到一个或多个 DHCP 提供，选择其中一个，广播 DHCP 请求报文
  • 表明接受哪个服务器的提供，也通知其他服务器拒绝它们的提供

4. DHCP ACK（DHCP Acknowledgement）：

  • 服务器广播 DHCP ACK 报文，确认请求
  • 客户端收到后即可使用该 IP 地址，租期开始计时

DHCP 租期（Lease）： IP 地址不是永久分配的，而是有租期（如 24 小时）。租期过半时客户端尝试续租（单播给服务器），续租失败则在租期到期后停止使用该地址并重新发起 DHCP 过程。

DHCP 中继代理（DHCP Relay Agent）： DHCP 服务器通常不在每个子网中都部署一台，路由器可以配置为 DHCP 中继代理，将子网内客户端的 DHCP 广播转发到其他子网中的 DHCP 服务器（单播），服务器响应再由中继代理转发回客户端。

DHCP 的局限： 每次连接到新网络都要重新获取 IP 地址，对移动设备而言，IP 地址会改变，正在进行中的 TCP 连接会中断。

IP 地址块的获取

组织从 ISP 获取一块 IP 地址（通常是 CIDR 块），ISP 从区域因特网注册机构（如 ARIN、RIPE、APNIC）获取更大的地址块，最终由 ICANN（Internet Corporation for Assigned Names and Numbers）管理全球 IP 地址空间。

IPv4 地址耗尽（Address Exhaustion）： IPv4 地址空间仅 232≈43 亿个地址，已于 2011 年基本耗尽。应对措施：NAT（短期解决）和 IPv6（长期解决）。

4.3.4 网络地址转换（NAT）

NAT（Network Address Translation，网络地址转换） 允许一个组织的内部网络使用私有 IP 地址（Private IP Address） ，对外只呈现一个（或少量）** 公网 IP 地址**。

私有 IP 地址范围：

地址块前缀长度地址数量
10.0.0.0/816,777,216
172.16.0.0/121,048,576
192.168.0.0/1665,536

这些地址只在内部网络中有意义，路由器不转发目的地为私有地址的分组。

NAT 工作原理

NAT 路由器维护一张 NAT 转换表（NAT Translation Table） ：

私网地址:端口          ←→        公网地址:端口
10.0.0.1:3345        ←→        138.76.29.7:5001
10.0.0.2:3345        ←→        138.76.29.7:5002
10.0.0.3:1234        ←→        138.76.29.7:5003

出站（内网→外网）：

  1. 内网主机（10.0.0.1:3345）发送分组到外网服务器（128.119.40.186:80）
  2. NAT 路由器将源地址/端口替换为公网地址/新端口（138.76.29.7:5001），记录映射关系
  3. 分组以公网地址发送到外网，外网服务器看到的源地址是 138.76.29.7:5001

入站（外网→内网）：

  1. 外网服务器响应，目的地址为 138.76.29.7:5001
  2. NAT 路由器查找转换表，找到 5001 对应 10.0.0.1:3345
  3. 将目的地址/端口替换为私网地址/端口，转发到内网主机

NAT 路由器对外表现为单一 IP 地址，但内部可以服务多达 216 个并发连接（端口号 16 位）。

NAT 的争议

优点：

  • 大幅缓解 IPv4 地址耗尽问题
  • 内部网络对外隐藏，提供一定安全性
  • 更换 ISP 时内部地址无需改变

批评：

  1. 违反端到端原则： 端到端原则要求路由器只做分组转发，不应修改分组内容。NAT 修改了 IP 地址和端口号，破坏了层次化设计
  2. 端口号被滥用： 端口号本应用于进程寻址（传输层），NAT 将其用于主机复用（网络层），混淆了层次
  3. P2P 问题： NAT 后的主机无法接受外部主动发起的连接，P2P 应用（如 BitTorrent、VoIP、网络游戏）需要特殊的 NAT 穿透（NAT Traversal） 技术（如 STUN、TURN、ICE）
  4. 违反无状态理念： 路由器应该是无状态的，NAT 需要维护连接状态表

4.3.5 IPv6

随着 IPv4 地址空间枯竭，IETF 开发了 IPv6，根本性地增大了地址空间，并对 IP 协议进行了改进。

IPv6 数据报格式

IPv6 数据报有固定的 40 字节首部（相比 IPv4 的可变长度首部）：

 0         7 8        15 16       23 24       31
+----------+-----------+-----------+-----------+
|  版本(4) | 流量类型(8)|        流标签(20)       |
+----------+-----------+-----------+-----------+
|      有效载荷长度(16)      |下一首部(8)|  跳限制(8) |
+----------------------------------------------------+
|                                                    |
|                  源地址（128 bits）                  |
|                                                    |
+----------------------------------------------------+
|                                                    |
|                  目的地址（128 bits）                |
|                                                    |
+----------------------------------------------------+
|                  数据（有效载荷）                    |
+----------------------------------------------------+

各字段说明：

字段大小说明
版本4 bitsIPv6 为 6
流量类型（Traffic Class）8 bits类似 IPv4 的 TOS，用于区分不同类型/优先级的数据报
流标签（Flow Label）20 bits标识同一"流"的数据报（如某个视频会话的所有分组），允许对特定流进行特殊处理
有效载荷长度（Payload Length）16 bits40 字节固定首部之后的字节数（即数据部分长度）
下一个首部（Next Header）8 bits指示该数据报的数据部分应交给哪个协议（类似 IPv4 协议字段），或指向扩展首部
跳限制（Hop Limit）8 bits类似 IPv4 的 TTL，每经过一台路由器减 1，减为 0 时丢弃
源地址128 bits
目的地址128 bits

IPv6 相比 IPv4 的改变：

  1. 扩展的地址容量： 地址从 32 位扩展到 128 位，地址空间 2128≈3.4×1038 ，彻底解决地址耗尽问题
  2. 简化的 40 字节固定首部： 路由器处理速度更快
  3. 取消分片： IPv6 不允许中间路由器分片，发送方通过路径 MTU 发现确定合适的分组大小；若分组太大，路由器直接丢弃并发送 ICMPv6 报文通知源主机
  4. 取消首部检验和： 传输层（TCP、UDP）已经提供检验和，每跳重新计算 IP 首部检验和开销较大，IPv6 取消了它
  5. 取消选项字段： 选项功能通过"下一个首部"指向的扩展首部（Extension Header） 实现，不影响固定首部的解析效率
  6. ICMPv6 扩展： 整合了 IPv4 的 ICMP、ARP（地址解析）、IGMP（组播管理）等功能，并新增了邻居发现（NDP，Neighbor Discovery Protocol）

IPv6 地址表示：

128 位分成 8 组，每组 16 位用冒号分隔的十六进制表示：

2001:0db8:0000:0000:0000:ff00:0042:8329

简化规则：

  • 每组前导 0 可省略：2001:db8:0:0:0:ff00:42:8329
  • 连续的全 0 组用 :: 替代（只能用一次）：2001:db8::ff00:42:8329

IPv6 特殊地址：

  • 环回地址：::1（等同 IPv4 的 127.0.0.1）
  • 未指定地址：::（等同 IPv4 的 0.0.0.0）
  • IPv4 映射地址：::ffff:x.x.x.x

从 IPv4 到 IPv6 的过渡

因特网不可能在某一天同时切换到 IPv6，过渡必须是渐进的，且要保持与现有 IPv4 基础设施的兼容性。

双栈（Dual Stack）：

节点同时支持 IPv4 和 IPv6，可以与 IPv4 节点通信（使用 IPv4），也可以与 IPv6 节点通信（使用 IPv6）。需要通过 DNS 查询结果（返回 A 记录还是 AAAA 记录）判断目标节点支持的版本。

隧道技术（Tunneling）：

当两台 IPv6 节点之间经过仅支持 IPv4 的区域时，将整个 IPv6 数据报封装在 IPv4 数据报的数据字段中传输，IPv4 首部的协议字段设为 41。

IPv6节点A → [IPv4首部|IPv6首部|数据] → IPv4路由器 → IPv6节点B
             ←────── IPv4 隧道 ────────→

隧道两端的 IPv6/IPv4 双栈节点负责封装和解封装。隧道对 IPv6 节点来说是透明的，就像直接连接一样。

4.4 通用转发和 SDN

4.4.1 传统转发 vs 通用转发

传统（基于目的地的）转发：

  • 仅根据目的 IP 地址查表
  • 转发表由路由选择算法（OSPF、BGP 等）计算
  • 每台路由器分别计算，分布式控制

通用转发（Generalized Forwarding）：

  • 根据多个首部字段的组合（跨越多个协议层）进行"匹配"
  • 匹配后执行多种可能的"动作"（不仅限于转发）
  • 由集中式控制器统一配置，灵活可编程

匹配加动作（Match-Plus-Action）范式：

通用转发的核心思想，每条转发规则描述：

  • 匹配（Match）： 对哪些分组生效（基于首部字段的值）
  • 动作（Action）： 对匹配的分组执行什么操作

4.4.2 OpenFlow 流表

OpenFlow 是最广泛使用的 SDN 标准，定义了控制器与交换机之间的接口以及流表格式。

流表（Flow Table）： 每台 OpenFlow 交换机维护一张流表，每条表项（流表项）包含：

1. 首部字段值（匹配字段）：

OpenFlow 1.0 支持匹配 12 个首部字段：

层次可匹配字段
链路层（第 2 层）入端口、以太网源/目的 MAC 地址、以太网类型、VLAN ID
网络层（第 3 层）IP 源/目的地址、IP 协议类型、IP 服务类型
传输层（第 4 层）TCP/UDP 源/目的端口号

字段可以使用通配符（*），匹配任意值，实现前缀匹配等。

2. 计数器：

  • 匹配该表项的分组数量
  • 匹配该表项的字节数量
  • 该表项上次更新的时间

3. 动作列表：

动作说明
转发（Forward）将分组转发到指定输出端口（可以是多个端口）
丢弃（Drop）丢弃该分组（用于防火墙功能）
修改字段（Modify-Field）修改分组中的某个首部字段值（用于 NAT 等）
封装/解封装添加或去除封装
发往控制器将分组发送给 SDN 控制器处理

流表匹配优先级： 若多个表项匹配同一分组，选择优先级最高的表项。若无匹配，默认行为由表中的"默认表项"决定（通常是发往控制器或丢弃）。

4.4.3 通用转发的强大之处

通用转发（流表）可以实现传统上由不同网络设备完成的功能：

路由器（Layer 3 转发）：

  • 匹配：目的 IP 地址前缀
  • 动作：转发到指定输出端口

二层交换机（Layer 2 转发）：

  • 匹配：目的 MAC 地址
  • 动作：转发到指定输出端口

防火墙：

  • 匹配：IP 地址 + TCP/UDP 端口号的组合
  • 动作：允许（转发）或禁止（丢弃）

NAT：

  • 匹配：IP 地址 + 端口号
  • 动作：修改 IP 地址和端口号字段，然后转发

负载均衡：

  • 匹配：目的 IP 地址（虚拟 IP）
  • 动作：修改目的 IP 为实际服务器 IP（多个表项，循环分配）

这种统一性是 SDN 的核心价值：将路由器、交换机、防火墙、NAT、负载均衡器等功能统一在一个通用的"匹配加动作"框架下，通过软件配置实现，而不需要专用硬件。

4.4.4 中间盒（Middleboxes）

中间盒（Middlebox）： 网络中执行分组转发以外其他功能的设备，包括：NAT 设备、防火墙、负载均衡器、内容缓存（Web 代理）、入侵检测系统（IDS）等。

传统上，这些中间盒是专用硬件设备，功能固定，难以管理。SDN 和通用转发提供了用软件替代这些专用硬件的可能性，形成网络功能虚拟化（NFV，Network Function Virtualization） 趋势。

NFV： 在通用商用服务器上以软件形式实现原本由专用硬件完成的网络功能，降低成本，提高灵活性和可管理性。

本章小结

本章介绍了网络层数据平面的核心内容，主要包括：

  1. 网络层概述： 转发（数据平面，硬件，纳秒级）vs 路由选择（控制平面，软件，秒级）；传统每台路由器控制 vs SDN 集中控制；IP 尽力而为服务模型

  2. 路由器工作原理： 四个组成部分（输入端口、交换结构、输出端口、路由选择处理器）；最长前缀匹配（TCAM 实现）；三种交换结构（内存、总线、互联网络/Crossbar）；输入排队与 HOL 阻塞；输出排队与缓冲区设计（Bufferbloat、AQM/RED）；分组调度（FIFO、优先级队列、RR、WFQ）

  3. IPv4： 数据报格式（20 字节固定首部各字段含义）；IP 分片与重组（标识、MF 标志、片偏移）；CIDR 地址表示（a.b.c.d/x）和最长前缀匹配；DHCP 四步过程（Discover、Offer、Request、ACK）；NAT 工作原理（转换表、端口复用）及争议

  4. IPv6： 设计动机（IPv4 地址耗尽）；40 字节固定首部；与 IPv4 的主要区别（128 位地址、无分片、无首部检验和、扩展首部）；过渡机制（双栈、隧道）

  5. 通用转发与 SDN： 匹配加动作范式；OpenFlow 流表（12 个可匹配字段、计数器、动作列表）；流表实现路由器/交换机/防火墙/NAT/负载均衡等多种功能；中间盒与 NFV

第五章 网络层：控制平面

5.1 概述

第四章介绍了网络层的数据平面——路由器如何根据转发表将分组从输入端口转发到输出端口。本章介绍网络层的控制平面——转发表和流表是如何计算、维护和安装的。

控制平面有两种实现方式：

传统方式（每台路由器控制）：
每台路由器运行路由选择算法，与其他路由器的路由选择组件通信，共同计算转发表。OSPF 和 BGP 采用此方式。

SDN 方式（逻辑集中控制）：
远程控制器计算并向每台路由器分发转发表，路由器只负责执行转发。

本章先介绍路由选择算法的基本原理，再分别介绍 AS 内部路由（OSPF）、AS 间路由（BGP）、SDN 控制平面，最后介绍 ICMP。

5.2 路由选择算法

路由选择算法的目标是找到从发送方到接收方的"好"路径（通常是最低代价路径）。

图抽象： 将网络抽象为图 G=(N,E) ， N 为路由器（节点）集合， E 为链路（边）集合。每条边 (u,v) 有代价 c(u,v) （代价可以表示距离、链路速率、拥塞程度等）。

路径代价： 路径 P=(x1,x2,…,xp) 的代价为路径上各边代价之和。

最低代价路径（Least-Cost Path）： 从源节点到目的节点的所有路径中代价最小的路径。若所有边代价相同，最低代价路径等同于最短路径（跳数最少）。

路由选择算法的分类

按获取信息方式：

  • 全局路由选择算法（Global Routing Algorithm）： 以完整的网络图和链路代价作为输入，在计算开始前已知全局信息。链路状态（LS）算法属于此类，也称为集中式路由选择算法
  • 分散式路由选择算法（Decentralized Routing Algorithm）： 每个节点只知道与自己直接相连的链路信息，通过与邻居迭代交换信息逐步计算最低代价路径。距离向量（DV）算法属于此类

按路由是否随流量变化：

  • 静态路由选择（Static Routing）： 路由变化非常缓慢，通常是人工干预的结果
  • 动态路由选择（Dynamic Routing）： 随网络流量负载或拓扑的变化自动调整路由

5.2.1 链路状态路由选择算法

链路状态算法（LS Algorithm）中，网络拓扑和所有链路代价是已知的，通过链路状态广播（Link-State Broadcast） 让每台路由器都获得完整的网络视图，然后各自独立运行 Dijkstra 算法计算最短路径。

Dijkstra 算法

初始化：

  • D(v) ：从源节点 u 到节点 v 的当前最低代价路径代价，初始时对 u 的直接邻居 v 设为 c(u,v) ，其他节点设为 ∞
  • p(v) ：从 u 到 v 当前最低代价路径上 v 的前驱节点
  • N′ ：已确定最低代价路径的节点集合，初始为 {u}

迭代： 重复以下步骤，直到 N′ 包含所有节点：

  1. 从不在 N′ 中的节点中，找出 D(w) 最小的节点 w ，将 w 加入 N′
  2. 对 w 的每个不在 N′ 中的邻居 v ，更新：
D(v)=min(D(v), D(w)+c(w,v))

若更新，则 p(v)=w 。

示例（6 节点网络）：

设节点 u,v,w,x,y,z ，各边代价已知，求从 u 出发的最短路径：

步骤 N′ D(v),p(v) D(w),p(w) D(x),p(x) D(y),p(y) D(z),p(z)
0 {u} 2, u5, u1, u∞∞
1 {u,x} 2, u4, x—2, x∞
2 {u,x,v} —4, x—2, x∞
3 {u,x,v,y} —3, y——4, y
4 {u,x,v,y,w} ————4, y
5 {u,x,v,y,w,z} —————

复杂度： 基本实现 O(n2) ，使用最小堆优化后 O((n+E)log⁡n) ， n 为节点数， E 为边数。

LS 算法的问题：振荡（Oscillation）

若链路代价与链路上承载的流量有关（如拥塞越高代价越大），则可能产生路由振荡：流量改变导致代价改变，代价改变导致路由改变，路由改变导致流量再次改变，如此循环，路由周期性地来回变化，永远无法稳定。

解决方法： 路由器不在同一时刻广播链路状态（随机化广播时间），避免同步振荡。

5.2.2 距离向量路由选择算法

距离向量算法（DV Algorithm）是分散式、异步、迭代的：

  • 分散式： 每个节点只从直接相连的邻居处接收信息
  • 迭代： 持续计算，直到邻居之间不再交换信息（收敛）
  • 异步： 不要求所有节点同步操作

Bellman-Ford 方程

DV 算法基于 Bellman-Ford 动态规划方程：

dx(y)=minv{c(x,v)+dv(y)}

其中：

  • dx(y) ：节点 x 到节点 y 的最低代价路径代价
  • v ： x 的所有邻居
  • c(x,v) ： x 到邻居 v 的直接链路代价
  • dv(y) ：邻居 v 到 y 的最低代价（由 v 告知 x ）

方程含义：从 x 到 y 的最短路径，必然经过某个邻居 v ，代价为 c(x,v)+dv(y) ，取所有邻居中的最小值。

距离向量（Distance Vector）

每个节点 x 维护以下信息：

  • 对每个邻居 v ，直接链路代价 c(x,v)
  • 自身的距离向量 Dx=[Dx(y):y∈N] ，即 x 对到网络中所有其他节点代价的估计值
  • 每个邻居 v 的距离向量 Dv （由 v 发来）

DV 算法过程

初始化：

  • Dx(x)=0
  • 对邻居 v ： Dx(v)=c(x,v)
  • 对非邻居 y ： Dx(y)=∞
  • 向所有邻居发送自己的距离向量

每当：

  • 收到邻居 v 的距离向量更新，或
  • 发现某条直接链路代价改变

则： 对每个目的节点 y ，重新计算：

Dx(y)=minv{c(x,v)+Dv(y)}

若 Dx(y) 有变化，向所有邻居发送更新后的距离向量。

算法持续运行，直到没有更新发出，即达到收敛（Convergence） 。

链路代价变化与无穷计数问题

链路代价减小（好消息）： 收敛迅速。若 x - y 链路代价从 4 降为 1， y 更新距离向量，通知邻居，邻居更新，两次迭代内即可收敛，消息传播快。

链路代价增大（坏消息）： 可能产生无穷计数（Count-to-Infinity） 问题。

示例： 三节点线形网络 x−y−z ，代价均为 1。正常情况下 Dy(x)=1,Dz(x)=2 。

现在 x 和 y 之间的链路代价从 1 变为 60：

  1. y 检测到链路变化，更新 Dy(x)=60
  2. 但 y 同时看到 z 的距离向量中 Dz(x)=2 ，以为经过 z 到 x 的代价为 1+2=3<60 ，于是更新 Dy(x)=3 并通知邻居
  3. z 收到更新，重新计算 Dz(x)=1+3=4 ，通知邻居
  4. y 收到更新，重新计算 Dy(x)=1+4=5 ，通知邻居
  5. 如此反复， Dy(x) 和 Dz(x) 交替增大，直到超过 60 才收敛

这个过程需要大量迭代，称为无穷计数（Count-to-Infinity） 问题。问题根源： z 以为可以经过 y 到达 x ，但实际上 z 的路径本来就经过 y ， y 却以为可以经过 z 到达 x ——形成了路由环路。

毒性逆转（Poisoned Reverse）

毒性逆转规则： 若节点 z 经由节点 y 路由到目的地 x ，则 z 向 y 宣告到 x 的距离为无穷大（即"毒化"该路由，告诉 y 不要经由 z 到达 x ）。

继续上面的例子：由于 z 本来通过 y 到达 x ， z 向 y 宣告 Dz(x)=∞ 。 y 收到后不会以为可以经由 z 到达 x ，而是直接用代价 60 的直连链路，立即收敛。

毒性逆转的局限： 毒性逆转只能解决两节点之间的环路。对于三节点或更多节点形成的环路，毒性逆转无效，无穷计数问题仍然存在。这是 DV 算法的根本缺陷之一。

5.2.3 LS 与 DV 算法比较

比较维度LS 算法DV 算法
报文复杂度每台路由器广播链路状态， O(|N||E|) 条报文只与邻居交换，报文数量较少，但收敛时间较长
收敛速度较快， O(n2) 算法，广播后独立计算较慢，迭代收敛，可能出现路由振荡
鲁棒性路由器故障只影响自身广播的链路状态；各路由器独立计算自己的转发表，错误不扩散错误的距离信息会扩散到全网，影响所有路由器的计算结果
实现复杂度需要全局信息，初始广播开销大分散式，每个节点只需邻居信息，但存在无穷计数问题
实际使用OSPF、IS-ISRIP（已较少使用）、早期 BGP

两种算法各有优劣，实际中都有使用。因特网内部使用 OSPF（LS），早期域间路由使用 RIP（DV），现在域间路由使用 BGP（路径向量，DV 的变体）。

5.3 因特网中自治系统内部的路由选择：OSPF

5.3.1 为什么需要层次化路由

若将因特网中所有路由器作为一个整体运行 LS 或 DV 算法，存在两个问题：

规模问题（Scale）： 因特网有数亿台路由器，全局运行 LS 算法需要广播链路状态到每台路由器，消耗的带宽和计算资源不可想象；DV 算法则几乎不可能收敛。

管理自治问题（Administrative Autonomy）： 因特网是由各 ISP 运营的网络组成的，每个 ISP 希望按自己的方式管理网络，同时对外隐藏内部拓扑结构。

解决方案： 将路由器组织成自治系统（AS，Autonomous System） ，每个 AS 在同一管理机构下运行，有自己的 AS 编号（ASN，由 IANA 分配，16 位或 32 位）。

  • 域内路由（Intra-AS Routing）/ 内部网关协议（IGP，Interior Gateway Protocol）： AS 内部路由，同一 AS 内的路由器运行相同的路由选择算法，例如 OSPF
  • 域间路由（Inter-AS Routing）/ 外部网关协议（EGP，Exterior Gateway Protocol）： AS 之间路由，例如 BGP

5.3.2 OSPF

OSPF（Open Shortest Path First，开放最短路优先） 是广泛使用的 AS 内部路由选择协议，基于链路状态算法。"开放"表示协议规范是公开可用的（相对于私有协议）。

OSPF 工作原理：

  1. 路由器通过OSPF Hello 报文发现相邻路由器，建立邻居关系
  2. 路由器定期（或链路状态变化时）泛洪链路状态通告（LSA，Link State Advertisement） ，描述自身的链路状态（与哪些路由器相连，代价是多少）
  3. 每台路由器收集 AS 内所有 LSA，构建完整的链路状态数据库（LSDB，Link State Database）
  4. 每台路由器用 Dijkstra 算法，以自身为根，计算到 AS 内所有目的地的最短路径，生成转发表

OSPF 报文直接封装在 IP 数据报中，协议号为 89。OSPF 使用 IP 多播地址（224.0.0.5 发给所有 OSPF 路由器，224.0.0.6 发给指定路由器）。

OSPF 的主要特性：

安全性： 所有 OSPF 报文（Hello、LSA 等）都可以经过认证，防止恶意路由器注入虚假路由信息。可以配置简单口令认证或 MD5 认证。

多条等价路径： 若存在多条到同一目的地代价相同的路径，OSPF 允许同时使用这些路径（等价多路径，ECMP），进行流量分担，提高链路利用率。

集成单播和多播路由： MOSPF（Multicast OSPF） 扩展了 OSPF 以支持多播路由，使用与 OSPF 相同的链路状态数据库。

层次化 OSPF（Hierarchical OSPF）： 单个 AS 内可以进一步划分为区域（Area） ，实现两级层次：

  • 骨干区域（Backbone Area，Area 0）： 连接所有其他区域，所有区域间流量都必须经过骨干区域
  • 普通区域（Regular Area）： 每个普通区域运行自己的 OSPF 链路状态算法，LSA 只在区域内泛洪，不跨越区域
  • 区域边界路由器（ABR，Area Border Router）： 连接普通区域和骨干区域，汇总区域内的路由信息向骨干区域通告，并将骨干区域的路由信息通告给区域内路由器
  • AS 边界路由器（ASBR，AS Boundary Router）： 连接不同 AS，引入外部路由信息

层次化的好处：每台路由器只需维护本区域的链路状态数据库，大幅减少计算量和通信量；区域内拓扑变化只在区域内泛洪，不影响其他区域。

OSPF 路由器类型：

类型说明
内部路由器所有接口都在同一区域内
区域边界路由器（ABR）接口分布在多个区域，汇总区域路由
骨干路由器至少有一个接口在骨干区域
AS 边界路由器（ASBR）引入外部 AS 的路由信息

指定路由器（DR）和备用指定路由器（BDR）： 在广播型网络（如以太网）上，若每对路由器都建立邻接关系，则 n 台路由器需要 n(n−1)/2 条邻接关系，开销巨大。OSPF 选举一台 DR 和一台 BDR，其他路由器只与 DR/BDR 建立邻接关系，DR 负责泛洪链路状态，大幅减少通信量。

5.4 域间路由选择：BGP

5.4.1 BGP 的作用

若数据报要跨越多个 AS（这是因特网中绝大多数通信的情况），就需要域间路由选择协议。

BGP（Border Gateway Protocol，边界网关协议） 是当今因特网中唯一使用的域间路由选择协议，是"将因特网黏合在一起的胶水"，极其重要。BGP 目前的版本是 BGP4（RFC 4271）。

BGP 的两个核心功能：

  1. 从邻居 AS 获取子网可达性信息： 每个 AS 通过 BGP 得知因特网上存在哪些子网（IP 前缀），以及如何到达这些子网
  2. 向 AS 内部路由器传播可达性信息： 将从邻居 AS 学到的前缀信息通告给 AS 内部路由器，使其能够转发去往这些前缀的数据报

5.4.2 BGP 基础

BGP 会话

BGP 是基于 TCP 的协议（端口 179），两台路由器通过 TCP 连接交换 BGP 报文，称为 BGP 会话（BGP Session） 。

eBGP（External BGP，外部 BGP）：
跨越两个 AS 的 BGP 会话，即不同 AS 中的边界路由器之间的会话。用于在不同 AS 之间交换可达性信息。

iBGP（Internal BGP，内部 BGP）：
同一 AS 内部路由器之间的 BGP 会话。用于将通过 eBGP 学到的外部路由信息传播给 AS 内部的所有路由器。

iBGP 要求 AS 内部所有路由器之间都建立 iBGP 会话（全互联，Full Mesh），这是因为 BGP 路由不通过 iBGP 传递给第三方（防止路由信息被错误扩散）。对于大型 AS，全互联的 iBGP 会话数量为 n(n−1)/2 ，开销较大，可以使用路由反射器（Route Reflector） 或联邦（Confederation） 来解决。

注意： iBGP 和 OSPF 的区别——OSPF 是链路状态协议，计算 AS 内部路由；iBGP 是路径向量协议，传播 AS 外部可达性信息，两者用途不同，通常同时使用。

BGP 路由通告

BGP 中的路由信息以前缀（Prefix）+ 属性（Attribute） 的形式传播，称为 BGP 路由（BGP Route） 。

主要 BGP 属性：

AS-PATH（AS 路径）：
记录该路由通告经过的 AS 序列，如 AS2 AS1。每当路由通告经过一个 AS，该 AS 将自己的 ASN 添加到 AS-PATH 前面。

AS-PATH 有两个重要作用：

  1. 环路检测： 若路由器收到的 BGP 通告中 AS-PATH 包含自己的 ASN，则丢弃该通告（否则会形成环路）
  2. 路由选择： AS-PATH 越短，通常认为路径越好

NEXT-HOP（下一跳）：
该属性的值是发出本路由通告的边界路由器的 IP 地址（即进入下一个 AS 的路由器接口地址）。NEXT-HOP 是连接 iBGP 路由信息和 OSPF 路由信息的关键：AS 内部路由器通过 OSPF 找到到 NEXT-HOP 的路径，再加上 BGP 前缀路由，就能转发去往 AS 外部的数据报。

LOCAL-PREF（本地偏好）：
AS 管理员手动配置的策略属性，值越大越优先。用于在多条出口路径中选择首选路径。LOCAL-PREF 只在 AS 内部通过 iBGP 传播，不通过 eBGP 传递给其他 AS。

MED（Multi-Exit Discriminator，多出口鉴别器）：
当两个 AS 之间有多个连接点时，MED 允许一个 AS 向另一个 AS 建议优选哪个连接点（值越小越优先）。

BGP 路由通告的策略控制

BGP 通告不仅是技术问题，更是商业策略问题。ISP 之间有商业关系，这决定了路由如何通告：

客户-提供商（Customer-Provider）关系： 小 ISP 付钱给大 ISP（提供商）获取全球连接。提供商向客户通告所有路由，客户向提供商通告自己的路由（但不向提供商通告从其他提供商学到的路由，以免成为"免费中转"）。

对等（Peer）关系： 同级别 ISP 之间免费互换各自客户网络的路由，但不向对方通告从第三方学到的路由。

路由过滤（Route Filtering）： BGP 路由器可以根据策略选择性地接受或拒绝路由通告，也可以选择性地向哪些邻居通告哪些路由。这是运营商网络管理的核心工具。

5.4.3 BGP 路由选择

当一台 BGP 路由器收到同一前缀的多条路由（来自不同邻居），必须选择一条最优路由。BGP 的路由选择过程按以下优先级顺序进行：

1. LOCAL-PREF 值（本地偏好）： LOCAL-PREF 最高的路由优先。这是 AS 管理员配置的策略，优先级最高。

2. 最短 AS-PATH： AS-PATH 跳数最少的路由优先。即经过的 AS 数量最少。

3. 最近的 NEXT-HOP：热土豆路由（Hot Potato Routing）

热土豆路由：在 LOCAL-PREF 相同且 AS-PATH 相同的情况下，选择使到 NEXT-HOP 路由器的 AS 内部代价（OSPF 代价）最小的路由，即尽可能快地将流量移出本 AS（“把烫手山芋扔出去”）。

热土豆路由是自私的：不考虑全局路径代价，只关心本 AS 内部的代价，将流量尽快交给其他 AS 处理。

4. BGP 标识符（BGP Identifier）： 若前三条均相同，选择 BGP 标识符（路由器 ID）最小的邻居的路由，作为最终决胜条件。

实际实现中还有其他细节（如 MED 比较、eBGP vs iBGP 优先等），但上述四条是最核心的。

5.4.4 IP 任播（IP Anycast）

IP 任播（IP Anycast） 是 BGP 的一个有趣应用。

场景： CDN 和 DNS 服务通常在多个地理位置部署完全相同的服务（相同内容，相同功能），希望用户请求被路由到地理位置最近（网络上距离最短）的服务器。

实现方法： 多台服务器使用同一个 IP 地址，通过 BGP 各自向因特网通告该地址的可达性。因特网路由器根据 BGP 选择最短路径，自然将用户请求路由到网络距离最近的那台服务器。

应用： DNS 根服务器、CDN 节点分发、DDoS 防御（流量分散到多个节点吸收）。

任播 vs 单播 vs 多播 vs 广播：

通信类型含义
单播（Unicast）一对一
任播（Anycast）一对多中最近的一个
多播（Multicast）一对多（组成员）
广播（Broadcast）一对所有

5.4.5 域间路由选择和域内路由选择为何不同

原因 1：策略（Policy）

域间路由涉及不同组织（ISP）的商业利益，路由决策必须反映商业策略（谁付钱给谁，谁与谁对等），不能只追求最短路径。BGP 提供了丰富的策略工具（LOCAL-PREF、路由过滤等）。

域内路由只在单一组织内部，策略相对简单，追求性能（最短路径、最低代价）即可。

原因 2：规模（Scale）

因特网有数十万个 AS，全球路由表有数十万条前缀。域间路由必须能够处理这种规模。BGP 使用前缀聚合（CIDR）减少路由条目数量。

域内路由的规模通常较小（数百至数千台路由器），OSPF 的链路状态数据库可以维持在合理大小。

原因 3：性能（Performance）

域内路由器之间相互信任（同一组织），追求最优路径性能。

域间路由器之间属于不同组织，互不完全信任，策略和商业利益优先于单纯的性能优化。

5.5 SDN 控制平面

5.5.1 SDN 体系结构

SDN 将控制平面从数据平面中分离出来，由逻辑集中的控制器（Controller） 统一管理。

SDN 体系结构的四个关键特征：

  1. 基于流的转发： 交换机按照控制器下发的流表进行转发，流表可以基于多个首部字段（OpenFlow），而不仅仅是目的 IP 地址

  2. 数据平面与控制平面分离： 交换机只做快速转发（数据平面），路由计算和策略决策在远程控制器中完成（控制平面）

  3. 网络控制功能驻留在数据平面设备外部： 控制器运行在普通服务器上（而非专用硬件），可以集中部署，也可以分布式部署（但逻辑上是集中的）

  4. 网络是可编程的： 网络管理员通过控制器上运行的网络控制应用（Network-Control Application）定制网络行为，不需要修改交换机硬件或底层软件

5.5.2 SDN 控制平面组件

SDN 控制平面分为三层：

数据平面（交换机层）

SDN 交换机（SDN-Controlled Switch）：

  • 执行快速分组转发，根据流表进行"匹配加动作"
  • 流表由控制器下发，交换机本身不计算路由
  • 提供与控制器通信的 API（如 OpenFlow）
  • 交换机可以由多家厂商生产，只要支持标准 API 即可（硬件/软件解耦）

SDN 控制器（Controller Layer）

控制器是 SDN 的核心，维护网络的完整状态信息，并通过 API 向上（网络控制应用）和向下（交换机）提供接口。

控制器的功能模块：

功能说明
链路状态信息维护网络拓扑（链路连接关系和代价）
交换机信息记录各交换机的特性和流表
主机位置信息追踪主机连接到哪个交换机端口
统计信息收集流量统计，用于监控和负载均衡

南向接口（Southbound Interface）： 控制器与交换机之间的接口，如 OpenFlow。控制器通过南向接口向交换机下发流表项，交换机通过南向接口向控制器上报事件（如新主机接入、链路故障）。

北向接口（Northbound Interface）： 控制器与网络控制应用之间的接口，通常是 REST API。应用程序通过北向接口读取网络状态、安装流表项。

控制器的分布式实现： 逻辑上集中，物理上可以分布。多台控制器服务器协同工作，通过共识协议（如 Paxos、Raft）维护一致的网络状态视图，避免单点故障。典型开源控制器：ONOS（Open Network Operating System） 、OpenDaylight。

网络控制应用层（Application Layer）

网络控制应用是 SDN 的"大脑"，通过北向 API 与控制器交互，实现各种网络功能：

  • 路由选择应用： 计算路径并安装转发规则（替代传统 OSPF/BGP）
  • 负载均衡应用： 将流量分配到多台服务器
  • 防火墙应用： 基于流表实现访问控制
  • 流量工程应用（Traffic Engineering）： 优化网络流量分布，避免拥塞
  • 虚拟网络（VN）/ 网络切片： 在物理网络上创建多个逻辑隔离的虚拟网络

5.5.3 OpenFlow 协议

OpenFlow 是最广泛使用的南向接口协议（RFC 3848，ONF 标准），定义了控制器与交换机之间交换的报文类型。

OpenFlow 运行在 TCP 上，通常使用 6653 端口，可选 TLS 加密。

控制器→交换机的报文（主动下发）：

报文类型说明
Features查询交换机的特性和能力
Configuration设置交换机参数
Modify-State增加、删除、修改流表项；设置端口属性
Send-Packet让交换机从指定端口发送特定分组（用于探测等）

交换机→控制器的报文（事件上报）：

报文类型说明
Packet-In将分组（或首部）发送给控制器（没有匹配流表项时）
Flow-Removed通知控制器某流表项已超时被删除
Port-Status通知控制器端口状态变化（如链路故障、新连接）

双向报文：

报文类型说明
Hello控制器和交换机握手，协商 OpenFlow 版本
Echo心跳检测，验证连接活跃
Error通知错误

5.5.4 SDN 的数据平面和控制平面交互示例

示例：链路故障时的路由更新

  1. 交换机 s1 检测到与 s2 之间的链路故障
  2. s1 向 SDN 控制器发送 Port-Status 报文，报告端口状态变化
  3. 控制器更新链路状态数据库，标记 s1 - s2 链路故障
  4. Dijkstra 路由选择应用（运行在控制器上）被通知链路状态变化，重新计算受影响的路径
  5. 路由选择应用通过北向 API 请求控制器更新相关交换机的流表
  6. 控制器向相关交换机（如 s1 、 s3 、 s4 ）发送 Modify-State 报文，更新流表项
  7. 数据转发按新路由进行

整个过程自动完成，无需管理员手动干预，且速度远快于传统路由协议（传统协议需要 LSA 洪泛、Dijkstra 计算等多步骤，SDN 可以直接下发）。

5.5.5 SDN 的挑战

可扩展性： 单一控制器可能成为大型网络的瓶颈，分布式控制器协调有一定开销。

安全性： 控制器是单点攻击目标，若控制器被攻陷，整个网络的转发行为都可能被篡改。需要对控制器进行安全加固和冗余部署。

标准化： 南向接口（OpenFlow）已较为成熟，但北向接口缺乏统一标准，不同控制器 API 不兼容。

与传统网络集成： 实际网络中 SDN 设备和传统设备往往并存（Hybrid SDN），需要处理互操作性问题。

尽管存在挑战，SDN 已在数据中心（Google B4、Facebook Fabric）、广域网（谷歌 ONIX）和移动核心网（5G 核心网）中得到大规模部署。

5.6 互联网控制报文协议（ICMP）

5.6.1 ICMP 概述

ICMP（Internet Control Message Protocol，互联网控制报文协议） 是 IP 协议的配套协议，用于主机和路由器之间传递网络层控制信息——差错报告和查询。

ICMP 报文封装在 IP 数据报中传输（IP 协议号为 1），因此严格说 ICMP 不是网络层协议，而是位于 IP 之上，但通常将其归入网络层讨论。

ICMP 位于 IP 之上，但低于 TCP/UDP，是网络层与传输层之间的"辅助通道"。

5.6.2 ICMP 报文类型

ICMP 报文由类型（Type） 和代码（Code） 字段标识，后面通常跟引起该 ICMP 报文的原始 IP 数据报的首部和前 8 个字节（用于定位引起差错的报文段和上层协议）。

常用 ICMP 报文：

类型代码描述用途
00Echo 回答ping 响应
30目的网络不可达路由器无路由到目的网络
31目的主机不可达目的主机不可达
32目的协议不可达目的主机不支持该传输层协议
33目的端口不可达目的端口无进程监听
36目的网络未知
37目的主机未知
40源抑制（已废弃）曾用于拥塞控制，现已废弃
50网络重定向路由器通知主机有更好的路由
51主机重定向
80Echo 请求ping 请求
90路由器通告
100路由器发现
110TTL 超时数据报 TTL 减为 0 被丢弃
120IP 首部错误IP 首部参数有问题

5.6.3 ping 和 Traceroute 的实现

ping

ping 程序利用 ICMP 的 Echo 请求（类型 8，代码 0）和 Echo 回答（类型 0，代码 0）报文测试主机可达性和往返时延（RTT）。

工作原理：

  1. ping 向目的主机发送 ICMP Echo 请求报文，包含标识符和序号字段
  2. 目的主机收到后，回复 ICMP Echo 回答报文，内容与请求相同
  3. ping 计算从发送到接收的时间差，即 RTT

Traceroute

traceroute（Linux/Mac）或 tracert（Windows）利用 ICMP TTL 超时报文追踪数据报经过的路径。

工作原理：

  1. 源主机向目的主机发送一系列 UDP 报文段（目的端口号为不太可能被使用的端口，如 33434 以上），TTL 从 1 开始逐渐递增：

    • TTL=1 的第一组报文（通常 3 个）
    • TTL=2 的第二组报文
    • TTL=3 的第三组报文
    • ……

  2. 当 TTL=1 的报文到达路径上第一台路由器时，路由器将 TTL 减为 0，丢弃该数据报，并向源主机返回 ICMP TTL 超时报文（类型 11，代码 0） 。ICMP 报文的源地址即为该路由器的 IP 地址。源主机计算从发送到收到 ICMP 报文的时间差（RTT）。

  3. TTL=2 的报文到达第二台路由器时同样触发 ICMP TTL 超时，源主机得知第二跳路由器的地址和时延。

  4. 以此类推，直到 UDP 报文到达目的主机。由于端口不可用，目的主机返回 ICMP 端口不可达报文（类型 3，代码 3） 。源主机收到此报文，知道路径已追踪完毕，停止发送。

发送 3 个报文的原因： 每个 TTL 值发送 3 个报文，对应输出中每跳的 3 个 RTT 值，可以反映时延的波动情况。

Traceroute 的局限：

  • 防火墙可能阻止 ICMP 或特定端口的 UDP 报文，导致某些跳显示 * * *
  • 路由可能非对称（去程和回程路径不同），traceroute 显示的是去程路径，不能反映完整的端到端路径
  • 同一条路径上不同时刻测量结果可能不同（负载均衡、路由变化）

5.6.4 ICMPv6

IPv6 将 IPv4 的 ICMP、ARP（地址解析）、IGMP（组播管理）整合到 ICMPv6 中，协议号为 58。

ICMPv6 的主要新功能：

邻居发现协议（NDP，Neighbor Discovery Protocol）：

替代 IPv4 中的 ARP，用于：

  • 地址解析： 通过 IPv6 地址获取 MAC 地址（邻居请求/邻居通告报文）
  • 路由器发现： 主机发现本地路由器（路由器请求/路由器通告报文）
  • 无状态地址自动配置（SLAAC）： 主机根据路由器通告的前缀自动生成 IPv6 地址
  • 重复地址检测（DAD）： 确保 IPv6 地址在本地网络中唯一

ICMPv6 重要报文类型：

类型描述
1目的不可达
2分组太大（取代 IPv4 的分片通知）
3超时（TTL/跳数限制超时）
4参数问题
128Echo 请求
129Echo 回答
133路由器请求（RS）
134路由器通告（RA）
135邻居请求（NS）
136邻居通告（NA）
137重定向

5.7 网络管理和 SNMP、NETCONF/YANG

5.7.1 网络管理概述

网络管理（Network Management） 包括对网络的监控、配置、故障排除和性能优化等活动。网络管理涉及：

  • 管理服务器（Managing Server）： 运行在网络运营中心（NOC）的应用程序，协调网络管理活动
  • 被管设备（Managed Device）： 网络中受管理的硬件设备（路由器、交换机、主机等）
  • 管理信息库（MIB，Management Information Base）： 被管设备维护的管理信息（接口状态、流量统计、错误计数等）的集合
  • 网络管理代理（Agent）： 运行在被管设备上的软件，响应管理服务器的请求，收集和上报管理信息
  • 网络管理协议（Network Management Protocol）： 管理服务器与代理之间通信的协议

5.7.2 SNMP

SNMP（Simple Network Management Protocol，简单网络管理协议） 是因特网标准网络管理协议，使用 UDP（端口 161/162）。

MIB（管理信息库）： 被管设备上的信息集合，每个信息对象有唯一的对象标识符（OID，Object Identifier） 。MIB 对象用 SMI（Management Information Structure） 语言定义。

SNMP 报文类型：

报文类型方向说明
GetRequest管理服务器→代理获取一个或多个 MIB 对象的值
GetNextRequest管理服务器→代理获取 MIB 中下一个对象的值（用于遍历 MIB）
GetBulkRequest管理服务器→代理批量获取大量数据（SNMPv2+）
InformRequest管理服务器→管理服务器通知远程管理服务器 MIB 信息（SNMPv2+）
SetRequest管理服务器→代理设置 MIB 对象的值（配置设备）
Response代理→管理服务器响应 Get/Set 请求
Trap代理→管理服务器代理主动通知管理服务器发生了某个事件（如接口故障）

SNMP 操作模式：

  • 请求-响应模式： 管理服务器向代理发送请求，代理回复（Get/Set）
  • 陷阱（Trap）模式： 代理主动向管理服务器发送通知，无需轮询

SNMP 版本：

  • SNMPv1： 最基本，安全性差（社区字符串明文传输）
  • SNMPv2： 增加 GetBulk 等功能，但安全性改进有限
  • SNMPv3： 增加认证和加密，显著提升安全性，是目前推荐版本

5.7.3 NETCONF 和 YANG

随着网络规模扩大和 SDN 的兴起，SNMP 的局限性越来越明显：配置能力弱、事务性差（无法原子性配置多设备）、数据模型不规范。

NETCONF（Network Configuration Protocol，RFC 6241）： 新一代网络配置协议，基于 XML，运行在 SSH 之上（端口 830）。

NETCONF 的特点：

  • 事务性配置： 支持配置的原子性提交（要么全部成功，要么全部回滚），可以同时对多台设备进行事务性配置
  • 候选配置（Candidate Configuration）： 在提交前可以验证配置的合法性
  • 运行配置和启动配置： 明确区分当前运行的配置和设备重启后加载的配置
  • 通知机制： 设备可以向管理系统推送事件通知

YANG（Yet Another Next Generation，RFC 6020）： 为 NETCONF 设计的数据建模语言，定义网络设备配置和状态数据的结构、语法和语义。YANG 模型被多个厂商和标准组织（IETF、OpenConfig）共同维护，提高了互操作性。

NETCONF vs SNMP：

比较维度SNMPNETCONF
主要用途监控为主，配置为辅配置为主
传输协议UDPSSH（TCP）
数据格式BER（二进制）XML
事务支持无有（原子性提交）
数据模型语言SMIYANG
安全性SNMPv3 才有依赖 SSH，默认安全

本章小结

本章介绍了网络层控制平面的核心内容，主要包括：

  1. 路由选择算法： 图抽象与最低代价路径；链路状态算法（Dijkstra，全局信息， O(n2) ，振荡问题）；距离向量算法（Bellman-Ford，分散式，无穷计数问题，毒性逆转）；LS vs DV 的报文复杂度、收敛速度和鲁棒性比较

  2. AS 内部路由：OSPF： 层次化路由的必要性（规模和管理自治）；OSPF 基于链路状态算法（Dijkstra）；LSA 泛洪；OSPF 特性（认证、ECMP、层次化区域划分、DR/BDR）；区域类型（骨干区域 Area 0、普通区域、ABR、ASBR）

  3. AS 间路由：BGP： eBGP（跨 AS）和 iBGP（AS 内部传播外部路由）；BGP 路由属性（AS-PATH、NEXT-HOP、LOCAL-PREF、MED）；路由通告与策略控制（客户-提供商关系、对等关系、路由过滤）；BGP 路由选择顺序（LOCAL-PREF→AS-PATH→热土豆路由→BGP 标识符）；IP 任播；域内外路由差异（策略、规模、性能）

  4. SDN 控制平面： 四个关键特征（基于流转发、数据平面与控制平面分离、控制平面外置、网络可编程）；三层架构（数据平面交换机层、SDN 控制器层、网络控制应用层）；南向接口（OpenFlow 报文类型）；北向接口（REST API）；控制器分布式实现（ONOS、OpenDaylight）；SDN 交互示例（链路故障路由更新）；SDN 挑战（可扩展性、安全性、标准化）

  5. ICMP： ICMP 报文结构（类型、代码）；常用报文（Echo 请求/回答、TTL 超时、目的不可达）；ping 实现（Echo 请求/回答）；Traceroute 实现（TTL 递增触发 ICMP TTL 超时，最终触发 ICMP 端口不可达）；ICMPv6（整合 ARP/IGMP，新增 NDP/SLAAC/DAD）

  6. 网络管理： SNMP（MIB、OID、报文类型、请求-响应和 Trap 模式、SNMPv3 安全性）；NETCONF/YANG（事务性配置、候选配置、XML 数据格式、YANG 数据建模语言）；SNMP vs NETCONF 比较

第六章 链路层和局域网

6.1 链路层概述

6.1.1 链路层提供的服务

节点（Node）： 运行链路层协议的任何设备，包括主机、路由器、交换机、WiFi 接入点等。

链路（Link）： 沿通信路径连接相邻节点的通信信道。

数据报（网络层分组）在从源到目的地的整个路径上，需要经过若干段链路传输。在不同的链路上，数据报可能由不同的链路层协议处理——第一段链路可能是以太网，中间某段可能是无线链路，最后一段可能是光纤链路。不同链路层协议提供不同的服务，就像不同的交通方式（公共汽车、地铁、飞机）为一次旅途提供不同的运输服务。

链路层可能提供的服务包括：

成帧（Framing）：
将网络层数据报封装成帧（Frame） ，加上首部和尾部字段。帧结构由链路层协议规定，不同协议的帧结构不同。

链路接入（Link Access）：
介质访问控制（MAC，Medium Access Control）协议规定了帧在链路上传输的规则。对于点对点链路（两端只有一个发送方和一个接收方），MAC 协议很简单；对于多个节点共享同一广播链路的情况，MAC 协议需要协调多个节点的传输，防止碰撞。

可靠交付（Reliable Delivery）：
部分链路层协议提供从一个节点到相邻节点的可靠数据传输（确认和重传），类似 TCP，但作用范围仅限于单段链路。

注意：并非所有链路层协议都提供可靠交付。有线链路（如以太网）差错率极低，通常不提供可靠交付，认为端到端由 TCP 保证即可；无线链路差错率较高，链路层可靠传输有助于在无线链路本身就纠正差错，减轻传输层负担。

差错检测和纠正（Error Detection and Correction）：
发送方在帧中加入差错检测比特，接收方进行差错检测，如果检测到差错则丢弃帧或（在有纠错能力的情况下）纠正差错。

链路层差错检测比传输层（UDP 检验和）更复杂，通常用硬件实现，能检测更多类型的差错。

6.1.2 链路层在何处实现

链路层主要在网络适配器（Network Adapter） 中实现，也称网络接口卡（NIC，Network Interface Card） 或网卡。

网卡的核心芯片称为链路层控制器（Link-Layer Controller） ，实现了链路层的大部分功能（成帧、链路接入、差错检测等），通常是专用芯片（如 Intel 82579 以太网控制器）。

链路层的功能分布：

  • 大部分在硬件（网卡）中实现： 成帧、物理链路接入、差错检测、半双工/全双工控制
  • 部分在软件（驱动程序）中实现： 组装链路层地址信息、响应控制器中断、传递数据报给网络层

在发送端，网卡从网络层接收数据报，封装成帧，按照链路访问协议将帧传输到链路上。在接收端，网卡接收帧，提取数据报，传递给网络层（通过中断驱动程序通知 CPU）。

从体系结构角度看，链路层是"部分在硬件、部分在软件"实现的，是硬件和软件的结合体。

6.2 差错检测和纠正技术

在帧的传输过程中，比特翻转可能由信号衰减、电磁干扰等导致。差错检测的目标是检测出这些翻转，差错纠正更进一步，能够在不重传的情况下恢复原始数据。

设发送的数据为 D （ d 位），附加差错检测和纠正比特（EDC，Error-Detection and Correction bits），总共发送 D+EDC 。接收方收到 D′ 和 EDC′ ，根据两者判断是否发生差错。

注意： 差错检测并不能保证 100% 可靠，存在未检测到的差错（Undetected Error） 的可能性，EDC 越多，未检测到差错的概率越低。

6.2.1 奇偶校验

单比特奇偶校验（Single-Bit Parity）：

在数据比特中添加一个校验位（Parity Bit） ，使得所有比特（含校验位）中 1 的个数为偶数（偶校验）或奇数（奇校验）。

  • 偶校验： 校验位使 1 的总数为偶数
  • 若传输中发生奇数个比特翻转，接收方可检测到（1 的总数奇偶性改变）
  • 若发生偶数个比特翻转，则无法检测

单比特奇偶校验只能检测单比特差错，检测能力有限，现代网络很少单独使用。

二维奇偶校验（Two-Dimensional Parity）：

将数据比特排成二维矩阵，对每行和每列分别计算校验位。

数据位：          行校验位：
1 0 1 1 0          1
0 1 0 1 1          1
1 0 1 1 0          1
列校验位：1 1 0 1 1

检测和纠正能力：

  • 可以检测到任意单比特差错，并能确定错误位的行和列，从而纠正单比特差错
  • 可以检测到（但不能纠正）** 任意两比特差错**
  • 对于更多比特差错，检测能力下降

二维奇偶校验是前向纠错（FEC，Forward Error Correction） 的一种，接收方无需请求重传即可纠错。FEC 在信道质量较差（如无线链路、光盘存储）的场景中有重要价值，也用于需要实时纠错的场景。

6.2.2 检验和

检验和（Checksum） 在第 3 章（UDP 检验和）和第 4 章（IP 首部检验和）已有介绍，此处简要回顾。

将数据视为 16 位整数序列，求和后取反码（进位回卷），得到检验和。接收方将所有 16 位整数（含检验和）相加，结果应为全 1，否则有差错。

检验和的实现简单，计算开销小，适合软件实现，因此用于传输层（TCP、UDP）和网络层（IPv4 首部）。但检验和的差错检测能力相对较弱（特别是对突发差错），链路层更多使用 CRC。

6.2.3 循环冗余检验（CRC）

CRC（Cyclic Redundancy Check，循环冗余检验） 是现代计算机网络中最广泛使用的差错检测技术，也称多项式编码（Polynomial Code） ，因为它将比特串看作多项式，运算在有限域（GF(2)，即模 2 运算）上进行。

CRC 原理

生成多项式 G （Generator）： 发送方和接收方事先约定一个 r+1 位的比特模式（即 r 阶多项式）， G 的最高位和最低位必须为 1。

发送方的计算：

  1. 在数据 D （ d 位）末尾附加 r 个 0，得到 d+r 位的 D⋅2r （等价于左移 r 位）
  2. 用模 2 除法将 D⋅2r 除以 G ，得到余数 R （ r 位）
  3. 发送 ⟨D,R⟩ （ d+r 位），使得 D⋅2r⊕R 能被 G 整除（ ⊕ 为异或）

模 2 运算：

  • 模 2 加法等同于异或（XOR）： 1+1=0,1+0=1,0+0=0 ，不进位
  • 模 2 减法等同于加法（因为 −1≡1(mod2) ）
  • 模 2 除法类似普通长除法，但用异或代替减法

接收方的验证：

接收到 ⟨D′,R′⟩ ，用模 2 除法将其除以 G ，若余数为 0，则认为无差错；若余数非 0，则检测到差错。

CRC 的差错检测能力

对于 r 位 CRC（ r 阶生成多项式），可以检测：

  • 所有单比特差错
  • 所有双比特差错（若 G 至少有 3 个 1）
  • 所有奇数个比特的差错（若 G 含因子 x+1 ）
  • 所有长度 ≤r 位的突发差错（连续的若干位翻转）
  • 长度 =r+1 位突发差错中的大部分（概率 1−2−(r−1) ）
  • 长度 >r+1 位突发差错中的大部分（概率 1−2−r ）

常用 CRC 标准：

标准生成多项式 r 应用
CRC-8 x8+x2+x+1 8ATM 首部差错控制
CRC-16 x16+x15+x2+1 16HDLC、USB
CRC-32 x32+x26+…+1 32以太网、WiFi、ZIP
CRC-CCITT x16+x12+x5+1 16X.25、HDLC

以太网和 WiFi 使用 CRC-32，可检测所有不超过 32 位的突发差错。CRC 通常在网卡硬件中以极快速度计算，不影响传输速率。

6.3 多路访问链路和协议

6.3.1 两种链路类型

点对点链路（Point-to-Point Link）：
链路两端各只有一个节点，无共享问题。例如：PPP（点对点协议）、HDLC。

广播链路（Broadcast Link）：
多个节点连接到同一共享广播媒体，一个节点发送的帧会被所有其他节点收到。例如：传统以太网、无线局域网（WiFi）。

当多个节点同时在广播链路上发送帧时，所有节点同时收到多个帧，发生碰撞（Collision） ，碰撞的帧在接收端互相干扰，都无法被正确解读。

多路访问问题（Multiple Access Problem）： 如何协调多个节点对共享广播信道的访问，避免或解决碰撞。

MAC 协议（Medium Access Control Protocol）： 规定节点如何在共享广播信道上传输的规则，是链路层的重要组成部分。

理想 MAC 协议的特性（信道速率 R bps）：

  1. 只有一个节点发送时，该节点的吞吐量为 R
  2. 有 M 个节点发送时，每个节点的平均吞吐量为 R/M
  3. 协议是分散的（Decentralized），没有主节点（避免单点故障）
  4. 协议简单，不昂贵

6.3.2 信道划分协议

信道划分协议将信道资源（带宽或时间）划分为小份，分配给各节点专用，从根本上避免碰撞。

TDMA（时分多路复用）

将时间划分为固定长度的帧，每帧再划分为 N 个时隙（ N 为节点数），每个节点分配一个固定时隙。

  • 优点： 无碰撞，每个节点获得固定 R/N 的带宽，公平
  • 缺点： 若某节点没有数据发送，其时隙被浪费，其他节点也不能使用；节点数量变化时需要重新划分

FDMA（频分多路复用）

将信道频谱划分为 N 个频段，每个节点分配一个固定频段。

  • 优点： 无碰撞，各节点同时发送互不干扰
  • 缺点： 与 TDMA 类似，节点不用时频段空闲浪费

CDMA（码分多路复用）

为每个节点分配不同的编码（码片序列），不同节点可以同时在相同频率上发送，接收方通过编码区分不同节点的信号。

  • 优点： 节点可以同时发送，频谱利用率高
  • 缺点： 需要精确的功率控制（远近效应），编解码复杂
  • 应用： 3G 蜂窝网络

6.3.3 随机接入协议

随机接入协议允许节点以信道全速率 R 发送，不预先划分资源。当发生碰撞时，通过重传机制解决。

时隙 ALOHA

假设：

  • 所有帧等长（ L bits）
  • 时间被划分为长度为 L/R 秒的时隙（恰好传输一帧）
  • 节点只在时隙开始时发送帧
  • 所有节点时钟同步

规则：

  • 有帧要发送：在下一时隙开始时发送
  • 未发生碰撞：成功，继续
  • 发生碰撞：在后续每个时隙以概率 p 重传，以概率 1−p 等待

效率分析：

设共 N 个节点，每个节点在时隙中以概率 p 发送（有帧时）。某时隙只有一个节点发送（成功传输）的概率为：

P(成功)=N⋅p⋅(1−p)N−1

对 p 求导，得最优 p∗=1/N ，最大成功概率为 (1−1/N)N−1 。

当 N→∞ 时，最大效率为：

limN→∞(1−1/N)N−1⋅11/N=e−1≈0.368

时隙 ALOHA 的最大效率约为 37%，即信道利用率最高约 37%，其余时隙要么空闲（无节点发送）要么碰撞。

时隙 ALOHA 的优点： 某个节点活跃时可以以全速率 R 传输，分散式，简单。
缺点： 约 37% 的效率，碰撞浪费时隙，需要时钟同步。

ALOHA（纯 ALOHA）

纯 ALOHA（Pure ALOHA / Unslotted ALOHA） 是时隙 ALOHA 的前身（1970 年 Norman Abramson 在夏威夷大学提出，用于卫星通信），没有时隙，不需要时钟同步。

规则： 节点有帧立即发送，发生碰撞则等待一个随机时间后重传。

效率分析：

在纯 ALOHA 中，帧 t0 时刻开始发送，它可能与 [t0−1,t0] （前一帧还在发送）或 [t0,t0+1] （后续帧开始）区间内开始发送的帧发生碰撞，因此脆弱期（Vulnerable Period）是时隙 ALOHA 的两倍。

最大效率为：

e−1/2=1/(2e)≈0.184

纯 ALOHA 的最大效率约为 18%，低于时隙 ALOHA，代价是不需要时钟同步。

CSMA（载波侦听多路访问）

CSMA（Carrier Sense Multiple Access，载波侦听多路访问） 的基本思想是**“先听后说”**：

  • 载波侦听（Carrier Sense）： 发送前先侦听信道，若信道空闲才发送，若信道忙则等待
  • 礼貌类比： 就像在会议中，等别人说完再发言

CSMA 能大幅减少碰撞，但不能完全消除碰撞：原因是传播时延（Propagation Delay） ——即使 A 开始发送，B 在 A 的信号到达之前侦听到信道空闲，也会开始发送，两者发生碰撞。传播时延越大，CSMA 的碰撞概率越高。

CSMA/CD（Carrier Sense Multiple Access with Collision Detection，带碰撞检测的 CSMA）：

以太网使用 CSMA/CD。在 CSMA 基础上增加碰撞检测（Collision Detection） ：

  1. 节点侦听信道
  2. 若信道空闲，开始发送
  3. 发送期间持续侦听（检测碰撞）
  4. 若检测到碰撞（自己发出的信号与别人的信号叠加，电压异常）：
    a. 立即停止发送，避免浪费时间继续传输已损坏的帧
    b. 发送一段阻塞信号（Jam Signal，32位） ，让所有节点都知道发生了碰撞
    c. 进入二进制指数退避（Binary Exponential Backoff）

二进制指数退避：

第 n 次碰撞后（ n=1,2,…,10 ），从 {0,1,2,…,2n−1} 中随机选择一个等待时隙数 K ，等待 K⋅512 位时间后重传。

  • 第 1 次碰撞： K∈{0,1}
  • 第 2 次碰撞： K∈{0,1,2,3}
  • 第 10 次碰撞： K∈{0,1,…,1023}
  • 第 10 次之后：最大仍为 {0,…,1023}
  • 超过 16 次碰撞：放弃，向上层报告错误

随着碰撞次数增加，等待范围指数扩大，从而使发生碰撞的节点逐渐分散传输时间，减少再次碰撞的概率。

CSMA/CD 的效率：

ECSMA/CD=11+5dprop/dtrans

其中 dprop 为两端间最大传播时延， dtrans 为最大帧的传输时延。当 dprop→0 或 dtrans→∞ 时，效率趋向 1，远优于 ALOHA。

无线网络中的 CSMA/CA（碰撞避免）：

无线网络中碰撞检测困难（无法同时发送和接收，且信号强度差异大），使用 CSMA/CA（Collision Avoidance） 代替 CSMA/CD，详见第 7 章。

6.3.4 轮流协议

轮流协议试在信道划分协议（低负载时效率低）和随机接入协议（高负载时碰撞多）之间取得平衡。

轮询协议（Polling Protocol）

指定一个主节点（Master Node） ，主节点依次以循环方式轮询每个节点，告知它可以发送的最大帧数。

  • 若某节点没有数据，主节点轮询下一个
  • 主节点不断轮询，无需节点竞争

优点： 无碰撞，无空闲时隙（除非所有节点都没有数据）
缺点：

  • 轮询开销（Polling Overhead）： 每次轮询都需要时间
  • 延迟（Latency）： 节点必须等待被轮询才能发送
  • 单点故障（Single Point of Failure）： 主节点故障则整个信道不可用

应用： 蓝牙（Bluetooth）采用轮询协议的变体。

令牌传递协议（Token-Passing Protocol）

网络中没有主节点，节点之间按预设顺序传递一个特殊帧（称为令牌，Token），持有令牌的节点才有权发送帧，发送完毕后将令牌传给下一个节点。

优点： 无碰撞，分散式，公平
缺点：

  • 令牌开销： 需要额外的带宽传递令牌
  • 令牌丢失： 节点故障可能导致令牌丢失，需要复杂的恢复机制
  • 延迟： 节点可能需要等待令牌转一圈才能发送

应用： IEEE 802.5 令牌环（Token Ring，已基本淘汰）、FDDI（光纤分布式数据接口）。

6.4 交换局域网

6.4.1 链路层寻址和 ARP

MAC 地址

在局域网中，每个网络接口（而非主机）都有一个链路层地址，称为 MAC 地址（MAC Address） ，也称物理地址（Physical Address）或 LAN 地址。

MAC 地址格式：

  • 48 位（6 字节），通常用 6 组十六进制数表示，以连字符或冒号分隔
  • 例：1A-23-F9-CD-06-9B 或 1A:23:F9:CD:06:9B

MAC 地址的特点：

  • 全球唯一性： IEEE 负责管理 MAC 地址空间，前 3 字节（24 位）为组织唯一标识符（OUI，Organizationally Unique Identifier） ，由 IEEE 分配给网卡制造商；后 3 字节由制造商自行分配，保证不重复
  • 扁平化（Flat）： MAC 地址没有层次结构，不像 IP 地址那样体现位置信息。一块网卡不管插在哪台机器、哪个网络中，其 MAC 地址不变（理论上）
  • 广播地址： FF-FF-FF-FF-FF-FF，发往此地址的帧被局域网上所有节点接收

MAC 地址 vs IP 地址的类比：

MAC 地址好比一个人的身份证号（固定不变，全球唯一），IP 地址好比邮政地址（随位置变化，反映位置层次）。路由器类比邮局：负责将信件（IP 数据报）从一个邮政地址（IP 地址）路由到另一个，而不关心信件上的姓名（MAC 地址）。

ARP（地址解析协议）

ARP（Address Resolution Protocol，地址解析协议） 用于将 IP 地址解析为 MAC 地址，是 IP 地址和 MAC 地址之间的桥梁。

为什么需要 ARP？

发送方知道目的地的 IP 地址，但要在局域网上发送链路层帧，需要知道目的地的 MAC 地址。ARP 完成这个查找工作。

ARP 表（ARP Table / ARP Cache）：

每个主机和路由器在内存中维护一张 ARP 表，记录 IP 地址到 MAC 地址的映射：<IP 地址, MAC 地址, TTL>。TTL 通常为 20 分钟，过期后删除条目（以适应接口 IP 地址的变化）。

ARP 工作过程（同一子网内）：

  1. 主机 A 要向 IP 地址为 222.222.222.220 的主机 B 发送数据报，查 ARP 表发现没有对应条目
  2. A 构造 ARP 查询分组（ARP Query Packet） ，包含自己的 IP 地址、MAC 地址和 B 的 IP 地址
  3. A 将 ARP 查询分组封装成链路层帧，目的 MAC 地址为广播地址 FF-FF-FF-FF-FF-FF，向子网广播
  4. 子网上所有节点都收到该广播帧，但只有 B（IP 地址匹配）回复
  5. B 向 A 发送 ARP 响应分组（ARP Reply Packet） ，包含 B 的 MAC 地址，以单播方式发送给 A
  6. A 收到响应，将 B 的 IP-MAC 映射记录到 ARP 表，此后直接用该 MAC 地址封装帧

ARP 是即插即用的：无需手动配置，ARP 表自动建立和维护。

跨子网发送（经路由器）：

若 A（子网 1）要发送数据报给 C（子网 2），且两个子网通过路由器 R 连接：

  1. A 查找路由表，确定 C 的 IP 前缀，发现需经路由器 R（默认网关）
  2. A 用 ARP 获取路由器 R 在子网 1 一侧接口的 MAC 地址（设为 111-111-111-111）
  3. A 构造帧：源 MAC = A 的 MAC，目的 MAC = R 的 MAC（111-111-111-111） ，IP 数据报目的 IP = C 的 IP
  4. 路由器 R 收到帧，提取 IP 数据报，查找路由表，确定从子网 2 的接口转发
  5. R 用 ARP 获取 C 的 MAC 地址（在子网 2 中广播 ARP 查询）
  6. R 构造新的帧：源 MAC = R 在子网 2 的接口 MAC，目的 MAC = C 的 MAC，IP 数据报不变（源 IP = A，目的 IP = C）
  7. C 收到帧

关键点： 跨越路由器时，MAC 地址（帧首部）每跳都改变，但 IP 地址（IP 数据报首部）从源到目的保持不变。

ARP 欺骗（ARP Spoofing）：

ARP 协议没有认证机制，攻击者可以发送伪造的 ARP 响应，将受害者的 IP 地址映射到攻击者的 MAC 地址，从而截获受害者的流量（中间人攻击，Man-in-the-Middle Attack）。防御措施包括动态 ARP 检测（DAI）和使用 IPv6（用 NDP 替代 ARP，有更好的安全机制）。

6.4.2 以太网

以太网（Ethernet） 是迄今为止最广泛使用的有线局域网技术，由 Xerox 公司的 Bob Metcalfe 等人于 1970 年代发明，后由 Xerox、Intel 和 DEC 联合标准化（DIX 标准），成为 IEEE 802.3 标准。

以太网的成功原因：

  • 早期技术门槛低，成本低
  • 先于令牌环等竞争技术广泛部署，网络效应强
  • 持续演进（10Mbps → 100Mbps → 1Gbps → 10Gbps → 100Gbps），向后兼容性好

以太网帧结构

+----------+----------+------+------+---------+-----+
| 前同步码  | 目的MAC   | 源MAC| 类型 |  数据    | CRC |
|  8字节   |  6字节   | 6字节|2字节 | 46~1500B |4字节|
+----------+----------+------+------+---------+-----+

各字段说明：

字段大小说明
前同步码（Preamble）8 字节前 7 字节为 10101010，最后 1 字节为 10101011（SFD，帧起始界定符）。用于接收方时钟同步（锁相），SFD 的最后两个 1 表示帧即将开始
目的 MAC 地址6 字节目的接口的 MAC 地址；可以是单播、多播或广播地址
源 MAC 地址6 字节发送接口的 MAC 地址
类型（Type）2 字节标识上层协议（如 0x0800 = IPv4，0x86DD = IPv6，0x0806 = ARP），用于多路分解
数据（Payload）46~1500 字节承载的 IP 数据报（或其他网络层分组）。最大 1500 字节（即以太网的 MTU）；最小 46 字节（若数据不足 46 字节，需要填充，Padding）
CRC4 字节CRC-32 差错检测，覆盖目的MAC、源MAC、类型和数据字段（不含前同步码）

最小帧长度： 以太网规定最小帧长为 64 字节（不含前同步码），即数据字段最少 46 字节。这是 CSMA/CD 机制的要求——发送方在完成帧传输前必须能检测到碰撞，帧长不够则可能在传输结束后才检测到碰撞，导致无法正确处理。

以太网 MTU = 1500 字节，这是 IP 分片参考的典型 MTU 值。

以太网服务特性

无连接（Connectionless）： 以太网 NIC 发送帧前不与接收方 NIC 进行握手，直接发送。

不可靠（Unreliable）： 接收方 NIC 不向发送方 NIC 发送确认。若帧因 CRC 差错被接收方丢弃，发送方不知道，也不会重传。丢失的帧能否恢复取决于上层协议（如 TCP 会重传丢失的报文段）。

以太网不提供可靠交付是有意为之的设计——将可靠性留给端到端的传输层（TCP）处理，简化了链路层设计，提高了传输效率。

以太网技术演进

技术速率媒体标准
10BASE5（“粗缆以太网”）10 Mbps同轴电缆（粗）802.3
10BASE2（“细缆以太网”）10 Mbps同轴电缆（细）802.3a
10BASE-T10 Mbps双绞线（UTP）802.3i
100BASE-TX（快速以太网）100 Mbps双绞线（Cat 5）802.3u
1000BASE-T（千兆以太网）1 Gbps双绞线（Cat 5e/6）802.3ab
10GBASE-T10 Gbps双绞线（Cat 6a/7）802.3an
40GBASE-T40 Gbps双绞线（Cat 8）802.3bq
100GBASE-SR4100 Gbps多模光纤802.3bm

命名规范：[速率]BASE-[媒体]，速率单位 Mbps，BASE 表示基带传输。

6.4.3 链路层交换机

链路层交换机（Link-Layer Switch） 是现代局域网的核心设备，工作在链路层（第 2 层），根据 MAC 地址转发帧。

交换机对网络层透明：主机和路由器不知道交换机的存在，也不需要配置交换机（即插即用）。

交换机的转发和过滤

交换表（Switch Table）： 每台交换机维护一张交换表，每个表项包含：

  • MAC 地址
  • 该 MAC 地址可到达的接口（端口号）
  • 该条目的 TTL

转发和过滤（Forwarding and Filtering）：

当一个帧到达交换机接口 x ，交换机查交换表：

  1. 查到目的 MAC，且对应接口不是 x （接口为 y ）： 将帧转发到接口 y （过滤掉接口 x ，不回送）
  2. 查到目的 MAC，且对应接口是 x ： 丢弃该帧（目的地就在同一接口的段，无需转发）
  3. 未查到目的 MAC： 向除接口 x 之外的所有接口泛洪（Flood） ——将帧复制并转发到所有其他接口

过滤（Filtering）： 确定是否转发帧，还是丢弃帧。
转发（Forwarding）： 确定帧应被导向哪个接口。

自学习（Self-Learning）

交换机的交换表是自动建立的，无需手动配置：

  1. 交换机初始时交换表为空
  2. 每当收到一个帧，交换机将帧的源 MAC 地址和到达接口记录到交换表，同时记录当前时间（作为 TTL 起点）
  3. 若某条目在一定时间内没有收到来自该 MAC 地址的帧，则删除该条目（老化机制，Aging）

通过自学习，交换机逐渐建立完整的 MAC-接口映射，之后就能正确转发而不需要泛洪。

自学习举例：

初始：交换表为空。

  1. A 向 B 发帧，到达交换机接口 1：

    • 记录 (A, 接口1) 到交换表
    • 查表找不到 B，向接口 2、3、4 泛洪

  2. B 收到帧，向 A 发回复帧，到达交换机接口 2：

    • 记录 (B, 接口2) 到交换表
    • 查表找到 A 对应接口 1，单播转发到接口 1

  3. 此后 A 和 B 的通信都通过单播转发，不再泛洪

交换机 vs 路由器

比较维度链路层交换机路由器
工作层次第 2 层（链路层）第 3 层（网络层）
寻址MAC 地址IP 地址
转发依据交换表（自学习）转发表（路由选择算法）
即插即用是（自学习）否（需要配置 IP 地址和路由）
广播域不隔离广播（同一交换机下共享广播域）隔离广播域（每个路由器接口是独立广播域）
生成树需要 STP 防止环路IP 层有 TTL 防止环路
安全性较弱（依赖 MAC，可欺骗）较强（IP 层过滤）
速度快（硬件转发，不需要处理 IP 首部）相对较慢（需要处理 IP 首部）

什么时候用交换机，什么时候用路由器？

  • 小型局域网（几十台主机）：交换机足够，即插即用，简单高效
  • 大型网络：需要路由器隔离广播域，防止广播风暴；需要路由器实现 IP 寻址和跨网络通信

生成树协议（STP）

多台交换机连接时，为了提高可靠性，管理员可能创建冗余链路（Redundant Link） ，但这会导致广播帧无限循环（广播风暴，Broadcast Storm） ——帧在环路中不断复制，最终耗尽网络资源。

STP（Spanning Tree Protocol，生成树协议，IEEE 802.1D） 的解决方法：在逻辑上"关闭"部分冗余链路，使拓扑形成无环的生成树（Spanning Tree） ，同时保留物理冗余链路以备故障时切换。

STP 选举过程：

  1. 选举根桥（Root Bridge）： Bridge ID（优先级+MAC地址）最小的交换机成为根桥
  2. 每台非根桥交换机选出到根桥代价最小的端口（根端口，Root Port）
  3. 每条网段选出到根桥代价最小的交换机端口（指定端口，Designated Port）
  4. 其他端口设为阻塞状态（Blocking），不转发数据帧

RSTP（Rapid STP，快速生成树，IEEE 802.1w）： 改进了 STP 的收敛速度，从分钟级缩短到秒级甚至毫秒级。

6.4.4 VLAN（虚拟局域网）

VLAN（Virtual Local Area Network，虚拟局域网） 是在单一物理网络基础设施上创建多个逻辑上隔离的局域网的技术。

引入 VLAN 的动机：

在没有 VLAN 的情况下，一台交换机上的所有端口都在同一广播域中，存在以下问题：

  • 安全性： 不同部门（如工程部和市场部）的流量可以相互访问，存在安全隐患
  • 广播隔离： 广播风暴影响整个物理网络
  • 灵活性： 用户移动到新位置时，可能需要改变物理连线

VLAN 的基本概念：

  • 基于端口的 VLAN（Port-Based VLAN）： 交换机端口被分成若干组，每组构成一个 VLAN。同一 VLAN 内的端口可以相互通信，不同 VLAN 的端口默认隔离
  • 一台交换机可以配置多个 VLAN（如 VLAN 1、VLAN 2、VLAN 3）
  • VLAN 间路由需要通过路由器（或三层交换机）——将路由器的一个接口划入一个 VLAN，另一个接口划入另一个 VLAN

VLAN 干线（Trunk Link）：

当多台交换机上存在同一 VLAN 时，需要一条干线端口（Trunk Port） 连接多台交换机，干线承载所有 VLAN 的流量。

802.1Q VLAN 标签：

为了在干线上区分不同 VLAN 的帧，IEEE 802.1Q 标准在以太网帧首部插入一个 4 字节的 VLAN 标签（VLAN Tag） ：

| 目的MAC | 源MAC | 802.1Q标签(4B) | 类型(2B) | 数据 | CRC |
                   ↑
          TPID(2B) + TCI(2B)
          0x8100   优先级(3b)+DEI(1b)+VLAN ID(12b)
  • TPID（Tag Protocol Identifier）： 固定为 0x8100，标识这是一个 802.1Q 帧
  • VLAN ID（VID）： 12 位，取值 1~4094，标识帧属于哪个 VLAN
  • 优先级（PCP，Priority Code Point）： 3 位，用于 QoS

VLAN 的工作方式：

  • 接入端口（Access Port）：连接终端设备，不携带 VLAN 标签；交换机在帧进入时打上标签，发出时去掉标签
  • 干线端口（Trunk Port）：连接其他交换机或路由器，帧保留 VLAN 标签传输

三层交换机（Layer 3 Switch）： 集成了路由功能的交换机，可以在硬件中完成 VLAN 间路由，速度比外接路由器快，是现代企业网的主流选择。

6.5 数据中心网络

6.5.1 数据中心网络概述

大型数据中心（如亚马逊 AWS、谷歌、微软 Azure、Facebook 的数据中心）拥有数万至数十万台服务器，支撑着搜索、电子商务、社交媒体、视频流等大规模互联网应用。

数据中心网络不同于传统企业网：

  • 规模巨大： 数万到数十万台服务器
  • 带宽需求极高： 服务器之间的东西向流量（Server-to-Server）远大于进出数据中心的南北向流量（Client-to-Server）
  • 高可靠性要求： 任何链路或节点故障都应能快速恢复
  • 低时延要求： 分布式计算任务对时延极其敏感

6.5.2 数据中心网络拓扑

传统三层树状拓扑：

            核心路由器/交换机
           /               \
       汇聚层交换机      汇聚层交换机
      /    \              /    \
  接入层  接入层        接入层  接入层
  交换机  交换机        交换机  交换机
  /  \    /  \          /  \   /  \
服务器 ...          服务器 ...
  • 接入层（Access Layer / ToR，Top of Rack）： 每个机架（Rack，通常 20~40 台服务器）顶部有一台架顶交换机（ToR Switch），连接机架内所有服务器。服务器与 ToR 交换机通常使用 1 Gbps 或 10 Gbps 以太网连接
  • 汇聚层（Aggregation Layer）： 连接若干个机架的 ToR 交换机，汇聚层交换机通常有较高端口密度和更高的链路速率（10 Gbps 或 40 Gbps）
  • 核心层（Core Layer）： 连接所有汇聚层交换机，提供数据中心与外部因特网的连接，使用 100 Gbps 或更高速率

传统三层拓扑的问题：

  • 带宽瓶颈： 接入层到汇聚层、汇聚层到核心层之间的"订购超额（Oversubscription）"问题——下层带宽之和远大于上层链路带宽，服务器间通信受限
  • 核心层瓶颈： 所有跨汇聚层的流量都经过核心层，核心层成为瓶颈
  • 树状结构扩展性差： 增加服务器数量需要升级核心和汇聚层设备

Fat-Tree 拓扑（胖树）

Fat-Tree（胖树） 是一种专为数据中心设计的网络拓扑，使用大量商用交换机（而非少数高端核心交换机）构建高带宽、无瓶颈的网络：

核心交换机层：(k/2)² 台
    ↕（全互联）
汇聚交换机层：k个Pod，每Pod k/2台
    ↕
接入交换机层：k个Pod，每Pod k/2台
    ↕
服务器：每接入交换机连k/2台

k 端口 Fat-Tree 可以连接 k3/4 台服务器，且任意两台服务器之间的通信带宽之和等于服务器接入带宽（无超额订购）——称为无阻塞（Non-Blocking） 或 全二分带宽（Full Bisection Bandwidth） 。

Fat-Tree 的优势：

  • 使用廉价商用交换机（不需要核心高端交换机）
  • 无带宽瓶颈，横向流量不受限制
  • 多路径可利用，配合 ECMP（等价多路径）分散流量

6.5.3 数据中心网络协议

数据中心的特殊需求催生了一些新的或改进的协议：

ECMP（Equal-Cost Multi-Path，等价多路径路由）：
多条等价路径同时使用，分散流量负载。在 Fat-Tree 中，两台服务器之间通常有多条等价路径，ECMP 可以利用所有路径提高总带宽。

RDMA（Remote Direct Memory Access，远程直接内存访问）：
高性能计算和存储场景中，允许服务器直接读写另一台服务器的内存，不经过 CPU，极大降低时延和 CPU 开销。

  • RoCE（RDMA over Converged Ethernet）： 在以太网上实现 RDMA
  • InfiniBand： 专用高速网络，原生支持 RDMA

数据中心 TCP 改进：

  • DCTCP（Data Center TCP）： 利用 ECN 在数据中心环境下保持极低的队列占用，减少时延抖动
  • 针对短流（Mice Flows）的优化： 数据中心中大量短流（如 RPC 请求）对时延极其敏感，传统 TCP 的慢启动和拥塞控制不够高效

SDN 在数据中心的应用：
谷歌的 B4、Andromeda 等系统，Facebook 的 Fabric 网络，都大规模使用 SDN 管理数据中心网络，实现流量工程、灵活的拓扑管理和快速故障恢复。

6.6 一天的网络历程（综合案例）

本节将前面几章的知识综合，追踪一个 HTTP 请求从主机到 Web 服务器的完整过程，涵盖 DHCP、ARP、DNS、TCP、HTTP 等协议的协同工作。

场景设定：

Bob 带着笔记本电脑来到学校，连接到学校的以太网接口，浏览器请求 www.google.com。

步骤 1：获取 IP 地址（DHCP）

  1. 操作系统创建 DHCP 请求报文（封装在 UDP 中，源端口 68，目的端口 67），再封装在 IP 数据报中（源 IP 0.0.0.0，目的 IP 255.255.255.255），再封装成以太网帧（目的 MAC 为广播地址）
  2. 以太网帧广播到接入交换机
  3. 交换机泛洪到所有端口（此时交换表还没有 Bob 的记录）
  4. 路由器（网关）收到 DHCP 请求，DHCP 服务器（运行在路由器上或单独服务器）分配 IP 地址（如 68.85.2.101），发送 DHCP 响应
  5. Bob 的笔记本收到 DHCP 响应，得到：IP 地址、子网掩码、默认网关 IP、DNS 服务器 IP

步骤 2：解析域名（DNS）

  1. 浏览器要访问 www.google.com，需要将其解析为 IP 地址
  2. 操作系统构造 DNS 查询报文（UDP，目的端口 53，目的 IP 为 DNS 服务器 IP）
  3. 要发送 DNS 查询，需要知道 DNS 服务器的 MAC 地址。因为 DNS 服务器在默认网关之外，Bob 需要将帧发往默认网关，所以需要网关路由器的 MAC 地址
  4. Bob 发送 ARP 查询，广播查询默认网关 IP 对应的 MAC 地址
  5. 路由器回复 ARP 响应，告知自己的 MAC 地址
  6. Bob 将 DNS 查询封装成以太网帧（目的 MAC = 路由器 MAC），发送到路由器
  7. 路由器转发 DNS 查询到 DNS 服务器（可能经过多个路由器）
  8. DNS 服务器回复 www.google.com 的 IP 地址（如 64.233.169.105）
  9. Bob 收到 DNS 响应，得到 Google 服务器的 IP 地址

步骤 3：建立 TCP 连接

  1. 浏览器创建 TCP 套接字，发起三次握手：发送 SYN 报文段到 Google 服务器 IP 64.233.169.105，端口 80
  2. 报文段封装在 IP 数据报中，再封装成以太网帧（目的 MAC = 路由器 MAC，IP 数据报目的 IP = Google IP）
  3. 路由器转发，经过因特网中的若干路由器，到达 Google 服务器
  4. Google 服务器回复 SYNACK，Bob 发送 ACK，TCP 连接建立

步骤 4：发送 HTTP 请求

  1. TCP 连接建立后，浏览器发送 HTTP GET 请求（GET / HTTP/1.1\r\nHost: www.google.com\r\n...）
  2. Google 服务器处理请求，返回 HTTP 响应（含 HTML 页面）
  3. 浏览器收到响应，渲染显示页面

这个过程展示了所有层次协议的协同工作：物理层（以太网信号）→ 链路层（以太网帧、MAC 地址、ARP）→ 网络层（IP 数据报、DNS、DHCP、路由选择）→ 传输层（TCP 连接建立）→ 应用层（DNS、HTTP）。

本章小结

本章介绍了链路层和局域网的核心内容，主要包括：

  1. 链路层概述： 链路层提供的服务（成帧、链路接入、可靠交付、差错检测纠正）；链路层在网卡（NIC）中实现，硬件和软件结合

  2. 差错检测和纠正： 奇偶校验（单比特：检测奇数个差错；二维：检测并纠正单比特差错）；检验和（软件实现，用于传输层和网络层）；CRC（多项式编码，硬件实现，差错检测能力强，以太网使用 CRC-32）

  3. 多路访问协议： 信道划分协议（TDMA/FDMA/CDMA，消除碰撞但资源固定，效率低）；随机接入协议（时隙 ALOHA 效率~37%，纯 ALOHA 效率~18%，CSMA/CD 效率更高，二进制指数退避）；轮流协议（轮询协议、令牌传递协议，无碰撞，有延迟）

  4. 以太网： MAC 地址（48 位，全球唯一，扁平化，广播地址 FF-FF-FF-FF-FF-FF）；ARP（广播查询，单播响应，ARP 表缓存，跨路由器时 MAC 地址每跳改变）；以太网帧结构（前同步码、目的/源 MAC、类型、数据、CRC）；以太网特性（无连接、不可靠、CSMA/CD）；以太网技术演进（10M→100M→1G→10G→100G）

  5. 链路层交换机： 基于 MAC 地址转发；自学习（记录源 MAC-接口映射，老化机制）；转发和过滤逻辑（查到→转发/丢弃，未查到→泛洪）；STP（防广播风暴，生成逻辑无环树）；交换机 vs 路由器（层次、寻址、即插即用、广播域）

  6. VLAN： 在单一物理网络上创建多个逻辑隔离的局域网；基于端口的 VLAN；802.1Q VLAN 标签（4字节，含 12 位 VLAN ID）；干线端口承载多 VLAN 流量；VLAN 间路由需要三层设备

  7. 数据中心网络： 传统三层树状拓扑的问题（超额订购、核心瓶颈）；Fat-Tree 拓扑（全二分带宽、无阻塞、廉价商用交换机）；数据中心专用协议（ECMP、RDMA/RoCE、DCTCP）；SDN 在数据中心的应用

  8. 综合案例： DHCP→ARP→DNS→TCP→HTTP 完整流程，展示各层协议协同工作

第七章 无线网络和移动网络

7.1 概述

无线网络和移动网络是当今因特网中增长最快的部分。笔记本电脑、智能手机、平板、可穿戴设备、IoT 设备的爆发式增长，使得无线网络成为绝大多数用户接入因特网的主要方式。

无线网络的组成要素：

无线主机（Wireless Host）：
运行应用程序的端系统，可能是移动的（手机、笔记本），也可能是静止的（桌面机通过 WiFi 接入）。移动性不是无线网络的必要条件——无线仅表示接入方式，主机可以静止使用无线链路。

基站（Base Station）：
负责在有线网络和自己覆盖范围内的无线主机之间中继数据。典型的基站包括：

  • WiFi 接入点（AP，Access Point） ：覆盖范围数十米
  • 蜂窝基站（Cell Tower / eNodeB） ：覆盖范围数公里至数十公里

当无线主机在基站覆盖范围内通信时，称该主机与基站关联（Associated） 。

无线链路（Wireless Link）：
主机通过无线链路连接到基站（或直接连接到其他主机）。无线链路的关键参数：

  • 覆盖区域（Coverage Area）
  • 链路速率（Link Rate）

不同无线技术在覆盖范围和链路速率上有很大差异，形成不同应用场景。

基础设施模式（Infrastructure Mode）：
无线主机通过基站连接到有线网络，是最常见的使用方式。

自组织网络（Ad Hoc Network）：
无线主机之间直接通信，没有基站和有线基础设施。主机自组织成网络，自行完成路由选择。适用于临时场景（如战场通信、灾难救援）。

7.1.1 无线网络的分类

按覆盖范围和技术分类：

技术覆盖范围链路速率标准
蓝牙（Bluetooth）~10 m1~3 MbpsIEEE 802.15
ZigBee~10~100 m250 KbpsIEEE 802.15.4
WiFi（WLAN）~100 m最高数 GbpsIEEE 802.11
WiMAX~10 km最高 40 MbpsIEEE 802.16
4G LTE~10 km最高 100 Mbps3GPP
5G NR~1 km（毫米波）最高数 Gbps3GPP
卫星（LEO）全球数百 MbpsStarlink 等

按移动性分类：

  • 无移动性： 使用无线接入，但主机静止（如家庭 WiFi）
  • 低移动性： 在单一基站覆盖范围内移动（如在办公室内走动）
  • 高移动性： 跨基站移动，需要切换（Handover）

7.1.2 无线链路的特点

无线链路与有线链路有根本性的不同，这些差异是无线网络协议设计复杂性的根本原因：

路径损耗（Path Loss）：
电磁波信号强度随传播距离增加而衰减，且受障碍物（建筑物、树木）影响而进一步减弱。在自由空间中，信号强度与距离的平方成反比（Friis 传播公式）；在有障碍物的环境中衰减更快。

多路径传播（Multipath Propagation）：
信号从发送方到接收方可能经过多条路径（直射、反射、绕射），不同路径的信号相位不同，到达接收方后可能相互增强（同相叠加）或相互抵消（反相叠加），导致多路径衰落（Multipath Fading） 。接收方感知到的信号强度随位置的细微变化而剧烈波动。

干扰（Interference）：
使用相同频段的其他无线设备会产生干扰（如 2.4 GHz 频段的 WiFi 和蓝牙相互干扰，微波炉也工作在 2.4 GHz 附近）。

信噪比（SNR，Signal-to-Noise Ratio）：
接收信号强度与噪声强度之比，通常用分贝（dB）表示： SNR(dB)=10log10⁡(SNR) 。SNR 越高，差错越少；SNR 越低，差错越多。

SNR 与 BER（误码率，Bit Error Rate）的关系：给定调制方式，SNR 越高，BER 越低；给定 SNR，调制阶数越高（每符号携带更多比特），BER 越高。

自适应调制（Adaptive Modulation）：
无线系统可以根据当前信道条件（SNR）动态选择调制方式：

  • 信道好（SNR 高）→ 高阶调制（如 256-QAM，每符号 8 bits）→ 高速率，低可靠性
  • 信道差（SNR 低）→ 低阶调制（如 BPSK，每符号 1 bit）→ 低速率，高可靠性

这就是为什么在 WiFi 路由器旁边网速快，远离后网速下降的原因。

隐藏终端问题（Hidden Terminal Problem）：

A ←────────→ B ←────────→ C
        （A和C不互相感知）

A 和 C 都与 B 通信，但 A 感知不到 C 的存在（物理障碍或距离太远），C 也感知不到 A。A 和 C 可能同时向 B 发送，在 B 处发生碰撞，但两者的 CSMA 无法检测到这个碰撞（因为各自侦听自己附近的信道是空闲的）。

暴露终端问题（Exposed Terminal Problem）：

A ←────────→ B      C ←────────→ D
           （B和C相互感知，A和D不相互感知）

B 向 A 发送，C 感知到信道忙（因为 C 能感知 B 的信号），于是 C 不向 D 发送，但实际上 C 向 D 发送不会干扰 B 向 A 的传输（D 感知不到 B 的信号）。C 本可以发送却没有发送，造成浪费。

这两个问题是无线网络中 CSMA/CA 协议设计需要解决的核心挑战。

7.2 WiFi：IEEE 802.11 无线局域网

IEEE 802.11（WiFi） 是当今最广泛使用的无线局域网标准，由 IEEE 802.11 工作组制定，多个版本对应不同的技术规格。

7.2.1 802.11 标准演进

标准发布年份频段最高速率俗称
802.11b19992.4 GHz11 MbpsWiFi 1
802.11a19995 GHz54 MbpsWiFi 2
802.11g20032.4 GHz54 MbpsWiFi 3
802.11n20092.4/5 GHz600 MbpsWiFi 4（HT）
802.11ac20135 GHz~3.5 GbpsWiFi 5（VHT）
802.11ax20192.4/5/6 GHz~9.6 GbpsWiFi 6（HE）
802.11be20242.4/5/6 GHz~46 GbpsWiFi 7（EHT）

2.4 GHz vs 5 GHz 频段：

比较2.4 GHz5 GHz
覆盖范围更大（穿透力强）较小
干扰更多（蓝牙、微波炉等）较少
信道数量少（3个不重叠信道）多（23个不重叠信道）
速率较低较高

7.2.2 802.11 体系结构

基本服务集（BSS，Basic Service Set）：

802.11 LAN 的基本构建块是 BSS，包含一个接入点（AP，Access Point） 和若干关联的无线站（Wireless Station） 。

AP 是 BSS 的基站，通过有线链路（通常是以太网）连接到交换机，再连接到因特网。

每个 AP 有一个 SSID（Service Set Identifier，服务集标识符） （即我们通常所说的 WiFi 名称）和一个工作信道（Channel） 。

信道与干扰：

802.11b/g 在 2.4 GHz 频段定义了 11 个信道（在中国），相邻信道频率重叠，信道 1、6、11 互不重叠，可以同时使用而不互相干扰（三个不重叠信道）。若两个相邻 AP 使用相同信道，且覆盖范围重叠，则两个 BSS 中的站会相互干扰（碰撞）。

无线接入过程：

主机连接（关联）到 AP 的过程：

1. 扫描信道：

  • 被动扫描（Passive Scanning）： AP 定期广播信标帧（Beacon Frame） ，包含 SSID 和 AP 的 MAC 地址；无线主机扫描所有信道，收集信标帧，得知附近有哪些 AP
  • 主动扫描（Active Scanning）： 主机主动广播探测请求帧（Probe Request Frame） ，AP 收到后回复探测响应帧（Probe Response Frame）

2. 选择 AP：

主机从收到的信标帧（或探测响应）中选择要关联的 AP，通常选择信号最强或用户配置的 AP。

3. 认证（Authentication）：

  • 开放认证（Open Authentication）： 任何主机都可以关联（家庭 WiFi 通常靠 WPA2 密码实现认证）
  • 企业认证（802.1X）： 使用 RADIUS 服务器验证用户身份，适合企业网络

4. 关联（Association）：

主机发送关联请求帧（Association Request Frame） ，AP 回复关联响应帧（Association Response Frame） ，确认关联建立。

5. 获取 IP 地址：

关联完成后，主机通过 DHCP 获取 IP 地址（与有线网络相同）。

7.2.3 802.11 MAC 协议：CSMA/CA

无线网络中碰撞检测（CD）不可行，原因：

  1. 无法同时发送和接收： 无线网卡在发送时，自己的信号远强于来自远处的其他信号，无法"听到"碰撞
  2. 隐藏终端问题： 某些发送方无法感知其他发送方的存在

因此 802.11 使用碰撞避免（CA，Collision Avoidance） 代替碰撞检测，尽量避免碰撞发生，而不是检测到碰撞后再处理。

帧间间隔（IFS，Inter-Frame Space）：

802.11 定义了多种 IFS，通过不同长度的等待时间实现优先级控制：

  • SIFS（Short IFS，短帧间间隔）： 最短，用于需要立即响应的帧（ACK、CTS），优先级最高
  • DIFS（Distributed Coordination Function IFS）： 用于普通数据帧，比 SIFS 长，优先级低于 ACK/CTS

CSMA/CA 基本流程

发送方：

  1. 侦听信道： 若信道空闲持续 DIFS 时间，则进入步骤 2；若信道忙，等待信道空闲，再等待 DIFS
  2. 随机退避（Random Backoff）： 随机选择一个退避计数器值（从竞争窗口 CW 中均匀随机选取），计数器只在信道空闲时递减，信道忙时暂停倒计时
  3. 计数器归零时发送帧
  4. 等待 ACK： 发送完整帧后，等待接收方的 ACK 确认：
    • 收到 ACK：成功，继续
    • 未收到 ACK（超时）：认为发生碰撞，倒退至步骤 2，竞争窗口 CW 加倍（指数退避），重新选择退避计数器值，重传

接收方：

收到帧后，等待 SIFS 时间，发送 ACK 帧。因为 SIFS < DIFS，其他站点在 ACK 发出期间感知信道忙，不会干扰 ACK 的传输。

为什么 CSMA/CA 使用随机退避而不是立即发送？

若多个站点同时等待信道空闲后发送，会同时发送造成碰撞。随机退避使各站点以不同的时延重传，降低碰撞概率。竞争窗口加倍（指数退避）使得多次碰撞后各站点分散的程度越来越大，最终能够成功传输。

RTS/CTS 机制（解决隐藏终端问题）

RTS/CTS（Request to Send / Clear to Send）是可选机制，专门针对隐藏终端问题：

RTS/CTS 流程：

  1. A 想向 B 发送数据，先发送 RTS 帧（Request to Send） 给 B，RTS 帧包含本次传输所需的总时间（NAV，网络分配向量）
  2. B 收到 RTS 后，广播 CTS 帧（Clear to Send） ，包含相同的 NAV 值
  3. 所有听到 CTS 的站点（包括 A 的隐藏终端）设置 NAV 定时器，在 NAV 期间内不发送（虚拟载波侦听）
  4. A 收到 CTS，开始发送数据帧
  5. B 收到数据帧，发送 ACK

RTS/CTS 的好处：

  • 让隐藏终端知道信道被预约，避免碰撞
  • 即使 RTS 或 CTS 碰撞（造成损失的只是短小的控制帧，而非长数据帧），也比数据帧碰撞的代价小

RTS/CTS 的开销：

  • 额外的 RTS 和 CTS 帧引入时延和带宽开销
  • 对于短帧，RTS/CTS 的开销可能超过其带来的好处

实践： RTS/CTS 通常只对超过一定长度阈值的帧启用（802.11 中可配置 RTS 阈值，默认 2346 字节，即大多数情况下不启用 RTS/CTS）。

7.2.4 802.11 帧结构

802.11 帧比以太网帧复杂，有 4 个地址字段（而以太网只有 2 个）：

+------+------+----+----+------+------+------+------+-----+------+-----+
| 帧控制| 时延 | 地址1| 地址2| 地址3| 序号 | 地址4| 有效 | CRC |
| 2字节|2字节 | 6字节| 6字节| 6字节|2字节 | 6字节| 载荷  |4字节|
+------+------+----+----+------+------+------+------+-----+------+-----+

帧控制字段（2字节） 包含多个子字段：

  • 协议版本（2 bits）
  • 类型（2 bits）： 管理帧（00）、控制帧（01）、数据帧（10）
  • 子类型（4 bits）： 区分信标帧、探测帧、RTS、CTS、ACK、数据等
  • To DS / From DS（各 1 bit）： 指示帧的来源和去向（见地址字段说明）
  • MF（More Fragments）： 是否还有后续片段
  • Retry（1 bit）： 是否为重传帧
  • Power Management（1 bit）： 站点的电源管理状态
  • More Data（1 bit）： AP 是否还有待发送的帧（用于节能模式）
  • Protected Frame（1 bit）： 是否加密（如 WPA2）
  • Order（1 bit）

时延字段（Duration）： NAV 值，告知其他站点信道被预约的持续时间（用于虚拟载波侦听）

4 个地址字段：

802.11 有 4 个地址字段，在不同情况下含义不同。最常见的基础设施模式（To DS = 1，From DS = 0）：

字段含义（To DS = 1，From DS = 0，即站→AP→有线网）
地址 1AP 的 MAC 地址（接收这个帧的 AP）
地址 2发送这个帧的站点的 MAC 地址（源站）
地址 3目的 IP 对应的 MAC 地址（路由器接口 MAC）
地址 4仅在自组织网络（From DS=1，To DS=1）中使用

为什么需要 3 个 MAC 地址？

考虑站点 H1 通过 AP 发送数据报给路由器 R1：

  • AP 需要知道这个帧是发给自己的：地址 1 = AP 的 MAC
  • AP 需要知道帧从哪里来（以便回复 ACK）：地址 2 = H1 的 MAC
  • AP 将帧转换为以太网帧发给路由器，需要路由器的 MAC：地址 3 = R1 的 MAC

若只有 2 个地址字段（如以太网），AP 在转发时就不知道原始发送方的 MAC 地址。

序号字段（Sequence Number）： 用于对帧编号，实现可靠传输（ARQ）——接收方通过序号识别重复帧（重传帧），发送方通过 ACK 和序号确认。

7.2.5 802.11 的节能机制

无线设备（尤其是移动设备）电池容量有限，无线网卡持续收发消耗大量电量。802.11 提供节能模式（Power Save Mode） ：

节能模式工作原理：

  1. 站点通知 AP 自己进入睡眠状态（帧控制字段的 Power Management 位置 1）
  2. AP 缓存发给该睡眠站点的帧
  3. AP 在每个信标帧（通常每 100ms 发一次） 中包含 TIM（Traffic Indication Map） ，列出有待接收帧的站点
  4. 睡眠中的站点在每个信标帧前短暂醒来，接收信标帧，检查 TIM
  5. 若 TIM 中有自己，发送 PS-Poll 帧（Power Save Poll）请求 AP 传送缓存的帧，接收完后返回睡眠
  6. 若 TIM 中没有自己，继续睡眠到下一个信标帧

WiFi 6（802.11ax）的改进——TWT（Target Wake Time）：
AP 与各站点协商特定的唤醒时间，站点只在约定时间醒来，其余时间深度睡眠，大幅减少电量消耗，特别适合 IoT 设备。

7.2.6 WiFi 安全：WPA3

WEP（Wired Equivalent Privacy，有线等效保密）：
802.11 最早的安全机制，使用 RC4 流密码和 40 位密钥，已被证明存在严重安全漏洞（密钥重用、IV 空间太小），可在数分钟内被破解。2003 年起已被废弃。

WPA（WiFi Protected Access）：
WEP 的过渡替代，修复了部分 WEP 的问题，使用 TKIP（Temporal Key Integrity Protocol）和 MIC（Message Integrity Code），但仍基于 RC4，安全性有限。

WPA2（IEEE 802.11i）：

  • 使用 AES（Advanced Encryption Standard） 加密，安全性显著提升
  • CCMP（Counter Mode with CBC-MAC Protocol） ：认证加密模式，同时提供机密性和完整性
  • 两种认证模式：
    • WPA2-Personal（PSK，Pre-Shared Key）： 使用预共享密钥（即 WiFi 密码），适合家庭和小型办公室
    • WPA2-Enterprise（802.1X）： 使用 RADIUS 服务器进行用户认证，每个用户有独立的凭证，适合企业
  • 仍存在 KRACK（Key Reinstallation Attack）等漏洞

WPA3（2018年发布）：

  • SAE（Simultaneous Authentication of Equals，对等同步认证）： 替代 PSK，使用 Dragonfly 握手协议，防止字典攻击（即使密码被截获的握手信息也无法离线暴力破解）
  • 前向保密（Forward Secrecy）： 即使长期密钥被泄露，过去的通信内容也无法被解密
  • 强制使用 Protected Management Frames（PMF） ：防止伪造的管理帧（如伪造的取消关联帧）攻击
  • WPA3-Enterprise： 要求使用 192 位加密套件，适合高安全要求场景
  • Enhanced Open（OWE，Opportunistic Wireless Encryption）： 对开放（无密码）WiFi 的流量进行加密，防止窃听，但不需要密码

7.3 蜂窝网络：4G 和 5G

7.3.1 蜂窝网络概述

蜂窝网络（Cellular Network） 是覆盖广域的无线网络，允许用户在移动中保持网络连接，是智能手机接入因特网的主要方式。

"蜂窝"名称来自于网络的覆盖区域划分：地理区域被划分为若干小区（Cell） ，每个小区中心有一个基站（Base Station） ，负责该小区内所有移动设备的通信。相邻小区使用不同的频率或编码，避免干扰。

蜂窝网络的演进：

代时期主要特点典型技术
1G1980s模拟语音AMPS
2G1990s数字语音，低速数据GSM、CDMA
3G2000s数字语音 + 宽带数据UMTS（WCDMA）、CDMA2000
4G LTE2010s全 IP，高速数据LTE、LTE-Advanced
5G2020s超高速，超低时延，大连接5G NR

7.3.2 4G LTE 网络架构

4G LTE（Long-Term Evolution）是当前最广泛部署的蜂窝网络技术，实现了全 IP 架构（语音和数据都通过 IP 传输）。

LTE 网络分为两个主要部分：

移动设备(UE) ──无线──→ eNodeB(基站) ──→ EPC(演进分组核心) ──→ 因特网
                           ↕
                         X2接口
                      （基站间直接通信，用于切换）

无线接入网（RAN，Radio Access Network）

eNodeB（Evolved Node B，演进基站）：
4G 的基站，负责：

  • 无线资源管理（分配上下行资源）
  • 无线链路层处理（调制解调、编解码、HARQ）
  • 与移动设备（UE，User Equipment）的无线通信
  • 与 EPC 的数据转发
  • 通过 X2 接口与相邻 eNodeB 通信（用于切换协调）

LTE 无线链路技术：

  • 下行（基站→UE）： OFDMA（正交频分多址），将频段划分为多个窄子载波，每个子载波独立调制，抗多路径干扰能力强
  • 上行（UE→基站）： SC-FDMA（单载波频分多址），类似 OFDMA 但峰均比更低，更节省 UE 功耗
  • MIMO（Multiple-Input Multiple-Output）： 多天线技术，在发送端和接收端各使用多根天线，通过空间复用提高吞吐量，或通过波束成形提高信号质量

演进分组核心网（EPC，Evolved Packet Core）

EPC 是 4G 网络的核心网络，负责用户管理、认证、数据转发等功能：

MME（Mobility Management Entity，移动管理实体）：

  • 用户认证（与 HSS 交互）
  • 移动性管理（跟踪用户位置，处理切换）
  • 会话管理（建立和释放数据会话）
  • 寻呼（当有呼叫或数据时定位空闲 UE）

HSS（Home Subscriber Server，归属用户服务器）：

  • 存储用户的签约信息（允许使用哪些服务、最大速率等）
  • 用于认证和授权
  • 功能类似 DNS：根据 IMSI（国际移动用户标识）查找用户信息

S-GW（Serving Gateway，服务网关）：

  • 用户平面数据的锚点，负责数据包的转发
  • 切换时维护数据路径的连续性（临时缓存切换期间的数据包）

P-GW（PDN Gateway，分组数据网络网关）：

  • 连接 LTE 网络与外部因特网（PDN，Packet Data Network）
  • 为 UE 分配 IP 地址（类似 DHCP 的功能）
  • 执行策略控制（QoS、流量整形）
  • 对外代表整个运营商网络（NAT 功能）

PCRF（Policy and Charging Rules Function，策略和计费规则功能）：

  • 基于用户签约和实时网络状况决定 QoS 策略
  • 控制计费

LTE 数据路径：

UE ──无线──→ eNodeB ──S1-U──→ S-GW ──S5──→ P-GW ──→ 因特网
  • eNodeB 和 S-GW 之间：S1-U 接口（用户平面）
  • S-GW 和 P-GW 之间：S5 接口（本地归属时为直连，漫游时可能经过运营商间接口）

7.3.3 5G 网络

5G NR（New Radio） 是第五代蜂窝网络标准，由 3GPP 在 Release 15（2018年）开始定义。

5G 的三大应用场景

eMBB（Enhanced Mobile Broadband，增强移动宽带）：

  • 超高下行速率（峰值 20 Gbps）
  • 适合高清视频流、AR/VR 等带宽密集应用
  • 连续广域覆盖的典型 5G 使用场景

URLLC（Ultra-Reliable Low-Latency Communication，超可靠低时延通信）：

  • 端到端时延 < 1 ms
  • 可靠性 > 99.9999%（“六个九”）
  • 适合工业控制、远程手术、自动驾驶等对时延极敏感的场景

mMTC（Massive Machine-Type Communication，大规模机器类通信）：

  • 支持每平方公里 100 万个设备连接
  • 超低功耗（设备电池可用数年）
  • 适合 IoT 传感器大规模部署

5G 关键技术

毫米波（mmWave，Millimeter Wave）：

  • 频段：24 GHz~100 GHz
  • 超大带宽（可达数 GHz），理论速率极高
  • 缺点： 传播距离短（通常 < 200m），穿透力弱（被建筑物、树木、甚至雨水阻挡），需要密集部署小基站（Small Cell）
  • 应用： 城市热点、室内覆盖、固定无线接入（FWA）

低频段（Sub-6 GHz）：

  • 频段：700 MHz~6 GHz
  • 覆盖范围大，穿透力强
  • 带宽相对较小，速率低于毫米波
  • 应用： 广域覆盖，与 4G 协同部署

大规模 MIMO（Massive MIMO）：

  • 基站使用数十至数百根天线（相比 4G 的 2~8 根）
  • 通过波束成形（Beamforming） 将能量集中在特定方向（指向用户），而不是全向广播，大幅提高频谱效率和用户速率
  • 同时服务多个用户（MU-MIMO，Multi-User MIMO）

网络切片（Network Slicing）：

  • 在同一物理网络基础设施上，创建多个逻辑隔离的虚拟网络，每个切片具有独立的 QoS 保证
  • eMBB 切片：大带宽，较大时延可接受
  • URLLC 切片：超低时延，极高可靠性
  • mMTC 切片：大连接数，低功耗
  • 基于 SDN 和 NFV 技术实现

5G 核心网（5GC）：

  • 完全基于服务化架构（SBA，Service-Based Architecture），所有功能模块通过 REST API 交互
  • 控制平面和用户平面完全分离（CUPS）
  • 支持网络切片、边缘计算（MEC）
  • 主要网络功能：AMF（接入和移动性管理）、SMF（会话管理）、UPF（用户平面转发）、UDM（统一数据管理）等

移动边缘计算（MEC，Mobile Edge Computing）：

  • 将计算资源部署在网络边缘（靠近基站），减少数据传输到云端的时延
  • 适合 AR/VR、自动驾驶等低时延应用

7.4 移动管理

7.4.1 移动性的挑战

当移动用户从一个网络区域移动到另一个区域时，面临两个主要挑战：

寻址（Addressing）： 如何让发送方找到移动用户的当前位置？用户的 IP 地址随位置变化，发送方怎么知道用户现在在哪里？

数据路径维护（Data Path Continuity）： 用户移动时，正在进行的 TCP 连接应该如何处理？理想情况下，连接不中断，用户感知不到切换（无缝切换）。

7.4.2 移动性管理的方法

方法 1：让路由选择协议处理

每次移动主机移动到新位置时，向整个网络广播自己的新位置（类似链路状态通告）。发送方通过正常路由选择找到移动主机。

问题： 网络规模大时，维护移动主机位置信息的开销不可接受。

方法 2：归属代理（Home Agent）

这是 4G/5G 采用的基本思路：

  • 归属网络（Home Network）： 移动用户签约的运营商网络，用户有固定的归属 IP 地址（或标识符）
  • 归属代理（Home Agent）： 归属网络中代表移动用户的实体（在 4G 中类似 P-GW 的功能）
  • 转交地址（Care-of Address）： 移动用户在当前访问网络中临时获得的地址

工作原理（类比邮政转发）：

  1. 移动用户到达新网络，获取转交地址，向归属代理注册
  2. 发送方将数据发送到移动用户的归属地址
  3. 归属代理拦截数据，通过隧道转发到用户当前的转交地址
  4. 移动用户直接向发送方回复（三角路由）或通过归属代理回复

7.4.3 4G LTE 中的切换

切换（Handover） 是移动设备从一个基站（eNodeB）移动到另一个基站时，维持连接的过程。

切换的触发条件：

  • 当前服务基站的信号强度低于阈值
  • 测量报告（Measurement Report）显示相邻基站信号更强
  • 负载均衡需要

基于 X2 接口的切换（X2-based Handover）：

这是 LTE 中最常见、最快速的切换方式（源和目标 eNodeB 之间有直接 X2 接口）：

准备阶段：

  1. 源 eNodeB（Source eNB）收到 UE 的测量报告，决定切换到目标 eNodeB（Target eNB）
  2. 源 eNB 通过 X2 接口向目标 eNB 发送切换请求（Handover Request） ，包含 UE 的上下文信息（QoS 参数、安全密钥等）
  3. 目标 eNB 准备资源，回复切换请求确认（Handover Request Acknowledge） ，包含为 UE 分配的临时标识符（C-RNTI）

执行阶段：

  1. 源 eNB 向 UE 发送切换命令（Handover Command） ，告知目标 eNB 的信息
  2. 源 eNB 开始向目标 eNB 转发（通过 X2 隧道）来自 S-GW 的数据包（避免切换期间丢包）
  3. UE 与源 eNB 断开，向目标 eNB 发起接入（发送切换确认，Handover Confirm）
  4. 目标 eNB 向 S-GW 发送路径切换请求（Path Switch Request） ，请求将下行数据发送到自己这里

完成阶段：

  1. S-GW 更新下行转发路径（从源 eNB 切换到目标 eNB），向 P-GW 发送端点更新
  2. S-GW 通知目标 eNB 路径切换完成，向源 eNB 发送序列号状态传输（SN Status Transfer） （确保数据包连续性）
  3. 目标 eNB 通知 MME，MME 更新位置信息
  4. 源 eNB 释放资源

切换期间的数据连续性：

  • 下行： S-GW 向目标 eNB 转发路径，切换期间源 eNB 暂时存储并通过 X2 转发到目标 eNB
  • 上行： UE 切换到目标 eNB 后直接向目标 eNB 发送，目标 eNB 将未按序的数据包转发给 S-GW

基于 S1 接口的切换（S1-based Handover）：
当源和目标 eNodeB 之间没有 X2 接口（如属于不同运营商），切换通过 MME（经 S1 接口）协调，步骤更多，时延更大。

7.4.4 5G 中的移动性管理

5G 的移动性管理与 4G 类似，但有以下改进：

AMF（Access and Mobility Management Function）： 5G 中替代 MME，负责接入控制和移动性管理，采用服务化架构，可以灵活扩展。

双连接（Dual Connectivity）： UE 同时连接到两个基站（gNB），一个作为主节点（MN），另一个作为辅助节点（SN），提高吞吐量和移动鲁棒性。

非独立组网（NSA，Non-Standalone）和独立组网（SA，Standalone）：

  • NSA： 5G 无线接入叠加在 4G 核心网上，复用 4G 基础设施，部署快但功能受限
  • SA： 5G 无线接入 + 5G 核心网（5GC），支持完整的 5G 功能（网络切片、MEC 等），但需要更多基础设施建设

7.5 移动 IP（Mobile IP）

移动 IP（Mobile IP，RFC 3344 for IPv4，RFC 6275 for IPv6） 是 IETF 定义的支持 IP 层移动性的标准协议，使移动主机在不同网络之间移动时保持其归属 IP 地址不变。

移动 IP 的三个组件：

移动节点（Mobile Node，MN）： 移动的主机或路由器，有一个归属地址（Home Address） （永久 IP 地址）

归属代理（Home Agent，HA）： 归属网络中的路由器，代表移动节点截获发往归属地址的数据报，并通过隧道转发到移动节点当前位置

外地代理（Foreign Agent，FA）（IPv4）： 移动节点访问的外地网络中的路由器，帮助移动节点注册和接收数据报（IPv6 中移动节点可以自行管理，不需要 FA）

移动 IP 工作过程（IPv4）：

  1. 正常情况（在归属网络）： 移动节点直接连接归属网络，使用归属地址正常通信

  2. 移动到外地网络：
    a. 移动节点到达外地网络，外地代理广播代理通告（Agent Advertisement）
    b. 移动节点从外地代理获取转交地址（Care-of Address，CoA） （外地代理的 IP 地址，或通过 DHCP 获取新地址）
    c. 移动节点向归属代理注册（Registration） ：发送注册请求（含归属地址、转交地址、认证信息），归属代理回复注册应答

  3. 数据转发：
    a. 通信方向移动节点的归属地址发送数据报
    b. 归属代理拦截数据报（通过代理 ARP 或路由），将其封装在新的 IP 数据报中（IP-in-IP 隧道），目的地址为转交地址，转发到外地代理
    c. 外地代理解封装，将原始数据报交给移动节点
    d. 移动节点的回复： 可以直接发给通信方（三角路由），也可以通过归属代理（对称路由）

三角路由（Triangular Routing）问题：
数据从通信方 → 归属网络 → 外地网络，路径可能很低效（如通信方和移动节点都在同一城市，但归属网络在另一个国家，数据要绕一大圈）。

路由优化（Route Optimization）： 归属代理将移动节点的转交地址通告给通信方，通信方直接与移动节点建立隧道（通信方 → 移动节点），绕过归属代理。但这要求通信方支持移动 IP，实现复杂。

移动 IP 的局限：

  • 三角路由效率低
  • 需要修改通信对端支持路由优化
  • 实际部署中，4G/5G 等蜂窝网络有自己的移动性管理机制（如前述 LTE 切换），不依赖移动 IP
  • 移动 IP 更多用于跨异构网络（如 WiFi 和蜂窝网络之间）切换的场景

本章小结

本章介绍了无线网络和移动网络的核心内容，主要包括：

  1. 无线网络概述： 无线主机、基站、无线链路的概念；基础设施模式 vs 自组织网络；无线链路的特点（路径损耗、多路径衰落、干扰、SNR 与 BER 关系、自适应调制）；隐藏终端和暴露终端问题

  2. WiFi（802.11）： 标准演进（802.11b/a/g/n/ac/ax）；BSS 体系结构（AP、SSID、信道）；接入过程（被动/主动扫描、关联、认证）；CSMA/CA 协议（侦听、随机退避、等待 ACK、指数退避）；RTS/CTS 机制（解决隐藏终端问题、NAV）；802.11 帧结构（帧控制、4 个地址字段、序号）；节能机制（TIM、PS-Poll、WiFi 6 TWT）；WiFi 安全演进（WEP→WPA→WPA2→WPA3，SAE 前向保密）

  3. 4G LTE： 三大应用场景（eMBB、URLLC、mMTC）；网络架构（eNodeB、EPC：MME、HSS、S-GW、P-GW、PCRF）；无线链路技术（OFDMA 下行、SC-FDMA 上行、MIMO）；数据路径（UE→eNB→S-GW→P-GW→因特网）

  4. 5G NR： 三大场景（eMBB/URLLC/mMTC）；关键技术（毫米波频谱、低频段、大规模 MIMO 和波束成形、网络切片、服务化架构 5GC）；MEC；NSA vs SA 部署模式

  5. 移动管理： 移动性的挑战（寻址和数据路径连续性）；归属代理方法；4G LTE 切换过程（准备→执行→完成，X2 接口直接切换 vs S1 接口 MME 协调切换，数据连续性保障）；5G 移动性改进（AMF、双连接）

  6. 移动 IP： 三个组件（移动节点、归属代理、外地代理）；工作过程（注册转交地址、IP-in-IP 隧道转发）；三角路由问题；路由优化；实际局限性

第八章 计算机网络中的安全

8.1 什么是网络安全

在深入具体的安全机制之前，首先需要明确网络安全的目标以及攻击者可能采用的手段。

8.1.1 网络安全的目标

机密性（Confidentiality）：
只有发送方和预期的接收方能够理解传输报文的内容。由于窃听者可能截获报文，这要求对报文进行加密（Encryption） ，使截获者无法理解内容。

报文完整性（Message Integrity）：
确保通信内容在传输过程中未被篡改，无论是恶意篡改还是意外损坏。发送方和接收方需要一种机制来验证报文是否被修改。

端点鉴别（End-point Authentication）：
发送方和接收方都应能确认对方的身份，即通信对端确实是其声称的那个实体，而不是冒充者。

运行安全性（Operational Security）：
几乎所有组织（企业、大学、政府机构）都有与因特网相连的内部网络，这些网络面临潜在攻击。保护内部网络免受外部攻击，包括使用防火墙、入侵检测系统等。

8.1.2 攻击者与攻击手段

设想网络安全场景中的角色：

  • Alice 和 Bob： 希望安全通信的两方（合法用户）
  • Trudy（Intruder，入侵者）： 试图干扰 Alice 和 Bob 通信的攻击者

Trudy 可能的攻击行为：

  • 窃听（Eavesdropping）： 嗅探并记录信道上传输的报文（被动攻击）
  • 篡改（Modification）： 修改报文中的比特（主动攻击）
  • 冒充（Impersonation）： 伪装成合法用户（主动攻击）
  • 劫持（Hijacking）： 接管正在进行的连接，将合法用户踢出（主动攻击）
  • 拒绝服务（Denial of Service）： 阻止合法用户使用服务（主动攻击）

8.2 密码学原理

密码学（Cryptography）是网络安全的核心技术基础，提供机密性、完整性验证和身份鉴别等功能。

8.2.1 对称密钥密码学

对称密钥密码（Symmetric Key Cryptography）： 发送方和接收方使用相同的密钥 KS 进行加密和解密。

加密：c=KS(m)解密：m=KS(c)

其中 m 为明文， c 为密文。

替换密码（古典密码）

凯撒密码（Caesar Cipher）：
将每个字母向后移动 k 位（如 k=3 时，a→d，b→e，…，z→c）。密钥空间只有 25 种（ k=1,…,25 ），极易破解（枚举或频率分析）。

单码替换密码（Monoalphabetic Cipher）：
将字母表中每个字母映射到另一个不同字母，密钥是一个随机的字母表置换，密钥空间为 26! （约 4×1026 ）种排列。

尽管密钥空间巨大，单码替换密码可以被频率分析（Frequency Analysis） 破解：统计密文中各字母（或字母组合）的出现频率，与已知的自然语言字母频率分布（如英文中 e、t、a、o 最常见）比较，推断出密钥映射关系。

多码替换密码（Polyalphabetic Cipher）：
使用多个单码替换密码，每个字符位置使用不同的替换规则，增加频率分析难度。Vigenère 密码是经典例子（用关键词中每个字母对应的移位量轮流加密）。

分组密码（Block Cipher）

现代对称密钥密码使用分组密码（Block Cipher） ：将明文分成固定长度的块，对每块分别加密，产生等长的密文块。

分组密码的核心设计原则：

  • 混淆（Confusion）： 使密文与密钥的关系尽可能复杂（通常通过替换实现）
  • 扩散（Diffusion）： 使明文中每个比特的变化影响密文中多个比特（通过置换实现）

现代分组密码通过多轮迭代混淆和扩散操作，使密文与明文和密钥的关系极其复杂，在计算上不可区分于随机排列。

DES（Data Encryption Standard，数据加密标准）：

  • 64 位块大小，56 位密钥
  • 由 IBM 开发，1977 年成为美国联邦标准
  • 已被证明不安全：56 位密钥空间（ 256≈7.2×1016 ）可被现代计算机暴力破解（1999 年用专用硬件在 22 小时内破解）
  • 3DES（Triple DES）： 用三个不同密钥（或两个不同密钥）对数据做三次 DES 运算，有效密钥长度 112 或 168 位，仍在部分遗留系统中使用

AES（Advanced Encryption Standard，高级加密标准）：

  • 128 位块大小，密钥长度 128、192 或 256 位
  • 2001 年由 NIST 选定，替代 DES，现为事实上的对称加密标准
  • 基于 Rijndael 算法，由比利时密码学家 Joan Daemen 和 Vincent Rijmen 设计
  • 运行 10/12/14 轮（取决于密钥长度），每轮包含字节替换、行移位、列混合、轮密钥加四个操作
  • 目前没有实际可行的攻击方法，128 位密钥穷举需要 2128 次操作

密码分组链接（CBC）

若直接对明文分块加密（ECB 模式，Electronic CodeBook），相同的明文块会产生相同的密文块，存在安全隐患（如图像加密后仍能看出大致轮廓）。

CBC（Cipher Block Chaining，密码分组链接） 解决这个问题：

ci=KS(mi⊕ci−1)

每个明文块在加密前先与前一个密文块做异或，使得即使相同的明文块也会产生不同的密文块。第一块使用初始向量（IV，Initialization Vector） 代替 ci−1 。IV 是随机生成的，与密文一起发送（不需要保密，但每次加密应不同）。

解密：

mi=KS−1(ci)⊕ci−1

CTR 模式（Counter Mode）： 另一种常用分组密码运行模式，将计数器值加密后与明文异或，无需逆向加密运算（解密和加密使用相同操作），支持并行计算和随机访问，适合流媒体等场景。

8.2.2 公开密钥密码学

对称密钥密码存在一个根本性问题：密钥分发问题——Alice 和 Bob 如何安全地商定共享密钥？若他们不曾见过面，且通信信道是不安全的，如何安全交换密钥？

公开密钥密码学（Public Key Cryptography） 从根本上解决了这个问题，由 Diffie 和 Hellman（1976）以及独立的 Merkle 提出（Diffie-Hellman 密钥交换协议），后被 Rivest、Shamir 和 Adleman 具体实现为 RSA 算法（1978）。

核心思想： 每个实体有一对密钥——公钥（Public Key） KB+ 和私钥（Private Key） KB− ：

  • 公钥公开（任何人都可以知道）
  • 私钥秘密（只有 Bob 自己知道）
  • 用公钥加密的内容只能用配对的私钥解密
  • 用私钥加密的内容只能用配对的公钥解密
KB−(KB+(m))=mKB+(KB−(m))=m

加密（Alice 向 Bob 发送秘密消息）：

  1. Alice 获取 Bob 的公钥 KB+ （从公钥目录或 Bob 直接发送）
  2. Alice 用 Bob 的公钥加密消息： c=KB+(m)
  3. Bob 用自己的私钥解密： m=KB−(c)=KB−(KB+(m))

即使 Trudy 截获密文 c ，由于没有 Bob 的私钥，无法解密。

RSA 算法

RSA（Rivest-Shamir-Adleman）是最广泛使用的公钥密码算法，其安全性基于大整数分解的计算困难性。

密钥生成：

  1. 选择两个大素数 p 和 q （实际中通常每个超过 512 位）
  2. 计算 n=pq ， z=(p−1)(q−1)
  3. 选择一个与 z 互素的数 e （ gcd(e,z)=1 ， 1<e<z ）
  4. 找到 d 使得 ed≡1(modz) （即 d 是 e 模 z 的乘法逆元）
  5. 公钥： (n,e) ；私钥： (n,d)

加密与解密：

  • 加密（用公钥）： c=memodn
  • 解密（用私钥）： m=cdmodn=(me)dmodn=medmodn

由 Euler 定理可以证明 med≡m(modn) ，因此解密正确。

数值示例（简化版）：

取 p=5,q=7 ，则 n=35,z=24 。

选 e=5 （ gcd(5,24)=1 ），求 d ： 5d≡1(mod24) ，解得 d=5 （ 5×5=25=1×24+1 ）。

公钥 (35,5) ，私钥 (35,5) （此例中 e=d ，仅因数字简单）。

加密 m=12 ： c=125mod35=248832mod35=17

解密 c=17 ： m=175mod35=1419857mod35=12 ✓

RSA 的安全性：
破解 RSA 等价于分解 n 为 p 和 q （目前最好的算法复杂度约为次指数级）。实际中使用 2048 位或更长的密钥，分解如此大的数在计算上是不可行的。

RSA 的效率问题：
RSA 的模幂运算计算开销远大于 AES 等对称加密（约慢 1000 倍）。实际中通常不用 RSA 直接加密大量数据，而是：

  1. 用 RSA 安全地交换一个会话密钥（Session Key） （随机生成的对称密钥）
  2. 用会话密钥和 AES 加密实际数据

这种混合方式兼顾了 RSA 的密钥分发优势和 AES 的加密效率。

Diffie-Hellman 密钥交换

DH（Diffie-Hellman）密钥交换 允许两方在不安全信道上协商出共享密钥，而不需要预先共享任何秘密：

  1. 公开协商大素数 p 和原根 g （ 1<g<p ）
  2. Alice 选随机私钥 a ，计算 A=gamodp ，发给 Bob
  3. Bob 选随机私钥 b ，计算 B=gbmodp ，发给 Alice
  4. Alice 计算 K=Bamodp=gabmodp
  5. Bob 计算 K=Abmodp=gabmodp
  6. 双方得到相同的共享密钥 K ，攻击者即使知道 p,g,A,B ，也无法（在合理时间内）计算出 K （离散对数困难问题）

DH 密钥交换本身不提供身份认证，容易遭受中间人攻击（Trudy 分别与 Alice 和 Bob 建立各自的 DH 会话），需要结合数字签名或证书验证身份。

椭圆曲线密码（ECC，Elliptic Curve Cryptography）：
基于椭圆曲线离散对数问题，在相同安全级别下密钥长度远短于 RSA（256 位 ECC ≈ 3072 位 RSA），计算效率更高，已广泛用于 TLS 1.3 等现代协议。

8.3 报文完整性和数字签名

8.3.1 密码散列函数

密码散列函数（Cryptographic Hash Function） 将任意长度的输入映射为固定长度的输出（散列值，Hash Value），具有以下关键性质：

  1. 确定性： 相同输入总产生相同输出
  2. 高效计算： 给定输入，快速计算散列值
  3. 单向性（抗原像攻击）： 给定散列值 h ，计算上无法找到满足 H(m)=h 的 m
  4. 弱抗碰撞性（抗第二原像攻击）： 给定 m ，计算上无法找到 m′≠m 使得 H(m)=H(m′)
  5. 强抗碰撞性（抗碰撞攻击）： 计算上无法找到任意一对 m≠m′ 使得 H(m)=H(m′) （生日攻击）

常用密码散列函数：

算法输出长度状态
MD5128 bits已不安全（碰撞已被发现）
SHA-1160 bits已不安全（2017年谷歌找到碰撞）
SHA-256256 bits安全，广泛使用
SHA-384384 bits安全
SHA-512512 bits安全
SHA-3（Keccak）可变安全，新标准

生日悖论与散列安全： 若散列值为 n 位，则随机散列约 2n/2 个输入后，有超过 50% 的概率找到碰撞。这就是为什么 MD5（128位）需要 264 次操作，SHA-1（160位）需要 280 次操作——在现代计算条件下已可行，因此不再安全。

8.3.2 报文鉴别码（MAC）

MAC（Message Authentication Code，报文鉴别码） 利用共享密钥提供报文完整性和源鉴别。

基于散列函数的 MAC（HMAC）：

Alice 和 Bob 共享一个密钥 s （鉴别密钥），发送方计算：

MAC=H(m+s)

（ + 表示拼接，实际中 HMAC 的计算略复杂）

发送 (m,H(m+s)) 。接收方收到后，用相同的 s 计算 H(m′+s) ，比较是否等于收到的 MAC 值：

  • 相等：报文未被篡改，且来自知道密钥 s 的人
  • 不等：报文被篡改或来源不可信

HMAC（Hash-based MAC，RFC 2104） 是标准化的 HMAC 算法：

HMAC(K,m)=H((K⊕opad)∥H((K⊕ipad)∥m))

其中 opad 和 ipad 是固定的填充常量， ∥ 表示拼接， ⊕ 表示异或。

MAC vs 加密的区别：

  • MAC 提供完整性和鉴别，不提供机密性（报文本身未加密）
  • MAC 需要共享密钥
  • 若需要机密性，需要在 MAC 之外或之上加密（通常用 Encrypt-then-MAC 顺序）

8.3.3 数字签名

数字签名（Digital Signature） 使用公钥密码实现报文完整性和不可抵赖性，解决了 MAC 无法解决的问题：

  • MAC 只能向知道密钥的接收方证明，无法向第三方证明
  • 数字签名可以向任何人公开验证，且发送方无法否认（不可抵赖性）

数字签名的核心：用私钥签名，用公钥验证

签名过程（Bob 对报文 m 签名）：

  1. Bob 对报文计算散列值： H(m)
  2. Bob 用自己的私钥 KB− 加密散列值，得到签名： σ=KB−(H(m))
  3. Bob 发送 (m,σ)

验证过程（Alice 验证 Bob 的签名）：

  1. Alice 用 Bob 的公钥 KB+ 解密签名： H′=KB+(σ)
  2. Alice 自己计算报文散列值： H(m)
  3. 比较 H′ 和 H(m) ：
    • 相等：签名有效，报文确实由持有 KB− 的人签名，且内容未被篡改
    • 不等：签名无效或报文被篡改

数字签名为什么先散列再签名？

  • RSA 直接对长报文签名（模幂运算）效率极低
  • 散列值固定长度（如 256 位），签名计算快
  • 散列函数的抗碰撞性保证了对散列值签名等价于对原报文签名

数字签名提供的保证：

  1. 完整性： 任何对报文的修改都会改变散列值，导致验证失败
  2. 源鉴别： 只有持有 KB− 的人能产生有效签名
  3. 不可抵赖性（Non-repudiation）： Bob 不能否认自己签了名，因为只有 Bob 有 KB− （若私钥未泄露），任何第三方都可以验证

8.3.4 公钥证书和 PKI

问题：公钥的真实性

Alice 获得了声称是 Bob 的公钥，但如何确认这个公钥确实属于 Bob，而不是 Trudy 的公钥？若 Trudy 用自己的私钥签名，声称是 Bob，Alice 用 Trudy 的公钥（以为是 Bob 的）验证，无法识破。

解决方案：公钥证书（Public Key Certificate）

CA（Certification Authority，认证中心）： 被普遍信任的第三方机构，负责将公钥与实体身份绑定，颁发数字证书。

证书（Certificate） 包含：

  • 实体身份信息（如主机名 www.amazon.com、组织名称等）
  • 实体的公钥
  • 证书有效期
  • 颁发者（CA）信息
  • CA 对以上内容的数字签名

要验证 Bob 的公钥，Alice 只需：

  1. 获取 Bob 的证书
  2. 用 CA 的公钥验证证书上的签名（CA 公钥是预先内置在操作系统/浏览器中的，被称为信任锚，Trust Anchor）
  3. 若签名有效，证书中的公钥就是 Bob 的真实公钥

X.509 标准： 定义了公钥证书的格式，是 TLS/HTTPS 等协议使用的证书格式。

PKI（Public Key Infrastructure，公钥基础设施）： 支撑公钥证书管理的整套体系，包括 CA、证书注册机构（RA）、证书目录、证书撤销机制等。

CA 层次结构：

根 CA（Root CA，自签名证书，预装在操作系统/浏览器中）
    ↓ 签发
中间 CA（Intermediate CA）
    ↓ 签发
终端实体证书（如 www.google.com 的证书）

证书链（Certificate Chain）： 从终端实体证书到根 CA 的证书链，验证时从下到上逐级验证签名。

证书撤销（Certificate Revocation）：
若私钥泄露或证书信息有误，需要撤销证书：

  • CRL（Certificate Revocation List，证书撤销列表）： CA 定期发布被撤销证书的列表，客户端检查
  • OCSP（Online Certificate Status Protocol，在线证书状态协议）： 实时查询证书状态，比 CRL 更及时

8.4 端点鉴别

8.4.1 鉴别协议的演进

ap 1.0（朴素鉴别）：

Alice 发送：“I am Alice”

漏洞： 任何人都可以声称是 Alice，无法验证。

ap 2.0（加上 IP 地址）：

Alice 发送包含自己 IP 地址的报文。

漏洞： Trudy 可以伪造源 IP 地址（IP 欺骗）。

ap 3.0（口令）：

Alice 发送包含秘密口令的报文。

漏洞： Trudy 窃听后可以重放 Alice 的口令（重放攻击，Replay Attack）。

ap 3.1（加密口令）：

Alice 发送加密的口令。

漏洞： Trudy 虽不能解密，但可以记录并重放加密后的口令，效果相同（重放攻击仍然有效）。

ap 4.0（随机数挑战）：

使用随机数（Nonce） 防止重放攻击：

  1. Bob 向 Alice 发送一个随机数 R （挑战）
  2. Alice 用双方共享的秘密密钥 KAB 加密 R ，发送 KAB(R) （响应）
  3. Bob 解密响应，验证是否等于 R ：等于则 Alice 通过鉴别

关键： 每次鉴别的 R 不同，所以 Trudy 无法重放上次的响应。

使用公钥的 ap 5.0：

  1. Bob 发送随机数 R
  2. Alice 用自己的私钥 KA− 签名 R ，发送 KA−(R)
  3. Bob 用 Alice 的公钥验证： KA+(KA−(R))=R ，验证成功则 Alice 通过鉴别
  4. Bob 如何确认 Alice 的公钥？ 需要 Alice 发送包含其公钥的证书（由可信 CA 签名），Bob 验证证书，提取 Alice 的公钥

8.5 保护电子邮件

8.5.1 安全电子邮件的需求

安全电子邮件需要满足：

  • 机密性： 只有接收方能读取邮件内容
  • 完整性： 确认邮件未被篡改
  • 发送方鉴别： 确认邮件确实来自声称的发送方

8.5.2 提供机密性

Alice 要向 Bob 发送机密邮件：

  1. Alice 生成一个随机的对称会话密钥 KS
  2. Alice 用 KS 加密邮件内容（使用 AES 等）： KS(m)
  3. Alice 用 Bob 的公钥加密会话密钥： KB+(KS)
  4. Alice 发送 {KS(m), KB+(KS)}

Bob 解密过程：

  1. 用自己的私钥解密得到 KS ： KB−(KB+(KS))=KS
  2. 用 KS 解密得到邮件内容： KS−1(KS(m))=m

这种方式结合了公钥密码（安全分发会话密钥）和对称密码（高效加密内容）的优势。

8.5.3 提供发送方鉴别和完整性

Alice 希望 Bob 确认邮件来自她且未被篡改：

  1. Alice 计算报文散列值 H(m)
  2. Alice 用自己的私钥签名散列值： KA−(H(m)) （数字签名）
  3. Alice 发送 {m, KA−(H(m))}

Bob 验证：

  1. 从 Alice 的证书获取 Alice 的公钥 KA+
  2. 解密签名： KA+(KA−(H(m)))=H(m)
  3. 计算收到报文的散列值 H(m)
  4. 比较两个散列值，若相等则鉴别和完整性均验证通过

8.5.4 同时提供机密性、完整性和鉴别

结合上述两种方法：

  1. Alice 先对报文签名（提供完整性和鉴别）： {m, KA−(H(m))}
  2. 再对签名后的内容加密（提供机密性）：生成会话密钥 KS ，加密内容和签名
  3. 用 Bob 的公钥加密会话密钥

PGP（Pretty Good Privacy） 正是采用这种方式，是广泛使用的电子邮件加密软件（使用 OpenPGP 标准，RFC 4880），提供完整性、鉴别和机密性。

8.6 保护 TCP 连接：TLS

TLS（Transport Layer Security，传输层安全协议） 是因特网上最广泛使用的安全协议，是 HTTPS（HTTP over TLS）的基础。TLS 的前身是 SSL（Secure Sockets Layer，由 Netscape 开发）。

TLS 在传输层（TCP）之上、应用层之下提供安全服务，对上层应用透明。

8.6.1 TLS 提供的服务

  • 机密性： 使用对称加密保护数据
  • 报文完整性： 使用 MAC 或 AEAD（认证加密）防止篡改
  • 服务器鉴别： 使用证书验证服务器身份（TLS 1.3 中几乎总是要求）
  • 客户端鉴别（可选）： 服务器可要求客户端提供证书（双向 TLS，mTLS）

8.6.2 TLS 握手过程

TLS 1.2 握手（旧版，现已被 TLS 1.3 取代）需要 2 RTT；TLS 1.3 进行了显著改进，通常只需 1 RTT，对于曾经连接过的服务器甚至可以 0 RTT。

TLS 1.3 握手（1 RTT）

第一步（客户端 Hello）：

客户端发送：

  • 支持的 TLS 版本（Client Hello）
  • 客户端随机数 ClientRandom
  • 支持的密码套件列表（Cipher Suites，如 TLS_AES_128_GCM_SHA256）
  • Supported Groups： 客户端支持的 DH 参数组（椭圆曲线或有限域）
  • Key Share： 客户端的 DH 公钥（预先计算好，无需等待服务器确认，因此节省了 1 RTT）

第二步（服务器 Hello + 后续）：

服务器发送：

  • 选定的 TLS 版本和密码套件
  • 服务器随机数 ServerRandom
  • Key Share： 服务器的 DH 公钥
  • （以下内容已加密）服务器证书
  • 服务器对握手消息的签名（Certificate Verify）
  • Finished 消息（MAC）

双方此时可以根据 DH 密钥交换计算出预主密钥（Pre-Master Secret） ，再结合 ClientRandom 和 ServerRandom 派生出多个会话密钥：

Master Secret=PRF(Pre-Master Secret, ClientRandom, ServerRandom)

从 Master Secret 派生出：

  • 客户端加密密钥
  • 服务器加密密钥
  • 客户端 MAC 密钥
  • 服务器 MAC 密钥

第三步（客户端完成）：

客户端验证服务器证书，验证服务器签名和 Finished 消息，发送自己的 Finished 消息。握手完成，开始加密通信。

TLS 1.3 的改进：

  • 删除不安全算法： 去除 RSA 密钥交换（不提供前向保密）、RC4、DES、3DES、MD5 等
  • 强制前向保密（Perfect Forward Secrecy，PFS）： 所有密钥交换使用 (EC)DHE（临时 DH），即使服务器私钥泄露，过去的会话密钥也无法恢复（因为 DH 临时密钥已销毁）
  • 减少握手往返： 1 RTT（相比 TLS 1.2 的 2 RTT）
  • 0-RTT 恢复（早期数据）： 对于曾连接过的服务器，客户端可以在握手完成前发送早期数据（0 RTT），但存在重放攻击风险，需要服务器采取防重放措施

AEAD（认证加密）

TLS 1.3 使用 AEAD（Authenticated Encryption with Associated Data，带关联数据的认证加密） 算法，同时提供加密和完整性保护，无需单独的 MAC：

常用 AEAD 算法：

  • AES-128-GCM（AES Galois/Counter Mode） ：最广泛使用
  • AES-256-GCM
  • ChaCha20-Poly1305：适合没有 AES 硬件加速的设备（如低端移动设备）

8.6.3 TLS 记录协议

握手完成后，应用数据通过 TLS 记录协议 传输：

  1. 分片： 将应用数据分成最大 214 字节的片段
  2. 压缩（TLS 1.3 已废弃）： TLS 1.2 曾支持压缩，但 CRIME 攻击证明在加密前压缩存在安全隐患，TLS 1.3 完全删除
  3. 加密和认证（AEAD）： 用会话密钥加密并认证，附加序列号防止重放
  4. 封装： 加上 TLS 记录首部（内容类型、版本、长度）传输

8.6.4 HTTPS

HTTPS（HTTP over TLS） 是 HTTP 与 TLS 的结合，使用 TCP 端口 443。

HTTPS 连接建立过程：

  1. TCP 三次握手（1.5 RTT）
  2. TLS 1.3 握手（1 RTT）
  3. 发送 HTTP 请求（+0.5 RTT）

合计约 3 RTT（相比 HTTP 的 1.5 RTT，HTTPS 的开销在首次连接时较明显）。

HTTP Strict Transport Security（HSTS）： 服务器通过响应头告知浏览器，该域名只能通过 HTTPS 访问，浏览器缓存该策略（最长 2 年），避免降级攻击（将 HTTPS 降级为 HTTP）。

8.7 网络层安全：IPsec 和 VPN

8.7.1 IPsec 概述

IPsec（IP Security，IP 安全） 是在网络层提供安全服务的协议族（RFC 4301 等），为 IP 数据报提供加密、完整性保护和源鉴别。

IPsec 的主要特点：

  • 工作在网络层，对上层协议（TCP、UDP）透明
  • 可以保护主机间、路由器间、主机与路由器间的通信
  • 支持两种模式：传输模式和隧道模式

8.7.2 IPsec 两种模式

传输模式（Transport Mode）：

只加密/认证 IP 数据报的有效载荷部分（即 TCP/UDP 报文段），IP 首部保持不变（但被认证）。

原始 IP 数据报：
| IP 首部 | TCP 首部 | 数据 |

传输模式后（AH）：
| IP 首部 | AH 首部 | TCP 首部 | 数据 |

传输模式后（ESP）：
| IP 首部 | ESP 首部 | TCP 首部 | 数据 | ESP 尾 | ESP 认证 |
                   |←── 加密 ──→|        |←─ 认证 ─→|

传输模式适用于主机到主机的端到端安全（如两台服务器之间的安全通信）。

隧道模式（Tunnel Mode）：

将整个 IP 数据报（包括原始 IP 首部）封装在新的 IP 数据报中，新 IP 首部的源/目的地址为隧道端点（如两个网关路由器）的地址。

原始 IP 数据报：
| 原始 IP 首部 | TCP 首部 | 数据 |

隧道模式后（ESP）：
| 新 IP 首部 | ESP 首部 | 原始 IP 首部 | TCP 首部 | 数据 | ESP 尾 | ESP 认证 |
                       |←─────────── 加密 ─────────────→|      |←── 认证 ──→|

隧道模式适用于网关到网关（如 VPN）或主机到网关的场景。外部网络只能看到隧道端点的地址，无法看到内部主机的 IP 地址，增加了隐私性。

8.7.3 IPsec 协议：AH 和 ESP

AH（Authentication Header，认证首部）：

  • 提供源鉴别和数据完整性
  • 不提供加密（机密性）
  • 对整个数据报（包括 IP 首部的不变字段）进行认证，因此对 NAT 不友好（NAT 修改 IP 首部会破坏认证）

ESP（Encapsulating Security Payload，封装安全有效载荷）：

  • 提供加密（机密性）
  • 提供数据完整性和源鉴别（但只认证 ESP 首部之后的内容，不包括外部 IP 首部）
  • NAT 友好（外部 IP 首部不被认证）
  • 实际中几乎总是使用 ESP，很少单独使用 AH

8.7.4 安全关联（SA）

SA（Security Association，安全关联） 是 IPsec 的核心概念，表示从发送方到接收方的单向逻辑连接。

SA 确定了通信时使用的安全参数：

  • 使用的协议（AH 或 ESP）
  • 加密算法和密钥
  • 认证算法和密钥
  • SA 的生存时间

每个 SA 由三个参数唯一标识：

  • SPI（Security Parameter Index，安全参数索引）： 32 位标识符
  • 目的 IP 地址
  • 协议（AH 或 ESP）

双向通信需要两个 SA（每个方向一个）。

安全关联数据库（SAD，Security Association Database）： 每个主机/路由器维护 SAD，存储所有 SA 的参数。

安全策略数据库（SPD，Security Policy Database）： 决定哪些流量需要 IPsec 处理（加密/认证/绕过），以及使用哪个 SA。

8.7.5 IKE（Internet Key Exchange）

IKE（Internet Key Exchange，因特网密钥交换，RFC 7296） 是 IPsec 使用的密钥交换协议，用于自动协商和建立 SA（密钥交换、算法协商等），替代手动配置密钥（Manual Keying）。

IKEv2 分两个阶段：

  1. IKE SA 建立（IKE_SA_INIT）： 建立加密的 IKE 通道（基于 DH 密钥交换），协商加密和认证算法
  2. 子 SA 建立（IKE_AUTH）： 在加密的 IKE 通道上，鉴别双方身份（使用证书或预共享密钥），建立 IPsec SA（用于实际数据保护）

8.7.6 VPN

VPN（Virtual Private Network，虚拟专用网络） 是 IPsec 隧道模式最重要的应用，允许组织通过公共因特网安全地连接分布在不同地点的私有网络，或允许远程员工安全地访问公司内网。

站点到站点 VPN（Site-to-Site VPN）：

两个站点的网关路由器建立 IPsec 隧道，两个站点的内部主机之间的流量经过隧道保护，对内部主机透明。

[公司总部内网]──→[网关路由器]──IPsec隧道──[网关路由器]──→[分支机构内网]
                            ←───── 因特网 ─────→

远程访问 VPN（Remote Access VPN）：

远程员工在本地设备上运行 VPN 客户端，与公司网关建立 IPsec（或 SSL/TLS）隧道，访问公司内网资源。

常用 VPN 协议：

  • IPsec/IKEv2： 安全性高，速度快，适合移动设备
  • OpenVPN： 基于 TLS，开源，跨平台，能穿透防火墙（使用 TCP 443 端口）
  • WireGuard： 新兴协议，代码简洁（约 4000 行），性能优秀，已被 Linux 内核收录

8.8 保护无线局域网

8.8.1 802.11 安全概述

第 7 章已介绍 WiFi 安全的演进（WEP → WPA → WPA2 → WPA3），本节从网络安全角度深入分析。

WEP 的致命缺陷：

  1. IV 空间太小： WEP 使用 24 位 IV（初始向量），约 1600 万种组合，在忙碌网络中几小时内就会重用 IV，相同 IV 和密钥加密不同明文，可被攻击
  2. IV 明文传输： IV 不加密地附在帧中，攻击者可以收集大量（IV, 密文）对
  3. RC4 流密码弱点： 特定 IV 值会泄露密钥信息
  4. 无完整性保护： WEP 使用 CRC-32 检验，但 CRC 不是密码学安全的 MAC，攻击者可以有针对性地篡改帧内容

实际攻击： 2001 年 Fluhrer、Mantin 和 Shamir 发表论文，通过收集足够多的特定弱 IV 帧，可以在数小时内恢复 WEP 密钥。工具 aircrack-ng 可在数分钟内破解 WEP。

WPA2（802.11i）的改进：

  • CCMP（AES-CTR + CMAC）： 使用 AES 块密码，128 位密钥，经过密码学证明安全
  • 四次握手（4-Way Handshake）： 在关联后协商会话密钥，每次连接密钥不同
  • PMK（Pairwise Master Key）： 由预共享密钥（PSK）和握手随机数派生，用于生成会话密钥（PTK）
  • GTK（Group Temporal Key）： 用于广播/多播帧加密

WPA2 的已知漏洞：

  • KRACK（Key Reinstallation Attack，2017）： 利用四次握手的重放漏洞，强制重装已使用的密钥，导致密钥流重用。已通过打补丁修复
  • PMKID 攻击（2018）： 无需捕获完整四次握手，只需捕获一个 PMKID 帧即可进行字典攻击（PSK 强度不足时危险）

8.9 防火墙和入侵检测系统

8.9.1 防火墙

防火墙（Firewall） 是位于内部网络和外部网络（通常是因特网）之间的软硬件系统，根据预定义的策略规则决定允许哪些流量通过，阻止哪些流量。

防火墙的三个目标：

  1. 所有进出流量都经过防火墙
  2. 只有符合安全策略的流量才被放行
  3. 防火墙本身能够抵抗攻击

无状态分组过滤（Stateless Packet Filtering）

最简单的防火墙类型，对每个分组独立做决策，不跟踪连接状态。

根据分组首部字段过滤：

  • 源/目的 IP 地址
  • 传输层协议（TCP、UDP、ICMP）
  • 源/目的端口号
  • TCP 标志位（SYN、ACK、FIN 等）
  • ICMP 类型和代码

防火墙规则示例：

动作源地址目的地址协议源端口目的端口标志位说明
允许任意222.22/16TCP> 102380任意允许外部访问内部 Web 服务器
允许222.22/16任意TCP80> 1023ACK允许 Web 响应返回
允许任意222.22/16TCP> 102325任意允许外部邮件进入
拒绝任意任意任意任意任意任意默认拒绝所有其他流量

无状态过滤的局限：

  • 不跟踪连接状态，可能放行攻击者构造的带 ACK 标志的分组（即使没有对应的 SYN）
  • 无法处理 FTP 等使用动态端口的协议

有状态分组过滤（Stateful Packet Filtering）

有状态防火墙跟踪每条 TCP 连接的状态（SYN → ESTABLISHED → FIN_WAIT → CLOSED），只放行属于已建立连接的回复分组。

连接跟踪表（Connection Tracking Table） 记录每条活跃连接的四元组（源IP、源端口、目的IP、目的端口）和连接状态。

优势：

  • 能够识别并阻止不属于任何已建立连接的分组（如带 ACK 标志但无对应 SYN 的分组）
  • 能处理动态端口协议（通过跟踪控制连接了解数据连接的端口）

应用网关（Application Gateway / 代理防火墙）

应用网关工作在应用层，深度检查应用层协议内容，而不仅仅是网络层和传输层首部。

工作原理： 应用网关充当代理（Proxy） ，终止外部连接，检查应用层内容，再与内部服务器建立新连接。

  • HTTP 代理： 检查 HTTP 请求和响应，过滤恶意内容、实现 URL 过滤
  • SMTP 代理： 过滤垃圾邮件和恶意附件
  • FTP 代理： 控制 FTP 命令

优势： 可以深度检查应用内容，防御应用层攻击
缺点： 每个协议需要单独的应用网关，性能开销大，配置复杂

防火墙部署拓扑

DMZ（Demilitarized Zone，非军事区）：

                    ┌─── 内部防火墙 ───→ 内部网络（最受保护）
因特网 ──外部防火墙──→ DMZ（公共服务器：Web、邮件、DNS）

DMZ 位于两个防火墙之间，放置对外提供服务的服务器（Web、邮件、DNS）。即使 DMZ 中的服务器被攻陷，内部网络仍受内部防火墙保护。

防火墙的局限性：

  • 无法防御来自内部的攻击（内部员工恶意行为或内部主机被入侵）
  • 无法防御利用被允许端口（如 80 端口）进行的应用层攻击
  • 加密流量（如 HTTPS、VPN）可能绕过检查（除非使用 SSL 检查代理）
  • 防火墙本身可能成为单点故障（需要高可用部署）

8.9.2 入侵检测系统（IDS）

IDS（Intrusion Detection System，入侵检测系统） 对网络流量进行深度分析，检测可能的攻击行为，并向管理员发出警报。

IDS vs 防火墙：

  • 防火墙基于规则阻止特定流量（主动防御）
  • IDS 监控流量，检测异常，发出警报（被动检测）

IDS 的两种检测方法：

基于特征的 IDS（Signature-Based IDS）：

维护一个已知攻击特征库（如特定的恶意字节序列、特定的 SQL 注入模式、已知恶意软件的网络行为），对每个分组或会话与特征库匹配：

  • 优点： 对已知攻击检测准确率高，误报率低
  • 缺点： 无法检测零日攻击（Zero-Day Attack） （攻击特征库中没有记录的新型攻击）；攻击者可以轻微修改攻击手法绕过特征匹配

基于异常的 IDS（Anomaly-Based IDS）：

建立正常网络流量的基线模型，检测与基线显著偏离的流量：

  • 优点： 理论上可以检测未知攻击（零日攻击）
  • 缺点： 误报率（False Positive）较高（正常业务的临时高峰可能被误报为攻击）；漏报率（False Negative）也可能较高；"正常"基线难以精确建立

IPS（Intrusion Prevention System，入侵防御系统）：

在 IDS 的基础上，能够主动阻断检测到的攻击流量（类似于在线防火墙 + IDS 的结合），而不仅仅是发出警报。

SIEM（Security Information and Event Management，安全信息和事件管理）：

收集来自防火墙、IDS、服务器、应用等多个来源的日志和事件，进行关联分析，提供统一的安全态势视图，辅助安全分析师进行事件调查和响应。

8.10 网络安全实践中的其他主题

8.10.1 DNS 安全（DNSSEC）

DNS 的安全威胁：

  • DNS 缓存中毒（DNS Cache Poisoning）： 攻击者向 DNS 缓存服务器注入虚假 DNS 响应，将合法域名解析到攻击者控制的 IP 地址，用于钓鱼、中间人攻击
  • DNS 放大攻击（DNS Amplification Attack）： 攻击者伪造受害者 IP 地址，向大量开放 DNS 解析器发送小 DNS 查询，解析器向受害者返回大量大型响应，放大 DDoS 流量

DNSSEC（DNS Security Extensions，DNS 安全扩展，RFC 4033）：

为 DNS 记录添加数字签名，使查询方能够验证响应的真实性和完整性：

  • 每个 DNS 区域有一对密钥（ZSK，Zone Signing Key）
  • 区域中所有资源记录被 ZSK 签名
  • ZSK 的公钥被更上层区域（父区域）的密钥签名，形成信任链
  • 最终由根区（.）的密钥签名，信任链的根被 IANA 管理

DNSSEC 解决了 DNS 欺骗问题，但部署进度缓慢（需要 DNS 服务器和客户端都支持），且不解决 DDoS 攻击问题。

8.10.2 BGP 安全（RPKI 和 BGPsec）

BGP 劫持（BGP Hijacking）： 攻击者或配置错误的 AS 宣告本不属于自己的 IP 前缀，导致其他 AS 的流量被错误路由到攻击者控制的 AS（历史事件：2008 年巴基斯坦电信导致全球 YouTube 流量中断，2010 年中国电信劫持大量美国网络流量）。

RPKI（Resource Public Key Infrastructure，资源公钥基础设施）：

  • 为 IP 地址块和 AS 号码提供权威性映射
  • 每个 IP 前缀的合法持有者签发 ROA（Route Origin Authorization，路由起源授权） ，声明哪个 AS 可以宣告该前缀
  • 路由器验证 BGP 路由是否有对应的 ROA，过滤非法宣告

BGPsec： 进一步为整个 AS-PATH 添加签名，防止路径伪造，但部署更为复杂，尚未广泛采用。

本章小结

本章系统介绍了计算机网络安全的核心内容，主要包括：

  1. 网络安全目标： 机密性（加密）、报文完整性（MAC/签名）、端点鉴别（证书/随机数挑战）、运行安全性（防火墙/IDS）；攻击手段（窃听、篡改、冒充、劫持、DoS）
  2. 密码学原理： 对称密钥密码（替换密码→分组密码，DES 不安全，AES 安全，CBC 模式解决相同明文问题）；公钥密码（RSA 安全性基于大整数分解，私钥签名公钥验证，效率问题用混合加密解决）；Diffie-Hellman 密钥交换（离散对数困难，前向保密）；ECC（更短密钥，更高效率）
  3. 报文完整性和数字签名： 密码散列函数（单向性、抗碰撞性，MD5/SHA-1 不安全，SHA-256 安全）；MAC/HMAC（共享密钥提供完整性和鉴别）；数字签名（私钥签散列值，公钥验证，提供不可抵赖性）；公钥证书和 PKI（CA 签发证书，X.509 格式，证书链，CRL/OCSP 撤销）
  4. 端点鉴别： 鉴别协议演进（ap 1.0~5.0）；随机数挑战防重放攻击；公钥鉴别结合证书
  5. 安全电子邮件： 混合加密提供机密性（对称密钥加密内容，公钥加密对称密钥）；数字签名提供完整性和鉴别；PGP
  6. TLS： TLS 1.3 握手（1 RTT，DH 密钥交换，前向保密，证书鉴别）；AEAD 认证加密（AES-GCM、ChaCha20-Poly1305）；TLS 记录协议；HTTPS；HSTS
  7. IPsec 和 VPN： AH（认证，无加密）vs ESP（加密+认证）；传输模式（端到端，IP 首部不变）vs 隧道模式（网关间，整个数据报封装）；SA 和 SAD/SPD；IKEv2 自动密钥协商；VPN（站点到站点/远程访问，IPsec/OpenVPN/WireGuard）
  8. 无线网络安全： WEP 的致命缺陷（IV 重用、RC4 弱点）；WPA2（AES-CCMP，四次握手，PTK/GTK）；KRACK 漏洞；WPA3（SAE 防字典攻击，前向保密，PMF）
  9. 防火墙和 IDS： 无状态分组过滤（首部字段规则，简单但不跟踪状态）；有状态分组过滤（连接跟踪表，更安全）；应用网关（应用层深度检查，代理方式）；DMZ 部署；IDS（基于特征：准确但无法检测零日攻击；基于异常：可检测未知攻击但误报率高）；IPS；SIEM
  10. 其他安全主题： DNSSEC（为 DNS 记录签名，信任链，防缓存中毒）；BGP 安全（RPKI/ROA 防 BGP 劫持）

本系列笔记依据 《计算机网络：自顶向下方法》第八版（Computer Networking: A Top-Down Approach, 8th Edition，James F. Kurose & Keith W. Ross 著）整理撰写，内容按照原书章节顺序展开，涵盖应用层、传输层、网络层（数据平面与控制平面）、链路层、无线网络与移动网络、网络安全共八章核心内容。

笔记以个人学习为目的，在忠实原书内容的基础上对知识点进行了梳理、归纳和适当补充，部分表述经过重新组织以便于理解，不代表原书观点的完整或权威表达。如需深入学习，请以原书为准。

如笔记中存在疏漏、错误或表述不当之处，欢迎批评指正

]]> https://loogeking.github.io/posts/%E8%AE%A1%E7%AE%97%E6%9C%BA%E7%BD%91%E7%BB%9C/ 2026-06-20T09:52:50.000Z 可用于计算机网络学习以及408考研 计算机网络 2026-06-22T10:20:31.709Z