术语表

人工智能

原文名称 · AI

从数据中找出规律并据此作答的程序

人工智能是这样一种程序：它查看大量例子，找出其中的规律，再用这些规律来作答或判断。它不是生命，也不像人那样思考。它只是极快地计算出接下来最可能出现的内容。

深入学习

大语言模型

原文名称 · LLM

学习海量文本后续写句子的人工智能

大语言模型读过海量文本，学会了哪个词后面容易接哪个词。你写下问题后，它不断挑选最可能的下一个词，拼成一段回答。因此它读起来很流畅，内容却可能是错的。

深入学习

提示词

原文名称 · Prompt

你写给人工智能的话 — 你的指令

提示词就是你输入给人工智能的那段话。它不是咒语，但写法很重要：你越清楚地说明自己是谁、想要什么、希望以什么形式呈现，答案就越好。回答不理想时，重写提示词通常比反复争辩更快。

深入学习

系统提示词

原文名称 · System prompt

对话开始前预先设定的指令

系统提示词是放在你的消息之前的指令：助手应当是谁、必须始终做什么、绝不能做什么。你通常看不到它，但它影响每一个回答。Lyen 的教学原则就写在里面。

词元

原文名称 · Token

人工智能实际计数的文本小块

人工智能并不是按字或按词阅读，而是把文本切成叫作词元的小块来处理。短词可能是一个词元，长词会分成好几个。长度上限和 API 计费都按词元数计算，而不是按字数，所以谈成本或容量时总会遇到这个词。

上下文窗口

原文名称 · Context window

人工智能一次能同时看住的文本量

上下文窗口就是人工智能工作的那张桌子：你的问题、目前为止的对话、你粘贴的文档，都必须放得下。对话超过这个大小后，最早的部分会被挤出桌面，人工智能就真的再也看不到它了。长对话里它开始忘记开头说过的话，原因就在这里。

幻觉（凭空生成）

原文名称 · Hallucination

毫无依据却说得很像真的答案

在这个领域，这个词只指一件事：把错误或没有依据的内容，用十分肯定的口吻说出来。它与人产生幻觉的体验毫无关系——机器并没有在经历什么。它的成因是模型在挑选听起来合理的词，而不是核对来源，所以人名、数字和引文都必须另行核实。

温度（temperature）

原文名称 · Temperature

在稳妥一致与出人意料之间调节的旋钮

温度决定模型挑选下一个词时有多大胆。调低，它就总选最可能的词，回答稳定、可重复，适合查事实和写代码。调高，它会去够那些不太可能的词，回答更多样，出错也更多，适合用来发散想法。

参数（parameter）

原文名称 · Parameter

模型在学习中不断调整的众多数字之一

参数在英文里叫 parameter（很多个时叫 parameters）。它是模型在学习时自己调整的所有数字。权重是最大的一类，偏置、嵌入和归一化系数也都是参数。一个 7B 模型大约有 70 亿个参数。参数多会让模型运行起来更重，但不一定更好。

深入学习

训练

原文名称 · Training

反复给模型看例子，直到它的数字调好

训练就是模型被造出来的过程：一个接一个地看例子，先猜一个答案，再被告知差了多少，然后把数字往正确的方向挪一点。重复几十亿次，规律就固定下来了。它既慢又贵，所以模型训练一次，之后反复使用。

微调

原文名称 · Fine-tuning

在已训练好的模型上再教它你自己的例子

不必从零造模型，而是拿一个已经训练好的模型，用你自己准备的少量例子继续训练，让它带上你的语气或领域特点。这比从头训练便宜得多。不过对初学者来说，把提示词写清楚往往就够了，根本用不上微调。

推理（运行）

原文名称 · Inference

真正运行训练好的模型来得到答案

推理就是日常使用模型本身：你把文字送进去，模型算一遍，答案出来。这个过程中模型什么也没学到，运行前后完全一样。人们谈论人工智能服务的成本或速度时，说的通常就是这一步。

检索增强生成（RAG）

先把资料查出来，再让人工智能据此作答

在这种做法里，系统先从你的文档中检索与问题相关的段落，再把这些段落交给人工智能，让它依据这些内容作答。人工智能不再凭记忆回答，编造的内容因此大幅减少，你还能核对它用了哪份资料。

智能体

原文名称 · Agent

能使用工具并自行分步推进的人工智能

普通聊天机器人只会回话。智能体则被交给工具——读文件、上网搜索、执行命令——并根据每一步的结果自行决定下一步，逐步完成目标。它更有用，也更危险，所以必须明确告诉它哪些可以碰、哪些绝对不能碰。广义上说，智能体就是模型加 Harness——LangChain 把它写成 "Agent = Model + Harness"。

子智能体

原文名称 · Sub-agent

主智能体为完成一部分工作而启动的帮手智能体

子智能体在自己全新的上下文窗口里工作，所以它可以读很多文件、做大范围搜索，最后只汇报结果，让主对话保持简短。只给子智能体一件范围很小的工作和它需要的工具 —— 并且像检查其他草稿一样检查它的汇报。

深入学习

Ralph Loop（拉尔夫循环）

一遍又一遍地把同样的提示词交给智能体，直到工作真正完成

每当智能体想停下来，一个钩子（hook）就把同样的提示词再交给它，它会接着已经保存在文件和 Git 里的工作继续做。循环需要一个可以检查的终点，还要有上限，比如最多跑几轮，否则它可能永远转下去。

深入学习

技能包

原文名称 · Skill

人工智能在需要时加载的可复用说明包

技能包是一个小文件夹，里面装着针对某一类工作的说明，必要时还有脚本。人工智能只在遇到那类工作时才读取它，于是知识可以不断增加，而不必让每次对话都背上全部内容。如果你在提示词里一再重复同一段说明，那就是该把它做成技能包的信号。

深入学习

神经网络

原文名称 · Neural network

从例子中学会规律的简单运算网络

神经网络就是把大量非常简单的运算一层层连接起来。规则不是人写出来的，而是给它看很多例子，它自己一点点调整内部的数字，直到答案对得上。名字来自对脑细胞的比喻，但它其实只是电脑在做算术，并不是会思考的生命。

深入学习

机器学习

原文名称 · Machine learning

不写规则，而是用例子来教电脑

普通编程是人来写规则：遇到这种情况就那样做。机器学习则是给电脑看成千上万个带答案的例子，让它自己找出规律。所以它能很好地处理照片、语音这类不规整的东西；同样，例子不好时它也会很有把握地给出错误答案。

深入学习

深度学习

原文名称 · Deep learning

层数很多的机器学习，是当今人工智能的基础

深度学习就是用层数很多的神经网络来做机器学习。前面的层先看出照片里的边缘这类简单特征，越往后越能认出人脸这样复杂的东西。今天人们谈论的人工智能，包括聊天模型，几乎都是这样造出来的。

深入学习

Transformer

支撑几乎所有现代语言模型的网络结构

Transformer 是 2017 年提出的一种神经网络组织方式，它让输入中的每个词都能同时与其他所有词相互权衡。正因如此，长句子才不会前后走偏。GPT 里的 T 指的就是它，你叫得出名字的聊天模型几乎都是 Transformer。

深入学习 详细了解 GPT

权重（weight）

原文名称 · Weight

决定一个输入占多大分量的、训练学到的数字

权重在英文里叫 weight（很多个时叫 weights）。它是神经网络里每条连接上的数字，要乘到输入上，决定这个输入对结果影响有多大。权重不是人手动输入的，而是训练一点点调整，直到答案变好才找到的。模型文件里大部分就是这些数字，所以开放模型就是可以下载权重的模型。

深入学习

提示词工程

原文名称 · Prompt engineering

把问题问好，让人工智能答得好的手艺

提示词工程是把请求写清楚的实用本领：让模型知道该以什么身份、为了什么目标、给出什么样式的答案，以及哪些事实是它猜不到的。它更像是给新同事交代工作，而不是写程序。同一个模型，只因问法不同，可能显得出色，也可能显得毫无用处。

深入学习

聊天机器人

原文名称 · Chatbot

可以用日常语言对话的程序

聊天机器人是指你用平常的句子打字或说话，而不是点按钮来使用的程序。早年的聊天机器人只会照固定脚本走，稍一偏题就卡住；如今的多半是在对话窗口背后接了一个语言模型。本站的 Lyen 就是一个，和所有聊天机器人一样，它是按规则运行的软件，不是人。

深入学习

MCP

把人工智能接到工具和资料上的通用接口

MCP 是 Model Context Protocol 的缩写，指人工智能助手伸手到自身之外时所用的一套约定：读取文件、查询数据库、调用别的服务。在它出现之前，每个工具都要单独接线。可以把它当作人工智能助手的 USB 接口——形状统一，按它做的东西插上就能用。智能体就是 MCP 客户端，把自己的功能提供给智能体使用的程序就是 MCP 服务器——例如 WebMCP，就是网站通过网页浏览器把自己的功能提供给智能体使用。

深入学习

MCP 服务器(MCP server)

通过 MCP 向 AI 应用提供工具和数据的程序

MCP 服务器是通过 MCP 提供自己能做的事——可调用的工具、可读取的数据、预先写好的提示词——的程序。任何支持 MCP 的应用都能连接它：Claude Code、Codex、Claude Desktop，或者你自己写的程序。服务器可以在你的电脑上运行，通过标准输入输出通信；也可以在网上运行，通过 HTTP 通信。服务器提供的东西会由智能体执行，所以安装前先读一读它。

深入学习

概率

原文名称 · Probability

用 0 到 1 表示某件事有多可能发生的数

概率表示一件事有多可能发生，0 表示绝不会，1 表示一定会，也常写成百分比。语言模型会给每一个可能出现的下一个词元算出概率，所有概率加起来正好是 1。概率高只说明这个词很符合学到的模式，并不说明这句话是真的。

深入学习

语言模型

原文名称 · Language model

计算下一个词元最可能是什么的程序

语言模型是一种程序：读入一段文本，给每一个可能出现的下一个词元算出概率。它写东西的方式是选出一个词元，接到文本末尾，然后再算一遍。如今的大语言模型（LLM）是用海量文本训练出来的神经网络，但语言模型也可以很小 —— 本站的二元模型只是一张词频统计表，也算语言模型。

深入学习

采样

原文名称 · Sampling

按概率加权随机抽出下一个词元

语言模型写字时，会给每一个可能的下一个词元一个概率。采样就是按这些概率随机抽一个，概率越高越容易被抽中，而不是每次都拿第一名。所以同一个问题可能得到不同的回答 —— 采样也可能恰好重复同一个回答。温度、top-k 和 top-p 会改变抽取的方式。

深入学习

贪心解码

原文名称 · Greedy decoding

每一步都只选概率最高的那个词元

贪心解码不做随机抽取：每一步都直接拿概率最高的候选。于是同样的输入每次都得到同样的结果，适合查事实和写代码，但读起来可能平淡、爱重复。每一步都选第一名，并不保证整句话是最好的，也不能让答案变成真的。

深入学习

二元模型

原文名称 · Bigram

统计相邻两个词，用来预测下一个词

二元组（bigram）是并排出现的两个词。二元模型统计训练句子里每个词后面跟着哪个词、跟了几次，再把次数换算成概率。它只看紧挨着的前一个词，所以只是教学用的小玩具，不是现代神经网络语言模型的工作方式。你可以在“打造人工智能”页面亲手做一个。

深入学习

下一个词元预测

原文名称 · Next-token prediction

一次又一次地猜下一个词元是什么，从而写出文字。

语言模型生成文字的基本方式。根据目前的上下文，它为每一个可能的下一个词元计算概率，选出一个接在末尾，再用变长的上下文重复这个过程，直到回答结束。

深入学习

概率分布

原文名称 · Probability distribution

列出所有可能的结果，以及每个结果有多大可能，加起来是100%。

概率分布给每一个可能的结果一个概率，让它们加起来等于1（100%）。语言模型会为下一个词元在整个词表上生成一个概率分布，然后由贪心解码或采样从中选出一个。

深入学习

自回归

原文名称 · Autoregressive

一次生成一个词元，再把它当作输入接着生成

自回归模型一次只写一个词元。每个新词元都接到文本末尾，到目前为止的整段文本又成为选择下一个词元的输入。正因为这样循环，回答才会一个字一个字地冒出来；也正因为这样，前面一个错的词元会把后面的内容整个带偏。

深入学习

上下文

原文名称 · Context

为了一次回答交给模型的全部文本

上下文是模型为一次回答收到的全部内容：系统提示词、到目前为止的对话、附加的文件，以及应用加进去的搜索结果。模型的权重始终不变 —— 回答不同，是因为上下文不同。放什么进去由应用决定，没放进去的东西，模型就根本用不上。能放多少，受上下文窗口的限制。

详细了解权重和参数

推理模式

原文名称 · Reasoning mode

回答前先多花一些计算的设置

在推理模式下，模型会先生成中间步骤 —— 演算、检查、换条路试试 —— 然后才给出最终答案。这对数学、代码和多步骤的问题常常有帮助，但会用掉更多词元、花更长时间，而且仍然不保证答案正确。屏幕上显示的“思考中…”只是产品的界面，并不能证明它像人一样在思考。

深入学习

分词器

原文名称 · Tokenizer

把文本切成词元并编上号的工具

分词器把文本切成词元，再把每个词元换成它自己词表里的 ID 号。词元可以是整个词、词的一部分、单个字符或字节，空格和标点也算。每个模型系列都有自己的分词器，所以同一句话可能被切成不同数量的词元。人工智能实验室用的是教学用的简单分词，不是真正的 LLM 分词器。

深入学习

注意力

原文名称 · Attention

模型把其他词元的信息混合进来的方式

注意力是 Transformer 内部的一个步骤：每个词元给上下文中其他每个词元打分，分数决定各自的信息要混入多少。句子里的“它”就是这样和它指代的名词连起来的。在生成文本的模型里，注意力是因果的：一个词元只能用前面的位置，绝不能用还没写出来的词。

深入学习

softmax

原文名称 · Softmax

把原始分数（logit）变成加起来为 1 的概率

每一步，模型都会给词表里的每个词元一个原始分数，叫作 logit。softmax 把这串分数变成 0 到 1 之间、加起来等于 1 的概率，而且顺序不变：分数最高的，概率也最高。在 softmax 之前，分数会先除以温度，结果因此变得更尖锐或更平坦。

深入学习

top-k 与 top-p

原文名称 · Top-k and top-p

限定采样只能从哪些候选里抽

在采样之前，这两个设置会先剔除不太可能的候选。top-k 只保留概率最高的 k 个词元。top-p 从最高的开始依次保留，直到概率加起来至少达到 p 为止，所以每一步保留的数量都可能不同。两者都能让奇怪的词更少出现，但都不会核实事实。

深入学习

梯度下降

原文名称 · Gradient descent

朝着让损失变小的方向，一点点调整权重

梯度下降是大多数模型学习的方式。做完一轮预测后，它会计算梯度：每个权重该往哪个方向、以多大力度移动，损失才会变小。然后每个权重都朝那个方向迈一小步，步子的大小由学习率决定。这样重复很多次，权重就会接近与数据相符的值 —— 在“亲手开发人工智能”页面，w 会从 0 变到大约 2。

深入学习 详细了解权重和参数

学习率

原文名称 · Learning rate

每次更新时权重迈出的步子有多大

在梯度下降里，学习率会乘到每一次修正上。太小，训练慢得像爬；太大，权重会来回乱跳甚至发散，而不是稳定下来。这个值不是模型自己学出来的 —— 它是由人来选、来试的超参数。“亲手开发人工智能”页面用的是 0.01，“输入 × w + b”的任务用 0.05。

深入学习 详细了解权重和参数

损失

原文名称 · Loss

表示预测错得有多离谱的一个数

损失衡量模型的预测和正确答案之间的差距，并把它归结成一个数。训练就是修改权重，让这个数变小。计算它的公式叫损失函数：“亲手开发人工智能”页面用的是误差平方的平均值，别的任务会用别的公式。只在训练数据上损失低，并不能证明模型在新数据上也好用。

深入学习 详细了解权重和参数

训练数据

原文名称 · Training data

模型用来学出权重的示例

训练数据是训练时给模型看的一批示例 —— 对语言模型是句子，对图像分类器是贴好标签的照片，对小型回归是“输入–答案”对。模型只能学到这些数据里有的模式，连同其中的错误和空缺也会一起学。专门留出来做检查的数据（验证数据和测试数据）不能拿来训练。

详细了解权重和参数

评估指标

原文名称 · Evaluation metric

衡量模型在没见过的数据上表现如何的分数

评估就是衡量训练好的模型表现得怎么样，要用它没学过的数据，再加上一个指标 —— 一种固定的打分方法。准确率，也就是答对的比例，是最简单的指标；别的指标会分别统计不同种类的错误。在一份测试集上分数好，只是证据，不是证明：错的答案也要看，测试数据也不能拿去训练。

分类模型

原文名称 · Classification

预测某样东西属于哪一类

分类是一种任务，答案是事先定好的几个类别之一：是不是垃圾邮件、是三种鸢尾花中的哪一种、图片里是哪个数字。模型给每个类别打一个分，再选分数最高的那个（argmax）。答案只有两种叫二分类，三种以上叫多分类。如果答案是一个连续的数，那就是回归。

深入学习

回归

原文名称 · Regression

预测连续尺度上的一个数

回归是一种任务，答案是一个数而不是类别：房价、明天的降雨量（毫米）、“输入 × 2”的结果。打分看模型给出的数离真实值有多远，常用误差平方。“亲手开发人工智能”页面里的小程序就是回归；判断一朵花是哪种鸢尾花，则是分类。

深入学习

过拟合

原文名称 · Overfitting

把训练数据记得太死，换了新数据就出错

模型学到的是训练数据里的怪癖和噪声，而不是普遍的规律，这就是过拟合。它在训练过的示例上分数很高，在新示例上却明显变差。把训练分数和留出的验证数据或测试数据上的分数对比，就能发现它；更多数据、更简单的模型或更早停止训练都可能有帮助。

深入学习

超参数

原文名称 · Hyperparameter

训练前由人选定、不靠学习得到的设置

超参数是训练开始前由人选定的设置：学习率、训练多少轮、层数、近邻数 k、树的深度。训练不会改变它们 —— 训练改变的是参数（权重）。好的取值要多试几个，在验证数据上比较着选，绝不能用最终的测试数据来选。

深入学习 详细了解权重和参数

验证数据

原文名称 · Validation data

留出来挑选设置的数据，和测试集分开

数据通常分成三份：用来学习的训练数据，用来比较超参数等设置的验证数据，以及最后只用一次、给出最终分数的测试数据。交叉验证把训练数据分成几份，轮流留出其中一份来检查，数据少的时候比较结果更稳定。一边盯着测试分数一边调参，会让那个分数看起来比实际更好。

深入学习

激活函数

原文名称 · Activation function

神经元把输入加起来之后要套用的函数

神经网络里的一个神经元先把输入合成 z = w·x + b，再让 z 通过激活函数。sigmoid 把任何数压到 0 到 1 之间；ReLU 把负数变成 0，正数保持不变。如果没有这种“不是直线”的一步，叠再多层也只等于一次直线计算，网络就学不会弯曲的规律。

深入学习

运行器（推理引擎）

原文名称 · Runner (inference engine)

加载模型并让它写出文字的程序

训练好的模型只是一个装满数字的文件。运行器加载这些数字，把你的文字变成词元，运行模型给下一个词元打分，选出一个，再重复，一边生成一边把文字显示出来。Ollama 和 llama.cpp 就是可以在自己电脑上用的运行器。

深入学习

KV 缓存

原文名称 · KV cache

存下注意力的中间结果，不必重算前面的词元

在注意力里，每个词元都会产生一个键（key）和一个值（value）。自回归生成时，前面的词元不会再变，所以把它们的键和值留在内存里 —— 这就是 KV 缓存 —— 每生成一个新词元都直接复用，而不是重新计算。这样生成会快很多，但缓存会随上下文变长而变大，可能占用大量 GPU 内存。

深入学习 详细了解权重和参数

工具调用

原文名称 · Tool call

模型写出结构化请求，让应用去运行工具

模型只能生成文本，自己没法做事。在工具调用里，它输出一段结构化的请求 —— 工具的名字和参数，通常是 JSON —— 应用检查这段请求，必要时先征求许可，再去运行工具。结果会作为新的上下文送回模型。把这个循环一再重复，就是人们说的智能体。

深入学习

多模态

原文名称 · Multimodal

能处理不止一种数据，比如文字和图片

多模态模型能接收或生成不止一种数据 —— 文字、图片、音频或视频。例如，模型可以收下一张照片，再用文字回答关于它的问题。每一种输入都会先变成模型能计算的数字。看起来是多模态的功能，不一定都是一个模型完成的：应用可能先用另一个语音识别模型把语音转成文字。

深入学习

氛围编程

原文名称 · Vibe coding

说出你想要什么，让人工智能来写代码

氛围编程就是用平常的话描述你想做的东西 —— 长什么样、怎么运作 —— 让人工智能工具去写代码，然后检查结果、再提修改要求。这是尝试想法、做小型网页应用或游戏的快捷方式。生成的代码仍然要你来测试，因为它可能有错误或安全问题。在 SONUB 的氛围编程页面，Lyen 会做出应用并显示预览。

深入学习

查询、键和值

原文名称 · Query, key and value

注意力用来查找信息的三个向量

在注意力里，每个位置都会用自己的词元生成三个向量。查询（query）说明这个位置在找什么，每个键（key）说明前面某个位置装着什么，值（value）则是那个位置要传出去的信息。模型把查询和每个键比一比，把得分变成加起来等于 1 的权重，再按这些权重把值混合起来。

深入学习

BPE

不断合并最常见的一对来造分词器的方法

BPE（字节对编码）用训练文本来造分词器。它从单个字符或字节开始，找出相邻两块中出现最多的一对，把它合成新的一块，然后一直重复，直到词表够大。常见的词最后变成一个词元，少见的词会被切成好几块，所以任何文本都还能写出来。

深入学习 详细了解 GPT

合并规则

原文名称 · Merge rules

BPE 分词器按顺序合并的字符对清单

BPE 在学习时，会按顺序记下它合并过的每一对。这份清单就是合并规则。给新文本分词时，分词器按同样的顺序套用同样的规则。规则和词表存在一起；如果改了规则，词元编号也会变，模型权重就得重新训练。

深入学习 详细了解权重和参数

对话记录

原文名称 · Chat history

每次提新问题时一起发给模型的之前的消息

语言模型在两次请求之间什么都不保留。聊天应用之所以像是记得，是因为它把之前的消息和新问题一起再发一遍。这份消息列表就是对话记录。它必须放得进模型的上下文长度，所以很长的对话会被截短或概括。没有它，每个问题都会被单独回答。

深入学习

计算图

原文名称 · Computation graph

记下哪一步计算用了哪些数字的记录

模型在算答案时，训练库会把每一步都记下来：哪些数字进了哪次加法或乘法，又得出了什么。这条步骤链就是计算图。反向传播从损失出发沿着它往回走，一步步算出每个数字对结果影响有多大。

深入学习

解码器

原文名称 · Decoder

根据前面的词元写出下一个词元的 Transformer

解码器是一种 Transformer，它只看当前位置之前的词元，并预测下一个。然后把这个词元加上去，再重复一遍，GPT 这类模型就是这样写出文字的。最早的 Transformer 还有一个一次读完整段输入的编码器，但如今大多数聊天模型都只有解码器。

深入学习 详细了解 GPT

扩散模型

原文名称 · Diffusion model

一步步去掉噪点来生成图片的模型

扩散模型从一张全是随机噪点的图开始，按你的文字引导，每一步去掉一点噪点，直到图片显现出来。训练时，它给真实图片加噪点，再学习怎样把噪点去掉。Stable Diffusion 等许多图片和视频生成器都是这样工作的，和一次写一个词元的语言模型不同。

深入学习

encode / decode

把文本变成词元编号，再把编号变回文本

encode 是分词器的一步：把文本切成词元，再把每个词元换成它在词表里的编号。decode 正好相反：查出每个编号对应的那一块，再拼回文本。好的分词器在 encode 之后再 decode，会原样还原文本，这是一个值得跑一跑的简单测试。

深入学习

执行提供程序

原文名称 · Execution provider

让 ONNX Runtime 在某种芯片上运行模型的插件

ONNX Runtime 自己并不会和每种芯片打交道。执行提供程序就是把模型的计算交给某一种硬件的部分，比如 NVIDIA GPU（CUDA 或 TensorRT）、Apple 芯片（Core ML）或普通 CPU。你按顺序列出想用的提供程序，某个提供程序跑不了的部分会交给下一个。

深入学习

FreeToken

在个人电脑上运行超大 MoE 模型的运行时

FreeToken 是 /ai/internals 页面介绍的一个运行时。它专门用来在个人电脑上运行超大的 MoE 模型——这类模型处理每个词元时只用一部分专家。它把 NVIDIA GPU、CPU、内存（RAM）以及它们之间的连接当作一台推理机器来用。

深入学习

梯度裁剪

原文名称 · Gradient clipping

梯度太大时把它缩小

有时一个批次会算出非常大的梯度，一次更新就把权重甩得很远，损失突然跳高或变成 nan。梯度裁剪会量一量整个梯度的大小，如果超过设定的上限，就在更新前把它缩到上限。方向不变，只是步子变短了。

深入学习 详细了解权重和参数

归一化

原文名称 · Normalization

在网络内部重新调整数字的大小，让训练保持稳定

数字穿过很多层时，可能越变越大或越变越小，直到训练出问题。归一化在每一步把它们重新调整。Transformer 用的是层归一化：对每个词元，先把数字平移到平均为 0、分散程度为 1，再乘上并加上两组学来的数，这两组数也是参数。

深入学习 详细了解权重和参数

MLP

一层接一层叠起来的基础神经网络

MLP（多层感知机）让数字依次穿过两层或更多层。每一层都乘上权重、加上偏置，再用 ReLU 或 GELU 这样的激活函数。每个 Transformer 块里都有一个小小的两层 MLP，它分别处理每个词元，在注意力把其他词元的信息混进来之后，再改变这个词元的特征。

深入学习 详细了解 GPT 详细了解权重和参数

动量

原文名称 · Momentum

把上一次更新的一部分带进下一次

普通的 SGD 只按当前的梯度移动权重，所以可能走成之字形。动量会把过去的更新累计起来，每走新的一步都加上其中一部分，于是权重朝着稳定的方向一直滚下去，小小的起伏就不那么要紧了。这个累计值是优化器必须存进检查点的额外状态；普通 SGD 没有这一项。

深入学习 详细了解权重和参数

负对数

原文名称 · Negative log

−log(p)：概率越小，这个数越大

对一个概率取对数，再在前面加个负号，得到的数在概率为 1 时是 0，概率往 0 掉时就迅速变大。训练时用它作为正确词元的损失：很有把握地答对几乎不扣分，很有把握地答错就扣很多。

深入学习

ONNX

AI 模型通用的文件格式

ONNX（Open Neural Network Exchange，开放神经网络交换）是一种开放的模型文件格式。用 PyTorch 或其他框架训练的模型可以导出成 .onnx 文件，然后不需要原来的训练代码，就能由不同的程序在不同设备上运行。它由 Microsoft 和 Facebook 在 2017 年发起。

深入学习

ONNX Runtime

在许多设备上运行 ONNX 模型的引擎

ONNX Runtime 是 Microsoft 的开源引擎，用来运行 .onnx 模型。它能在 Windows、macOS、Linux、手机和浏览器里运行，并通过执行提供程序使用 GPU 等加速硬件。在 SONUB 上，朗读文字的语音模型就由它运行。

深入学习

输出层

原文名称 · Output layer

最后一层：给词表里每个词元打一个分

输出层把某个位置的最后一个向量，变成词表里每个词元各一个分数。接着 Softmax 把这些分数变成下一个词元的概率。因为每个词元都需要一行权重，词表越大，这一层就越大。

深入学习 详细了解权重和参数

3B、7B、8B（参数量）

原文名称 · 3B, 7B, 8B (parameter count)

模型大小：B 是十亿（billion）个参数，不是字节

3B、7B、70B 这样的名字说的是参数的个数：7B 表示大约 70 亿个单独的数。它不是文件大小，也不是向量的个数。占多少内存取决于每个数用几个字节，所以同一个 8B 模型，用 16 位大约 16 GB，用 4 位大约 4 GB，还没算额外开销。

深入学习

缩放因子

原文名称 · Quantization scale

把存下的整数还原成数值的乘数

量化文件把权重存成小整数。用的时候，运行时把每个整数乘上存在旁边的缩放因子。GGUF 这类格式给每一小块权重（比如 32 个数）各存一个缩放因子，所以文件里除了整数，还有这些缩放因子和其他元数据。这就是实际文件比简单估算稍大一些的原因。

深入学习 详细了解权重和参数

残差连接

原文名称 · Residual connection

把一层的输入加回到它的输出上

残差连接把进入一层的东西加到这一层出来的东西上：输出 = 输入 + 层(输入)。原来的信息被保留下来，这一层只需学会要改什么。它还给梯度留了一条穿过很多层的捷径，深层 Transformer 正是因此才训练得起来。

深入学习

RoPE

通过旋转向量告诉注意力词元的位置

RoPE（旋转位置嵌入）给位置信息的方法是：按词元所在的位置，把每个查询向量和键向量旋转一个角度。注意力比较两个词元时，结果就会取决于它们相隔多远。它在 2021 年提出，Llama 等许多开放模型都在用。

深入学习

SGD

按每个小批次的梯度反方向轻推权重

SGD（随机梯度下降）是最简单的训练规则：在一个随机的小批次上算出损失的梯度，然后把每个权重朝梯度的反方向挪一小步，步子大小就是学习率。换下一个批次，再重复。Adam 等优化器在这个想法上加了动量之类的额外状态；普通 SGD 没有需要额外保存的东西。

深入学习 详细了解权重和参数

sherpa-onnx

离线语音识别和语音合成的开源工具包

sherpa-onnx 是 Next-gen Kaldi 团队的开源项目，用 ONNX Runtime 运行语音模型。它不用联网，就能在电脑、手机和小型开发板上把语音变成文字、把文字变成语音。在 SONUB 上，它就是把你的声音变成文字的引擎。

深入学习

SLM

能在普通设备上运行的小型语言模型

SLM（小型语言模型）的工作方式和 LLM 一样，但参数少得多，所以能在笔记本电脑或手机上运行，回答更快，成本也更低。没有固定的分界线；参数在几十亿个以下的模型通常被称为小模型。它们在广泛的知识和长推理上较弱，但很适合范围窄的任务。

深入学习 详细了解权重和参数

语音识别

原文名称 · Speech-to-text

把说出的话变成文字

语音识别（Speech-to-text，STT）把说话的声音变成文字。模型一小段一小段地听声音，写出最可能的词语。这些文字接着可以发给语言模型。一些较新的模型可以直接接收声音，不必先写成文字。

深入学习

TensorRT-LLM

NVIDIA 在自家 GPU 上快速运行 LLM 的库

TensorRT-LLM 是 NVIDIA 的开源库，专门为 NVIDIA GPU 优化大语言模型。它针对具体的那块 GPU 编译模型，并加入把许多请求打包处理、量化等技巧，让服务器能同时回答更多用户。它只面向 NVIDIA 硬件。

深入学习

语音合成

原文名称 · Text-to-speech

把写好的文字变成说话的声音

语音合成（Text-to-speech，TTS）把文字读出来。模型把文字变成声音，并决定发音、节奏和语调。在 SONUB 上，Lyen 的声音就是这样，用 ONNX Runtime 运行的模型生成的。

深入学习

训练步

原文名称 · Training step

训练中对权重的一次更新

一个训练步就是一轮这样的事：取一个批次，让模型前向计算，算出损失，做反向传播，再更新权重。训练日志通常会把步数和损失一起打印出来，你可以看着损失随步数下降。把整个数据集完整过一遍是另一个单位，叫作轮次（epoch）。

深入学习 详细了解权重和参数

vLLM

快速提供 LLM 服务的开源服务器引擎

vLLM 是起源于 UC Berkeley 的开源引擎，用来给许多用户提供语言模型服务。它的 PagedAttention 方法像电脑管理内存那样，把 KV 缓存存成一小页一小页，几乎不浪费 GPU 内存，还能把许多请求合在一起处理。它提供和 OpenAI 形式一样的 API。

深入学习

VLM

也能看图片的语言模型

VLM（视觉语言模型）除了文字还能接收图片，并用文字回答。图像部分把图片变成语言模型能和词元一起读的向量。你可以问它照片里有什么，让它读图表或截图。它写出来的仍然是文字；生成图片是扩散模型等其他模型的工作。

深入学习

注意力头

原文名称 · Attention head

一整套注意力计算

一个注意力头有自己的查询、键和值权重，并算一次注意力。一层通常并排放着好几个头，每个头都能学会找不同的关联，比如前一个词或句子的主语。它们的结果会拼起来再传下去。看一个头在看哪里是有用的线索，但不能完整解释模型。

深入学习 详细了解 GPT 详细了解权重和参数

llama.cpp

在自己电脑上运行语言模型的 C/C++ 程序

llama.cpp 是 Georgi Gerganov 发起的开源程序，用纯 C/C++ 在 CPU 和 GPU（包括 Apple 芯片）上运行语言模型，不需要 Python。它读取 GGUF 文件，还带有转换和量化模型的工具。Ollama 和手机应用等许多其他应用都建立在它上面。

深入学习

模型检查点

原文名称 · Model checkpoint

训练中或训练后保存下来的一份模型权重

检查点是一个文件，保存训练某一刻的权重，常常还有设置、优化器状态和步数。如果训练中断，可以从它接着训练；训练结束时，最后一个检查点就是你要运行的模型。模型检查点和 Claude Code 的检查点不同，后者是用来撤回文件修改的。

深入学习 详细了解 GPT 详细了解权重和参数

位置嵌入

原文名称 · Positional embedding

告诉模型一个词元在文本中位置的向量

注意力本身不知道词元的顺序，所以“dog bites man”和“man bites dog”看起来会一样。位置嵌入给词元自己的向量加上一个代表位置的向量。GPT-2 给每个位置学一个向量，最多 1,024 个位置；其他模型用 RoPE 等不同方法。

深入学习 详细了解 GPT

Transformer 块

原文名称 · Transformer block

Transformer 里反复出现的一层：注意力加一个 MLP

Transformer 块是一遍又一遍叠起来的那个单元。块里面，注意力先在词元之间混合信息，接着一个小 MLP 改变每个词元的特征，两者周围还有归一化和残差相加。GPT-2 small 叠了 12 个一模一样的块；更大的模型叠得更多，每一块也更宽。

深入学习 详细了解 GPT

反向传播

原文名称 · Backpropagation

把误差往回追，求出每个权重的梯度

前向计算得出损失之后，反向传播沿着计算图往回走，用链式法则求出损失对每个权重的梯度：也就是这个权重稍微变一点，损失会变多少。梯度下降再用这些梯度去更新权重。在 PyTorch 里，调用一次 loss.backward() 就能完成。

深入学习 详细了解权重和参数

PyTorch

最主流的 Python 神经网络库

PyTorch 是 Python 的开源深度学习库，最早由 Meta（当时叫 Facebook）发布，现在由 Linux 基金会旗下的 PyTorch 基金会管理。它提供能放在 GPU 上的张量和自动求导，所以 loss.backward() 会替你算出所有梯度。导入时写作 torch。

深入学习

GPT

预测下一个词元的 Transformer 语言模型

GPT 是 Generative Pre-trained Transformer（生成式预训练 Transformer）的缩写。它是只有解码器的 Transformer，在大量文本上训练来预测下一个词元，然后一次一个词元地写出文字。OpenAI 用这个名字给自己的模型命名，从 2018 年的 GPT-1 到如今 ChatGPT 背后的 GPT 模型，很多其他模型也采用同样的设计。

深入学习

词表

原文名称 · Vocabulary

分词器认识的词元清单，每个都有一个 ID

分词器的词表是它能切出的所有小块组成的固定清单，每一块都有一个编号（ID）。模型给词表里每一项准备一行嵌入和一个输出分数，所以词表的大小决定了模型的形状。模型只能和训练时用的那份词表一起工作：换成别的词表，编号的意思就全变了。

深入学习 详细了解 GPT

交叉熵

原文名称 · Cross-entropy

常用的下一个词元损失：正确词元概率的 −log

交叉熵损失只看模型给正确答案的概率，并取它的负对数。如果正确词元的概率是 1，损失就是 0；这个概率越低，损失越大。在许多词元上取平均，就是语言模型训练想要压低的那个数。损失低说明在这些数据上猜得准，不代表文字内容是真的。

深入学习

导数

原文名称 · Derivative

输入稍微变一点时，输出会变多少

导数衡量一个值在另一个值变动一点点时变得有多快。训练中，损失对某个权重的导数说明这个权重该往哪个方向、用多大力气去调。梯度就是所有权重的导数放在一起。你不用亲手去算：库会自动算好。

深入学习 详细了解权重和参数

Dropout

训练时随机关掉网络的一部分

Dropout 在每个训练步都把一层输出中随机的一部分（比如 10%）设为零。这样网络就没法只依赖某一个单元，有助于防止过拟合。推理时会关掉 Dropout，所有单元都用上。比例设得太高，训练会变慢，模型也会变弱。

深入学习

前向传播

原文名称 · Forward pass

让输入依次穿过每一层，一直到输出

前向传播就是模型做它平常的计算：输入按顺序穿过每一层，最后变成分数或预测。训练时，用这个输出算出损失，然后反向传播朝相反的方向走。推理时只需要前向传播。

深入学习

随机种子

原文名称 · Random seed

让“随机”结果可以重现的起始数字

电脑用一个叫作种子的起始值来产生随机数。种子相同，产生的数列就相同，所以训练、打乱数据或采样都能为了核对而原样重来。种子只能让一次运行可以重现，并不能让答案变正确。某些 GPU 运算在不同次运行之间仍可能有细微差别。

深入学习

OCR

读出图片或扫描页里的文字

OCR（光学字符识别）把图片里的文字，比如照片或扫描的 PDF，变成电脑可以搜索和复制的真正文字。扫描的 PDF 在 OCR 读过之前只是一页页的图片。结果可能有错，手写字或模糊的图片尤其如此，所以重要的文字要核对一下。

深入学习

Adam

广泛使用、会为每个权重调整步子的优化器

Adam 是 2014 年发表的优化器，如今训练包括 Transformer 在内的大多数神经网络时都默认用它。它为每个权重记着最近梯度的移动平均（类似动量），以及梯度大小的移动平均，并用它们为这个权重选合适的步子。它通常比普通 SGD 训练得更快、更平稳，代价是要存下这些额外的状态。

深入学习 详细了解权重和参数

适配器

原文名称 · Adapter

在冻结的模型上额外训练的一小组权重

微调时不必改动模型的全部权重，可以把它们冻结，另外训练一个加在旁边的小适配器。LoRA 是最有名的一种：它学两个很窄的矩阵，用它们的乘积来调整一个权重矩阵。适配器文件比模型小得多，同一个基础模型可以为不同任务留着好几个适配器。

深入学习 详细了解权重和参数

智能体记忆

原文名称 · Agent memory

智能体保存并重新载入的、关于之前工作和规则的内容

语言模型在两次会话之间会忘掉一切。智能体记忆是 Harness 中的一部分，它把有用的事实、规则和进度记下来（通常写在文件里），下次再载入上下文。比如 Claude Code 在每次会话开始时会读 CLAUDE.md 和它的自动记忆。这种记忆是文件里的文字，不是电脑的内存（RAM）。

深入学习

智能体式系统

原文名称 · Agentic system

把语言模型和工具连起来去完成工作

智能体式系统指任何把语言模型和工具、文件、循环连在一起，让它能执行任务、而不只是回答一次的设置。Anthropic 用这个词同时指两种情况：由代码决定步骤的固定工作流，以及由模型自己决定步骤的智能体。讨论这类系统怎么设计时会用到这个说法。

深入学习

argmax

最大值所在的位置，而不是那个值本身

max 返回一串数里最大的那个数；argmax 返回它在哪里。分类器用 argmax 挑出分数最高的类别，贪心解码用它挑出最可能的下一个词元。位置通常从 0 开始数。

深入学习

基准模型

原文名称 · Baseline model

定下“要超过的分数”的非常简单的模型

相信一个聪明的模型之前，先把它和简单的基准比一比，比如总是猜最常见的类别，或者用平均值。如果你的模型只比基准好一点点，说明它几乎没学到什么。把基准和分数并排报告，才能看出这个数字真正的意思。

深入学习

批次（batch）

原文名称 · Batch

在一步里一起处理的一组样本

训练时不会一次只看一个样本。它取一个批次，比如 12 段文本，一起算出损失，然后做一次更新。批次越大，GPU 用得越充分，但需要更多内存；如果训练时内存不够，首先要试的就是调小批次大小。

深入学习 详细了解 GPT

块大小

原文名称 · Block size

模型一次读多少个词元——也就是它的上下文长度

在 nanoGPT 这类代码里，块大小是一个训练样本里最多的词元数，也是模型能用的最长上下文。注意力需要的内存会随它迅速增长，所以训练内存不够时，常见的办法就是调小块大小。模型看不到比块大小更远的地方。

深入学习 详细了解 GPT

BM25

按相同词语给结果排序的经典搜索公式

BM25 按文档和搜索词共有的词来打分。少见的词比常见的词更重要，同一个词重复得越多，加分越少（饱和），长文档也会被调整，不会只因为长就胜出。它速度快，擅长准确的名字和代码；嵌入检索更擅长找用不同词表达的同一个意思，很多系统两者都用。

深入学习

概率校准

原文名称 · Calibration

模型给的分数是否和它真正答对的频率一致

如果模型的分数可以当作真实的概率来读，就说它校准得好：在它打了 0.8 分的所有答案里，大约 80% 是对的。很多模型输出 0 到 1 之间、看起来像百分比的数，其实并没有校准，所以在把分数当作概率之前，先用留出的数据检查一下。

深入学习

因果掩码

原文名称 · Causal mask

遮住后面的词元，让注意力只能往前看

训练时模型一次看到整句话，但它预测每个词元时只能用前面的词元。因果掩码在 softmax 之前把这些分数设成负无穷，挡住每个位置去关注它后面的位置。没有它，模型会从“未来”抄答案，什么有用的东西都学不到。

深入学习

字符级模型

原文名称 · Character-level model

以单个字符为词元的语言模型

字符级模型把每个字母、空格和标点都当作一个词元，所以词表很小，也不用学分词器。它很适合练手，比如 nanoGPT 的莎士比亚例子，但每句话需要的步数比用词片词元的模型多得多。它的权重只配得上它自己的字符词表，不能换到需要 GPT-2 词元的运行程序里。

深入学习 详细了解 GPT 详细了解权重和参数

聊天模板

原文名称 · Chat template

聊天模型要求的消息的准确格式

聊天模型是用一种固定格式写的对话训练出来的，用特殊词元标出 system、user 和 assistant 各部分从哪里开始、到哪里结束。聊天模板把你的消息列表变成这种文本。Ollama、llama.cpp 这类运行程序会从模型文件里读出它。模板不对，模型可能会东拉西扯、重复自己或者回答得很奇怪。

深入学习

保存的指令

原文名称 · Saved instructions

ChatGPT 套用到每个新对话的偏好设置

在 ChatGPT 的设置里，你可以保存关于自己和希望怎样回答的指令，比如“我是初学者，请用短句”。ChatGPT 会把它们加到每个新对话里，你就不必每次重复。它们终究只是指令：能引导回答，但不能保证结果，也不要把秘密写进去。

深入学习 详细了解 GPT

闭源模型

原文名称 · Closed model

只能通过公司的应用或 API 使用的模型

闭源模型不公开权重。你通过公司的应用或 API 来用它，价格、限制以及旧版本什么时候下线都由公司决定。Claude、Gemini 和 ChatGPT 背后的 GPT 模型都是闭源模型。它们往往最强，但你的数据会传到公司的服务器上。

深入学习 详细了解 GPT 详细了解权重和参数

完成短语

原文名称 · Completion promise

只有工作真正完成时，智能体才能说出的一句话

在 Ralph Loop 里，你要选一个完成短语，比如 DONE 这样的短词。循环会一直进行，直到智能体准确写出这句话，而提示词会告诉智能体只有真的完成时才能写。它要和最多轮数、预算一起用，因为智能体可能永远到不了终点，所以之后还要自己检查工作。

深入学习

上下文管理

原文名称 · Context management

决定把什么放进模型有限的上下文

模型一次能读的内容有限。上下文管理是 Harness 的工作：决定放进什么——哪些文件、哪些之前的消息、哪些工具结果——以及对话变长时要概括或丢掉什么。好的上下文管理让重要的事实留在视野里、把杂音挡在外面，任务越长，这一点越重要。

深入学习

Core ML

在 iPhone、iPad 和 Mac 上运行模型的 Apple 框架

Core ML 是 Apple 内置的框架，用来在 Apple 设备的应用里运行机器学习模型。它能用 CPU、GPU 和神经网络引擎（Neural Engine）芯片，在设备上运行，不用把数据发到服务器。PyTorch 等工具做出的模型要先转换成 Core ML 格式，比如用 Apple 的 coremltools。

深入学习

累积概率

原文名称 · Cumulative probability

从最大的开始往下一直相加的概率总和

把候选从最可能到最不可能排好，再把它们的概率一个个加起来：这个不断累加的总和就是累积概率。Top-p 采样就用它：p = 0.9 时，它留下总和达到 90% 的最小一组候选，只从这些里抽，所以候选的个数会随模型的把握程度而变化。

深入学习

决策树

原文名称 · Decision tree

连续问是或否的问题来分类的模型

决策树会学出一串关于特征的问题，比如“花瓣长度 < 2.5 cm？”，每个回答通向下一个问题，直到一片叶子给出类别。它很容易看懂。如果不限制深度任它生长，它能把训练数据背得一字不差，在新数据上反而更差，这就是过拟合。

深入学习

嵌入模型

原文名称 · Embedding model

把文本变成向量、按意思来搜索的模型

嵌入模型不写文字。它读一个句子或一篇文档，输出一个向量，让意思相近的文本得到方向相近的向量。搜索、推荐和 RAG 系统用这些向量来找相关的文本。小型的嵌入模型甚至能在手机上运行，用来搜索你自己的笔记。

深入学习

嵌入检索

原文名称 · Embedding search

按意思向量的远近找文本，而不是按相同的词

嵌入检索用同一个嵌入模型把问题和每篇文档都变成向量，返回向量最接近的文档，常常用余弦相似度来衡量。你搜“修我的汽车”，它也能找到“车辆维修”，这是按词匹配会漏掉的。向量接近表示意思相关，不代表文档是真的，也不代表它回答了问题。

深入学习

嵌入空间

原文名称 · Embedding space

嵌入向量所在的多维空间

每个嵌入向量都是一个几百维空间里的点。在这个空间里，模型认为相似的东西会挨在一起。距离只在同一个模型的向量之间才有意义：两个不同的嵌入模型构建的是不同的空间，它们的向量不能拿来比。

深入学习

前馈层

原文名称 · Feed-forward layer

Transformer 块里单独处理每个词元的部分

注意力在词元之间混合信息之后，前馈层用同一个小网络分别处理每个词元的向量：通常是一个更宽的层、一个 GELU 这样的激活函数，再加一个回到原来宽度的层。它就是块里的 MLP，在大模型里，大部分参数都在这里。

深入学习 详细了解 GPT 详细了解权重和参数

GELU

许多 Transformer 使用的平滑激活函数

GELU（Gaussian Error Linear Unit，高斯误差线性单元）是和 ReLU 类似的激活函数，只是在零点处是一个平滑的弯，而不是尖角：很大的正数几乎原样通过，很大的负数几乎变成 0，靠近零的值会被轻轻压小。GPT-2 和 BERT 的前馈层都用它。

深入学习 详细了解 GPT

泛化

原文名称 · Generalization

在从没见过的新数据上也表现好

训练的目的不是在训练样本上拿高分，而是在新样本上也表现好。这种能力就叫泛化。要用训练时留出来的数据来衡量它。一个在训练数据上完美、在新数据上很差的模型，是在死记硬背而不是泛化，这就是过拟合。

深入学习

GPT-2

OpenAI 2019 年的 Transformer 模型，学习用的经典

GPT-2 是 OpenAI 在 2019 年发布的只有解码器的 Transformer 语言模型，大小从 1.24 亿到 15 亿个参数不等。它的设计——词元嵌入和位置嵌入、叠起来的 Transformer 块、覆盖 50,257 个词元词表的输出层——简单而且文档齐全，所以 nanoGPT 等项目会重新实现它，来讲解 LLM 是怎样工作的。

深入学习 详细了解 GPT 详细了解权重和参数

任务交接

原文名称 · Handoff

一个智能体把任务连同上下文交给另一个智能体

任务交接时，一个智能体把剩下的任务交给更合适的另一个智能体，同时交出对方需要知道的信息。Harness 决定带过去多少上下文、由哪个模型接手、结果怎样传回来。上下文太少，下一个智能体会重复做；太多，它又会迷失。

深入学习

隐藏层

原文名称 · Hidden layer

网络输入和输出之间的层

隐藏层位于输入和输出层之间。它接收数字，乘上权重，套用激活函数，再把新的数字传下去，构建出在输入和答案里都看不见的特征。深度学习的意思就是有很多隐藏层。

深入学习 详细了解权重和参数

Imagen

Google 早期的文生图模型系列

Imagen 是 Google 把文字描述变成图片的一系列模型。截至 2026 年 10 月，SONUB 的课程提到，Gemini API 里较早的 Imagen 模型已经退役，Google 在那里的图片生成和编辑改由 Nano Banana 模型提供。

深入学习

遵从指令

原文名称 · Instruction following

模型照着吩咐去做的忠实程度

遵从指令指模型多好地服从提示词或系统提示词里的指令：格式、长度、语言、不准做的事。各个模型在这方面差别很大，也会专门被测试。即使是很强的模型也会跑偏，所以应用不能只靠指令来保证安全；权限这类真正的限制必须由代码来执行。

深入学习

k 近邻（k-NN）

原文名称 · k-nearest neighbours (k-NN)

按最相似的 k 个训练样本来分类

k-NN 几乎不用训练：它把所有训练样本都留着。要给一个新样本分类时，它找出最近的 k 个样本，取其中最多的类别。近邻数 k 是在训练之外由你选的超参数：k 太小会跟着噪声走，k 太大会把差别抹平。

深入学习

LangChain

构建 LLM 应用和智能体的开源框架

LangChain 是一个开源框架，有 Python 和 JavaScript 两个版本，用来在语言模型之上构建应用：把模型和工具、文档、记忆以及其他模型连起来。配套的 LangGraph 用来构建步骤明确的智能体。LangChain 把 Harness 描述为模型周围的一切，SONUB 的课程引用了这个说法。

深入学习

LiteRT

Google 在手机和小型设备上运行模型的运行时

LiteRT 是 Google 的端侧机器学习运行时，是 TensorFlow Lite 从 2024 年起的新名字。它在 Android、iOS、网页和小型开发板上运行模型，有条件时会用手机的 GPU 或其他加速硬件，不用把数据发到服务器。

深入学习

llama.rn

把 llama.cpp 放进 React Native 应用的库

llama.rn 是一个开源的 React Native 库，它包装了 llama.cpp，让用 React Native 写的手机应用能载入 GGUF 模型，在设备上生成文字，不需要服务器。PocketPal AI 就是这样做出来的应用。Flutter 应用做同样的事时，用的是其他 llama.cpp 绑定。

深入学习

主智能体

原文名称 · Main agent

和你对话、把部分工作交给子智能体的那个智能体

主智能体就是你对话里的那一个。遇到某一部分工作，比如搜索整个项目，它可以启动一个子智能体，给它全新的上下文和更少的工具，然后只收回总结。这样主智能体的上下文就能保持干净。最终答案仍由主智能体负责。

深入学习

最多轮数

原文名称 · Maximum number of rounds

一个循环最多能跑几次的上限

智能体循环可能永远靠自己到不了终点，而每一轮都要花词元和钱。最多轮数是一个硬性的刹车：跑满这么多轮，不管怎样循环都会结束。每次都要设好它，再配上一个可以检查的终点和词元预算。

深入学习

MCP 主机

原文名称 · MCP host

人使用的 AI 应用，里面装着 MCP 客户端

MCP 里有三种角色。主机（Host）是人使用的 AI 应用，比如 Claude Code、Claude Desktop 或代码编辑器。在主机里面，每个服务器各有一个客户端负责保持连接，每个服务器提供工具和数据。主机决定启动哪些服务器，并且应该在使用工具之前先问用户。

深入学习

initialize

第一个 MCP 请求，用来商定版本（2025-11-25 及更早的规范）

在 2025-11-25 及更早的 MCP 规范中，每个会话都从 initialize 开始。客户端发出它会说的协议版本和它能做的事；服务器回复它要用的版本、它提供的东西（比如工具）以及它的名字。接着客户端发出 notifications/initialized 通知，之后才能用 tools/list 和 tools/call。最新规范（2026-07-28）去掉了这次握手：每个请求都在 _meta 里带上版本。

深入学习

tools/call

请服务器运行它的某个工具的 MCP 请求

tools/call 指明一个工具并给出它的参数。服务器运行这个工具，回复结果（通常是文本内容）或者错误。用哪个工具由模型决定，但请求由主机应用发出，运行任何有风险的操作之前，主机应用都应该先问用户。

深入学习

tools/list

问服务器有哪些工具的 MCP 请求

tools/list 问一个 MCP 服务器能做什么。服务器返回每个工具的名字、一段说明（模型读它来决定什么时候用这个工具），以及描述参数的输入 schema。因为模型会相信这些说明，所以只连接你信任的服务器。

深入学习

Nano Banana

Google 的 Gemini 图片生成和编辑模型

Nano Banana 是 Google 给那些根据文字生成和编辑图片的 Gemini 模型起的通俗名字。你可以描述一张新图片，也可以上传一张图片要求修改，比如换个背景，同时保持同一个人或物体不变。在 Gemini 应用里和通过 Gemini API 都能使用。

深入学习

nanochat

Karpathy 做小型聊天 LLM 的全流程项目

nanochat 是 Andrej Karpathy 在 2025 年发布的开源项目，是 nanoGPT 的后继者。它在一个小小的代码库里覆盖了整条流程：训练分词器、预训练、为聊天做微调、评估，以及一个和结果对话的网页。它是为了让人学习类似 ChatGPT 的模型从头到尾是怎样做出来的。

深入学习 详细了解 GPT

nanoGPT

训练 GPT-2 风格模型的简短 PyTorch 代码

nanoGPT 是 Andrej Karpathy 的开源代码，用几百行 PyTorch 来训练和微调 GPT 风格的模型。它能在大 GPU 上复现 GPT-2，也能在笔记本电脑的 CPU 上几分钟训练出一个很小的字符级莎士比亚模型。作者现在把它标为旧项目并推荐 nanochat，但它仍是看清 GPT-2 风格模型的好办法。

深入学习 详细了解 GPT

Ollama

在你的电脑上下载并运行开放模型的应用

Ollama 是 macOS、Windows 和 Linux 上的免费运行程序。一条命令就能下载一个开放模型并开始和它聊天，Ollama 还会提供一个本地 API，让你自己的程序调用。它替你处理量化后的模型文件和聊天模板，所以是离线运行模型最容易的第一步。

深入学习

开放模型

原文名称 · Open model

可以下载权重、自己运行的模型

开放模型会公开权重，所以你可以下载它，在自己的电脑或服务器上运行，往往免费，也不用把数据发出去。很多是开放权重而不是完全开源：权重是公开的，但训练数据和代码不一定公开，许可证也可能有限制。Llama、Gemma 和 Qwen 都是例子。

深入学习

优化器

原文名称 · Optimizer

把梯度变成权重更新的规则

反向传播告诉你每个权重的梯度；优化器决定怎样用它来改变权重。普通 SGD 朝梯度的反方向走固定的一步。Adam 等优化器还会记住过去的梯度，以选出更好的步子。优化器的状态会存进检查点，这样训练才能接着进行。

深入学习 详细了解权重和参数

PocketPal AI

离线和小模型聊天的免费手机应用

PocketPal AI 是 iPhone 和 Android 上的开源应用，它下载 GGUF 格式的小型语言模型并在手机上运行，让你不联网也能聊天。它基于 llama.cpp 之上的 llama.rn 构建。手机内存小，所以最适合用小而且量化得比较狠的模型。

深入学习

模型后训练

原文名称 · Post-training

在预训练之后进行、教会特定行为的训练

预训练用海量数据教模型把文字接着写下去。后训练在这之后进行：用示例对话做微调，从人类或自动化的反馈中学习，练习使用工具这类任务。原始的文字预测器正是在这里变成有用的助手，编程智能体也是在这里学会和自己的 Harness 配合好。

深入学习

Q4_K_M

GGUF 文件常用的 4 位量化类型

Q4_K_M 是 llama.cpp 的“k-quant”类型之一。它把大部分权重存成大约 4 位，把一些更敏感的部分用更多位来存（M 表示 medium，中等），并把权重分成共享缩放因子的块。它在文件大小和质量之间取得了受欢迎的平衡，大小约为 FP16 的 30%。

深入学习 详细了解权重和参数

推荐系统

原文名称 · Recommender system

预测你会喜欢什么并推荐给你的 AI

推荐系统根据一个人以及和他相似的人以前做过的事，预测他可能想要哪些视频、歌曲或商品，并把它们排在前面。它是用得最广的 AI 之一，尽管它不聊天也不写文字。它很好地提醒我们：AI 远不止 ChatGPT。

深入学习 详细了解 GPT

回归系数

原文名称 · Regression coefficient

回归模型给每个输入乘上的、学来的数

线性回归用这样的公式来预测：价格 = a × 面积 + b。a 和 b 这两个数是在训练时从数据中找出来的：它们就是系数，也是参数，和树的深度这类你自己选的设置不同。系数表示这个输入增加 1 时，预测会变动多少。

深入学习 详细了解权重和参数

基于规则的系统

原文名称 · Rule-based system

只按人写好的规则做决定的程序

基于规则的系统按人写的“如果……就……”规则行事，比如“如果标题里有‘白送的钱’，就标为垃圾邮件”。它不从数据中学习，所以容易解释，但遇到没人想到的情况就会出错。机器学习则是从例子中找出规则。两者都算 AI。

深入学习

相似度

原文名称 · Similarity

表示两个向量或文本有多像的数

相似度衡量两个向量有多接近。最常用的余弦相似度比较它们的方向：1 表示方向相同，0 表示无关，−1 表示相反。嵌入检索按它给文档排序。相似度高表示意思相关，不代表两句话说的是同一个真实的事情。

深入学习

fit

原文名称 · scikit-learn fit

scikit-learn 中用数据训练模型的方法

在 scikit-learn 里，每个模型都用同样的方式训练：model.fit(X, y) 从输入 X 和答案 y 中学习。之后 model.predict(X_new) 给出预测。只在训练部分上 fit，把测试部分留到最后，否则分数会看起来比实际好。

深入学习

结束条件

原文名称 · Stop condition

说明智能体的工作什么时候算完成的、可以检查的规则

结束条件告诉智能体什么时候停下，比如“tests/ 里所有测试都通过，页面打开没有错误”。智能体每做一步就检查一次，在条件成立之前一直工作。“把它弄得更好”这种含糊的愿望永远没有尽头，所以长时间运行的循环还需要轮数或词元的上限。

深入学习

停止词元

原文名称 · Stop token

表示“文本到这里结束”的特殊词元

停止词元是标出一段文本结尾的特殊词元。训练时，模型在每个样本的结尾都会看到它，于是学会答案在哪里结束。生成时，一旦选中这个词元或达到长度上限，程序就会停下。没有它，模型会一直往下加词。

深入学习 详细了解 GPT

特殊词元

原文名称 · Special token

不代表文字、而是标记位置的保留词元

特殊词元是分词器为某种用途保留的词元，而不是一段文字。[BOS] 表示文本开始，[EOS] 表示结束，模型输出 EOS 时生成就停止。[PAD] 用来填补空位，[UNK] 代替分词器不认识的字符。XSLM 把换行当作真实模型里的 EOS 来用。

深入学习

safetensors

安全存储模型权重的文件格式

safetensors 是一种保存模型权重的文件格式。文件里只有数字，外加一个小小的 JSON 头部，列出每一层的名称、数据类型和形状。以前基于 Python pickle 的格式在打开文件时可能运行隐藏的代码，而 safetensors 不会，所以 Hugging Face 默认使用它。

深入学习 详细了解权重和参数

预训练

原文名称 · Pre-training

训练语言模型的第一个也是规模最大的阶段

预训练是构建语言模型的第一个阶段：模型在海量文本上学习预测下一个词元。这让它能整体地处理语言，但还不能很好地遵循指令。之后的指令微调等阶段再把它塑造成助手。

深入学习

指令微调（SFT）

原文名称 · Instruction tuning (SFT)

用成对的请求和回答做额外训练，让模型遵循指令

指令微调也叫 SFT（监督微调），是用成对的请求和优质回答对预训练好的模型做进一步训练。这样模型会按照人们提问的方式来回答，而不只是把文字接着写下去。它是模型后训练的一部分。

深入学习

Llama

Meta 公开权重的语言模型系列

Llama 是 Meta 开发的语言模型系列。Meta 公开了模型的权重，所以任何人都可以在 Meta 许可证条款允许的范围内下载，并在自己的电脑上运行。llama.cpp 和 Ollama 等工具最初也是从运行 Llama 模型起步的。

详细了解权重和参数

Qwen

阿里巴巴推出的语言模型系列

Qwen 是 Alibaba Cloud 开发的语言模型系列。从适合笔记本电脑的小模型到适合服务器的大模型，包括 Qwen3-Coder 这样的编程模型，很多 Qwen 模型都公开了权重。也可以通过 OpenRouter 等服务来使用。

详细了解权重和参数

词频饱和

原文名称 · Term frequency saturation

关键词搜索中，一个词多重复几次，加的分会越来越少

在 BM25 关键词搜索里，一个词在文档中出现得多，文档的分数会提高，但每多出现一次，加的分都比上一次少。分数会趋于平稳，而不是无限增长。这样一篇文档就不能只靠把一个词重复很多遍来胜出。

深入学习

阈值

原文名称 · Threshold

分数高过它，模型的回答才算“是”的那条线

分类器给出的往往是一个分数，而不是最终答案。阈值就是你画的那条线：分数高于它算“是”，低于它算“否”。移动阈值会改变哪些样本被判为正例——把它调高，模型说“是”的次数变少，但更谨慎。0.7 分并不自动等于 70% 的概率。

深入学习

词元预算

原文名称 · Token budget

一个任务或智能体循环最多能用的词元数

词元预算给智能体在一个任务上能花的词元数设了上限。AI 服务按词元收费，所以预算也就是费用上限。没有预算的循环可能跑一整夜、一直花钱；预算用完时，即使目标还没达到，智能体也会停下。

深入学习

验证损失

原文名称 · Validation loss

在模型没训练过的文本上测出的损失

训练时你要盯着两个数。训练损失是在模型学习的文本上测的；验证损失是在它从来不拿来训练的另一份文本上测的。如果训练损失一直下降，验证损失却开始上升，说明模型在死记硬背而不是学习一般规律——这时就该停下，或者把模型调小。

深入学习

Antigravity CLI

Google 在终端里用的编程智能体，用 agy 启动

Antigravity CLI 是 Google 在终端里运行的编程智能体。用官方页面上的脚本安装，然后在项目文件夹里用 agy 命令启动；第一次会打开浏览器，用 Google 账号登录。它使用 Google 的 Gemini 模型，和 Claude Code、Codex 一样，在你批准它的计划后读取、修改和运行文件。Google 还为从较早的 Gemini CLI 转过来的人发布了一份指南。

深入学习

Claude Cowork

在你的文件和应用之间执行多步骤工作的 Claude 功能

Claude Cowork 是 Claude 桌面应用的一个功能，用来做不是编程的多步骤工作：整理文件夹里的文件、把一堆收据做成电子表格，或者根据几份文档起草一份报告。你给它一个文件夹并描述想要的结果；它规划步骤，在你看着的时候一步步做完。和所有智能体一样，它做出来的是草稿，你仍然要检查。

深入学习

特征

原文名称 · Feature

模型用来做判断的一个输入值，比如房子面积

特征是模型要看的一项输入数据。预测房价的模型可能会用面积、房间数和到车站的距离；在表格里，每一列通常就是一个特征。选出有用的特征很重要：和答案无关的特征只会增加杂音，可能让模型变差。

深入学习

Hugging Face

大家分享 AI 模型和数据集的网站和公司

Hugging Face 是一个大家发布和下载 AI 模型、数据集以及小型演示应用的网站——就像 GitHub 之于代码。这家公司还做开源的 Python 库，比如 Transformers，用来载入并运行这些模型。很多开放模型，从极小的到非常大的，都是从那里下载的。

图像生成

原文名称 · Image generation

AI 根据文字描述画出一张新图片

图像生成指 AI 模型把一段文字描述（提示词）变成一张新图片，很多模型还能修改你给它的图片。想要好结果，要描述主体、风格、尺寸以及哪些地方不能变，然后一次只改一处。用图片之前，要检查有没有写错的文字、多出来的手指这类错误，以及人物、品牌和画风的权利问题。

深入学习

图像识别

原文名称 · Image recognition

说出图片里有什么的 AI

图像识别是看一张图片、说出里面有什么的 AI：一只猫、一个停车标志、一个手写数字。它通常用在大量带标签照片上训练出来的深度神经网络来完成。手机用它整理相册，汽车用它读路标。

LoRA

便宜的微调方法：冻结模型，只训练一个小附加件

LoRA（Low-Rank Adaptation，低秩适配）是微调大模型的便宜方法。原来的权重保持冻结；只训练一些小的额外矩阵（叫作适配器），再把它们加到原来的权重上。因为要训练的数少得多，需要的 GPU 内存和存储空间都小很多，一个基础模型还能在几个面向不同工作的小适配器之间切换。

详细了解权重和参数

矩阵乘法

原文名称 · Matrix multiplication

按“行乘列”把两张数字表相乘

矩阵乘法把两个矩阵合在一起：结果里的每个数，都是第一个矩阵的一行和第二个矩阵的一列逐项相乘再相加得到的。里面的两个尺寸必须一致——4×3 的矩阵乘 3×2 的矩阵，得到 4×2 的矩阵。神经网络里几乎所有的工作都是矩阵乘法，所以 AI 会用专门为同时做大量矩阵乘法而造的 GPU。

深入学习

神经元

原文名称 · Neuron

神经网络里最小的计算单元

人工神经元接收几个数，把每个数乘上一个权重，再和偏置一起加起来，然后让这个和穿过激活函数。很多神经元并排组成一层，一层层叠起来就成了神经网络。这个名字来自脑细胞，但这里的神经元只是算术而已。

深入学习 详细了解权重和参数

优化

原文名称 · Optimization

调整模型的数，让损失尽量变小

在机器学习里，优化指一步步改变模型的权重，让损失——也就是预测错得有多离谱——变小。梯度下降是常用的方法：算出朝哪个方向能降低损失，再往那边挪一点。优化找的是对训练数据好的数，这和在新数据上也对不是一回事。

详细了解权重和参数

输出格式

原文名称 · Output format

你要求答案呈现的样子：列表、表格、JSON、文件

输出格式是提示词中说明答案该是什么样子的部分：带项目符号的列表、指定列的表格、指定键的 JSON，或者一个文件。把它说清楚，你就不必再改写答案，程序也能直接读结果。它是好提示词的六个部分之一，另外五个是角色、目标、背景、示例和限制。

深入学习

正例

原文名称 · Positive class

是或否分类器里，模型要找的“是”那一边

在只有两个答案的分类器里，正例就是你想找出来的那一类——垃圾邮件过滤器里的垃圾邮件、医学检查里的疾病。“正”不表示好，只表示“检测到了要找的东西”。精确率、召回率和混淆矩阵都是相对这一类来计算的。

scikit-learn

做经典机器学习的 Python 库

scikit-learn 是一个免费的 Python 库，用于经典机器学习：分类、回归、聚类和模型评估。每个模型的用法都一样——用 fit() 从数据中学习，用 predict() 给出答案——所以它是初学者常用的第一个工具。它不是用来训练大型神经网络的；那要用 PyTorch。

词元 ID

原文名称 · Token ID

分词器给词表里每个词元编的号

分词器有一份词表——它认识的所有词元的编号清单。词元 ID 就是一个词元在这份清单里的编号。模型从来看不到字母：文本被变成一串词元 ID，模型处理这些数字，它输出的 ID 再被变回文本。同一个词在不同模型里可能有不同的 ID。

详细了解 GPT

ChatGPT

OpenAI 的 AI 聊天服务

ChatGPT 是 OpenAI 做的聊天服务，2022 年 11 月向公众开放。你输入问题，大语言模型写出答案；它还能读附加的文件和图片，打开相应功能时还能上网搜索。它的回答是草稿——流畅的文字也可能是错的，所以要核对事实和数字。

深入学习 详细了解 GPT

Gemini

Google 的 AI 模型系列和它的聊天应用

Gemini 是 Google 的大语言模型的名字，也是基于这些模型的聊天应用的名字。这些模型是多模态的：能接收文字、图片、声音和视频。Google 的编程智能体 Antigravity CLI 和较早的 Gemini CLI 也都运行在 Gemini 模型上。

Grok

xAI 的 AI 模型系列及其聊天应用

Grok 是 xAI 开发的大语言模型的名称，也是基于这些模型的聊天应用（网页、手机和 X 内）的名称。Grok Build（也叫 Grok CLI）是另一回事：它是在终端里运行的 xAI 编程智能体。简单说，Grok 是模型，Grok CLI 是使用这个模型的工具。

SKILL.md

定义一个智能体技能的文件：名字、说明和步骤

每个智能体技能都是一个文件夹，里面有一个叫 SKILL.md 的文件。文件开头的两行 --- 之间写着技能的名字，以及告诉智能体什么时候用它的说明；下面是用普通 Markdown 写的指示。智能体一开始只读名字和说明，任务需要时才载入其余部分。脚本和参考文件也可以放在同一个文件夹里。

深入学习

Gemini CLI

Google 较早的终端开源 AI 智能体

Gemini CLI 是 Google 的开源 AI 智能体，在终端里运行，使用 Gemini 模型。它和 Claude Code、Codex 一样，读文件、运行命令、遵照指示文件，也支持智能体技能。SONUB 的 AI 课程现在讲的是 Google 较新的 Antigravity CLI（agy）；Google 为 Gemini CLI 用户发布了迁移指南，所以照着旧教程做之前，先看看官方页面。

MCP 资源

原文名称 · Resources

MCP 服务器提供给应用读取的数据

MCP 服务器可以提供三种东西：模型调用的工具、用户挑选的提示词，以及资源——应用可以读取的数据，比如一个文件、一条记录或一份笔记清单。每个资源都有自己的地址（URI），比如 notes://shopping。工具会做事；资源只交出内容。

深入学习

Claude

Anthropic 的 AI 模型系列和聊天服务

Claude 是 Anthropic 做的大语言模型系列，也是它在网页、桌面和手机上的聊天应用的名字。Claude Code 是另一回事：它是一个 Harness 程序，用 Claude 模型来处理你的文件。简单说，Claude 是模型，Claude Code 是围绕模型的工具。

GitHub Copilot

GitHub 帮你写代码的 AI 助手

GitHub Copilot 是 GitHub 的 AI 编程助手。在代码编辑器里，它会在你打字时建议接下来的几行，并在聊天面板里回答问题；在智能体模式和 Copilot CLI 里，它还能修改文件、运行命令。它也会读智能体技能。它的建议只是猜测，所以你仍然要读一读、测一测。

OpenCode

终端里的开源 AI 编程智能体

OpenCode 是在终端里运行的开源编程智能体。它的工作方式和 Claude Code 或 Codex 一样——读项目、改文件、运行命令——但你可以把它接到许多不同提供商的模型上。它也会读智能体技能。

深入学习

Grok CLI

xAI 在终端里用的 AI 编程智能体（Grok Build）

Grok 是 xAI 的 AI 模型的名字。Grok Build，也叫 Grok CLI，是 xAI 在终端里运行的编程智能体，和 Claude Code、Codex 类似。可以用官方安装脚本安装，也可以作为全局 npm 包安装，再用它的版本命令检查是否装好。

Orca

让几个 AI 编程智能体并排运行的开源桌面应用

Orca 是一个开源桌面应用，可以同时运行几个 AI 编程智能体，比如 Claude Code、Codex 和 OpenCode。每个智能体在自己的 Git worktree 里工作，所以它们的修改不会互相冲突，你可以在一个窗口里比较、审查结果。每个智能体的订阅都需要你自己准备。

AlphaGo

Google DeepMind 做的下围棋的 AI

AlphaGo 是 Google DeepMind 做的围棋程序。2016 年 3 月，它以 4 比 1 战胜了世界顶尖棋手之一李世石——很多专家原本以为这还要再等十年。它把深度神经网络和搜索结合起来，并通过和自己对弈（强化学习）不断变强。

深入学习

二分类

原文名称 · Binary classification

答案只能是两个选项之一的分类

二分类是只有两种可能答案的分类问题：垃圾邮件或不是、欺诈或正常、生病或健康。模型通常给出 0 到 1 之间的分数，再用阈值把它变成“是”或“否”。你想检测出来的那一边叫作正例。

深入学习

多分类

原文名称 · Multiclass classification

答案是三个或更多选项之一的分类

在多分类里，每个输入只得到三个或更多标签中的一个：猫、狗或兔子；数字 0 到 9。模型给每个类别打一个分，softmax 把它们变成概率，最高的那个就是答案。如果一个输入可以同时有好几个标签，那是另一种任务（多标签）。

深入学习

思维链

原文名称 · Chain-of-thought

要求模型把步骤写出来的提示方法

思维链（CoT）提示要求模型在给出最终答案前，先写出解题步骤，比如“请一步一步地解”。因为语言模型一次生成一个词元，写出来的步骤会成为后面内容的上下文，往往能让数学和逻辑题答得更好。写出来的步骤只是文字，并不保证就是答案真正被算出来的过程。

链式法则

原文名称 · Chain rule

求“函数套函数”斜率的规则：把斜率相乘

链式法则说，复合函数的斜率（导数）等于外层函数的斜率乘以内层函数的斜率。神经网络是一长串函数，所以反向传播从输出一直到第一层，一遍又一遍地使用链式法则，求出每个权重怎样影响损失。很多小斜率相乘，梯度就会消失；很多大斜率相乘，梯度就会爆炸。

详细了解权重和参数

复合函数

原文名称 · Composite function

把一个函数的输出送进另一个函数而得到的函数

复合函数把一个函数放进另一个函数里：先算出 g(x)，再把结果送给 f，写作 f(g(x))。神经网络就是一个巨大的复合函数——每一层都接收上一层的输出。求这种函数的斜率，用的就是链式法则。

聚类

原文名称 · Clustering

在没有给定答案的情况下把相似的数据分组

聚类在没有人贴过标签时，把相似的东西分成几组——比如按买什么、多久买一次，把商店的顾客分成几群。它是一种无监督学习：算法找出分组，再由人来决定每组代表什么。k-means 是常用的方法，你要告诉它分成几组。

深入学习

混淆矩阵

原文名称 · Confusion matrix

按种类统计答对和答错次数的表

混淆矩阵把分类器的答案和真实答案放在一起比。对是或否的任务，它有四格：真正例、假正例、假负例和真负例。准确率、精确率和召回率都是用这四个数算出来的，所以这张表不仅显示模型错了多少次，还显示它错在哪个方向。

假正例

原文名称 · False positive

模型说“是”，真实答案却是“否”

假正例是一次误报：东西不在，模型却说在——普通邮件被送进垃圾箱、健康的人被标成生病。假正例多，就表示精确率低。它比假负例更糟还是更好，取决于在这项工作里每种错误的代价。

假负例

原文名称 · False negative

模型说“否”，真实答案却是“是”

假负例是一次漏报：东西明明在，模型却没抓到——垃圾邮件进了收件箱、检查没发现的疾病。假负例多，就表示召回率低。在医学筛查里，漏掉一例的代价可能远比误报大，所以那里更看重召回率。

召回率

原文名称 · Recall

所有真正的“是”当中，模型找出来的比例

召回率是真正的正例中被模型正确找出来的比例：真正例 ÷（真正例 + 假负例）。召回率低表示漏掉很多——垃圾邮件溜进了收件箱。提高召回率通常会降低精确率，因为抓得越多，放进来的误报也越多。

精确率

原文名称 · Precision

模型判为“是”的所有结果中，真正是的比例

精确率是模型回答“是”的结果中答对的比例：真正例 ÷（真正例 + 假正例）。精确率低表示误报很多——普通邮件进了垃圾箱。让模型更严格会提高精确率，但通常会降低召回率。（在计算机里，“精度”还指一个数用多少位来存——那是另一个概念。）

F1 分数

原文名称 · F1 score

把精确率和召回率合成一个数

F1 分数是精确率和召回率的调和平均：2 × P × R ÷ (P + R)。只有两者都高时它才高；一个好、一个差，F1 就会很低。所以在各类别数量不均衡时它很有用，那种情况下光看准确率可能很好看，模型却漏掉了大部分正例。

调和平均

原文名称 · Harmonic mean

偏向较小那个值的平均数

两个数 a 和 b 的调和平均是 2ab ÷ (a + b)。和普通平均不同，它会被较小的那个数强烈拉低，所以一个强的值掩盖不了一个弱的值。F1 分数就用它来合并精确率和召回率。

余弦相似度

原文名称 · Cosine similarity

两个向量指向同一方向的程度，从 −1 到 1

余弦相似度衡量两个向量之间的夹角，不管它们有多长。1 表示方向相同，0 表示无关（互相垂直），−1 表示方向相反。嵌入检索用它来找意思向量和问题指向同一方向的文本。向量接近表示话题相似，不代表句子是真的。

数据偏差

原文名称 · Data bias

偏向一边、让模型变得不公平的训练数据

当训练数据不能公平地代表模型将来会遇到的人或情况时，就会产生数据偏差。模型会把这种倾斜学进去——比如某一群体的照片很少的人脸识别模型，对这个群体会犯更多错。要按群体分别检查结果，并且不只修模型，还要修数据。

深入学习

深度研究

原文名称 · Deep research

AI 花几分钟搜索大量来源、写出报告的功能

深度研究是 AI 聊天服务（比如 ChatGPT、Gemini 和 Claude）的一项功能：AI 花几分钟搜索、阅读许多网页，然后写出一份带来源链接的报告。它能省下好几个小时的搜索，但报告仍可能读错或引错来源，所以要打开链接，亲自核对重要的说法。

深入学习 详细了解 GPT

深度伪造

原文名称 · Deepfake

用 AI 做出、看起来像真的的假视频、照片或声音

深度伪造是用深度学习做出来的假视频、照片或录音，看起来或听起来像真人。同样的技术在电影和配音中有正当用途，但用它让别人“说”没说过的话、用来行骗，或者制作真实人物的色情图像，都可能构成犯罪。看到令人震惊的片段，先查一查来源再相信。

深入学习

维度

原文名称 · Dimension

一个向量里有几个数

向量的维度就是它装着几个数：[1.2, 0.5, 3.0] 是一个 3 维向量。每个数可以看作沿一条轴的位置，所以两个数构成平面地图上的一个点，三个数构成空间里的一个点。AI 用的嵌入常常有几百甚至几千维——多得画不出来，但算法是一样的。

深入学习

训练轮次

原文名称 · Epoch

把全部训练数据完整过一遍

一个轮次（epoch）就是模型把训练数据中的每个样本都看过一遍的一轮。训练通常要跑好几个轮次。每轮结束后，在验证数据上检查损失：如果训练损失还在下降，验证损失却不再改善甚至上升，那么再多的轮次只会让模型死记硬背。

深入学习

人工智能法

原文名称 · EU AI Act

按风险等级管理 AI 的欧盟法律

欧盟《人工智能法》（EU AI Act）是欧盟关于人工智能的法律，2024 年 8 月 1 日生效，是第一部这类全面的 AI 法律。它按风险给 AI 系统分级：有些用途被禁止，高风险用途（比如招聘或信用评分）必须满足严格的规定，其他用途则要求透明——比如内容由 AI 生成时必须告诉人们。它的规定在几年里分阶段生效。

深入学习

专家系统

原文名称 · Expert system

由人类专家写的规则组成的早期 AI

专家系统是一种早期的 AI，在 20 世纪 70 和 80 年代很流行，由人类专家写下的大量“如果这样，就那样”的规则组成——比如诊断疾病的规则。它能说明自己用了哪些规则，但遇到没人写过规则的情况就会出错，让几千条规则保持最新也很难。从数据中学习规则的机器学习在很大程度上取代了它。

深入学习

人脸识别

原文名称 · Face recognition

认出图片里是谁的脸的 AI

人脸识别是在图片中找到一张脸、并把它和已知的某个人对上的 AI，比如手机看一眼你就解锁。它的做法是把一张脸变成向量，再比较向量。对训练照片里人数偏少的群体，它可能不那么准确；在公共场所对人使用它，还会带来隐私和法律问题。

深入学习

生成式人工智能

原文名称 · Generative AI

生成新的文字、图片、声音或视频的 AI

生成式人工智能是能产出新内容——文字、图片、音乐、声音、视频或代码——而不只是分类或预测标签的 AI。聊天助手和图像生成器都是例子。它的输出是根据训练数据里的规律拼出来的，所以可能说得很有把握却仍然是错的（幻觉）。

知识蒸馏

原文名称 · Knowledge distillation

训练一个小模型去模仿大模型

知识蒸馏训练一个小的“学生”模型，去模仿大的“老师”模型的输出，而不只是正确答案。学生从老师完整的概率分数中学习，这些分数带有更多信息，所以学生常常能接近老师的水平，同时小得多、快得多。这是一种设计上的取舍：用一些准确度换速度和成本。

数据标签

原文名称 · Label

附在每个训练样本上的正确答案

标签是附在一条训练数据上的答案：猫的照片上写着“猫”，垃圾邮件上写着“垃圾邮件”，房屋记录上写着价格。监督学习需要标签，标签的质量也限制着模型——错误或前后不一的标签会教出错误的答案。打标签往往是由人来做的慢活。

深入学习

监督学习

原文名称 · Supervised learning

从带着正确答案的例子中学习

在监督学习中，模型从配有正确答案（标签）的例子中学习：标着“猫”或“狗”的照片、附有价格的房子。它调整自己去对上这些答案，再为新的例子预测答案。分类和回归是两大类。它需要大量带标签的数据，这往往是最花钱的部分。

深入学习

无监督学习

原文名称 · Unsupervised learning

从没有附带答案的数据中学出结构

无监督学习处理没有标签的数据，自己在其中找结构——相似的东西组成的群（聚类）、不寻常的东西，或者描述数据的更简单方式。在打标签太贵时它很有用。它找出来的分组没有名字；它们代表什么由人来决定。

深入学习

强化学习

原文名称 · Reinforcement learning

通过尝试行动、获得奖励或惩罚来学习

在强化学习中，智能体在一个环境里尝试各种行动，并根据结果得到奖励或惩罚。经过许多次尝试，它学会哪些行动从长远看能得到最多奖励。AlphaGo 就是这样通过和自己对弈变强的，RLHF 也用它来塑造聊天模型的回答方式。奖励设计得不好，就可能教出错误的行为。

深入学习

奖励模型

原文名称 · Reward model

给两个答案打分、判断人们更喜欢哪一个的模型

奖励模型是用“人们从两个答案中选出更好的一个”这样的比较数据训练出来的。它学会给任何答案打分，在强化学习中代替人的判断。它的弱点很要紧：语言模型可能学会讨好奖励模型——比如写又长又奉承的回答——而不是真正变好。

RLHF

基于人类反馈的强化学习：用人们的偏好来调整模型

RLHF（Reinforcement Learning from Human Feedback，基于人类反馈的强化学习）用人类的偏好来塑造语言模型。通常是：① 用好的示例答案微调模型，② 让人们比较一对对答案，用他们的选择训练奖励模型，③ 用强化学习让模型写出奖励模型打高分的答案。聊天助手能遵从指令、礼貌地回答，主要就是因为它。

模型卡

原文名称 · Model card

说明模型用途和会在哪里出错的简短文档

模型卡是和模型一起发布的文档。它说明模型适合和不适合做什么、用什么数据训练、怎样评估、已知的局限和偏差，以及许可证。它帮助别人判断这个模型是否适合自己的工作。Hugging Face 上的模型通常都附有一份。

n-gram

靠计数，根据前 n−1 个词预测下一个词的模型

n-gram 模型统计在一段文本里，每个词跟在前 n−1 个词后面出现了多少次，再把次数变成概率。二元模型（n = 2）看前一个词，三元模型看前两个词。它速度快、容易理解，但用不到更前面的内容，而且没见过的词序列概率为零——这些局限正是神经语言模型克服的。

深入学习

数值微分

原文名称 · Numerical differentiation

把输入轻轻推一点点来估算斜率

数值微分给输入加上一个极小的量 h，看输出变化了多少，以此估算斜率：(f(x + h) − f(x)) ÷ h。它简单，适合用来核对，但只是近似值，而且每个参数都要多算一次——对有数百万个权重的模型来说太慢了。深度学习框架用的是自动微分。

详细了解权重和参数

端侧 AI

原文名称 · On-device AI

不用服务器、在手机或笔记本电脑上直接运行的 AI

端侧 AI 在你自己的手机、笔记本电脑或其他设备上运行模型，而不是把数据发到服务器。它让数据留在本地，离线也能用，回答也没有网络延迟。代价是内存、速度和电量都有限，所以端侧模型都比较小，常常经过量化——比不上最大的云端模型。

深入学习

困惑度

原文名称 · Perplexity

衡量语言模型对下一个词元有多不确定

困惑度衡量语言模型对一段文本预测得有多好；越低越好。困惑度为 10，表示模型平均每一步都像是要在 10 个词元中平均地挑一个那样不确定。它直接由损失算出（e 的平均损失次方）。困惑度低表示预测得好，不代表文字是真的或有用。

位置编码

原文名称 · Positional encoding

加到每个词元上、让模型知道它位置的数

注意力本身把输入当成一袋词元，分不清它们的顺序。位置编码解决这个问题：把每个位置——第 1、第 2、第 3……——变成数字，加到词元的嵌入上。没有它，在 Transformer 看来，“dog bites man”和“man bites dog”就是一样的。

误差

原文名称 · Prediction error

预测值离正确答案有多远

一次预测的误差是预测值减去正确值。训练时通常把误差平方再取平均（均方误差）作为损失，这样大的偏差比小的偏差分量重得多，正负误差也不会互相抵消。然后模型调整权重，让这个平均值变小。

深入学习 详细了解权重和参数

剪枝

原文名称 · Pruning

剪掉训练好的模型里最不重要的权重，让它变小

剪枝去掉那些对训练好的模型输出影响很小的权重或连接，让模型变小，有时也变快。这个名字来自园艺：剪掉树不需要的枝条。剪得太多会损害准确度，所以之后常常再做一小轮训练。它和量化、蒸馏一样，是缩小模型的几种方法之一。

详细了解权重和参数

可复现性

原文名称 · Reproducibility

能把实验重新跑一遍并得到同样的结果

如果别人用同样的数据、代码和设置再跑一遍实验能得到同样的结果，这个实验就是可复现的。为此，要记下数据版本、代码版本、库和 Python 的版本、随机种子以及确切的命令。即便如此，GPU 的计算在不同次运行之间也可能有细微差别。

基于规则的聊天机器人

原文名称 · Rule-based chatbot

只用人为固定模式写好的答案来回复的聊天机器人

基于规则的聊天机器人把你输入的内容和人写的规则——关键词或模式——对照，然后回复固定的答案。它可预测、成本低，几条 if 语句就能做出一个。但它处理不了规则以外的任何内容，这和会生成新回复的 LLM 聊天机器人不同。

深入学习

语音模型

原文名称 · Speech model

把文字变成语音、或把语音变成文字的 AI 模型

语音模型是处理说话声音的 AI 模型：把文字变成声音（语音合成），或把声音变成文字（语音识别）。小型语音模型可以在你自己的设备上运行——SONUB 的朗读声音只需下载一次，之后就在你自己的设备上把文字变成声音，而聊天消息仍然要发给语言模型服务。

深入学习

转置

原文名称 · Transpose

把行和列互换后的矩阵

矩阵的转置就是把行和列互换：第 1 行变成第 1 列，依此类推。一个 m × n 的矩阵变成 n × m，写作 Aᵀ。在做矩阵乘法前，经常要用它让形状对得上——比如注意力会把查询矩阵乘以转置后的键矩阵。

图灵测试

原文名称 · Turing test

测试机器的对话能否被当成人的对话

1950 年，艾伦·图灵提出了“模仿游戏”：一位评判者用文字和一个藏起来的人、一台藏起来的机器聊天，如果评判者无法可靠地分辨哪个是机器，机器就算通过。它后来被称为图灵测试。通过测试只说明机器能模仿人的对话——不说明它能理解、有感受或有意识。

深入学习

欠拟合

原文名称 · Underfitting

模型连训练过的数据都做不好

当模型太简单或训练太少，抓不住规律，连自己的训练数据都答错很多时，就是欠拟合。它和过拟合相反，过拟合是模型把训练数据贴得太紧。解决办法包括更大的模型、更好的特征或更多的训练。

深入学习

XAI

可解释人工智能：说明模型为什么给出这个答案的方法

XAI（可解释人工智能）是一类方法的研究领域，让人们看清模型为什么给出某个答案——比如哪些词或像素最重要。在影响到人的决定里它最要紧，比如贷款、招聘和医疗，这样才能找出并解释错误和不公平的理由。解释本身也是一种近似，需要核对。

深入学习

Amazon Bedrock

通过一个 API 使用多家公司 AI 模型的 AWS 服务

Amazon Bedrock 是 AWS 的云服务，让公司通过 AWS 调用多家提供商的 AI 模型——包括 Anthropic 的 Claude——并使用 AWS 的计费和安全设置。Claude Code 可以设置成通过 Bedrock 而不是 Anthropic 账户来使用 Claude，但这时一些需要 claude.ai 登录的功能就用不了。

审批策略

原文名称 · Approval policy

Codex 中规定智能体什么时候必须先问你的设置

在 Codex 里，沙箱决定智能体在技术上能做什么（写文件、上网），审批策略决定它什么时候必须停下来问你。on-request 在需要越出沙箱时才问；never 永远不问，适合脚本和隔离的容器。两者要一起设定。用 -a 或 config.toml 里的 approval_policy 来选。

深入学习

workspace-write

Codex 沙箱模式：只在项目文件夹里修改和运行命令

workspace-write 是 Codex 的一种沙箱模式。智能体可以在工作文件夹里修改文件、运行命令，但不能碰别处；网络默认关闭，.git 和 .codex 这类文件夹保持只读。在 Git 仓库里，它和 on-request 审批策略搭配是常见的选择。其他模式是 read-only（只看不改）和 danger-full-access。

深入学习

danger-full-access

没有沙箱的 Codex 模式：智能体什么都能做

danger-full-access 关掉 Codex 的沙箱：智能体可以用你这个用户的全部权限读写任何文件、使用网络。一条错误的命令就可能删掉或泄露你的数据，所以只在可以随时扔掉的隔离容器或虚拟机里使用它。

深入学习

config.toml

Codex 的设置文件 ~/.codex/config.toml

config.toml 是 Codex 保存默认设置的文件，位于主目录的 ~/.codex/config.toml。那些本来每次都要输入的选项——模型、推理努力程度、审批策略、沙箱模式、MCP 服务器——在这里写一次就行。它用 TOML 格式：key = value 这样的行和 [section] 小标题。

深入学习

配置档

原文名称 · Profile

用 -p 挑选的一组有名字的 Codex 设置

Codex 配置档（profile）是为某一类工作准备的一组有名字的设置——比如一个用严格沙箱、只读的“review”配置档。你的默认设置留在 config.toml 里，codex -p <名字> 让这次运行换成配置档里的设置。这样就不必一遍遍输入同样的选项。

深入学习

codex cloud

在 OpenAI 的云端运行 Codex 任务，再把结果用到本地

codex cloud 把任务交给运行在 OpenAI 云环境里的 Codex，而不是在你的电脑上跑。因为你的电脑空出来了，你可以同时跑好几个任务，只挑你想要的完成结果。codex apply 把云端任务的修改复制到你的本地仓库，你再像审查其他 diff 一样审查它们。

深入学习

Streamable HTTP

远程 MCP 服务器通过 HTTP 通信的方式

MCP 服务器主要有两种连接方式。本地服务器在你的电脑上运行，通过标准输入和输出（stdio）通信。远程服务器在别处运行，通过 HTTP 通信；目前的标准方式叫 streamable HTTP，服务器可以一次把回复发完，也可以分成几部分流式发送。添加时只要给出它的 URL。

深入学习

交叉审查

原文名称 · Cross-review

让另一个 AI 或人检查一个智能体完成的工作

交叉审查是指一个智能体做事，另一个——比如 codex review 这样的另一个 AI、一个子智能体，或者一个人——来检查。第二个检查者的盲点不同，能抓到第一个反复犯的错，包括它自己声称的“全部完成了”。这是智能体工作的一种习惯，不是交叉验证那样的统计方法。

深入学习

预训练权重

原文名称 · Pretrained weights

别人已经训练好的模型的数

预训练权重是别人已经训练好的模型学到的数，以文件形式发布，可以下载。从它们出发，就省掉了从零训练的巨大成本，再通过微调让它们适应你的工作。SONUB 的 XSLM 课程特意一个都不用：你自己写代码、亲手训练每一个数，这样就能看到它们是从哪里来的。

深入学习 详细了解权重和参数

渐进式披露

原文名称 · Progressive disclosure

先读一点，需要时才读更多

智能体用渐进式披露分三步载入技能：① 一开始只读每个技能的名字和说明；② 任务对得上时，读整个 SKILL.md；③ 只有需要时，才读它文件夹里额外的脚本和参考文件。这样就能装很多技能，而不会把上下文窗口塞满。

深入学习

研究预览

原文名称 · Research preview

功能的早期未完成版本，开放给大家试用

研究预览是新功能的早期版本，在完成之前就开放，让人们试用并反馈意见。它以后可能会改变、有限制或被撤掉，所以暂时不要在重要的工作中依赖它。Anthropic 给 Claude Code channels 这样的功能贴上这个标签。

Cursor

基于 VS Code 的 AI 代码编辑器

Cursor 是内置 AI 的代码编辑器，由 Anysphere 公司开发，基于 VS Code，所以界面和扩展用起来都很熟悉。它会在你打字时建议代码、回答关于项目的问题，还有一个能一次修改好几个文件的智能体模式。它也会读智能体技能和 AGENTS.md。（不是那个闪烁的文字光标。）

深入学习

Goose

最早由 Block 发布的开源 AI 智能体

Goose 是一个开源 AI 智能体，最早由支付公司 Block 发布，作为桌面应用或在终端里运行在你的电脑上。它能使用许多提供商的模型，并通过 MCP 连接工具。它也会读智能体技能。

深入学习

Kiro

AWS 出的、根据书面规格工作的 AI 代码编辑器

Kiro 是 AWS（Amazon Web Services）的 AI 代码编辑器。除了聊天和能修改代码的智能体，它还鼓励在智能体动手之前先写一份规格（spec）——需求、设计和任务清单。它也会读智能体技能。

深入学习

Junie

JetBrains 的 AI 编程智能体

Junie 是 JetBrains 的 AI 编程智能体，JetBrains 就是做 IntelliJ IDEA、PyCharm 和 PhpStorm 等代码编辑器的公司。它在这些编辑器里规划任务、修改文件、运行测试。它也会读智能体技能。

深入学习

Kimi

月之暗面的 AI 模型，也用在终端编程工具里

Kimi 是中国公司月之暗面（Moonshot AI）的 AI 模型和聊天应用的名字。部分 Kimi 模型以开放权重的形式发布。月之暗面还提供命令行编程智能体，所以 Kimi 会出现在能在终端里运行的 AI 工具清单中。

深入学习 详细了解权重和参数

Amp

起源于 Sourcegraph 的 AI 编程智能体

Amp 是一个 AI 编程智能体，起源于做代码搜索的 Sourcegraph 公司。它在终端和代码编辑器里运行，像 Claude Code 或 Codex 那样读项目、改文件、运行命令。它也会读智能体技能。

深入学习

OpenHands

做软件开发的开源 AI 智能体

OpenHands（原名 OpenDevin）是一个面向 AI 软件开发智能体的开源平台。它的智能体在沙箱里写代码、运行命令、浏览网页，你可以在自己的电脑或服务器上运行它。它也会读智能体技能。

深入学习

Roo Code

VS Code 的开源 AI 编程智能体扩展

Roo Code 是一个开源扩展，给 VS Code 加上 AI 编程智能体。它读取和修改文件，在你批准后运行终端命令，用哪个模型提供商由你选。它也会读智能体技能。

深入学习

Laravel Boost

帮助 AI 智能体处理 Laravel 项目的 Laravel 包

Laravel Boost 是 Laravel 团队为 AI 编程智能体做的官方包。装在 Laravel 项目里后，它给智能体提供一个 MCP 服务器，里面有检查应用（路由、数据库结构、日志）的工具、Laravel 专用的指南，以及按项目所用包版本可搜索的文档。它也能配合智能体技能使用。

深入学习

自动微分

原文名称 · Automatic differentiation

由库替你算出梯度

训练神经网络时，需要算出损失对每个权重的梯度。自动微分在运行时把每一步计算都记下来，再用链式法则沿着这份记录往回走，准确算出所有梯度。PyTorch 把这个功能叫作 autograd，所以你只需写正向计算。

深入学习 详细了解权重和参数

偏置（bias）

原文名称 · Bias term

加到神经元总和上的数，像权重一样通过学习得到

神经元把每个输入乘以权重，加在一起，然后再加上一个数，这就是偏置。有了偏置，即使所有输入都是零，神经元也能给出非零的答案，它还会改变神经元反应的难易程度。偏置也是参数，所以训练时会和权重一起调整。

深入学习 详细了解权重和参数

准确率

原文名称 · Accuracy (model)

模型答对的样本占全部样本的比例

准确率就是预测正确的个数除以样本总数。它容易看懂，但当某个答案远比其他答案常见时，就可能误导人：如果 100 封邮件里有 99 封是正常邮件，一个总是回答“正常”的模型也能得 99%。所以还要同时看精确率和召回率。

Agent Skills

把技能打包成 SKILL.md 文件夹的开放标准

Agent Skills 是一种开放格式，维护在 agentskills.io，规定技能的结构：一个文件夹，里面有 SKILL.md 文件，它的 front matter 写明名称和描述，还可以附带脚本和参考文件。因为格式是共用的，同一个技能文件夹可以给 Claude Code、Codex 和其他编程智能体使用。这个标准只规定格式，不检查技能是否安全。

深入学习

插件市场

原文名称 · Marketplace

Claude Code 里可以添加、安装插件的清单

插件市场是一个列出插件的仓库，插件是技能、子智能体、钩子和 MCP 服务器的打包。添加一个插件市场之后，你可以用一条命令安装其中任何插件，整个团队也能共享和更新同样的工具。只添加你信任的插件市场，因为插件可以在你的电脑上运行代码。

深入学习

Stop 钩子

原文名称 · Stop hook

智能体快要停下时运行的脚本

Stop 钩子是 Claude Code 在智能体每次结束自己的回合、快要停下时运行的钩子。脚本可以检查工作，挡住这次停止，让智能体回去接着做。Ralph Loop 就是建立在它上面的：钩子拦住停止，把同一个提示词再送进去，直到出现完成短语或达到上限。

深入学习

Claude Desktop

装在电脑上的 Anthropic Claude 应用

Claude Desktop 是 macOS 和 Windows 上的 Claude 应用。除了聊天，它还能连接你电脑上的 MCP 服务器，让 Claude 使用你允许的本地工具和文件，还能不开终端就运行 Claude Code 和 Cowork 任务。按 MCP 的说法，它是一个主机（Host）。

深入学习

Claude Agent SDK

在 Claude Code 的 Harness 上构建你自己智能体的库

Claude Agent SDK 就是运行 Claude Code 的那套 Harness——智能体循环、工具、权限和上下文管理——以 Python 和 TypeScript 库的形式提供。用它，你可以做出自己的智能体，读文件、运行命令、调用工具，而不必亲手写那个循环。它以前叫 Claude Code SDK。

自适应推理

原文名称 · Adaptive thinking

模型在每一步自己决定要不要先思考、思考多久

使用自适应推理时，模型在每一步自己决定回答前要不要思考、思考多久：简单的步骤很快，难的步骤想得久一些。你不用设固定的思考词元数，而是用努力程度来调整总量——越高，思考越多、检查越深；越低，越快越便宜。只有部分模型支持它。

思考词元

原文名称 · Thinking tokens

模型在写出答案前用来推理的词元

思考词元是推理模型在给出答案前、一步步解题时写出的词元。它们和其他词元一样要计费，也占上下文。思考预算是允许的最多思考词元数；在 Claude Code 里，你用努力程度来调高或调低思考，在预算固定的模型上，MAX_THINKING_TOKENS 设置给它设上限。

bypassPermissions

关掉所有确认的 Claude Code 权限模式

bypassPermissions 是一种权限模式，Claude Code 在这种模式下修改文件、运行命令完全不问你；--dangerously-skip-permissions 选项启动的就是它。因为没有任何东西能挡住错误或有害的命令，所以只在没有网络、也没有你在乎丢失的东西的容器或虚拟机里使用。

深入学习

记忆文件

原文名称 · Memory file

Claude Code 在每次会话开始时载入的指示文件

在 Claude Code 里，“记忆”指它在每次会话开始时读的指示文件——CLAUDE.md 文件（或 AGENTS.md），以及自动记忆的笔记。它们在你提问之前就被载入上下文，所以从第一条消息起就占掉一部分上下文窗口；要写得短一些。这种记忆是磁盘上的文本文件，不是电脑的内存（RAM）。

深入学习

ultrathink

加在请求里、让 Claude 在这一回合想得更深的词

在请求里放上 ultrathink，会让 Claude Code 在这一回合里想得更深，而不改变这次会话其余部分的模型或努力程度。遇到单独一个难的步骤，比如棘手的 bug 或设计决定，它很方便。想得越多，花的时间越长，用的词元也越多。

深入学习

Claude in Chrome

让 Claude 在你的浏览器里打开、点击和检查页面的 Chrome 扩展

Claude in Chrome 是一个浏览器扩展。和 Claude Code 连接后，Claude 可以在你自己的 Chrome 里打开页面、点击、输入、读取控制台错误，所以改完代码后，它能自己在屏幕上检查结果。它可以在 Chrome、Edge 和其他 Chromium 浏览器里使用，要用同一个 claude.ai 账号登录。

深入学习

PreToolUse

在使用工具之前运行、可以拦住它的钩子

PreToolUse 是在智能体使用工具之前触发的钩子事件——在修改文件之前、在运行 shell 命令之前。你的钩子命令能看到将要发生什么，并且可以阻止它：如果它以退出码 2 结束，这个操作就被拦下，写到 stderr 的消息会传回给智能体。它用来拦住危险的命令或对秘密文件的修改。Claude Code 和 Codex 都有它。

深入学习

PostToolUse

在使用工具之后马上运行的钩子

PostToolUse 是在智能体使用工具之后马上触发的钩子事件，比如在它修改文件之后。它不能撤回这个操作，但可以接着做些事——常见的用法是对智能体改过的每个文件运行 Prettier 这样的格式化工具。Claude Code 和 Codex 都有它。

深入学习

matcher

钩子里说明它适用于哪些工具的部分

钩子的 matcher 选定这个钩子为哪些工具运行。它是一个工具名或一个模式：Bash 表示 shell 命令，Edit|Write 表示文件修改。没有 matcher，钩子会对每个工具都运行，既慢，又可能拦住你并不想拦的东西。

深入学习

/clear

在 Claude Code 里开始一段全新的对话

输入 /clear 会清空对话，让下一个请求从干净的上下文窗口开始。转去做一件不相关的任务时就用它：旧消息不会再占满窗口，也不会把工作往错误的方向带。之前的会话会被保存，用 /resume 可以再打开。

深入学习

Esc

让 Claude Code 在工作中途停下的按键

Claude Code 工作时按 Esc，会立刻停止当前步骤，对话仍然保留，所以你可以说出哪里不对，再接着做。连按两次 Esc（或输入 /rewind）会打开检查点列表，你可以在那里让对话和代码回到更早的某个时刻。早点停下，比让错误的计划一路跑到底更省事。

深入学习

claude mcp add

在终端里给 Claude Code 注册一个 MCP 服务器

claude mcp add 给 Claude Code 加上一个新的 MCP 服务器，连同那个服务器提供的工具。远程服务器用 --transport http 加上它的地址来添加；在你电脑上运行的服务器，用 -- 加上启动它的命令来添加。claude mcp list 显示已注册的服务器，claude mcp remove 删除一个。

深入学习

--scope（MCP）

原文名称 · --scope (MCP)

决定添加的 MCP 服务器保存在哪里、谁能使用的选项

claude mcp add 把服务器保存在三种范围之一。默认的 local 只为你在这个项目里保存（存在 ~/.claude.json 里）；project 把它写进项目顶层的 .mcp.json，团队通过 git 就能拿到，第一次使用时要经过批准；user 让你在每个项目里都能用。这个范围和 Shell 课程里变量的作用域不是一回事。

深入学习

Shift+Tab

切换 Claude Code 权限模式的快捷键

在 Claude Code 的终端里，Shift+Tab 会在几种权限模式之间轮换：default 在每次编辑或运行命令之前都会询问，acceptEdits 编辑文件时不再询问，plan 只读取并先给出计划，什么都不改。大改动之前切换到计划模式，你就能先读一读计划并修改它。开着 default 以外的模式时，输入框下方会显示它的名字。从 v2.1.283 起，终端会话以 auto 模式启动，所以第一次按会切到 default，顺序是 auto → default → acceptEdits → plan。

深入学习

Anthropic

开发 Claude 的 AI 公司

Anthropic 是一家成立于 2021 年的 AI 研究公司。它开发 Claude 系列语言模型和 Claude Code 等工具，并发布关于让 AI 更安全的研究。

OpenAI

开发 ChatGPT 和 Codex 的 AI 公司

OpenAI 是一家成立于 2015 年的 AI 研究公司。它开发 GPT 系列模型、对话服务 ChatGPT 和编程智能体 Codex。

详细了解 GPT

钩子事件

原文名称 · Hook event

钩子运行的时机名称，例如 SessionStart

钩子事件是钩子（你的脚本）运行时机的名称：会话开始时、发送提示时、工具运行前后、Claude 停止时等。你在设置文件里写下事件和那时要运行的命令。

深入学习

技能设置项

原文名称 · Skill setting field

写在 SKILL.md 开头的 Claude Code 设置，例如 allowed-tools

SKILL.md 的前置元数据里除了 name 和 description，还有 Claude Code 会读取的项目：无需询问即可使用的工具、是否只能由你启动、是否显示在 / 菜单中。其他读取 Agent Skills 的智能体可能会忽略这些项目。

深入学习

XChat

在 XSLM 课程中亲手做的聊天机器人

XChat 是你在 XSLM 课程中亲手写的小型聊天程序。它把问题发给 Runner，由你自己训练的 GPT 生成回答，再由 XChat 显示——不使用预训练模型或外部 AI API。

深入学习 详细了解 GPT

--output-format

选择 claude -p 以什么格式输出结果

在没有对话界面的情况下运行 Claude Code（`claude -p`）时，这个选项决定输出什么。默认的 `text` 只输出回答文字；`json` 输出一个 JSON 对象，里面有回答（`result`）、会话 ID 和估算费用；`stream-json` 在运行过程中每发生一件事就输出一行 JSON。需要让别的程序读取字段的脚本，通常选 `json`。

深入学习

AGENTS.override.md

代替同一文件夹中 AGENTS.md 的 Codex 指令文件

Codex 在每个文件夹里先找 `AGENTS.override.md`，再找 `AGENTS.md`，而且每个文件夹只读一个文件，所以有这个文件时，旁边的 `AGENTS.md` 就不会被读取。想暂时试试别的指令、又不想修改或删除共用的文件时用它；删掉它就恢复原来的指令。Claude Code 不读取这个文件。

深入学习

skill-creator

帮你制作新智能体技能包的技能包

skill-creator 是一个引导你制作新技能包（装有 `SKILL.md` 的文件夹）的技能包：它会问这个技能包做什么、什么时候该用，然后据此写出文件。Codex 自带它，输入 `$skill-creator` 就能启动。Anthropic 公开的 skills 仓库里也有一个 skill-creator，它还能用示例提问来测试技能包。

深入学习

审批策略(approval policy)

决定 Codex 运行命令前是否先问你的规则

审批策略决定 Codex 在运行命令前是否停下来问你。用 `--ask-for-approval`（`-a`）设置：`on-request` 让沙箱允许的操作直接运行，其余的先问你；`never` 从不询问，但仍只在沙箱范围内运行。在受版本控制的文件夹里，Codex 推荐的 Auto 模式就是 `workspace-write` 沙箱加 `on-request`；旧值 `untrusted` 已不再支持。

深入学习

evals.json

写有技能包测试问题和预期结果的文件

evals.json 是用来测试技能包的题目列表：每道题写下用户可能提出的请求，以及好的结果应该是什么样。把同样的请求在有技能包和没有技能包时各运行一次再比较，就能看出技能包是否真的有用。它没有统一规定的格式；Anthropic 的 skill-creator 把它放在 `evals/evals.json`，使用下面的字段。

深入学习

NVIDIA

以用于 AI 的图形芯片（GPU）闻名的美国公司

NVIDIA（英伟达）是一家设计和销售显卡（GPU）的美国公司。GPU 最初是为了快速绘制游戏画面而做的，但它也擅长训练和运行 AI 模型所需的海量计算，所以大多数 AI 数据中心都在用。NVIDIA 还推出了 CUDA，这是一套用来编写在其 GPU 上运行的程序的工具。

深入学习

Google DeepMind

开发 AlphaGo 和 Gemini 的谷歌 AI 研究机构

Google DeepMind 是谷歌内部的 AI 研究机构。它开发了 2016 年战胜李世石九段的围棋 AI AlphaGo（阿尔法围棋），也在开发谷歌的 Gemini 模型。它是研究机构而不是单独的应用，它的成果出现在 Gemini 等谷歌产品里。

深入学习

NIST

发布 AI 风险管理指南的美国标准机构

NIST（美国国家标准与技术研究院）是制定计量和技术标准的美国政府机构。在 AI 领域，它发布了《AI 风险管理框架》（AI RMF），讲如何找出并降低 AI 系统的风险，还发布了把这套框架用于聊天机器人等生成式 AI 的《生成式 AI 概况》。这些是自愿遵循的指南，不是法律。

深入学习

Gartner

以 IT 趋势报告闻名的美国研究咨询公司

Gartner（高德纳）是一家美国研究公司，它调查企业，发布有关信息技术的报告和预测，例如技术成熟度曲线（Hype Cycle）图。新闻常引用 Gartner 对企业领导者的调查。它的数字说的是被调查的公司，而不是所有公司。

深入学习

安德烈·卡帕西

原文名称 · Andrej Karpathy

以 nanoGPT 和构建语言模型的免费课程闻名的 AI 研究者

安德烈·卡帕西（Andrej Karpathy）是 AI 研究者，曾是 OpenAI 的创始成员，并领导过特斯拉 Autopilot 的 AI 工作。他公开了 nanoGPT、makemore、nanochat 等小巧易读的项目，以及从零搭建神经网络的免费视频课程。他还在 2025 年提出了“氛围编程”（vibe coding）一词。

深入学习 详细了解 GPT

嵌入向量

原文名称 · Embedding

把含义变成数字，好让它们能互相比较

嵌入是把句子变成一串数字，并让含义相近的句子落在相近的位置。所以你搜「修车」时，系统也能找到讲「汽车维修」的段落——它比对的是意思，不是字面。

向量

原文名称 · Vector

表示一个位置的一串数字

向量不过是一串有顺序的数字，就像在地图上定位一个点的那两个数。人工智能用的是几百个数字的长串，于是每个向量都指向一个我们画不出来的空间里的位置。含义一旦成了点，「相似」就等于「靠近」。

数据库

原文名称 · Database

整理好的存储，能安全地查找和修改

数据库把应用的数据按规整的方式存起来，既能很快查到，也能在很多人同时写入时安全地修改而不损坏。可以把它想成一张两个人同时编辑也不会丢行的表格。像本站这样的网站，账号、帖子和成绩都住在里面。

深入学习

SQL

用来向数据库提问的语言

SQL 是你告诉数据库你想要什么的方式：选出这些行、加进这一条、把那个字段改掉。它读起来几乎就是压缩过的英语，作为第一门接触的计算机语言格外好上手。它从 1970 年代沿用至今，仍是与多数数据库打交道的标准办法。

JSON

程序之间交换数据用的纯文本格式

JSON 用名字和值成对的方式把数据写成纯文本，因此两个用不同语言写的程序也能互相看懂。几乎所有 API 都用它作答。因为它只是文本，你可以直接打开一个 JSON 文件自己读，很容易核对某个服务到底给了你什么。

独热向量

原文名称 · One-hot vector

一串 0 里只有一个 1，标出是哪个词

独热向量的长度和词表一样，除了这个词自己的位置是 1，其余全是 0。这是把词元 ID 变成可计算向量的最简单方法。它只说明“是哪个词”：任意两个词之间的距离都一样，所以不带任何意思或相似度。能表达意思的，是学习得到的嵌入向量。

深入学习

张量

原文名称 · Tensor

可以有任意多个维度的数字网格

张量是把数字排成一个或多个方向的容器。单个数是标量，一行数是向量，一张表是矩阵，好几张表叠起来就是更高维的张量。模型的参数都存在张量里，GPU 就是为了快速做张量乘法而造的。参数数量按里面的数字来数，而不是按容器来数：一个 2 × 3 的矩阵装着 6 个参数。

深入学习 详细了解权重和参数

比特和字节

原文名称 · Bits and bytes

计算机数据的最小单位：一个 0/1，以及 8 个一组

比特（bit，也叫位）是一个 0 或 1，是计算机存储的最小数据。字节（byte）是 8 个比特，能表示 256 种不同的值。文件大小和内存都按字节来算 —— KB、MB、GB。这也能解释 AI 模型的大小：用 8 位存一个参数要占 1 个字节，所以 80 亿个参数大约要 8 GB。

深入学习 详细了解权重和参数

CSV

以纯文本保存的表格，列与列之间用逗号隔开

CSV(逗号分隔值)用文字保存表格：一行是一行数据，列与列之间放一个逗号，第一行常常是列名。电子表格软件可以打开和保存它，Shell 工具也很好读——cut -d, 和 awk -F, 会在逗号处切开每一行。值本身含有逗号时会用引号包起来，而这些简单的工具看不懂这一点。

FP32

32 位小数格式——每个数 4 字节

FP32 用 32 位，也就是 4 字节，存一个小数（浮点数）。它是在电脑上训练时常用的格式，大约保留七位有效数字。同一个模型用 FP32 保存，大小是 FP16 的两倍，所以模型常常用更小的格式来分享或运行。

深入学习 详细了解权重和参数

INT8

8 位整数格式——每个数 1 字节

INT8 用 8 位，也就是 1 字节，存一个从 −128 到 127 的整数。量化模型把权重存成 INT8，用时乘上缩放因子，得到接近原值的数。这样文件大约是 FP32 的四分之一、FP16 的一半，准确度只损失一点点。

深入学习 详细了解权重和参数

标量

原文名称 · Scalar

单独一个数，而不是一串或一张表的数

标量就是一个数，比如 0.7。向量是一串标量，矩阵是一张标量组成的表。模型的参数按标量来数：一个 2 × 3 的矩阵装着 6 个标量，所以是 6 个参数。这就是为什么 8B 表示大约 80 亿个单独的数，而不是 80 亿个向量。

深入学习 详细了解权重和参数

点积

原文名称 · Dot product

同一位置相乘后全部相加得到的一个数

点积是把两个长度相同的数字列表中同一位置的数相乘，再全部加起来得到一个数。[1, 2, 3] 和 [4, 5, 6] 的点积是 4 + 10 + 18 = 32。两个向量的方向越一致，点积越大。在注意力中，Query 和 Key 的点积就是“有多相关”的分数；线性层（linear）也是用权重的每一行与输入做点积。

深入学习 详细了解权重和参数

欧几里得距离

原文名称 · Euclidean distance

用直线连接两点的长度——越短越相似

把两个向量中同一位置的数字相减，把每个差平方后全部加起来，再开平方根，得到的值就是它。[0, 0] 和 [0.3, 0.3] 的距离是 √(0.3² + 0.3²) = 0.424。在嵌入里，距离越短，意思就越相近；向量数据库就用这个距离找出最近的东西。

深入学习

数值精度

原文名称 · Numeric precision

存每个数时用多少位

精度说明每个数存得有多精确，通常用位数来表示：32 位、16 位、8 位、4 位。位数越少，模型越小，往往也越快，但数字会被四舍五入得更粗，质量可能稍微下降。量化就是把模型换成更低精度的操作。

深入学习 详细了解权重和参数

原子事务

原文名称 · Atomic transaction

要么全部完成、要么完全不发生的修改

原子事务是数据库当作一步来处理的一组修改：要么每个修改都保存，要么一个都不保存。如果服务器在中途崩溃，数据库会退回到之前的样子。游戏钱包需要它：玩家买道具时，扣金币和给道具这两件事绝不能只做了一半。

深入学习

数据库转储

原文名称 · Database dump

装着整个数据库内容的文件

数据库转储是一个把数据库里所有东西都复制下来的文件：表、表的设计以及每一行。你做转储是为了备份，或者把数据搬到另一台服务器，再把它载回去就能重建同样的数据库。因为它是你自己拥有的普通文件，如果你不再使用某个服务，转储也是你带走数据的出路。

建立索引

原文名称 · Indexing

建一份查找清单，让数据库快速找到行

索引是数据库额外保存的一份清单，按某个字段排好序，让它能直接跳到需要的行，而不用读每一行。给一个字段建立索引，会让按它搜索变快，但每次保存都会稍慢一些，也更占空间。只给部分字段建索引的存储，就只能按这些字段来搜索。

数据表

原文名称 · Table

数据库里由行和列组成、保存一类记录的表格

数据库把数据存在表里。每张表保存一类东西，比如玩家或道具；每一列是一个字段（名字、等级），每一行是一条记录。程序用查询来读取和修改表，有些系统还允许客户端订阅一张表，收到每一条改动过的行。

数据库查询

原文名称 · Query

向数据库要数据或修改数据的请求

查询是发给数据库的请求：找出这些行、数一数、加一行、改一行。大多数数据库接收用 SQL 写的查询。查询能有多灵活取决于存储：完整的 SQL 数据库几乎能回答任何问题，而简单的键值存储只能按键来查。

键值

原文名称 · Key-value

把每个值存在一个名字（键）下面，再按名字找到它

键值存储把数据存成一对对：一个键，比如 player:42，和一个值，比如这个玩家的存档。按键去要，就能拿回值，速度非常快。代价是你没法像 SQL 那样，轻松地跨很多值提问，比如“所有等级高于 10 的玩家”。

元数据

原文名称 · Metadata

描述其他数据的数据

元数据是关于数据的信息，而不是数据本身：照片的拍摄日期和相机、文件的大小和所有者，或者模型文件里的层名和数字格式。程序读它来知道怎样使用主要的数据。它会多占一些空间，所以模型文件会比单纯的权重稍大一些。

详细了解权重和参数

PostgreSQL

广泛使用的免费开源 SQL 数据库

PostgreSQL，常被叫作 Postgres，是一个开源数据库，把数据存在表里并回答 SQL 查询。它以用事务保护数据安全、以及 JSON 列这类功能而闻名。SONUB 运行在 PostgreSQL 上，Nakama 这类游戏服务器也用它存玩家数据。在 Docker 里，它通常作为一个叫 postgres 的独立容器运行。

Redis

把数据放在内存里的超快键值存储

Redis 把数据放在电脑的内存（RAM）里，而不是主要放在磁盘上，所以读写只要远不到一毫秒。网页应用把它用作缓存、后台任务队列，以及计数器或会话。它可以存到磁盘，但通常是主数据库旁边的帮手，而不是存放绝不能丢的数据的地方。

存储引擎

原文名称 · Storage engine

服务器里负责保存和读回数据的部分

存储引擎是数据库或游戏服务器里决定数据怎样写到磁盘、又怎样找回来的部分。在 Nakama 里，它把玩家的存档数据保存为带版本的 JSON 文档，并检查每一份归谁所有、谁可以读。它的设计决定了你能查什么：Nakama 的存储主要是键值形式，而不是随意的 SQL。

深入学习

结构定义（schema）

原文名称 · Schema

规定数据必须是什么形状的计划

Schema（结构定义）描述数据的形状：在数据库里，是有哪些表、每张表有哪些列和类型；对一个工具或 API，是它接收哪些输入、各是什么类型。程序会拿数据和 schema 对照，拒绝不符合的。AI 工具的输入 schema 就是告诉模型要发送哪些参数的东西。

JSON Schema

写出 JSON 必须是什么形状的标准方式

JSON Schema 是一份 JSON 文档，描述另一份 JSON 文档必须是什么样子：需要哪些键、每个值是什么类型、允许哪些值。工具用它自动检查数据。codex exec --output-schema 这类 AI 工具用它让模型的最终答案严格按这个形状返回。

JSONL

每行一个 JSON 对象的文本格式

JSONL（JSON Lines）每行写一个完整的 JSON 值，而不是一整份大的 JSON 文档。程序可以每收到一行就读取、处理这一行，很适合日志和进度流。codex exec --json 就是这样打印进度的：每一行是一个事件。

TOML

用 key = value 行写成的设置文件格式

TOML 是一种纯文本的设置文件格式。每一行是 key = value，用方括号括起来的 [section] 把相关的设置分成一组。它比 JSON 更容易让人阅读和编辑。Codex 把设置存在 ~/.codex/config.toml 里，把自定义的子智能体存在 .toml 文件里。

base64

把任何文件写成普通字母和数字的方法

base64 把原始的字节，比如一张图片，变成由 64 个安全字符（A–Z、a–z、0–9、+ 和 /）组成的文本。这样文件就能放进只接受文本的地方传送，比如发给 AI API 的 JSON。这段文本比原文件大约大三分之一，而且谁都能把它变回去，所以它不是加密。

zip

把许多文件打包成一个更小文件的格式

zip 文件把许多文件和文件夹打包成一个文件，通常还会变小。Cadeplay 这类游戏平台要求网页游戏以一个 zip 提交。关键是里面的结构：index.html 必须在最上层（或往下一层）。压缩了文件夹本身而不是它里面的内容，会多出一层目录，这是最常见的错误。

深入学习

压缩包

原文名称 · Archive file

把许多文件捆成一个、通常经过压缩的文件

压缩包把许多文件和文件夹装进一个文件里，通常还会变小。常见的有 .zip 和 .tar.gz。技能就是以压缩包的形式分享的：npx skills add 为每个技能下载一个压缩包再解开。这和 Claude Code 的压缩（compaction）不同，那是把对话变短，而不是处理文件。

digest

根据文件内容算出来的指纹值

digest 是根据文件的每一个字节算出来的一个短值，比如 sha256。同一个文件总是得到同样的 digest，哪怕只改一个字节，也会得到完全不同的值。所以比较 digest，不用比较整个文件就能知道文件有没有变。技能把自己压缩包的 digest 当作版本：digest 变了就是新版本。

sha256

计算文件指纹（哈希）的常用方法

SHA-256 是一种哈希函数：它把任何输入变成一个 256 位的值，通常写成 64 个十六进制字符。实际上不可能找到两个值相同的不同文件，所以它被用来检查下载的文件、给版本命名，也用在安全领域。无法从哈希值重建文件；它只用来识别文件。

GIF

能装短小循环动画的图片格式

GIF 是一种老的图片格式，能存好几帧并循环播放，所以被用来做屏幕录像这类短小无声的片段。每一帧最多只能用 256 种颜色，所以照片做成 GIF 会显得颗粒很粗。AI 浏览器工具可以把自己做过的操作录成 GIF，附在报告里。

ID

把一样东西和其他所有东西区分开的唯一名字或编号

ID（标识符）是只属于一样东西的标签，让程序能毫不混淆地指向它：用户编号、文件 ID、bundle ID、密钥 ID。在语言模型里，词表中的每个词元都有一个编号，就是它的词元 ID，模型处理的是这些编号，而不是字母。

存储单位（KB·MB·GB）

原文名称 · KB · MB · GB

表示文件和内存大小的单位

文件和内存的大小按字节来算，数字大了就加上单位：1 千字节（KB）是 1,000 字节，1 兆字节（MB）是一百万字节，1 吉字节（GB）是十亿字节。KiB、MiB 和 GiB 则按 2 的幂来算：1 KiB 是 1,024 字节，1 MiB 是 1,048,576 字节。很多程序写的是 MB，实际指的是 MiB，所以有点小差别很正常。

详细了解权重和参数

毫秒（ms）

原文名称 · Millisecond (ms)

千分之一秒

1 毫秒（ms）是 1/1000 秒。屏幕和程序用毫秒来计量很短的等待：400 ms 就是 0.4 秒，比半秒稍短。人能察觉大约 100 ms 以上的延迟，所以网页会尽量在这之前响应。

像素（px）

原文名称 · Pixel (px)

一个小小的色点；屏幕就是由它们排成的网格

像素是屏幕或图片上最小的点，装着一种颜色。几百万个像素并排在一起，就组成一张图像。在网页设计里，px 是 CSS 的单位：640 px 是一个宽度，但在高分辨率的手机上，一个 CSS 像素可能覆盖好几个真实的屏幕点。在游戏里，速度常常用“每秒多少像素”来表示。

NumPy

在数字网格上快速计算的 Python 库

NumPy 给 Python 加上了数组：可以一次性相加、相乘或比较的数字网格。它内部的循环是用 C 写的，所以比用 Python 循环遍历列表快很多倍。Python 里几乎所有 AI 和数据工具，比如 scikit-learn 和 PyTorch，都建立在同样的思路上，或者直接处理 NumPy 数组。

深入学习

NumPy 数组

原文名称 · Array (NumPy)

NumPy 一次性计算的、同一类型数字组成的网格

NumPy 数组把数字放在网格里：一行（1 维）、一张表（2 维）或更多维。它的所有值类型都一样，所以 NumPy 能一步处理整个数组：a * 2 把每个数都翻倍，a @ b 把两个矩阵相乘。它看起来像 Python 的列表，行为却不一样：+ 是把数相加，而不是把列表连起来。

深入学习

shape

数组在每个方向上有多少项

数组的 shape（形状）列出它在每个维度上的大小：(4, 3) 表示 4 行 3 列。形状决定了哪些运算能做。做矩阵乘法时，里面的两个数必须一致：(4, 3) @ (3, 2) 得到 (4, 2)，而 (4, 3) @ (2, 3) 会报 ValueError。NumPy 报错时，第一件事就是打印 .shape。

深入学习

广播

原文名称 · Broadcasting

NumPy 把较小的数组扩展到和较大的数组一样大

广播是 NumPy 把不同形状的数组合在一起计算的方法：它沿着缺少的方向重复较小的数组，而不真的复制内存。给数组加 1，就是给每个数都加 1；给一张 (4, 3) 的表加上一行 3 个值，就是把这行加到 4 行中的每一行上。如果形状对不齐，就会报错。

深入学习

向量化运算

原文名称 · Vectorised maths

一次对整个数组计算，而不是用循环

向量化运算是指对整个数组写一个运算，比如 a * b，而不是用 Python 的 for 循环一个个处理每个数。NumPy 会在快速的编译代码里跑这个循环，常常快几十倍。神经网络就是这样构建的：一层就是一次矩阵乘法，而不是几百万次单独的乘法。

深入学习

数据泄漏

原文名称 · Data leakage

测试数据的信息不小心混进了训练

当测试数据里的东西在训练时传到了模型那里，测试分数就会比模型的真实水平好看，这就是数据泄漏。常见的原因是在划分数据之前就对全部数据做预处理：这样缩放器学到的平均值就包含了测试行。要先划分，再只在训练部分上拟合每个预处理步骤。

深入学习

特征缩放

原文名称 · Scaling

训练前把各特征的数字调到相近的范围

特征缩放改变每个特征，让它的数落在相近的范围里，比如 0 到 1，或者平均为 0、分散程度为 1。不这样做的话，对比较距离的模型来说，以千计的特征会盖过以个位数计的特征。缩放器只能从训练数据中学它的数，否则就会造成数据泄漏。

深入学习

鸢尾花数据集

原文名称 · Iris dataset

经典的练习数据集：150 朵鸢尾花，3 个品种

鸢尾花数据集记录了 150 朵鸢尾花的测量值，三个品种各 50 朵。每朵花有四个特征：花萼的长度和宽度、花瓣的长度和宽度。任务是根据这些数字猜出品种。它小而干净，又内置在 scikit-learn 里，所以是学习分类时常用的第一个数据集。

深入学习

预处理

原文名称 · Preprocessing

在模型使用数据之前清理和整理数据

预处理是训练或推理前对原始数据做的所有事情：删掉坏掉的行、填补空缺、缩放数字、把文本变成词元，或者用 FFT 把声音变成频率。模型只有在数据是它期望的形式时才学得好。训练时用了什么预处理，之后对新数据也必须用同样的方式处理。

数据

原文名称 · Data

电脑存储和处理的事实：数字、文字、图片、声音

数据是电脑能存储和处理的任何信息：表格里的数字、文字、照片、录音、网站上的点击。程序读取数据、修改数据，再产生新的数据。AI 两次依赖它：模型从训练数据中学到权重，然后再处理你交给它的数据。

详细了解权重和参数

数据分析

原文名称 · Data analysis

检查数据，找出有用的事实和规律

数据分析是指清理、汇总数据并画成图表，来回答问题：哪种商品卖得最好、用户什么时候离开、某个改动有没有用。它常用 Python 的 NumPy 和 pandas、电子表格或 SQL 来做。现在上传一张表格、用普通的话提问，AI 聊天工具也能做简单的分析。

结构化数据

原文名称 · Structured data

放在固定的行列框架里的数据

结构化数据放在固定的框架里：每一行都有同样的列，每一列只放一种值，就像电子表格或数据库的表。这样很容易排序、筛选和计数。经典机器学习和 SQL 在这种数据上最好用，而文字和图片则需要先做更多预处理。

非结构化数据

原文名称 · Unstructured data

没有固定框架的数据：文字、照片、声音、视频

非结构化数据没有固定的行和列：邮件、文档、照片、录音、视频。世界上的大部分数据都是这样的。它很难直接计数或排序，所以要先变成数字，比如词元或嵌入，而语言模型和图像模型正是为处理这种数据而生的。

向量数据库

原文名称 · Vector database

存储嵌入、并找出最接近的那些的数据库

向量数据库存储嵌入向量——捕捉文字或图片意思的一串数——并能很快找出和查询最接近的向量。在 RAG 里，每段文档都存成一个向量；问题也变成向量，最接近的几段就交给模型。文档很少时，简单的内存搜索可能就够了。

Excel

Microsoft 用来做表格和计算的电子表格程序

Excel 是 Microsoft 的电子表格程序：一张由单元格组成的网格，你在里面输入数字和文字，写公式根据其他单元格来计算。它是做业务表格、预算和简单图表最常用的工具。AI 工具可以读你上传的 Excel 文件，回答关于它的问题，还能替你写公式。

电子表格公式

原文名称 · Formula

写在电子表格单元格里的计算

在电子表格里，公式是以 = 开头的指令，根据数字或其他单元格算出一个值，比如 =SUM(B2:B13) 或 =B2*1.1。源单元格一变，结果会自动更新。向 AI 要公式而不只是答案，你就能重复使用并核对这个计算。

声音信号

原文名称 · Sound signal

记录成随时间变化的值的声音

声音信号记录的是麦克风处的气压怎样随时间变化，存成一长串数字。画成图就是波形。声音 AI 很少直接用它：要先用 FFT 这类预处理把它分解成频率。这和 shell 用来让程序停下的“信号”是两回事。

波形

原文名称 · Waveform

声音怎样随时间振动的图

波形是把声音画成一条线：时间从左往右走，线随着振动上下起伏。波越高，声音越响；波越密，音调越高。音频编辑软件就是这样显示录音的。音乐 AI 可以直接处理波形，也可以处理 MIDI 音符，MIDI 只描述音乐而不含声音本身。

频率

原文名称 · Frequency

某样东西每秒振动多少次

频率是每秒振动的次数，单位是赫兹（Hz）。对声音来说，它就是音高：频率越高，听起来越高。A4 这个音是 440 Hz，人能听到大约 20 到 20,000 Hz。真实的声音同时混着许多频率；FFT 能测出每个频率有多强。

赫兹（Hz）

原文名称 · Hertz (Hz)

表示“每秒多少次”的单位

赫兹（Hz）计算某件事在一秒内发生多少次。它用来衡量声音的音高（A4 是 440 Hz）、声音采样的频繁程度（CD 用 44,100 Hz），以及屏幕重绘的频繁程度（120 Hz 的屏幕每秒刷新 120 次）。1 kHz 等于 1,000 Hz。

FFT

把声音快速拆成各个频率的算法

FFT（快速傅里叶变换）是一种算法，计算傅里叶变换比一步步硬算快得多。它取信号的一小段，报告其中每个频率有多强。声音 AI 几乎每次预处理都会用它，比如从录音生成频谱图。

傅里叶变换

原文名称 · Fourier transform

把信号拆成它所含频率的数学方法

傅里叶变换把一个随时间变化的信号，改写成一张频率清单，以及每个频率有多强。任何声音，不管多复杂，都可以看成许多简单的波叠加在一起，而这种变换能把它们找出来。电脑用的是 FFT，一种快速计算它的方法。

IEEE 754

用二进制位存储带小数的数的标准

IEEE 754 是浮点数的国际标准。它把一个数分成三部分存：一个符号位、决定大小的指数，以及装着数字的有效数（尾数）。32 位浮点数用 1 + 8 + 23 位。因为能装下的位数有限，在电脑上 0.1 + 0.2 并不正好等于 0.3。

尾数

原文名称 · Mantissa

存储的数中装着有效数字的部分

在 IEEE 754 中，一个数被分成符号、指数和尾数（也叫有效数）。尾数装着有效数字，指数说明小数点放在哪里。尾数的位越多，数越精确：32 位浮点数有 23 位，16 位浮点数只有 10 位，所以用 16 位训练能省内存，却会损失精度。

MIDI

把音乐记成音符而不是声音的标准

MIDI（Musical Instrument Digital Interface，乐器数字接口）是 1983 年的标准，让电子乐器和电脑交换演奏信息：哪个音、什么时候开始、持续多久、弹得多重。它不含声音，所以 MIDI 文件很小，可以用任何乐器的音色来播放。音乐 AI 有时从 MIDI 学习，因为音乐的结构很容易读出来。

采样率

原文名称 · Sampling rate

每秒测量声音多少次

录音时，电脑每秒测量信号很多次，把每次测量存成一个数。采样率就是每秒测量的次数，单位是赫兹：CD 用 44,100 Hz。采样率越高，能记录的声音越高，文件也越大。语音模型常用 16,000 Hz，因为说话不需要那么高。这和语言模型挑选词元时的“采样”不是一回事。

奈奎斯特频率

原文名称 · Nyquist frequency

一个采样率能记录的最高声音：采样率的一半

奈奎斯特频率是采样率的一半，也是一段录音能正确保存的最高频率。CD 的采样率是 44,100 Hz，所以能记录到 22,050 Hz，刚好高于人能听到的大约 20,000 Hz。超过上限的声音不会就这样消失；除非事先滤掉，否则它们会折回来，变成虚假的低音。

八度

原文名称 · Octave

频率翻倍的两个音之间的距离

八度是一个音和下一个同名音之间的距离：升高一个八度，频率加倍；降低一个八度，频率减半。A4 是 440 Hz，所以 A5 是 880 Hz，A3 是 220 Hz。这两个音听起来像同一个音，只是高一些或低一些，所以它们同名。

频谱图

原文名称 · Spectrogram

显示每一刻哪些频率响亮的图

频谱图显示每个频率的强度怎样随时间变化：横轴是时间，纵轴是频率，亮度是强度。它是对一段录音的许多小片段分别做 FFT 得到的。因为它把声音变成了图像，声音 AI 模型常常拿频谱图当输入。

对数函数

原文名称 · Logarithm (log)

把乘法变成加法的数学函数

对数回答的是“几次方能得到这个数？”：log₁₀(1000) = 3。它把乘法变成加法，把巨大的范围压缩成小范围。AI 在损失里用它：对正确答案得到的概率取对数，概率小就会得到很大的惩罚。这和记录事件的日志文件（log）不是一回事。

NaN

“Not a Number”（不是数字）：说明计算出了问题的信号

NaN 是一个特殊的浮点数值，意思是“不是数字”。它来自 JavaScript 里的 0/0、把 undefined 和数字相加这类计算，一旦出现，就会扩散到所有用到它的计算里。训练时损失变成 nan，通常说明学习率太高。NaN 甚至不等于它自己。

浮点数

原文名称 · Floating point

计算机用比特近似存储小数的方式

计算机按照 IEEE 754 标准，用固定数量的比特来存实数，所以很多小数只能近似地存下来。在 Python 里，0.1 + 0.2 得到 0.30000000000000004。这些舍入误差很小，但经过很多步计算后会累积起来。涉及金额时，要用整数（以分为单位）或 decimal 类型。

YAML

用缩进来写设置的文本格式

YAML 是写设置用的纯文本格式，一行写成“名字: 值”，用缩进表示什么属于什么。Docker Compose 文件、GitHub Actions、Flutter 的 pubspec.yaml，还有 SKILL.md 开头的 front matter 都用它。缩进要用空格，绝不能用 Tab；缩进错一格，意思就会变，或者整个文件读不了。

UUID

几乎不会重复的 128 位唯一编号

UUID（通用唯一识别码）是一个 128 位的数，写成 36 个字符，比如 3f2a1bc4-…。它可以在任何地方生成，不需要去查一份中央名单，两个随机生成的 UUID 实际上不会撞上。Linux 给每个文件系统一个 UUID；在 /etc/fstab 里用它，比用 sda1 这样的名字更安全，因为加一块硬盘后名字可能会变。

深入学习

UTF-8

把各种语言的文字存成字节的标准方式

电脑把文本存成数字。UTF-8 这种编码给每个字符，从英文字母、韩文到阿拉伯文和表情符号，都分配一串 1 到 4 个字节。一个英文字母占 1 个字节，一个韩文音节（常用汉字也一样）占 3 个字节。如今几乎所有网页和代码文件都用 UTF-8 保存。

深入学习

字节序（Endianness）

一个数的各个字节的存储顺序

大于一个字节的数会分成几个字节存储，字节序就是这些字节的排列顺序。小端序把最小的字节放在前面，大端序把最大的字节放在前面。读写同一个文件的程序必须使用相同的顺序，否则读出的数就会出错——safetensors 使用小端序。

深入学习

PDF

在任何设备上看起来都一样的文档文件

PDF（Portable Document Format）会把文档的页面、文字和图片完全按排好的样子保留下来，无论用哪台电脑或手机打开都一样。所以收据和记录常用这种格式。SONUB 会把预约证据导出成 PDF。

JPG（JPEG）

原文名称 · JPG (JPEG)

靠舍弃细节来节省空间的常见照片格式

JPG 也写作 JPEG，是最常见的照片格式。它丢掉肉眼几乎察觉不到的细节，让文件变小，所以同一张图反复保存，画质会一点点变差。它不能有透明背景——PNG 可以。

PNG

把每个像素都原样保留的图片格式

PNG 会把每个像素都原样保存（无损），还可以有透明背景，所以适合截图、标志和文字图片。同一张照片存成 PNG，通常比存成 JPG 大得多。

WebP

通常能让文件更小的网页图片格式

WebP 是 Google 为网页设计的图片格式。它既能像 JPG 那样压缩图片，也能像 PNG 那样保留每个像素，还可以有透明背景，文件通常比这两种都小。现在的浏览器都能打开，但有些旧程序打不开。

MP4

最常见的视频文件格式

MP4 是最常见的视频文件格式：一个文件里装着压缩过的画面和声音，几乎所有手机、电脑和浏览器都能播放。SONUB 的老师可以上传最大 50 MB 的 MP4 作为介绍视频，也可以改填一个 YouTube 地址。

国家代码

原文名称 · Country code

代表一个国家的两个字母，比如 KR 或 PH

国际标准 ISO 3166-1 给每个国家规定了一个两个字母的代码：韩国是 KR，菲律宾是 PH，美国是 US。这样写，任何语言里的国家名称都拼得一模一样。SONUB 在身份验证中用这种方式填写证件所属的国家。

API

一个程序调用另一个程序的固定窗口

API 是程序之间事先约定好的窗口：按规定的格式发去请求，就会按规定的格式收到回答。你不必看对方程序的内部，只需面对这个窗口。通过 API 使用人工智能，意思就是由你自己的应用去向模型提问，而不是由人手动输入。

API 密钥

原文名称 · API key

用来识别你并计费的密钥字符串 — 绝不可外泄

API 密钥是一串很长的秘密字符，用来告诉服务是谁在调用、该向谁计费。请把它当作银行卡号来对待：绝不要贴进聊天框、截图或公开代码仓库。一旦泄露，立刻到服务商后台删除该密钥并重新签发一个。

Git

把文件的每一次改动都记录下来的工具

Git 会保存项目的完整历史，让你看清什么时候改了什么，并能退回到任何一个早先的状态。它还让多人同时改同一批文件而不互相覆盖。Git 跑在你自己的电脑上，GitHub 则是保存 Git 项目副本的网站——两个名字很像，常被弄混。

深入学习

仓库

原文名称 · Repository

一个项目的文件夹，连同它的全部历史

仓库指的是被 Git 盯着的那个项目文件夹，再加上其中发生过的全部改动记录。克隆一个仓库，文件和这段历史会一起拷到你的电脑上。别人说代码在 GitHub 上，意思就是那里有一个可以拷贝的仓库。

深入学习

提交

原文名称 · Commit

历史里的一个存档点，附上这次为什么改

提交是把项目在某一刻的样子整个存下来，并附上一句话说明改了什么、为什么改。提交会一直留着，所以你随时能回到那个时刻。把改动拆小、说明写实在，历史才有用；一个巨大的提交只写“更新”，日后谁也看不懂。

深入学习

分支

原文名称 · Branch

不影响主线、可以另外干活的岔路

开一个分支，就是从主线上岔出来去试点东西，在你满意之前原来的那条线丝毫不动。试失败了，把分支丢掉即可；试成功了，再合并回去。团队之所以能同时做好几个功能而不互相干扰，靠的就是它。

深入学习

命令行(CLI)

原文名称 · Command line (CLI)

不用点鼠标，靠敲命令来干活

命令行界面是靠一行行敲指令来驱动的程序，而不是在菜单里点来点去。它看着朴素，却精确又好复现：你刚敲的那一行可以存下来、发给别人，明天原样再跑一遍。包括 Git 和人工智能编程助手在内，多数开发工具都提供命令行。

深入学习

终端

原文名称 · Terminal

用来敲命令的那个黑窗口

终端就是给你一块地方敲命令、并把结果打印出来的那个应用。在 Mac 上它叫“终端”，在 Windows 上是 Windows Terminal 或 PowerShell。光是在里面打字本身并不危险，窗口随时可以关掉；新手对它的畏惧，远远超过了实际的风险。

深入学习

算法

原文名称 · Algorithm

一份配方：按固定步骤走，总能得到同样的结果

算法就是把输入变成结果的一串有限步骤，跟菜谱一样。把名字按字母排序、找出最短路线，都是算法。这个词听着唬人，其实你每天都在照算法办事；电脑只是照做而已，不会觉得烦，也不会漏掉一行。

库

原文名称 · Library

别人写好的现成代码，拿来就能用

库是别人写好并验证过的一包代码，把它引入自己的项目，就不必把已经解决的问题再解一遍。读日期、画图表、发邮件，这些多半已经有人做得很好。会挑库同样是本事，因为你的程序会连同它的优点和缺陷一起继承下来。

开源

原文名称 · Open source

任何人都可以阅读、使用和修改代码的软件

开源软件把源代码公开，并附上许可证，允许任何人阅读、运行和修改。正因为这样敞开着，素不相识的人才会替它找出毛病，你也不会被某一家公司锁死。开源并不等于毫无义务：每种许可证条件不同，值得先看清用的是哪一种。

调试

原文名称 · Debugging

追查程序为什么出错，并把它改好

调试就是查明程序为何做出了你没打算让它做的事，然后把它改正。这活儿多半不靠灵光一闪，而靠沉住气一点点缩小范围：到底发生了什么，你原本期待什么，两者第一次分岔在哪里。新手常觉得需要调试说明自己不行；其实编程更大的那一半就是它。

错误信息

原文名称 · Error message

出了问题时程序显示的文字

错误信息是程序或浏览器做不到代码要求的事时显示的文字。它通常会说出哪里出了什么问题——常常还会写明第几行。它看起来吓人，却是你手里最有用的线索：读一读第一行，或者把它贴给 AI，问问是什么意思。

深入学习

Python

对初学者友好、在人工智能领域广泛使用的语言

Python 是一种编程语言，写出来的代码读起来几乎像平常的英语。它是数据分析和人工智能最常用的语言，PyTorch、NumPy 等大多数人工智能库都是从 Python 里调用的。在本站，你可以直接在浏览器里运行真正的 Python，什么都不用安装。

深入学习

程序

原文名称 · Program

计算机按顺序执行的一组指令

程序是一份指令清单，一步一步告诉计算机该做什么。应用、游戏和网站都是程序，人工智能聊天机器人也是。计算机只会照程序说的去做，所以程序出了问题，原因就在它的指令里，或者在交给它的输入里。

代码

原文名称 · Code

用编程语言写下的指令

代码是程序的文字，用 Python、JavaScript 这样的编程语言写成。人来写，计算机来运行。代码必须严格遵守语言的规则，少一个括号就可能运行不了。写代码也叫编程；人工智能工具也能写代码，但仍然需要人来检查。

代码编辑器

原文名称 · Code editor

用来编写和修改代码的程序

代码编辑器是用来编写和修改代码文件的程序。它会给代码的不同部分上不同的颜色，在你输入时指出错误，通常还内置了终端。VS Code（Visual Studio Code）是一款很受欢迎的免费编辑器，许多人工智能编程工具都以扩展的形式装在它上面。

流程图

原文名称 · Flowchart

按顺序画出一件事各个步骤的图

流程图把一件事的步骤画成方框，再用箭头连起来。圆角框表示开始或结束，长方形表示要做的事，菱形则提出一个“是或否”的问题，让路线分成两条。在写程序之前先画一张，就能清楚该发生什么、按什么顺序发生。

深入学习

输入和输出

原文名称 · Input and output

进入程序的东西和从程序出来的东西

输入是程序收到的东西：你敲的键、一次鼠标点击、一个文件，或者一个问题。输出是程序给回来的东西：屏幕上的文字、一段声音，或者一个保存下来的文件。在两者之间，程序对输入进行处理。人工智能聊天机器人也是同样的模式：你的问题是输入，它的回答是输出。

编程语法

原文名称 · Syntax

代码必须怎样书写的严格规则

语法是一种编程语言的书写规则：括号、冒号、引号和空格必须放在哪里。计算机不会去猜你的意思，所以哪怕少一个引号，也会出现语法错误，代码根本运行不起来。错误信息通常会指出是哪一行，那就是最先要看的地方。

运行时

原文名称 · Runtime

真正运行你的代码或模型的程序

运行时是真正把别处写好的东西跑起来的程序。Node.js 在浏览器之外运行 JavaScript，Pyodide 在浏览器里运行 Python，llama.cpp 读取人工智能模型文件并完成计算。这个词也指“程序正在运行的时候”，所以只在运行代码时才出现的错误叫运行时错误。

软件框架

原文名称 · Framework

现成的骨架，由你的代码往里填

框架是一大块现成的代码，已经决定好了应用要怎样组织；你写的是让它在合适时机调用的那些部分。库正好相反：你的代码想什么时候用就什么时候调用它。Web 框架能省下很多工作，但在底层，它们读请求、写响应用的仍然是普通的 HTTP，所以本站先让你看清这一来一回。

深入学习

SDK

为某个平台开发时用的一套代码和工具

SDK 是 software development kit（软件开发工具包）的缩写。平台把它发给开发者，让你的程序不必从零写起，就能用上平台的功能，比如云存档、排行榜或登录。里面通常有一个调用平台 API 的库，再加上文档和示例。在本站，它出现在 Cadeplay 的介绍里 —— Cadeplay 会替你把它的 SDK 加进游戏。

深入学习

构建步骤

原文名称 · Build step

把源代码变成可以运行或发布的文件

构建就是把你写的代码变成真正要运行的成品文件 —— 比如把一个 React 项目压成 dist 文件夹里的普通 HTML、CSS 和 JavaScript。做这一步的叫构建工具。做出来的成品也叫一个构建，所以“新构建”指的是游戏或应用新打包的一个版本。构建产物每次都会重新生成，所以不放进 Git。

深入学习

游戏引擎

原文名称 · Game engine

替游戏完成共同基础工作的软件

游戏引擎负责几乎每个游戏都需要的工作：往屏幕上画画面、读取输入、播放声音、物理计算，以及加载图片和声音。你在上面加上自己游戏的规则和美术。Godot、Unity、Unreal 和基于 Flutter 的 Flame 都是有名的例子。许多引擎能把同一个项目导出到网页、手机和桌面电脑。

深入学习

MVP

人们真的能用起来的最小版本

MVP 是 minimum viable product（最小可行产品）的缩写。对游戏来说，它是最小可玩的游戏：很小，但陌生人拿到手不用人教，就能从头玩到尾。它不是演示，也不是草图。尽早发布 MVP，能从真实玩家那里得到真实的反馈，这是一个人闷头做几个月也换不来的。

深入学习

.env 文件

原文名称 · .env file

把机密放在代码之外的文件

.env 文件是放在项目文件夹里的纯文本文件，每行写一条“名字=值”，比如令牌和密码。程序按名字读取值，所以机密本身从不出现在代码里。这个文件必须写进 .gitignore，绝不进入仓库；如果机密曾经被推送出去，就当它已经泄露，换一个新的。

CI（持续集成）

原文名称 · CI (continuous integration)

每次改代码都会自动运行的测试

持续集成（CI）是指每当有人把代码发到共享仓库，服务器就自动构建项目、运行测试。只要哪里坏了，团队几分钟内就会看到一个红色标记，那时改动还没合并进去。GitHub Actions 是一个使用广泛的 CI 服务。

版本控制

原文名称 · Version control

把文件的每一次改动都记录下来

版本控制是把一组文件的每一次改动记录下来的做法，连同是谁改的、什么时候改的、为什么改。有了它，你能比较任意两个版本、回到之前的版本，还能让好几个人安全地修改同一个项目。Git 是当今使用最广的版本控制工具。

深入学习

GitHub

在网上托管 Git 仓库的网站

GitHub 是一个网站，把 Git 仓库的副本存在互联网上，让团队能共享同一个项目。除了存放，它还提供用来审查改动的 Pull Request、问题列表和自动检查。Git 是你电脑上的工具；GitHub 是在网上保存仓库的服务之一，类似的还有 GitLab。

深入学习

Pull Request（PR）

原文名称 · Pull request (PR)

请人审查并合并你分支的请求

Pull Request（简称 PR）是 GitHub 这类网站上的一个页面，请团队把你分支上的改动合并进主分支。审查的人读 diff、留评论、批准；你再推送新的提交，同一个 PR 就会自动更新。它与其说是代码考试，不如说是说明你改了什么、为什么改的地方。

深入学习

diff（差异）

原文名称 · Diff

逐行显示改了什么

diff 显示文件两个版本之间的差异：以 - 开头的行是删掉的，以 + 开头的行是加上的。git diff 显示还没放进暂存区的改动，git diff --staged 显示马上要提交的内容。每次提交前读一遍 diff，是发现错误最简单的办法，人工智能做的改动也一样。

深入学习

.gitignore

列出 Git 不该跟踪的东西的文件

.gitignore 是项目里的一个文本文件，列出 Git 应该忽略的文件和文件夹，比如 node_modules、构建产物，以及存放机密的 .env 文件。每行写一个模式：末尾的 / 表示文件夹，* 匹配任意名字。它对已经提交过的文件不起作用；那些文件要先用 git rm --cached。

深入学习

快照

原文名称 · Snapshot

某一刻全部文件的完整样子

快照记录下项目里每个文件在某一刻的状态。Git 的每一次提交都是一张快照，而不只是一份改动清单；没有变的文件只是指向已经存好的那一份，所以快照并不占地方。正因为这样，Git 能瞬间跳到任何一次提交，也能很快比较两个时刻。

深入学习

工作区

原文名称 · Working tree

你看到并编辑的真实文件

工作区就是你眼里的项目文件夹：你实际打开、编辑的那些文件。Git 拿它和上一次提交比较，告诉你改了什么。改动可能待在三个地方，它是其中之一，另外两个是暂存区和仓库；git status 会告诉你每个改动在哪里。

深入学习

暂存区

原文名称 · Staging area

为下一次提交收集改动的地方

暂存区也叫索引（index），放着你为下一次提交挑好的改动。git add 把改动放进去，git commit 只保存暂存区里的内容。有了这个中间步骤，你可以改了五个文件，却只提交属于同一件事的两个，历史读起来就清楚。

深入学习

克隆

原文名称 · Clone

把整个仓库复制到你的电脑上

克隆就是把一个已有的仓库（通常在 GitHub 上）复制到你的电脑上：所有文件，再加上完整的历史。Git 还会把来源记成一个名叫 origin 的远程仓库，以后你就能拉取新的改动、推送自己的改动。克隆只做一次；之后用 git pull 保持最新。

深入学习

远程仓库

原文名称 · Remote

放在另一台电脑上的仓库副本

远程仓库是同一个仓库的另一份副本，通常在 GitHub 上，大家约好共用它。按惯例，主要的那个叫 origin。git push 把你的提交发过去，git pull 或 git fetch 把别人的提交拿回来。你本地的做法不会变；远程仓库只是大家碰头的地方。

深入学习

推送

原文名称 · Push

把你的提交发到远程仓库

推送就是把你分支上的提交上传到远程仓库，让别人能看到。第一次用 git push -u origin main 时，还会把你的分支和远程分支配成一对，以后只敲 git push 就行。如果别人先推送了，Git 会拒绝，直到你把他们的工作拉下来。git push --force 会覆盖别人的提交，所以在共享分支上别用。

深入学习

拉取

原文名称 · Pull

取回远程的提交并合并进来

拉取会从远程仓库下载新的提交，并马上把它们合进你当前的分支。它等于 git fetch 再加一次合并，所以如果你也改了同样的行，就可能发生冲突。git pull --rebase 则是把你自己的提交重新摞到上面，让历史保持一条直线。

深入学习

获取（fetch）

原文名称 · Fetch

下载远程的提交，但不合并

fetch 会从远程仓库下载最新的提交，但不动你自己的分支。新的工作先放在 origin/main 这样的名字下面，你可以先看一看，再决定要不要合并。所以想看看别人推送了什么，fetch 是安全的办法；git pull 则是 fetch 之后马上合并。

深入学习

合并

原文名称 · Merge

把两个分支的工作合到一起

合并就是把一个分支的提交并入另一个分支，通常是把做完的功能分支并入 main。如果两个分支改的是不同的地方，Git 会自己合好；如果改了同样的行却改得不一样，它就会停下来，留下冲突让你解决。合并会把历史按真实发生的样子保留下来。

深入学习

冲突

原文名称 · Conflict

两处改动碰到了同样的行

两个分支把一个文件的同样几行改成了不同的样子，Git 没法决定留哪个，这就是冲突。Git 会停下来，用 <<<<<<<、======= 和 >>>>>>> 标出位置。把文件改成正确的版本、删掉这些标记，然后 git add 再提交。冲突不是错误，而是 Git 在请人来做决定。

深入学习

复刻（fork）

原文名称 · Fork

在你名下的一份别人仓库的副本

fork 是把别人的仓库复制到你自己账号下的一份副本，通常在 GitHub 上。你不能向不属于你的项目推送，所以要推送到自己的 fork，再向原仓库发 Pull Request。fork 是给开源项目做贡献的常见方式。

深入学习

变基（rebase）

原文名称 · Rebase

把你的提交挪到另一个点的上面

rebase 把你的提交拿起来，在另一个提交之上重新放一遍，让历史读起来是一条直线。git rebase -i 还能在公开之前把提交合并、改写说明或调换顺序。rebase 会新建提交来替换原来的，所以别人已经拿到的提交，绝不要 rebase。

深入学习

HEAD

指向你此刻在历史中位置的指针

HEAD 是 Git 给你当前所在提交起的名字，通常就是当前分支的最新提交。很多命令都从它开始数：HEAD~1 是前一个提交，HEAD~3 是往前数三个。git reflog 会列出 HEAD 到过的每一个地方，丢掉的提交常常就是这样找回来的。

深入学习

变量

原文名称 · Variable

装着一个值的名字

变量是你给一个值起的名字，方便以后使用。在 Python 里，名字 = 值 就把它存起来了，这里的 = 意思是“把这个值放进这个名字”，而不是“等于”。变量装的东西随时可以换，凡是要写这个值的地方，都可以写它的名字。

深入学习

函数

原文名称 · Function

有名字、可以反复使用的一段代码

函数是一段有名字的代码，需要的时候随时可以再运行。在 Python 里用 def 来定义，把它接收的值列在括号里，再用 return 交回一个值。print() 和 len() 是 Python 自带的函数；用 def 就能做你自己的函数。

深入学习

条件

原文名称 · Condition

决定哪段代码要运行的“是或否”判断

条件是一个答案为 True 或 False 的问题，比如 score >= 60。if 语句只在条件为 True 时运行它下面的几行，else 处理另一种情况。里面的几行必须缩进四个空格；Python 就是靠这个知道 if 块在哪里结束。

深入学习

循环

原文名称 · Loop

一遍又一遍重复运行的代码

循环会把同样的几行一遍又一遍地运行。for 循环一次走过一个项目，比如 range(1, 11) 里的每个数，或者列表里的每一项。while 循环只要条件还是 True 就一直重复，所以如果条件永远不变成 False，它就永远停不下来。

深入学习

缩进

原文名称 · Indentation

行首的空格，用来把代码分组

缩进是行首空出来的位置。在 Python 里它是规则的一部分：if、for 或 def 下面的几行必须缩进，通常是四个空格，表示它们属于里面。该缩进的行没有缩进，或者宽度对不齐，Python 就会停下来报 IndentationError。

深入学习

列表

原文名称 · List

放在 [ ] 里、有顺序的一组值

列表把好几个值按顺序放在一个地方，用方括号括起来。每一项都有一个从 0 开始的位置编号，所以 fruits[0] 是第一项。可以用 append() 添加项目，用 len() 数有几项，用 for 循环一项一项地走过。

深入学习

字典

原文名称 · Dictionary

放在 { } 里的一对对键和值

Python 的字典在花括号里存放一对对的键和值，比如 {"math": 80}。查值靠键而不是靠位置，所以 scores["math"] 得到 80。给一个新键赋值就会加上一对，同一个键只能出现一次。在代码里它常被简写成 dict。

深入学习

访问令牌

原文名称 · Access token

让工具使用你账号的一串秘密字符

访问令牌是服务发给你的一长串秘密字符，让你的工具不用密码就能使用你的账号，比如把游戏上传到 Cadeplay。要像对待密码一样对待它：放在 .env 文件里，绝不粘贴到对话或代码里，一旦泄露就到服务的控制台把它删掉。它和人工智能计算文本时说的词元毫无关系。

深入学习

游戏循环

原文名称 · Game loop

游戏每秒重复很多次的一轮流程：读取输入、更新世界、绘制画面。

游戏循环是每个游戏的心脏。每转一圈，它读取玩家的输入，更新位置、碰撞和分数，再画出新画面。一圈就是一帧。引擎会替你运行这个循环，你来写循环里发生的事。

深入学习

FPS（每秒帧数）

原文名称 · FPS (frames per second)

游戏每秒画出多少张新画面。

FPS 统计游戏循环每秒完成多少次、显示多少个新帧。60 FPS 意味着每 16.7 毫秒一帧，感觉很流畅；低于约 30，游戏就开始卡顿。繁重的绘制，或更新里的慢代码，都会让 FPS 下降。

深入学习

精灵（Sprite）

在游戏里移动的小图片，比如角色、金币或子弹。

精灵是游戏每一帧画在某个位置上的 2D 图片。走路的角色常常是一张精灵图——一排依次显示就成了动画的小图。精灵通常带着一个用来做碰撞检测的碰撞箱。

深入学习

碰撞检测

原文名称 · Collision detection

每一帧用叫作碰撞箱的隐形盒子，检查游戏里的两个东西有没有碰到。

碰撞检测决定玩家什么时候落到平台上、捡到金币或者被击中。最简单的办法是给每个精灵一个矩形（碰撞箱），检查两个矩形是否重叠。引擎自带的物理系统可以替你做这件事。

深入学习

帧间隔时间（delta time）

原文名称 · Delta time

距上一帧过去的时间，用来让游戏在每台设备上都以同样的速度运行。

不同屏幕的刷新速度不同，所以每一帧花的时间并不一样。把速度乘以帧间隔时间（dt），东西就按“每秒的距离”而不是“每帧的距离”移动。不这样做，游戏在快的显示器上会变快，在慢的手机上会变慢。

深入学习

工作流

原文名称 · Workflow

完成一件工作的固定步骤顺序

工作流是一组总按同样顺序运行的步骤。在 AI 设计里，工作流沿着事先写好的路径走，而智能体自己决定下一步。在 GitHub 上，工作流是放在 .github/workflows/ 里的 YAML 文件，会自动运行一些步骤——比如有人留言时运行测试，或者请 Claude 修复一个 issue。

隐私政策

原文名称 · Privacy policy

说明应用收集哪些个人数据、为什么收集的公开页面

隐私政策是一个公开页面，说明一个应用或网站收集哪些个人数据、为什么收集、和谁共享，以及用户怎样删除这些数据。应用商店要求先填好它的网址才能发布应用，审核人员也会检查它和应用的实际行为是否一致。很多国家的法律也要求必须有。

深入学习

Babylon.js

在网页浏览器里运行的免费 3D 游戏引擎

Babylon.js 是一个开源引擎，用来做在网页里运行的 3D 游戏和场景，内置了物理、动画、光照和 3D 模型加载。它用 TypeScript 写成，也可以在 JavaScript 里使用。因为运行环境就是浏览器，玩家点开一个链接就能玩，什么都不用安装。

深入学习

Construct

在浏览器里使用、基本不用写代码的 2D 游戏制作工具

Construct 是一个在网页浏览器里运行的 2D 游戏引擎。你不用敲代码，而是在“事件表”上搭规则：发生这件事时，就做那件事。需要更多功能时，可以加上 JavaScript。它可以把游戏导出到网页和其他平台。

深入学习

C++

用在游戏引擎和浏览器内部、历史悠久的高速语言

C++ 是一种程序设计语言，代码会提前被转换成机器码，所以程序运行得非常快，还能直接控制内存。Unreal Engine 这样的游戏引擎、网页浏览器和许多大型游戏都是用它写的。代价是难：内存上出错会让程序崩溃，而且要学很久。

深入学习

C#

Microsoft 的程序设计语言，用来写 Unity 游戏

C#（读作“C sharp”）是 Microsoft 做的一种程序设计语言。Unity 的游戏脚本就是用它写的，它也用来写 Windows 程序和 Web 服务器。它比 C++ 容易，因为内存会自动帮你清理，但它周边的工具仍然多得要另花功夫去学。

深入学习

Dart

Google 的程序设计语言，用来写 Flutter 应用

Dart 是 Google 做的一种程序设计语言。Flutter 应用就是用它写的，所以学 Dart 是用 Flutter 做手机应用的第一步。它看起来和 JavaScript、Java 很像，既可以变成手机上运行很快的机器码，也可以变成网页用的 JavaScript。

深入学习

Defold

用 Lua 写脚本的免费轻量游戏引擎

Defold 是一个免费的游戏引擎，主要用来做 2D 游戏，打包出来的体积很小，所以游戏在手机和网页上加载得很快。游戏逻辑用 Lua 来写。它出现在游戏服务器页面上，是因为 Colyseus 这类服务器提供 Defold 的 SDK。

深入学习

Flutter

用一套代码做出手机、网页和桌面应用的 Google 工具包

Flutter 是 Google 推出的免费应用开发工具包。你用 Dart 把应用写一次，同一套代码就能做出 iPhone 应用、Android 应用、网页或桌面程序。画面上的每个部分都是一个组件（widget），把组件一层层套在别的组件里，就搭出整个画面。

深入学习

Flame

建立在 Flutter 之上的免费 2D 游戏引擎

Flame 是一个在 Flutter 里运行的开源 2D 游戏引擎。它补上了 Flutter 做游戏缺少的部分：游戏循环、精灵、碰撞检测和输入处理，而游戏周围的菜单仍然可以用普通的 Flutter 组件来做。它只能做 2D，不要打算用它做 3D 游戏。

深入学习

Godot

免费开源的 2D 和 3D 游戏引擎

Godot 是一个任何人都能免费使用的游戏引擎，卖游戏也不用交费用，因为它是以 MIT 许可证开源的。它能做 2D 和 3D 游戏，游戏代码用长得像 Python 的 GDScript 来写，也可以用 C#。它很轻，普通笔记本电脑就能跑。

深入学习

Go

Google 的程序设计语言，常用来写服务器

Go（也叫 Golang）是 Google 做的一种程序设计语言。Go 程序会编译成一个可执行文件，运行快，还能同时处理很多连接，所以常用来写服务器。Nakama 游戏服务器就是用 Go 写的，你也可以用自己的 Go 模块来扩展它。

深入学习

Haxe

能把一套代码转换成多种其他语言的程序设计语言

Haxe 是一种开源的程序设计语言，它的编译器能把同一套代码转换成 JavaScript、C++、C# 等目标语言。游戏开发者用它把同一款游戏发布到网页、桌面和手机上。它出现在游戏服务器页面上，是因为有些服务器提供 Haxe 的 SDK。

深入学习

Lua

很容易嵌进游戏里的小型脚本语言

Lua 是一种轻巧、简单的脚本语言，程序可以把它装在自己里面。游戏引擎和服务器把它嵌进去，这样不用重新构建整个程序，就能编写和修改游戏规则。Defold 用的是 Lua，Nakama 服务器除了 Go 和 TypeScript，也接受 Lua 模块。

深入学习

Phaser

做浏览器 2D 游戏的免费 JavaScript 框架

Phaser 是一个开源框架，用来做在网页浏览器里运行的 2D 游戏，用 JavaScript 或 TypeScript 来写。它替你运行游戏循环，并提供精灵、物理、声音和输入，所以你只需要写每一帧发生什么。很多人做的第一款网页游戏就是用它做的。

深入学习

PixiJS

在浏览器里快速绘制 2D 图形的 JavaScript 库

PixiJS 是一个开源库，借助显卡在网页里非常快地绘制 2D 图片和精灵。它只负责画：自己没有物理、声音和游戏规则，所以它是一个绘图库，而不是完整的游戏引擎。游戏要自己补上这些部分，或者使用 Phaser 这样的引擎。

深入学习

Unity

在手机、PC 和主机游戏中广泛使用、也最常被教的游戏引擎

Unity 是一个游戏引擎，很大一部分手机游戏和许多 PC、主机游戏都是用它做的。你在它的编辑器里搭建场景，用 C# 写游戏脚本。它几乎能导出到所有平台，包括网页（WebGL），所以很多课程都教它。用来做一个很小的第一款游戏，它显得太重了。

深入学习

Unreal Engine

Epic Games 做高品质 3D 游戏的引擎

Unreal Engine 是 Epic Games 推出的游戏引擎，在画面最重要的时候会选它：逼真的光照、材质和大型 3D 世界。游戏代码用 C++ 写，或者用蓝图可视化地搭出来。它需要性能强的电脑，用来做第一款小游戏太大了。

深入学习

蓝图（Blueprint）

Unreal Engine 用连接方框来搭游戏逻辑的方式

蓝图是 Unreal Engine 的可视化脚本系统。你不用敲代码，而是放上“按下按键时”“播放声音”这样的方框（节点），再在它们之间连线。不写 C++ 也能做出游戏逻辑，但蓝图图表一大，就会变得很难看懂。

深入学习

glTF

传送 3D 模型的标准文件格式

glTF 是由 Khronos Group 维护的一种开放的 3D 模型文件格式。一个文件里装着形状、材质、贴图和动画，引擎可以很快加载，所以常被称为“3D 界的 JPEG”。它有两种形式：.gltf（文本加上单独的文件）和 .glb（所有内容装进一个二进制文件）。

深入学习

TypeScript

加上类型、在运行前检查代码的 JavaScript

TypeScript 就是 JavaScript 加上类型：你写明每个变量存的是哪种值，检查器会在程序运行之前提醒你哪里写错了。浏览器运行的是 JavaScript，所以 TypeScript 要先被转换成普通的 JavaScript。大型网页应用、Babylon.js 和许多游戏服务器都用它。

深入学习

Rust

能挡住很多内存错误的高速程序设计语言

Rust 是一种程序设计语言，运行起来和 C++ 一样快，但会在编译时检查内存的使用，所以一整类崩溃和安全漏洞在程序运行之前就被挡住了。它用来写服务器、命令行工具，以及 SpacetimeDB 模块这类游戏后端。它以严格、难学出名。

深入学习

PHP

在服务器上生成网页的程序设计语言

PHP 是一种在 Web 服务器上运行的程序设计语言，它先把 HTML 页面生成好，再发给浏览器。网上很大一部分网站都跑在它上面，包括 WordPress，SONUB 本身也是一个 PHP（Laravel）程序。访问者永远看不到 PHP 代码，只能看到它生成的页面。

深入学习

Vite

快速创建和构建网页项目的工具

Vite 是一个前端构建工具。它能创建一个马上就能跑的项目（React、Vue 等），运行一个开发服务器，你一保存页面就会更新，再用一条命令把最终文件构建到 dist 文件夹里，任何 Web 服务器都能直接提供这些文件。它需要 Node.js。

深入学习

Pyodide

在网页浏览器里运行的 Python

Pyodide 是把真正的 Python 解释器转换成 WebAssembly，让它能在网页里运行。SONUB 的 Python 课程就用它，所以你的代码在你自己的电脑上运行，什么都不用安装。第一次加载要等一会儿，因为要下载运行环境。它不能像电脑上的 Python 那样开普通的网络服务器，也不能运行后台服务。

深入学习

A/B 测试

原文名称 · A/B testing

给不同的玩家看两个版本，比较哪个效果更好

在 A/B 测试里，玩家被随机分成两组：A 组看到现在的版本，B 组看到改过的版本，比如价格或新手教程不一样。然后比较一个事先选好的数字，比如第二天有多少玩家回来。它用测量代替猜测，但需要足够多的玩家，差别才有意义。

深入学习

年龄分级

原文名称 · Age rating

商店根据游戏内容给游戏定的年龄限制

游戏发布之前，商店会让你填一份内容问卷：用“是/否”回答游戏里有没有暴力、流血、赌博、和陌生人聊天等内容。你的回答决定了商店上显示的年龄分级，比如“12 岁及以上”。没填问卷是做好的游戏提交不了的常见原因，答错了以后还可能被下架。

深入学习

Apache 2.0

连专利也一起授权的宽松开源许可证

Apache License 2.0 是一种开源许可证：任何人都可以使用、修改、出售和分享代码，哪怕放进不公开源码的商业产品里也行。作为交换，你要保留版权和许可证声明，并标出你改过的文件。它还把贡献者对这些代码拥有的专利一起授权出来，这是公司喜欢它的原因之一。

深入学习

素材

原文名称 · Asset

游戏用到的图片、声音、模型等文件

素材是游戏除代码以外用来搭建的文件：图片、精灵、声音、音乐、3D 模型、字体和关卡数据。它们通常占了游戏体积的大部分。每一份素材你都必须有使用权，包括用 AI 生成的那些，所以发布之前要检查许可证。

深入学习

战斗通行证

原文名称 · Battle pass

整个赛季里靠玩游戏一级级解锁奖励的阶梯

战斗通行证是一种按赛季运行的游戏商品，一个赛季通常是几周或几个月。玩游戏、完成挑战能赚到点数，用来一级一级地解锁奖励。通常有一条免费路线和一条奖励更多的付费路线，赛季结束它也跟着结束，这给了玩家回来的理由。

深入学习

核心循环

原文名称 · Core loop

玩家一遍又一遍重复的那一小组动作

核心循环是玩家在游戏里反复做的事，比如：跳过障碍 → 收集金币 → 加速。如果这个循环不好玩，周围加再多东西也救不了这款游戏，所以要最先做出来并测试。它是一个设计上的概念，和代码里每一帧绘制画面的游戏循环不是一回事。

深入学习

生态系统

原文名称 · Ecosystem

围绕一项技术的全部工具、库和人

一项技术的生态系统，是围绕它长出来的一切：库、编辑器、教程、现成的素材、论坛，以及回答问题的人。生态大，意味着大多数问题在某个地方已经有了答案；生态年轻，意味着你要自己动手做、自己解决的更多。这是选择某个引擎或语言的一大理由。

深入学习

边界情况

原文名称 · Edge case

代码容易出错的少见或极端情况

边界情况是处在可能范围最边缘的输入或情况：名字是空的、分数刚好是零、手机在保存时断了信号，或者在同一帧里按下两个键。代码通常在普通情况下没问题，到这里就出错，所以把边界情况列出来逐个测试，能尽早发现错误。AI 很擅长把它们列出来。

深入学习

一帧

原文名称 · Frame

游戏画面的一张静止图片，每转一圈循环画一次

游戏靠快速画出许多静止的图片来表现动作，就像手翻书。每一张图片就是一帧：每一帧，游戏都要读取输入、更新位置、画出画面。在 60 帧每秒下，每帧大约有 16 毫秒。如果每帧都让东西移动固定的距离，游戏在刷新更快的屏幕上就会变快，所以要用帧间隔时间。

深入学习

游戏平衡

原文名称 · Balancing

调整难度、奖励和各种数值，让游戏感觉公平又好玩

游戏平衡就是调整游戏里的数字：跳得多高、一关有多少敌人、奖励给多少、道具卖多少钱。小小的改动就可能让游戏太简单、太难或者不公平。AI 可以模拟并建议数字，但感觉对不对，要由真正玩的人来决定。

深入学习

游戏逻辑

原文名称 · Game logic

执行游戏规则的代码

游戏逻辑是代码里决定发生什么的部分：有没有打中、分数怎么算、一关什么时候结束、谁赢了。绘制画面和播放声音是另外的部分。在网络游戏里，游戏逻辑常常由服务器来运行，这样玩家就没法靠改自己那份程序来作弊。

深入学习

切换为正式版本

原文名称 · Go live

把上传的构建变成玩家实际拿到的那个版本

在游戏平台上，上传构建和让它正式上线是两个步骤。通过检查的构建会一直等着，直到你把它切换为正式版本；从那一刻起，它就是玩家拿到的版本，游玩链接也随之开放。把两步分开，你就能先看一看构建，出了问题还可以用回滚换回上一个构建。

深入学习

公会

原文名称 · Guild

玩家在游戏里一起玩、长期存在的群体

公会（也叫战队）是玩家在游戏里创建和加入的群体，有成员、会长之类的角色、入会申请和群聊。玩家会为了彼此一次次回到游戏。对开发者来说，它是游戏服务器必须保存和管理的社区功能，所以选哪种服务器很重要。

深入学习

钩子

原文名称 · Hook

在内置操作之前或之后运行你自己代码的固定位置

钩子是程序特意留出的位置，让你在选定的时刻加进自己的代码。在 Nakama 游戏服务器上，每个内置调用的前后都可以挂钩子：比如在创建账号之前检查玩家的名字，或者在对局结束之后发奖励。不用改服务器本身的代码，就能扩展它。

深入学习

内购

原文名称 · In-app purchase

在应用里通过商店购买道具或功能

内购（应用内购买）是在应用或游戏里付的钱，比如金币、去广告版本或战令。在手机上，它要走商店自己的支付系统，商店会从价格里抽走一部分。商店会返回一张收据，游戏服务器应该先校验这张收据，再发放道具。

深入学习

检查器

原文名称 · Inspector

查看正在运行的场景、并修改其中数值的窗口

检查器是一种调试工具，它列出正在运行的游戏或页面里的对象，并显示它们的属性：位置、大小、颜色、物理设置。你可以改一个值，不用重启就马上看到结果。Babylon.js、Unity 和浏览器的开发者工具都有检查器。

深入学习

接口（interface）

原文名称 · Interface

一段代码承诺会提供的函数清单

在编程里，接口描述的是一个东西能做什么，而不是怎么做：它是一份函数清单，写明每个函数的输入和输出。只要代码具备这些函数，就能放在那个位置上使用。用 Go 写时，Nakama 服务器交给你的模块的是带类型的接口，所以编译器会检查你调用得对不对。

深入学习

排行榜

原文名称 · Leaderboard

按分数给玩家排名的列表

排行榜按分数、用时或其他数字给玩家排名。游戏常常每天或每周清零一次，让新玩家也有机会；服务器还要决定同分怎么排，并抓住发送假分数的作弊者。分数应该在服务器上检查，因为游戏客户端发来的任何东西都可能被改过。

深入学习

许可证

原文名称 · License

说明代码、美术或数据可以怎样使用的条款

许可证是跟着代码、图片、声音或数据一起来的书面许可：能不能用、能不能改、能不能卖，以及你作为交换必须做什么，比如注明作者。在网上找到某样东西，不等于你就可以用它。MIT 或 Apache 2.0 这类开源许可证允许的事很多，但每一种都有自己的条件。

深入学习

LiveOps

游戏上线后靠活动、商店调整和更新来运营

LiveOps（在线运营）是让已经发布的游戏保持活力的工作：周末活动、商店新道具、赛季、平衡调整和 A/B 测试，往往在后台面板里直接修改，不用发布新构建。能运营好几年的游戏都靠它，有些后端会出售 LiveOps 工具，让团队不必自己去造。

深入学习

本地化

原文名称 · Localization

让游戏的文字和内容适应每种语言和文化

本地化不只是翻译：除了文字，还要让日期、数字、货币、版面（有些语言更长，阿拉伯语从右往左读）和文化细节适合每个市场。人工智能能很快写出翻译初稿，但发布前应该由懂这门语言的人检查意思、用语和语气。

深入学习

玩家匹配

原文名称 · Matchmaking

把合适的玩家凑进同一局

玩家匹配决定在线游戏里谁和谁一起玩。匹配器收集想开局的玩家，再按规则把他们分组，比如水平相近、所在地区、延迟或游戏模式。好的匹配让对局公平、等待时间短，而这两个目标是互相拉扯的。

深入学习

元层

原文名称 · Meta layer

对局之外的一切：账号、好友、聊天、存档、排名

在游戏服务器里，元层指的是真正那一局游戏之外的功能：账号和登录、好友、公会、聊天、保存的进度、排行榜和商店。这些做起来无聊，又容易在细节上出错，所以很多团队会选一个已经带有这些功能的游戏服务器，而不是花几个月自己写。

深入学习

模块

原文名称 · Module

装进程序里使用的独立代码文件或代码包

模块是放在自己的文件或包里的一段代码，好让别的代码加载并重复使用。在 Python 里，`import json` 会加载 json 模块。在 Nakama 或 SpacetimeDB 这样的游戏服务器上，你上传自己的模块来加上游戏规则。写坏的模块照样能让运行它的程序崩溃。

深入学习

原生

原文名称 · Native

直接以设备自己的机器码运行

原生代码已经编译成它所运行的处理器的机器码，中间没有解释器或额外的层，所以能全速运行。原生应用是为某一个平台做的，比如 iPhone。在游戏服务器上，让你的逻辑在同一个进程里原生运行很快，但它一旦崩溃，整台服务器都会跟着倒下。

深入学习

NPC

游戏里由电脑控制、而不是由玩家控制的角色

NPC（非玩家角色）是游戏自己让它动起来的任何角色：店老板、发任务的人、站岗的敌兵。它的台词由开发者写好，行为来自代码里的规则，常常是一个状态机。人工智能可以很快给许多 NPC 写出台词初稿，但仍然要有人去读、去挑。

深入学习

游戏物理

原文名称 · Physics

游戏引擎里计算重力、碰撞和运动的部分

在游戏里，物理是让物体大致像现实世界那样运动的代码：重力把东西往下拉，物体相撞时会弹开、滑动、停下。引擎自带物理系统，你只要设置质量、速度和形状，不用自己写数学公式。它是为了手感好而调过的近似，不是精确的模拟。

深入学习

在线状态

原文名称 · Presence

现在谁在线的信息

在线状态是每个用户的实时状态：在线、离线、对局中、离开。好友列表和公会列表靠它在名字旁边显示一个绿点。服务器得跟踪每一个连接，状态一变就通知其他人，通常通过 WebSocket；人数一多，这件事比看上去难。

深入学习

QA

发布前检查产品有没有缺陷

QA（质量保证）是赶在玩家之前找出问题的工作：把关卡玩一遍，试各种奇怪的输入，在不同设备上测试，并写下每个 bug 怎样复现。人工智能可以列出测试场景，比如二十种把存档系统弄坏的办法，但判断是否好到可以发布，是人的工作。

深入学习

收据校验

原文名称 · Receipt validation

发放道具前确认商店购买是真的

内购完成后，商店会给游戏一张收据，证明买了什么。作弊者可以在自己的设备上伪造收据，所以游戏服务器会把收据发给 Apple 或 Google 的服务器，确认它是真的、而且没被用过，然后才发放道具。Nakama 这样的游戏服务器会替你做这项检查。

深入学习

Reducer

SpacetimeDB 里在数据库内部运行、修改表的函数

在 SpacetimeDB 里，数据库同时就是服务器。你上传一个模块，模块里叫作 reducer 的函数在数据库内部运行，每次运行都是一个事务，用来修改表。客户端调用的是 reducer，而不是 HTTP 端点，订阅的一方会立刻看到变化的行。在 Redux 这类网页工具里，这个词是另一个意思。

深入学习

回滚

原文名称 · Rollback

发布出问题后换回上一个版本

回滚就是撤销一次发布，换回之前能正常运行的版本。平台会保留以前的构建，所以出问题的更新几秒钟就能被替换，不用匆忙赶修复。它恢复的是代码；坏版本已经改动过的数据，比如游戏存档，可能要另外修复。

深入学习

确定性回滚

原文名称 · Deterministic rollback

晚到的输入一来，就倒回去重新演算游戏

在节奏很快的在线游戏里，等齐每个玩家的输入会让人觉得卡。用回滚的话，每台机器先用手头已有的输入继续运行；晚到的输入一来，就倒回那一帧，再快速重放到现在。这只有在模拟是确定性的时候才行得通：同样的输入，在每台机器上总是得出完全相同的结果。

深入学习

RPC

像调用本地函数一样调用另一台电脑上的函数

RPC（远程过程调用）让一个程序请另一台电脑带着一些参数运行某个指定名字的函数，并把结果送回来。在 Nakama 服务器上，你注册自己的 RPC，游戏按名字调用它们。MCP 的消息用的是 JSON-RPC 2.0，每次调用都是一个小 JSON 对象，里面有方法名和参数。

深入学习

Tick

游戏服务器按固定频率推进对局的一步

游戏服务器不是连续不断地更新世界，而是一个 tick 一个 tick 地往前走。每个 tick，它读取已经到达的输入，套用游戏规则，再把新的状态发给玩家。tick 率越高（比如每秒 60 次而不是 10 次），手感越灵敏，但要花更多运算和网络流量。

深入学习

状态机

原文名称 · State machine

东西同一时间只处于一种状态、并按规则切换的设计

状态机列出一个东西可能处于的各种状态，以及在它们之间切换的规则。游戏角色可能是站立、奔跑、跳跃或下落，“奔跑时按下跳跃键”就让它切换到跳跃。因为同一时间只有一种状态有效，代码就不会出现同时跳跃又蹲下这种不可能的组合。

深入学习

Steam

Valve 的 PC 游戏商店

Steam 是最大的 PC 游戏商店，由 Valve 运营。开发者按每款游戏付费，而不是每年交账号费，还要做一个商店页面，放上预告片、截图和标签。上线前攒下的愿望单非常重要，因为游戏推出时 Steam 会通知这些玩家。

深入学习

订阅

原文名称 · Subscribe

请求在某些数据一变化时就自动收到通知

订阅就是登记你关心的数据，让服务器把每一次变化推送给你，而不是你一遍又一遍地去问。在 SpacetimeDB 里，客户端订阅一个查询，它关心的行一变化就马上送到。这需要一条一直保持打开的连接，比如 WebSocket。

深入学习

测试轨道

原文名称 · Test track

先把构建只交给选定测试者的发布渠道

Google Play 的发布要经过几条轨道：内部测试、封闭测试、开放测试和正式版。测试轨道只把一个真能安装的构建发给你列出的测试者，让你在所有人拿到之前发现问题。新的个人开发者账号在申请正式版之前，必须先和至少 12 名测试者进行 14 天的封闭测试。Apple 的 TestFlight 起着类似的作用。

深入学习

UI

程序里人看得到、能操作的部分

UI（用户界面）是用户看到并操作的一切：按钮、菜单、文字、图标、输入框。好的 UI 让人一眼就知道下一步该做什么。UX（用户体验）是更大的问题：用起来感觉怎么样。在游戏里，UI 就是画在游戏世界上面的分数、血条和菜单。

深入学习

小组件

原文名称 · Widget

画面的一块积木

小组件（widget）是用户界面里一个可以重复使用的部分：一个按钮、一行文字、一个列表、一张卡片，或者一个装着其他小组件的框。画面就是把小组件一层层套进小组件里搭起来的。在 Flutter 里，屏幕上的一切都是 widget；在 Flame 里，游戏画布就放在普通的 Flutter widget 之间。

深入学习

愿望单

原文名称 · Wishlist

玩家在发售前收藏想玩的游戏的列表

在 Steam 上，玩家可以把即将推出的游戏加进愿望单。游戏上线或打折时，Steam 会通知他们，所以愿望单会变成首周销量。上线前靠好的商店页面和预告片攒愿望单，比大多数第一次发行的开发者以为的重要得多。

深入学习

应用审核

原文名称 · App review

商店在应用发布前进行的检查

应用或游戏出现在商店之前，商店会审核这个构建：会不会崩溃？是否遵守隐私、支付和内容方面的规定？商店里的文字是否如实？Apple 的 App Review 以严格出名。审核可能要好几天，也可能拒绝某个构建，所以要预留时间。每次更新都要再审一遍。

深入学习

Play Console

Google 用来发布和管理 Android 应用的网站

Google Play Console 是开发者把应用发布到 Google Play 的地方。你付一次性的注册费并验证身份，然后创建应用，上传用上传密钥签名的构建，填写商店信息和数据安全表单，再让它经过测试轨道和审核。销量和崩溃报告也显示在这里。

深入学习

应用商店

原文名称 · App store

人们查找和安装应用、游戏的网上商店

应用商店是查找、购买和安装应用的官方地方：iPhone 上是 Apple 的 App Store，Android 上是 Google Play，PC 游戏是 Steam。商店负责支付和更新，并在发布前审核每个应用。作为交换，开发者要付注册费，并把一部分销售额分给商店。包管理器有时被叫作代码的应用商店。

深入学习

Google Play

Google 的 Android 应用商店

Google Play 是 Android 应用和游戏的主要商店，能覆盖的手机最多。开发者通过 Play Console 发布，注册费只交一次。构建要经过测试轨道和审核；新的个人账号在第一次发布正式版之前，必须和真实的测试者完成一次封闭测试。

深入学习

原型

原文名称 · Prototype

为了检验一个想法而快速做出的粗糙版本

原型是为了回答一个问题而快速做出来的，比如“这个跳跃好玩吗？”，做完本来就打算扔掉。它可以用占位美术和乱糟糟的代码。它和 MVP 不一样：最小可玩的游戏是陌生人拿起来就能玩得开心的东西，而原型只要让你学到点什么就够了。

深入学习

二进制文件

原文名称 · Binary

机器读的字节文件，通常是拿来就能运行的程序

在开发者的日常说法里，二进制（binary）指编译好的程序：电脑直接运行的字节文件，而不是你能读的文字。“以单个二进制发布”是说整个服务器就是一个文件，复制过去就能运行。WebAssembly 这类二进制格式是给机器用的，不是给人看的。用文本编辑器打开二进制文件，只会看到一堆乱码。

深入学习

可执行文件

原文名称 · Executable

可以当作程序运行的文件

可执行文件是操作系统能当作程序启动的文件，双击它或输入它的名字就行。在 Windows 上它通常以 .exe 结尾；在 Linux 和 macOS 上，任何带执行权限的文件都能运行，脚本也算。比如 Caddy 就是单个可执行文件。上传网站常常拒收可执行文件，因为它们可能夹带有害代码。

深入学习

Conventional Commits

一种提交信息规则：先写改动的种类，比如 feat: 或 fix:

Conventional Commits（约定式提交）是一种广泛使用的提交信息约定。每条信息以类型加冒号开头，比如新功能用 feat:，修 bug 用 fix:，文档用 docs:，后面再写一句简短的说明。因为格式固定，工具就能读取历史，生成更新日志和版本号。

深入学习

Updates were rejected

远程有你还没有的提交时 Git 给出的消息

如果别人先往同一条分支推送了，远程就有了你这份副本里没有的提交，这时 git push 会停下并显示“Updates were rejected”。Git 拒绝推送，是因为推上去会把别人的工作丢掉。不要急着用 --force：先运行 git pull --rebase，把你的提交摞到他们的提交之上，有冲突就解决，然后再推送。

深入学习

提交历史

原文名称 · History

一个接一个叠起来的提交记录

在 Git 里，历史是仓库里每一次提交连成的链条，每个提交都指向它的前一个。git log 会显示它，最新的在最前面。提交信息写得清楚，几个月后历史还读得懂。改写别人已经拉取过的历史（rebase、强制推送）会弄坏他们的副本，所以只改写你自己还没推送的提交。

深入学习

main

仓库默认分支的常用名字

main 是大多数仓库给默认分支起的名字，这条分支放的是完成好、大家共用的版本。GitHub 给新仓库的默认分支起名 main；老项目可能叫 master。在团队里，没人直接往 main 上提交：你在一条分支上干活，经过评审后再通过 Pull Request 合并进去。

深入学习

Git 跟踪

原文名称 · Tracking

Git 因为文件属于仓库而盯着它的变化

被跟踪的文件，是 Git 已经知道的文件，因为它被添加并提交过；它的每一处改动 Git 都会报告。新文件在你 git add 之前一直是未跟踪的。把一个已经提交过的文件加进 .gitignore，并不会让 Git 停止跟踪它：得先用 git rm --cached 取消跟踪。

深入学习

跟踪分支

原文名称 · Tracking branch

和本地分支配成一对的远程分支

本地分支可以和远程上的一条分支连起来，这条远程分支就是它的跟踪分支（upstream，上游分支）。git push -u origin main 设置一次这个连接；之后直接用 git push 和 git pull 就知道往哪里去，git status 也会告诉你领先或落后几个提交。没有它，Git 会问你指的是哪条远程分支。

深入学习

GitLab

和 GitHub 类似的 Git 托管服务

GitLab 是托管 Git 仓库、让团队一起在上面工作的服务，和 GitHub 一样。它把 pull request 叫作“merge request”（合并请求），并有自己的 CI/CD 流水线。除了 gitlab.com 网站，公司还可以把 GitLab 装在自己的服务器上。日常的分支、推送、评审、合并流程都一样。

深入学习

GitHub Actions

GitHub 内置的自动化，仓库里发生某件事时就运行任务

每当事件发生——一次推送、一个新的 pull request、一条评论或一个定时——GitHub Actions 就会在 GitHub 的服务器上运行工作流。工作流是 .github/workflows/ 里的一个 YAML 文件，列出安装、测试、部署之类的步骤。Claude Code 和 Codex 可以在里面运行，比如有人在 pull request 里写 @claude 时作出回应。

深入学习

代码评审

原文名称 · Code review

合并之前，队友阅读改动并留下意见

代码评审时，别人会在你的改动进入主分支之前阅读它，通常是以 Pull Request 的形式。评审者找 bug、不清楚的代码和缺少的测试，留下评论，最后批准。小的 Pull Request 会被仔细评审；巨大的往往只被匆匆扫一眼。人工智能评审有帮助，但最后还是由人来决定。

深入学习

项目根目录

原文名称 · Project root

项目最上层的文件夹

项目根目录是装着整个项目的最上层文件夹：也就是运行 git init 的地方，.gitignore、package.json、README.md 或 CLAUDE.md 这类文件通常放在这里。工具会到这里找自己的设置，很多命令也要求从这里运行。

深入学习

Markdown

用 #、- 这样的符号写标题、列表和代码的纯文本写法

Markdown 是一种简单的文本格式：以 # 开头的一行变成标题，- 开始一个列表项，前后各夹两个星号的文字变成粗体。文件当作纯文本也读得懂，也能排好版漂亮地显示出来。README.md、CLAUDE.md、AGENTS.md 和 SKILL.md 都是 Markdown 文件，人工智能聊天的回答通常也用它来写。

深入学习

只读模式

原文名称 · Read-only

只能看、不能改

只读的意思是东西可以看，但不能改：只读文件不能编辑，只读磁盘不能写入。对 AI 编程工具来说，这是最安全的模式：在 Codex 的只读沙箱里，智能体可以读文件、运行无害的命令，但不能编辑文件。面对一个还不熟悉的项目，从它开始很合适。

深入学习

标准库

原文名称 · Standard library

Python 自带、不用安装就能用的模块

Python 的标准库是和 Python 一起安装好的一大批模块：处理 JSON 的 json、发网络请求的 urllib.request、开小型 Web 服务器的 http.server，还有 math、random 等很多。因为不需要用 pip 安装任何东西，只用标准库的程序在任何装了 Python 的地方都能运行。

深入学习

配置文件

原文名称 · Config file

保存程序启动时读取的设置的文件

配置文件保存会改变程序行为的选择，比如端口、文件夹、模型大小或权限，这样你改文件就能改变行为，不用改代码。常见格式有 JSON、YAML、TOML 和 .env。API 密钥这类机密，应该放在不进 Git 的文件里，而不是放在共享的配置文件里。

深入学习

Bug

让程序表现出错的程序错误

bug 是程序里的缺陷：程序崩溃、显示错误的结果，或者做了谁都没想要的事。bug 来自代码里的失误、意料之外的输入或变化了的条件。修 bug 先要能稳定地复现它，再找出原因（调试），最后加一个测试，让同样的 bug 不再回来。

深入学习

自动化测试

原文名称 · Software test

检查别的代码是否按预期工作的代码

测试是一个小程序：它用已知的输入运行你的代码，检查输出是不是你期望的；结果是通过或失败。每次修改后都跑一遍整套测试，这样修好一处却弄坏另一处时，马上就能发现。用 AI 编程工具时，测试就是安全网：你给出测试，让智能体一直改代码，直到测试通过。

深入学习

复现

原文名称 · Reproduce

故意让同样的结果或问题再次出现

复现就是在同样的条件下让它再发生一次。能一步步复现的 bug 就能修好、能测试；“有时候会出现”的 bug 很难修。在人工智能实验里，可复现性是指别人用同样的代码、数据和随机种子，能得到同样的结果。

深入学习

换行符

原文名称 · Newline

结束一行的看不见的字符，写作 \n

换行符是让文字移到下一行的字符。你看不见它，但它就在文件里：在代码里写作 \n。Linux 和 macOS 用 \n 结束一行，而 Windows 用 \r\n，这可能会让一些工具出错。HTTP 在每一行头部的末尾放 \r\n，并在正文前放一个空行。

深入学习

node_modules

npm 存放项目所装包的文件夹

运行 npm install 时，npm 会把 package.json 里列出的每个包，以及这些包需要的包，下载到项目的 node_modules 文件夹里。它可能涨到几百 MB。千万不要提交它：把它写进 .gitignore，因为任何人都能用 npm install，根据 package.json 和锁文件把它重新建出来。

深入学习

开销

原文名称 · Overhead

主要工作之外额外花掉的内存或时间

开销是叠加在真正工作之上的成本。人工智能模型运行时，内存里装的不只是权重，还有 KV 缓存、计算缓冲区和运行时自身的开销，所以权重文件是 4 GB 的模型，可能需要 5–8 GB 甚至更多。要把开销算进去，否则一个“纸面上放得下”的模型，实际可能放不下。

深入学习 详细了解权重和参数

计算缓冲区

原文名称 · Compute buffer

计算进行时使用的临时内存

计算缓冲区是程序为了在计算过程中存放中间结果而预留的工作空间。语言模型运行时，每一层都会算出下一层要用的数字，这些数字就存在这些缓冲区里。除了权重和 KV 缓存，还需要它们，这也是模型需要的内存比文件大小更多的原因之一。

深入学习 详细了解权重和参数

语法解析

原文名称 · Parsing

读取文字或代码，弄清它的结构

解析（parse）就是读一段文字，把它变成程序能使用的结构。浏览器在画出页面之前，先把 HTML 解析成一棵元素树；Shell 把一行命令解析成命令和它的参数；json.loads 把 JSON 文本解析成 Python 的值。解析错误的意思是，这段文字不符合预期的格式。

深入学习

断点

原文名称 · Breakpoint

让程序在那一行暂停的标记

断点告诉调试器，程序运行到某一行时就停下。暂停的时候，你可以查看每个变量，再一行一行往前走，看清问题到底出在哪里。在浏览器里，打开 DevTools → Sources，点一下行号就能设一个断点。

深入学习

输入事件

原文名称 · Input event

程序收到的“发生了某件事”的通知，比如按键或点击

输入事件是一条小消息，说明发生了什么：某个键按下了、鼠标移动了、手指碰到了屏幕。操作系统把设备送来的原始信号变成事件，排好队交给最前面的窗口，程序再依次对每个事件作出反应。网页用 onclick 这类监听器来处理它们。

深入学习

Roundtrip

把东西转换过去再转回来，检查有没有丢东西

往返（roundtrip）测试把数据朝一个方向转换，再转回来，然后检查结果是否和原来一样。在 XSLM 课程里，roundtrip: OK 表示整段训练文本被编码成词元编号，再解码回来，得到的文字完全相同，也就是分词器没有丢失任何东西。哪怕只变了一个字符，测试就会失败。

深入学习

Python 对象

原文名称 · Python object

程序里的一个值，连同属于它的函数

在 Python 里，每个值都是对象：数字、一段文字、列表、字典都是。对象有自己的类型，还带着专属于它的函数，叫作方法，用点号来调用，比如 fruits.append("pear")。类就是你设计自己的对象种类的方法。要把对象存进文件，得先把它转换成文字或数字。

深入学习

append

在列表末尾添加一个值的方法

list.append(value) 把一个新值放到列表末尾，并直接修改这个列表本身。它返回 None，所以要把 fruits.append("pear") 单独写成一行，而不是写成 fruits = fruits.append("pear")，那样 fruits 会变成 None。想一次添加多个值，就用 extend。

深入学习

Python 类

原文名称 · Class

把数据和函数打包、用来生成对象的模板

类描述的是一种对象：每个对象存什么数据、能做什么。用 class 写一次，就能按需要从它生成任意多个对象（实例），每个对象都有自己的值。类里面的函数叫方法，它会以 self 的形式收到对象本身。类只是一份设计，在你创建对象之前什么都不会发生。

深入学习

def

Python 中创建新函数的关键字

def 开始一个函数定义：先写函数名，括号里写参数，再加冒号，下面是缩进四个空格的函数体。定义函数并不会运行它；只有加上括号调用时才会运行。要把值送回去，就在里面用 return。

深入学习

字典的键

原文名称 · Key

在字典里用来找到值的名字

字典存放一对对的键和值，键就是你用来查值的标签：在 scores["math"] 里，"math" 就是键。每个键只能出现一次；给已有的键赋新值，会替换掉旧值。查找不存在的键会引发 KeyError，而 .get() 则会返回 None。

深入学习

FileNotFoundError

要打开的文件不存在时 Python 报的错

当程序要找的文件或文件夹不在它找的位置时，就会出现 FileNotFoundError，比如在错误的文件夹里运行 open("data/train.txt")。路径是相对于当前文件夹的，而不是相对于脚本所在的位置。用 pwd 看看自己在哪里，用 ls 列出文件，再检查拼写和大小写。

深入学习

HTTPServer

Python 自带的简单 Web 服务器

HTTPServer 是 Python 标准库（http.server 模块）里的一个小型 Web 服务器。你给它一个处理类，由它决定对 GET 或 POST 回答什么，它会一次处理一个请求。用来学习和做本机工具（比如 XSLM 运行器）没问题，但它不是为访客很多的公开网站设计的。

深入学习

len

数一数有多少个元素或字符的函数

len(x) 返回 x 的长度：列表里的元素个数、文字里的字符数，或字典里的键数。它不会改变 x。记住位置是从 0 开始的，所以列表的最后一个元素在 len(x) - 1，而不是 len(x)。

深入学习

None

Python 中表示“这里什么都没有”的值

None 是一个特殊的值，意思是“没有值”。没有 return 的函数会返回 None，dict.get() 遇到不存在的键也会返回 None。本该出现数字的地方打印出了 None，通常说明忘了写 return。用“is None”来检查它，并注意它和 0 或空文字都不一样。

深入学习

range

为循环生成一串数字的函数

range(start, stop, step) 生成从 start 开始、到 stop 为止但不包括 stop 的数字。range(1, 11) 得到 1 到 10，range(5) 得到 0 到 4。它最常和 for 循环一起用。忘了末尾那个数不包括在内，是最常见的错误。

深入学习

urlopen

发送 HTTP 请求并读取回答的 Python 函数

urllib.request.urlopen(url) 打开一个网址，发送请求并返回响应，响应的 .read() 会以字节的形式给出正文。要用 POST 发送 JSON，就传入一个 Request 对象。如果连不上服务器，或者服务器返回错误码，它会直接报错，而不是返回一个假的回答。它属于标准库，所以什么都不用安装。

深入学习

else

if 条件为假时执行的分支

else 给 if 语句加上第二条路：条件为真就执行 if 块，否则执行 else 块。elif（else if）在两者之间再检查另一个条件。else 自己不带条件，以冒号结尾，里面的行要像 if 块一样缩进。

深入学习

IndentationError

行的缩进不对时 Python 报的错

IndentationError 表示行首的空格和 Python 预期的不一样：冒号（if、for、def）后面的代码块没有缩进，或者同一个代码块里各行缩进的量不同。Python 用缩进而不是括号来划分代码块，所以缩进很重要。每一级用四个空格，不要把制表符和空格混在一起用。

深入学习

print

把值显示在屏幕上的 Python 函数

print() 把值写到标准输出（通常就是屏幕），然后换行。这是看程序在做什么最快的方法。它只负责显示：一个函数如果只把结果 print 出来却没有 return，返回的就是 None。在通过标准输出通信的程序里（比如 MCP 服务器），一条多余的 print 就会弄坏消息；日志要改写到 stderr。

深入学习

return

函数用来交回结果的关键字

return 结束函数，并把一个值交回给调用它的代码，这样结果就能存起来，或用在更多计算里。没有 return 的函数返回 None。return 和 print 不一样：print 只是把值显示在屏幕上，return 则把它传下去。

深入学习

assert

条件为假时让程序停下的检查语句

assert 条件 在条件为真时什么都不做，为假时引发 AssertionError，让程序停在那一行。它是快速写下“这件事必须成立”的方法，比如分词器能还原出原文，或者你要替换的文字确实存在。用 -O 运行 Python 时会跳过 assert，所以真正的程序所依赖的检查不要用它。

深入学习

Android App Bundle

发布应用时上传到 Google Play 的 .aab 文件

Android App Bundle（.aab）是你上传到 Google Play 的包。它装着应用的全部代码和资源，Google Play 会用它为每部手机生成一个更小、正好合适的安装文件。Google Play 上的新应用必须以 App Bundle 的形式上传，而不是旧式的 .apk 文件。

深入学习

上传密钥

原文名称 · Upload key

上传到 Play 之前给应用签名用的秘密密钥

Google Play 会检查每个新版本是否来自同一位开发者。你用上传密钥给应用包签名，Google 检查这个签名后，再用它自己的应用签名密钥重新签一次。密钥文件和它的密码要放在项目外面，做好备份，绝不要提交或分享。如果丢了，就得在 Play Console 里请 Google 重置。

深入学习

代码签名

原文名称 · Code signing

证明应用确实出自你手的数字印章

应用发布之前，要用一把秘密密钥给它签名。凭这个签名，商店和手机可以检查两件事：应用是谁做的，以及签名之后有没有人改动过它。Google Play 用的是你的上传密钥；Apple 用的是签名证书和描述文件，Xcode 的自动签名可以替你处理。上传时出现的签名错误，大多是选错了密钥或团队。

深入学习

描述文件

原文名称 · Provisioning profile

允许签过名的应用安装和运行的 Apple 文件

描述文件（Provisioning profile）把你的团队、应用的 Bundle ID、签名证书，以及测试时允许运行它的设备绑在一起。描述文件对不上，iPhone 就不会运行这个应用。打开自动签名后，Xcode 会替你创建和更新描述文件。界面上它常常只显示为“profile”，和用户资料没有任何关系。

深入学习

Bundle ID

应用独一无二的名牌，比如 com.company.app

每个 Apple 应用都有一个 Bundle ID，写法像倒过来的网址，比如 com.example.notes。App Store 里没有两个应用能共用同一个，它把你的 Xcode 项目、签名用的描述文件和 App Store Connect 里的应用记录连在一起。要慎重选择：一旦上传了构建，就不能再改。在 Android 上，同样的概念叫作应用 ID（application ID）。

深入学习

App Store Connect

Apple 用来登记和管理 App Store 应用的网站

App Store Connect 是 iPhone 应用在发布前后的落脚处。你在这里用 Bundle ID、名称和截图创建应用记录，填写隐私信息，查看 Xcode 上传的构建，邀请 TestFlight 测试者，并把应用提交给 App Review 审核。它相当于 Apple 这边的 Google Play Console。

深入学习

Apple Developer Program

在 App Store 发布应用所需的 Apple 付费会员

要把应用放上 App Store，或通过 TestFlight 交给测试者，你需要用 Apple 账户加入 Apple Developer Program。会员按年付费（大多数国家个人为 99 美元），可以使用 App Store Connect、签名证书和测试版工具。不加入也能用 Xcode 在自己的 iPhone 上构建和运行应用，但不能发布。

深入学习

TestFlight

Apple 在发布前把 iPhone 应用交给测试者的服务

上传到 App Store Connect 的每个构建都可以发到 TestFlight。测试者安装免费的 TestFlight 应用，接受你的邀请，就能比普通用户先试用这个构建。给外部测试者的构建要先经过一次简短的审核，每个构建 90 天后过期。修好测试者报告的问题，提高构建号，再上传一次。

深入学习

Xcode

Apple 用来开发 iPhone 和 Mac 应用的免费软件

Xcode 是为 Apple 设备做应用的官方工具。它只能在 Mac 上运行，可以从 Mac App Store 免费下载。即使你用 Flutter 或 React Native 写应用，最后的 iPhone 构建也要通过 Xcode 或它的命令行工具来签名、归档和上传。它还自带 iPhone 模拟器。

深入学习

Xcode 归档

原文名称 · Archive

Xcode 把应用打包成待上传的发布构建的步骤

归档（Archive）就是 iPhone 应用的发布版本，构建和签名都装在一个包里。在 Xcode 里选择 Product → Archive，再用 Distribute App 把它上传到 App Store Connect。每次上传的构建号都必须比上一次大。这个词和把旧文件收起来存档无关。

深入学习

发布版本

原文名称 · Release build

为在商店发布而做的、经过优化的最终构建

开发的时候，应用以调试构建运行：更慢、更大，还塞满了检查工具。发布版本去掉这些工具，优化代码，并用你的密钥签名，所以它就是用户从商店安装的那个版本。上传之前一定要测试发布版本，因为有些错误只在它里面出现。

深入学习

商店信息

原文名称 · Store listing

商店里显示的应用名称、介绍和截图

商店信息是人们安装前看到的页面：应用名称、简短介绍和完整介绍、图标、截图、分类，以及隐私政策的链接。你在 Play Console 或 App Store Connect 里填写，审核人员会检查它是否和应用实际做的事一致。误导人的商店信息是应用被拒的常见原因之一。

深入学习

数据安全表单

原文名称 · Data safety form

声明应用收集哪些数据的 Play Console 表单

Google Play 要求每个应用填写数据安全表单：收集或分享哪些类型的用户数据、为什么、数据是否加密、能否删除。这些回答会显示在应用的商店页面上给用户看。它们必须和应用的实际行为以及隐私政策一致，包括第三方库收集的数据。

深入学习

版本代码

原文名称 · Version code

每次上传应用都必须变大的内部编号

除了人们看到的版本名称（比如 1.2.0），每个应用构建还带着一个给商店用的整数：在 Android 上叫版本代码，在 iPhone 上叫构建号。每次上传的数字都必须比上一次大，否则商店会拒绝。在 Flutter 里，它就是 pubspec.yaml 中 version 那一行 + 号后面的数字。

深入学习

pubspec.yaml

Flutter 应用的设置文件：名称、版本和包

每个 Flutter 或 Dart 项目的根目录都有一个 pubspec.yaml 文件。它列出应用的名称、版本（版本名称和构建号用 + 连起来）、依赖的包，以及图片和字体等资源。改完包列表后要运行 flutter pub get。它是用 YAML 写的，所以缩进很重要。

深入学习

React Native

用 React 和 JavaScript 开发手机应用的框架

React Native 由 Meta 开发，让你用 React 的组件写法，以 JavaScript（或 TypeScript）把手机应用写一次，就能同时在 Android 和 iPhone 上运行。它不是把网页装进盒子里，而是画出真正的原生按钮和列表。它和 Flutter 是最受欢迎的两种跨平台方案。

深入学习

iOS

iPhone 的操作系统

iOS 是运行在每部 iPhone 上的软件，由 Apple 开发，就像大多数其他手机运行的是 Android 一样。应用要为每个系统分别构建，所以商店会分别要 iOS 构建和 Android 构建。iPhone 应用要在 Mac 上用 Xcode 构建，再通过 App Store 或 TestFlight 安装。

深入学习

语言绑定

原文名称 · Binding

让一种语言能调用另一种语言写的库的连接代码

很多速度很快的库（比如 llama.cpp）是用 C 或 C++ 写的。绑定把这样的库包起来，让你能从 Python、Dart 或 JavaScript 等其他语言调用它，就像它本来就是用那种语言写的。繁重的计算仍然由原来那段快速的代码来做。如果绑定比库本身旧，可能会缺少新功能。

深入学习

嵌入应用

原文名称 · Embed

把文件或模型放进应用里，让它跟着应用一起发布

嵌入就是把某样东西打包进你的应用，这样应用不用从服务器下载就能使用它。小型语言模型可以连同运行器一起嵌入手机应用，这样离线也能工作。这和嵌入向量（embedding，代表一个词或一句话的一串数字）是两回事。

深入学习

中间件

原文名称 · Middleware

插在请求和主要工作之间、多加一个步骤的代码

中间件是每个请求或步骤在主代码运行之前（或之后）都要经过的一层。它可以检查登录、写日志、压缩过长的上下文，或拦下不安全的操作，而主代码完全不用知道。Laravel 这类 Web 框架用中间件检查登录；智能体 harness 则在每次调用模型时都套上中间件。

边界值

原文名称 · Boundary value

正好落在界限上的测试值，比如恰好等于及格线的分数

错误最常藏在规则的边缘。如果程序规定 60 分及以上算及格，就要测试 59、60 和 61，而不只是 30 和 90。该写 > 的地方写成了 >=，这种错误只有在正好 60 分时才会暴露出来。空输入、0 和允许的最大数也都是边界值。

flush

把缓冲的输出立刻发出去，而不是等着

为了省事，程序会把要打印的内容先攒在缓冲区里，再成批发出去。如果另一个程序正在等每一行（MCP 客户端就是这样），这种延迟看起来就像卡住了。Python 里的 print(..., flush=True) 会把这一行立刻推出去。不加它，输出可能要等缓冲区满了或程序结束时才出现。

深入学习

vendor 文件夹

原文名称 · vendor folder

存放工具为项目下载的外部代码的文件夹

包管理工具会把别人写的代码放在单独的文件夹里：PHP 的 Composer 用 vendor/，npm 用 node_modules/。那里的文件永远不要改，因为下次安装会把它们覆盖掉；要改就去改包列表里的版本。所以给 AI 智能体的规则里常常写着“不要动 vendor/”。

elif

Python 的“else if”：第一个条件不成立时再检查另一个

在 Python 里，if 检查一个条件，elif（else if 的缩写）只在前面的条件都为假时才检查下一个，else 则接住剩下的所有情况。Python 从上往下走，只执行第一个为真的分支，所以要把最具体的条件放在前面。每一行都以冒号结尾，下面的代码要缩进。

深入学习

KeyError

在字典里查找不存在的键时 Python 报的错

字典靠键来找值。查找一个不存在的键，比如 scores["music"]，程序就会停下，显示 KeyError 和那个缺失的键。先检查拼写和大小写。如果键不存在是正常情况，就用 scores.get("music", 0)，它会返回一个默认值，而不是报错。

深入学习

ValueError

值的类型对、内容却不对时 Python 报的错

ValueError 表示函数拿到的值类型没错，却没法使用：int("abc") 拿到的是文字，但不是能当数字的文字。NumPy 在数组形状对不上时也会报它，比如 a @ b 里两个矩阵内侧的大小不同。先读报错信息的最后一行，再把值或它的 .shape 打印出来看看。

深入学习

ModuleNotFoundError

Python 报“No module named …”：这个包没有安装

Python 找不到某个包时，import numpy 就会失败，报 No module named 'numpy'。通常是没安装，或者装到了另一个 Python 或另一个虚拟环境里。先打开项目的 venv，用 python3 -m pip install numpy 安装，再用同一个 python3 运行程序。

深入学习

NameError

使用从未定义过的名字时 Python 报的错

NameError: name 'x' is not defined 表示 Python 遇到了一个它不认识的变量名或函数名。常见原因有拼写错误、大小写不对、在给变量赋值的那一行之前就用了它，或者忘了 import。Python 会一字不差地读名字，所以 Score 和 score 是两个不同的名字。

深入学习

pytest

找出并运行 Python 测试的工具

pytest 会运行项目里的所有测试，并报告哪些通过、哪些失败。它会寻找名叫 test_*.py 的文件和名字以 test_ 开头的函数，每个测试用一句普通的 assert 检查结果。给 AI 智能体定下“每次修改后都运行 python -m pytest”这条规则，它就能自己检查自己的工作。

深入学习

import

加载模块以便使用的 Python 语句

Python 一开始只有少数几个内置函数，其余的都在模块里。import re 加载正则表达式模块，之后就能用 re.search(...) 这样的写法调用它的函数。from math import sqrt 则直接引入一个名字。Python 自带的模块总能直接用；其他模块要先用 pip 安装。

深入学习

原始字符串

原文名称 · Raw string

写成 r"…"、原样保留反斜杠的 Python 字符串

在普通的 Python 字符串里，反斜杠表示一个特殊字符的开始："\n" 是换行，"\b" 是退格。在前面加上 r，比如 r"\b\d+"，每个反斜杠都会照原样保留。正则表达式里满是反斜杠，所以要养成把模式写成原始字符串的习惯。

深入学习

PyPI

Python 包索引，公开的 Python 包仓库

PyPI（pypi.org）是 pip 下载包的地方。任何人都能往上面发布，所以名字只错一个字母的包可能就是陷阱。安装新东西之前，要核对准确的名字、作者和下载量。它对 Python 的作用，就和 npm 仓库对 Node.js 的作用一样。

深入学习

requirements.txt

列出项目需要的 Python 包和版本的文件

requirements.txt 写着 Python 项目用到的每个库，通常还固定了版本，比如 numpy==2.1.3。有了它，任何人都能用一条命令重建出一样的环境。固定版本很重要，因为新版本可能改变行为，把昨天还能用的代码弄坏。

深入学习

数据类型

原文名称 · Data type

值的种类，比如整数、小数或文字

每个值都有数据类型，类型决定了你能拿它做什么。在 Python 里，3 是 int，3.0 是 float，"3" 是 str，True 是 bool。"3" + 4 会出错，因为文字和数字不能相加；要先用 int("3") 转换。选对类型对精度也很重要，比如处理金额和浮点数的时候。

深入学习

console.log

JavaScript 中打印值的函数

console.log 会打印你交给它的任何东西。在浏览器里，文字出现在开发者工具的 Console 面板；在 Node.js 里，它会输出到终端的标准输出，所以能像任何程序的输出一样，用管道交给其他命令。调试时，这是查看变量里装着什么最快的方法。

深入学习

JavaScript 引擎

原文名称 · JavaScript engine

浏览器或 Node.js 里负责运行 JavaScript 的程序

JavaScript 引擎读取 JavaScript 代码，把它快速转换成计算机能执行的指令。Chrome 和 Node.js 共用 Google 的 V8 引擎；Firefox 用 SpiderMonkey，Safari 用 JavaScriptCore。Node.js 就是把 V8 从浏览器里拿出来，再加上读写文件和使用网络的工具，用来做这些事而不是显示网页。

深入学习

process.argv

启动 Node.js 脚本时带上的那串词

process.argv 是一个数组，装着启动 Node.js 脚本的那行命令。第 0 项是 node 的路径，第 1 项是脚本的路径，从第 2 项开始才是你输入的参数。所以 node greet.js Mina 会把 "Mina" 放进 process.argv[2]。每一项都是文字，数字要用 Number() 转换。

深入学习

npm audit

npm 检查已安装的包有没有已知安全问题

npm install 之后，npm 会做一次快速的安全检查（audit），报告已安装的包里有多少个存在已知漏洞，以及严重程度如何。npm audit 显示详细信息，npm audit fix 会在不违反版本规则的前提下，升级能升级的包。并不是每条警告都会影响你的项目，但 high 和 critical 级别的一定要读。

深入学习

@latest

npm 中表示“最新发布的版本”的标签

在包名后面加上 @latest，就是向 npm 要当前标为 latest 的那个版本。npm install -g firebase-tools@latest 会更新一个全局工具，npx create-vite@latest 则确保用的是最新的项目生成工具，而不是缓存里的旧版本。你也可以写明版本，比如 prettier@3。

深入学习

npm prefix

决定全局包装在哪里的 npm 设置

npm 的 prefix 是存放全局安装的包及其命令的文件夹。如果它指向 /usr/local 这样的系统文件夹，npm install -g 就会因为没有权限而报 EACCES 失败。不要用 sudo，而是改用 nvm，或者把 prefix 移到你的主目录里，再把它的 bin 文件夹加进 PATH。

深入学习

npm 仓库

原文名称 · npm registry

npm 下载 JavaScript 包的在线仓库

npm 仓库（registry.npmjs.org）存放着数百万个已发布的 JavaScript 包。npm install 和 npx 从这里取包，并在缓存里留一份副本。任何人都能发布，所以运行一个包之前，要核对它的名字、作者和下载量。它是包的仓库，不是 Git 仓库。

深入学习

.nvmrc

写明项目使用哪个 Node.js 版本的文件

.nvmrc 文件放在项目文件夹里，只有一行：一个 Node.js 版本号，比如 22。任何人打开这个项目，运行 nvm use 就能用上同一个版本，“在我电脑上明明能跑”这类问题就少了。不带版本号运行 nvm install，会安装文件里写的那个版本。

深入学习

包管理器

原文名称 · Package manager

查找、安装、更新和删除软件的工具

包管理器就是用打字来操作的应用商店。它把程序连同它需要的一切一起下载下来，记录版本，还能干净地删除。操作系统有自己的包管理器（Alpine 用 apk，Ubuntu 用 apt，macOS 用 Homebrew，Windows 用 winget），编程语言也有自己的（JavaScript 用 npm，Python 用 pip）。

深入学习

脚手架

原文名称 · Scaffolding

自动生成新项目的初始骨架

脚手架工具会问你几个问题，然后生成新项目需要的文件夹、设置文件和示例代码，让你从一个已经能运行的东西开始。npx create-vite@latest 和 flutter create 是常见的例子。生成的文件只是起点，你可以随意修改和删除。

深入学习

脱字符（^）版本范围

原文名称 · Caret (^) version range

^4.17.21 表示“这个版本，或更新的兼容版本”

npm 的版本号分三部分：major.minor.patch。package.json 里在前面加脱字符，比如 ^4.17.21，表示允许从 4.17.21 到 5.0.0（不含）之间的任何版本，因为主版本号一变就可能不兼容。实际装上的确切版本写在 package-lock.json 里，npm ci 会一模一样地安装那个版本。

深入学习

--depth 1

只下载最新版本、不带历史记录的 git clone

普通的 git clone 会复制项目有史以来的每一个提交。git clone --depth 1 只取最后一个，所以快得多、也小得多，只想读代码或运行代码时正合适。代价是：在用 git fetch --unshallow 取回其余部分之前，你没法查看或回到更早的提交。

深入学习

哈希

原文名称 · Hash

根据内容算出的简短指纹，内容一变，值就变

哈希函数能把任意多的数据变成一串固定长度的短字符串。同样的输入总是得到同样的哈希，哪怕只改一个字母，结果也会完全不同。所以用哈希能很快看出文件有没有改过。Git 用哈希给每个提交命名，因此一个提交哈希正好指向代码的一个版本。

纯文本

原文名称 · Plain text

只有字符的文本，没有字体、颜色或隐藏格式

纯文本文件里只有字符，所以代码、HTML 和设置文件都必须存成纯文本。文字处理软件会加上隐藏的格式，把代码弄坏，所以在 TextEdit 里要先选“格式 → 制作纯文本”。在安全领域，纯文本（明文）也指没有加密的数据，比如用 HTTP 而不是 HTTPS 时传送的内容。

逻辑

原文名称 · Logic

程序做判断、做动作时遵循的规则和步骤

程序的逻辑就是它做决定的方式：事情按什么顺序发生、检查哪些条件、每种情况下怎么办。“游戏逻辑”决定谁得分、一局何时结束；“工具逻辑”决定工具拿到输入后做什么。说人工智能是逻辑的机器，意思是它按计算出来的步骤运行，没有感情，也没有意图。

权限

原文名称 · Permission

一个人或程序被允许读取、修改或运行的范围

权限就是做某件事的权利：读文件、改文件、运行命令、使用摄像头，或代表别人发帖。文件有权限，手机应用会申请权限，AI 智能体的权限则由你来给：哪些文件夹可以改，哪些命令可以不经询问就运行。只给这项工作需要的权限；加权限容易，挽回损失难。

linter

原文名称 · Linter

自动找出代码里的错误和违规写法的工具

linter 不运行代码，只读代码，然后指出可能的 bug 和风格问题：从没用过的变量、少了的引号、不安全的写法。运行它叫 linting，或者直接叫 lint，比如 npm run lint。机器给出的结果是明确的通过或不通过，所以测试和 lint 很适合当 AI 智能体独自工作时的完成标准。linter 找问题；格式化工具只整理排版。

深入学习

格式化工具

原文名称 · Formatter

把代码排版统一改写成固定风格的工具

格式化工具会改写空格、换行、引号和缩进，让项目里的所有代码看起来都一样，不管是谁（或什么）写的。它不会改变代码做的事。每次编辑后自动运行它，比如用 Claude Code 的钩子，就能让 AI 写的代码保持整洁，diff 也更容易审阅。

深入学习

Prettier

JavaScript、CSS、HTML 和 Markdown 常用的格式化工具

Prettier 是一个 npm 包，把代码统一整理成一种风格，几乎没有需要争论的设置。通常按项目安装为开发依赖，用 npx 运行。--write 会直接修改文件；--check 只报告哪些文件没整理好，适合自动检查。

深入学习

LTS

长期支持：多年都能得到修复的版本

LTS 版本是开发者承诺长期提供修复（尤其是安全修复）的版本。在 Node.js 里，偶数版本（22、24 等）会成为 LTS，支持大约 30 个月，奇数版本的寿命则很短。学习或运行服务器时，选 LTS 版本。

深入学习

README

项目的第一份文档：它是什么、怎么用

README.md 放在项目最上层的文件夹里，说明项目做什么、怎么安装和运行、接下来该看哪里。GitHub 会把它显示在仓库首页，所以访客最先读到的就是它。“README 说明了怎么运行这个应用”这样的目标，对 AI 智能体来说也是清楚的完成标准。

Issue

原文名称 · GitHub issue

GitHub 上记录一件任务、一个 bug 或一个想法的帖子

Issue 是 GitHub 仓库里带编号的一页，描述一项工作：一个 bug、一个功能或一个问题。大家可以评论、指派负责人、加标签，做完就关闭。在 PR 里写上“Fixes #12”，合并时就能自动关闭这个 Issue。GitHub Projects、Jira 这样的看板把 Issue 排成一张张卡片。

深入学习

扩展程序

原文名称 · Extension

给 Chrome 或 VS Code 增加新功能的附加程序

扩展程序是装在另一个应用里、为它增加功能的小程序。Claude in Chrome 这样的浏览器扩展来自 Chrome Web Store；Claude Code 或 Codex 扩展这样的编辑器扩展来自 VS Code Marketplace。扩展能读取你在那个应用里看到的内容，所以只安装可信发布者的扩展。

深入学习

错误日志

原文名称 · Error log

程序运行时写下的错误记录

程序会把出了什么错、什么时间、具体细节写进错误日志：一个文件、终端或某个服务。日志里的内容通常比屏幕上那条简短消息多，比如行号和调用链。向 AI 求助时，把日志里相关的几行，连同如何重现问题、你原本期望的结果一起给它，而不是贴上几千行。

平台

原文名称 · Platform

程序运行的基础，比如浏览器、手机或某个服务

平台就是程序要在上面运行的那个基础：操作系统（Android、iOS、Windows）、浏览器、游戏机，或带有自家工具的在线服务，比如游戏平台的 SDK。每个平台都有自己的规则和限制，所以应用商店要求每个平台分别构建一份。“跨平台”指一套代码能在多个平台上运行。

软件

原文名称 · Software

电脑上运行的所有程序，与机器本身相对

软件是程序及其所需数据的统称：应用、游戏、网站、操作系统和 AI 模型都算。硬件是摸得着的部分；软件是硬件要执行的指令。改软件比改硬件便宜、快得多，所以大多数新功能都是通过更新送来的。

自动化

原文名称 · Automation

让电脑代替人自己完成一项固定的工作

自动化就是把你反复手动做的工作变成电脑自己做的事：一个给 500 个文件改名的 shell 脚本、每周一运行的定时任务、每次 push 都运行的测试，或者收集周报的 AI 智能体。第一次要花些功夫，之后每次都不费力。只自动化你看懂了的步骤，并检查结果。

编程语言

原文名称 · Programming language

写出电脑能执行的指令所用的约定语言

编程语言有精确的词汇和语法，用来告诉电脑要做什么。Python、JavaScript、Bash、C 和 Rust 都是例子，各自适合不同的工作，从快速写个脚本到打造高速引擎。和人类语言不同，它没有猜的余地：少一个括号，程序就停下来。AI 也用这些语言写代码，所以读懂一种语言仍是关键本领。

版本

原文名称 · Version

程序、模型或文件的编号版次

程序、包和模型会随时间变化，每次发布的状态都有一个版本号，常写成“主版本.次版本.补丁”，比如 3.12.4。第一个数字变大，通常意味着可能让旧代码出错的改动。很多“我这能用、你那不行”的问题都来自版本不同，所以先检查版本，再用 requirements.txt 或 .nvmrc 这样的文件把版本固定下来。

常量

原文名称 · Constant

一旦设定就不能再改的、有名字的值

常量就像第一次赋值后就被锁住的变量。在 Bash 里，readonly PI=3.14 会让之后的任何修改都报错；在 JavaScript 里写 const。Python 没有真正的常量，所以大家把名字写成大写，比如 MAX_SIZE = 100，意思是“别改它”。必须处处保持不变的值，就用常量。

深入学习

声明

原文名称 · Declaration

在使用前先告知一个变量（及其种类）

声明就是告诉语言某个名字存在，有时还说明它的种类。Bash 通常不需要声明：name=Mina 当场就创建了变量。有些种类必须先声明，比如关联数组要用 declare -A。在 Java 或 C 这样的语言里，每个变量在使用前都要连同类型一起声明。

深入学习

定义函数

原文名称 · Definition

创建函数或变量，以便之后使用

定义就是给名字装上内容的地方：构成一个函数的那几行，或变量的第一次赋值。名字只有定义之后才能用，所以在脚本里，函数定义要写在调用它的行之前。set -u 会让 Bash 在用到从未定义过的变量时停下来，能帮你抓出拼写错误。

深入学习

.NET

微软推出的免费平台，用来开发和运行程序

.NET 是微软的开源平台，能在 Windows、macOS 和 Linux 上运行用 C#、F# 等语言写的程序。PowerShell 构建在 .NET 之上，所以它的正则表达式遵循 .NET 的规则：\d、\w、\s 和命名分组都能用。使用 PowerShell 并不需要懂 .NET。

深入学习

调用

原文名称 · Function call

通过名字运行一个函数或命令

定义函数只是描述这项工作；调用它才会让它运行。调用函数就是写出它的名字和参数，比如 Python 里的 print("hi") 或 Bash 里的 greet Mina，它可能还会交回一个结果。程序大部分都是在调用函数，有你自己写的，也有别人写的。AI 模型请程序运行某个工具，这叫工具调用。

嵌套

原文名称 · Nesting

把一个东西放进另一个同类的东西里

嵌套就是把一个结构放进同类结构里：循环里套循环、if 里套 if、列表里套列表，或者命令替换里再套一个，比如 $(dirname $(pwd))。$( ) 嵌套起来很干净，这也是它比反引号更受推荐的原因之一。嵌套太深很难读，超过三层就该把代码拆开了。

深入学习

switch 语句

原文名称 · switch statement

其他语言里的多路分支，相当于 Bash 的 case

在 JavaScript、C 和 Java 里，switch 把一个值和一串 case 逐个比较，运行匹配的那一块，比一长串 if/else if 更整洁。Bash 用 case … esac 做同样的事，而且每个 case 还可以是 *.txt 这样的模式。在 JavaScript 里，忘了写 break，下一个 case 也会跟着运行。

深入学习

代码块

原文名称 · Block

作为一个整体一起运行的一组代码行

块是一段属于同一组的代码：if 里 then 和 fi 之间的行、循环里 do 和 done 之间的行，或者函数 { } 里的内容。awk 还有特殊的 BEGIN 块和 END 块，分别在第一行之前和最后一行之后运行。块里的行要缩进，这样才看得出它在哪里结束；每个打开的块都必须关上。

深入学习

camelCase

把几个词连在一起、从第二个词起首字母大写的命名方式

camelCase 写多个词组成的名字时不加空格，从第二个词起每个词首字母大写：userName、totalPrice。JavaScript 的变量和函数用它；Python 更喜欢 snake_case（user_name）；文件名和网址常用 kebab-case（user-name）。照项目已有的风格来写，因为名字必须一字不差。

CHANGELOG

记录每个版本改了什么的文件

CHANGELOG（通常是 CHANGELOG.md）列出项目的每个版本，附上日期以及新增、改动和修复，最新的在最前面。像 Claude Code 这样变化很快的工具都会发布一份，让用户跟上新功能。它是写给人看的，不像提交历史那样记录每一个小步骤。

深入学习

发布说明

原文名称 · Release notes

告诉用户新版本有哪些变化的简短说明

发布说明向用户宣布新版本：新功能、重要修复，以及他们必须做的事，比如修改某项设置。它比 CHANGELOG 更短、更友好，常常根据上次发布以来的提交来起草。写发布说明是一件经常重复的工作，很适合做成 AI 智能体的技能。

命令注入

原文名称 · Command injection

把命令偷偷塞进输入、让它被执行的攻击

当程序用它控制不了的文本拼出 shell 命令，而那段文本里藏着额外的命令时，就会发生命令注入。像 a.txt; rm -rf ~ 这样的文件名，能把一条无害的命令变成破坏性的命令。要给变量加引号，绝不把不可信的文本交给 shell；使用 AI 智能体时，要留意那些来自网页或文件、而不是来自你的命令。

反馈循环

原文名称 · Feedback loop

尝试、检查结果、再修正的反复循环

反馈循环让干活的一方很快得到信号，知道上一次改动对不对，然后再试一次。对 AI 智能体来说，这个信号来自测试、linter、类型检查或截图，所以智能体能自己修正，不需要人盯着每一步。信号越快越清楚，工作就做得越好。

worktree

原文名称 · Worktree

同一个仓库在另一个分支上的第二个工作文件夹

git worktree 把同一仓库的另一个分支检出到单独的文件夹里，共用一份历史。每个文件夹都有自己的文件，所以两个 Claude Code 或 Codex 会话可以并行工作，互不覆盖。工作合并后，就删掉这个 worktree。每个 worktree 都需要单独安装依赖。

深入学习

并行

原文名称 · Parallel

同时并排推进几项工作

并行工作就是几项工作同时推进，而不是一个接一个。使用 AI 智能体时，你可以并行运行几个会话或子智能体，各自做自己的任务。危险在于两个干活的一方同时改同一个文件，所以给每个分配自己的 worktree 或自己的文件，最后再把结果合并起来。

深入学习

GitHub Project

GitHub 用卡片、表格或时间线管理 Issue 的看板

GitHub Project 把一个或多个仓库里的 Issue 和 PR 收集到一个看板上。你可以把它看成带列的看板、表格或路线图，还能加上优先级之类的自定义字段。gh 命令行工具能创建和移动条目，AI 智能体就是这样替你管理看板的。

深入学习

看板

原文名称 · Kanban

任务卡片按列移动的板子，比如 待办 → 完成

看板把工作显示成一列列的卡片，通常分为“待办”“进行中”和“完成”。把卡片移到下一列，进度一眼就能看出来；限制“进行中”里卡片的数量，可以避免团队同时开太多工作。这个方法来自丰田的工厂；GitHub Projects、Trello 和 Jira 都提供看板视图。

深入学习

Jira

Atlassian 的 Issue 和项目跟踪工具，公司里很常用

Jira 是 Atlassian 推出的付费网络服务，用看板、冲刺（sprint）和报表来跟踪 Issue、bug 和任务。很多公司用它代替 GitHub 的 Issue。通过 MCP 服务器，Claude Code 这样的 AI 智能体能在工作中读取和更新 Jira 工单。

JetBrains

IntelliJ IDEA、PyCharm、WebStorm 等 IDE 的开发商

JetBrains 是一家软件公司，它的 IDE 被专业开发者广泛使用：Java 和 Kotlin 用 IntelliJ IDEA，Python 用 PyCharm，JavaScript 用 WebStorm，PHP 用 PhpStorm，等等。页面上说“VS Code 或 JetBrains”，指的就是这些编辑器。Claude Code 有给它们用的插件，Android Studio 也是基于 IntelliJ 构建的。

深入学习

IDE

集成开发环境：在一个应用里编辑、运行和调试

IDE（集成开发环境）把代码编辑器、运行程序的方式、调试器、搜索、Git，常常还有终端，都放进一个窗口里。VS Code 装上扩展就成了 IDE；JetBrains 的产品和 Xcode 一装好就是完整的 IDE。AI 编程工具以扩展或插件的形式在 IDE 里运行，或者在它旁边的终端里运行。

处理程序

原文名称 · Handler

设定好在某件事发生时运行的代码

处理程序等着某一类事件，一发生就运行：点击按钮、对某个地址的请求、文件被保存。在 Claude Code 里，钩子的处理程序可以是 shell 命令、HTTP 地址、MCP 工具、LLM 提示或子智能体，每到它的时刻都会运行。是否运行它，不由模型决定。

全局

原文名称 · Global

适用于这台电脑上的所有项目，而不只是一个

全局的设置或安装在你电脑上的任何地方都有效；本地（项目）的只在一个项目文件夹里有效。npx skills add … -g 会全局安装技能，~/.claude/CLAUDE.md 存放每个项目都会读取的全局指令。同一样东西两边都有时，要看哪一边优先；对于技能，Claude Code 使用全局（个人）的那个。

深入学习

MIT 许可证

原文名称 · MIT License

简短的开源许可证：随便用，只要保留版权声明

MIT 许可证允许任何人使用、复制、修改、出售和分享软件，条件是版权声明和许可证文本要随软件一起保留。它还说明软件不提供任何担保。它是 GitHub 上最常见的许可证之一，因为它简短、要求又少。许可证文本通常放在名为 LICENSE 的文件里。

深入学习

pdfplumber

从 PDF 里提取文字和表格的 Python 库

pdfplumber 打开 PDF，一页一页给出其中的文字、带位置的单词和表格。它适用于含有真实文字的 PDF；扫描的 PDF 只是图片，需要改用 OCR。技能里告诉智能体“用 pdfplumber；只有扫描的 PDF 才用 OCR”，就给了一个明确的默认做法，而不是一串选项。

深入学习

P0 · P1

优先级标签：P0 最急，然后是 P1、P2 …

团队用简短的标签按优先级给问题排序。P0 表示“马上修”：服务挂了、数据正在丢失或有安全漏洞。P1 很严重，应该尽快修；P2 及更低的可以等一等。Codex 的 PR 审查默认只报告 P0 和 P1 的问题，让你只看重要的，不被杂音干扰。

深入学习

模板

原文名称 · Template

只需填空的现成框架

模板是一个带空白的现成形状：报告大纲、入门项目、写着 {name} 等着填的邮件。技能常在 assets/ 文件夹里附带模板，让智能体每次都产出同样的结构。聊天模板是一种特殊情况：模型训练时用的角色和消息的准确排列方式，运行模型的程序必须照着用，模型才能好好回答。

TODO

待办事项：在代码里是标出还没做完的工作的记号

TODO 的意思是“还要做”。开发者会在代码里留下 # TODO: handle empty input 这样的注释，之后用 grep 把它们找出来。在 Issue 和看板里，TODO 清单把一项任务拆成小步骤，一步步打勾，也能显示进度。旧的 TODO 很容易越积越多，所以把重要的转成 Issue。

仓库根目录

原文名称 · Repository root

Git 仓库最上层的文件夹

仓库根目录是用 Git 管理的项目最上层的文件夹——放着隐藏的 .git 文件夹的那一个。Claude Code 会从你启动它的文件夹开始，一路往上找 CLAUDE.md 文件和 .claude/skills，直到这个根目录为止，不会再往上。git rev-parse --show-toplevel 会打印它的路径。

git config

设置 Git 写进每个提交里的名字和邮箱

每个提交都会记下是谁做的，所以装好 Git 之后，要马上用 git config 告诉它一次你的名字和邮箱。加上 --global，设置会作用于这台电脑上的所有仓库；不加，就只作用于你所在的仓库。git config --list 显示现在设置了什么。

深入学习

强制 push

原文名称 · Force push

用你的历史覆盖远程历史的 push

远程仓库里有你没有的提交时，普通的 push 会被拒绝。git push --force 照样推上去，用你的版本替换远程分支，所以别人推上去的提交可能会消失，队友们的副本也会对不上。只在别人都没有拉取过的自己的分支上使用；--force-with-lease 更安全，因为远程在你上次 fetch 之后有变化时，它会停下来。

深入学习

reflog

Git 记录 HEAD 去过的每个地方的日志——丢失的提交在这里找

git reflog 从新到旧列出你的仓库里 HEAD 指向过的每个提交，包括 reset 或 rebase 之后已经没有分支能看到的提交。如果用 git reset --hard 丢了工作，就在这里找到那个提交，再回到它。它只保存在你的电脑上，旧的条目过一段时间（默认 90 天）就会过期。

深入学习

reset

把当前分支移回到更早的提交

git reset 把你的分支往回移，让后面的提交不再属于它。--soft 把那些改动保留在暂存区，默认的 --mixed 把它们保留为未暂存的改动，--hard 则把它们连同所有未提交的工作一起丢掉。只对还没 push 的提交使用；共享过的提交请用 git revert。

深入学习

git add

把改过的文件放进暂存区，准备下一次提交

git add 把改动复制到暂存区，以此挑选哪些改动进入下一次提交。只有 add 过的内容才会被提交，所以即使你改了很多文件，一次提交也可以只放一个有意义的改动。git add -p 能让你只选文件的一部分，git add . 会加入当前文件夹里的所有改动。

深入学习

revert

加一个反向的新提交，撤销旧的提交

git revert 新建一个提交，做的事和之前某个提交正好相反，于是那个改动没了，但历史里两个提交都还在。因为什么都没有被改写，所以它是撤销一个已经 push、别人也已经拉取过的提交的安全办法。如果后面的提交改过同样的行，可能会产生冲突。

深入学习

git status

显示改了什么，以及每个文件处在三个区域中的哪一个

git status 告诉你：你在哪个分支上，哪些文件改了但还没暂存，哪些已经暂存、等着下一次提交，哪些是新的、还没被跟踪。它什么都不改，所以拿不准时就运行它——add 之前、commit 之前、运行有风险的命令之前。它的输出还会提示下一步该用的命令。

深入学习

git log

从新到旧列出历史中的提交

git log 从最新到最旧显示当前分支的提交，每个都带着 ID、作者、日期和提交信息。一些选项能让它更好读：--oneline 每个提交一行，--graph 画出分支怎样分开又怎样合并。列表超过一屏时，按 q 离开。

深入学习

restore

丢掉还没提交的改动

git restore 把一个文件恢复成上一次提交时的样子，抹掉你对它做的未提交的修改。加上 --staged 时，它只把文件从暂存区里拿出来，保留修改。被丢掉的修改从来没有存进 Git，所以找不回来——先用 git status 或 git diff 检查。

深入学习

cherry-pick

只把另一个分支上的一个提交复制到这个分支

git cherry-pick 拿来某一个提交所做的改动，不管它在哪里，把它作为一个新提交应用到当前分支上。只需要功能分支里的一处修复时（比如要放到发布分支上），它很方便。复制出来的提交会有新的 ID，所以用这种办法挑很多提交，会让历史比合并更难看懂。

深入学习

stash

把没做完的工作暂时放到一边，之后再拿回来

git stash 把你未提交的改动存到另一堆里，让工作文件夹变干净，这样你就能切换分支去做紧急的修复。git stash pop 把改动拿回来，并把它们从那一堆里移除。Git 还没跟踪的新文件会留在原处，除非你加上 -u。

深入学习

git tag

贴在一个提交上的固定名字标签，比如 v1.0.0

git tag 把一个名字（通常是版本号）钉在一个提交上，这样你随时都能找到发布时的确切代码。和分支不同，你做新提交时标签不会移动。附注标签（-a）还会保存是谁、什么时候打的，以及一段说明；标签不会自动推送，除非你专门 push 它。

深入学习

git init

把当前文件夹变成一个新的 Git 仓库

git init 在当前文件夹里创建一个隐藏的 .git 文件夹，从此 Git 就能记录这个文件夹的历史。在你 add 和 commit 之前，什么都不会保存。要在项目文件夹本身里运行：在主目录里运行，它会跟踪你所有的文件。

深入学习

git apply

把 diff（补丁）文件里的改动应用到你的文件上

git apply 读取一份 diff——要删掉和要加上的行——把这些修改做到工作文件夹的文件里，但不提交。在别处做的改动（比如云端的 Codex 做的）就是这样落到你的副本里的。git apply --check 会先告诉你这个补丁能不能对得上。

深入学习

Git LFS

把大文件放在仓库之外的 Git 扩展

Git LFS（Large File Storage，大文件存储）让模型权重这类大文件不进入普通的 Git 历史。仓库里只保存一个很小的指针文件，真正的文件放到单独的存储空间。只要先运行一次 git lfs install，之后照常使用 git add、commit 和 push 即可。

深入学习 详细了解权重和参数

Traceback

显示错误发生位置的 Python 错误报告

Python 程序出错时会打印 traceback：从最外层的调用一直到出错的那一行，列出导致错误的一连串函数调用。要从下往上读——最后一行写着错误类型和信息，紧挨着的上面几行写着文件名和行号。

深入学习

uv

管理 Python 项目和包的快速工具

uv 是一个用来创建 Python 项目、配置虚拟环境并安装包的工具。它把 pip 和 venv 的工作合在一起做，而且快得多。例如，uv add torch 会把 PyTorch 安装到项目中。

深入学习

异步（async）

原文名称 · async (asynchronous)

等待慢任务时继续做其他工作的方式

异步代码会先启动一个慢任务（比如等待网络响应），在它完成之前去处理其他工作，而不是原地停着。在 Python 中用 async 和 await 来写。用这种方式写的 Web 服务器可以同时保持许多连接。

深入学习

.claude/agents/

Claude Code 存放子智能体文件的文件夹

每个子智能体都是一个 Markdown 文件，写着名字、说明、能用的工具和指示。项目里 .claude/agents/ 下的文件属于这个项目，可以提交给团队；~/.claude/agents/ 下的文件在你所有项目里都能用。Claude Code 会读说明，来决定什么时候把工作交给这个子智能体。

深入学习

~/.claude.json

主目录里 Claude Code 的个人设置文件

~/.claude.json 保存 Claude Code 为你的用户账户记下的状态：偏好、登录信息、每个项目的数据，以及用 local 或 user 范围添加的 MCP 服务器。它和 .claude 文件夹、settings.json 都不同。编辑它要小心，或者让 claude mcp add 这类命令替你修改。

深入学习

mcpServers

列出 MCP 服务器以及怎样启动它们的设置键

mcpServers 是 ~/.claude.json、项目的 .mcp.json 以及其他应用类似文件里的一个键，里面放着 MCP 服务器清单。每一项都有一个名字，并告诉应用怎样启动或连接这个服务器：一条带参数的命令，或者一个 URL。这一项写在哪里，决定了服务器在哪里能用。

深入学习

.claude/skills/

Claude Code 寻找技能的文件夹

每个技能都是一个带 SKILL.md 文件的文件夹，Claude Code 会在这里找这些文件夹。项目里的 .claude/skills/ 通过 Git 与团队共享；~/.claude/skills/ 存放你在所有项目里都能用的个人技能。Claude 会读每个技能的名字和说明，只有任务需要时才载入完整的指示。

深入学习

.mcp.json

列出整个团队共用的 MCP 服务器的项目文件

.mcp.json 放在仓库的最上层，列出这个项目的 MCP 服务器。因为它会提交到 Git，所以每个克隆项目的人都会得到同样的服务器；Claude Code 在第一次使用它们之前会请求批准。用 --scope project 运行 claude mcp add，就会写进这个文件。秘密要放在环境变量里，不要写在这个文件里。

深入学习

.claude/settings.json

Claude Code 的项目设置文件：权限规则、钩子等

.claude/settings.json 保存一个项目共用的设置：权限规则（allow、ask、deny）、钩子、环境变量等。它会被提交，让整个团队按同样的规则工作。个人的修改写在不提交的 .claude/settings.local.json 里，适用于你所有项目的设置写在 ~/.claude/settings.json 里。

深入学习

@路径导入

原文名称 · @path import

在 CLAUDE.md 里写 @路径，把另一个文件的内容拉进来

在 CLAUDE.md 里，像 @docs/architecture.md 这样的一行会导入那个文件：它的内容会在那个位置被读进来，就像直接写在那里一样。常见的用法是 @AGENTS.md，让 Claude Code 也遵守其他智能体读的共用指示。导入的文件在每次会话开始时都会载入上下文，所以要写得短一些。

深入学习

CLAUDE.local.md

不提交的、给 Claude Code 的个人项目指示

CLAUDE.local.md 放在项目里 CLAUDE.md 的旁边，保存只给你自己的指示——本地 URL、你的测试数据——并写在 .gitignore 里，所以永远不会被提交。默认情况下，只要工作文件夹或其上层文件夹里有 CLAUDE.md、.claude/CLAUDE.md 或 CLAUDE.local.md，Claude Code 就不读 AGENTS.md（~/.claude/CLAUDE.md 不算）。所以如果你依赖 AGENTS.md，个人笔记就放在 ~/.claude/CLAUDE.md 里，或在 /config 里把 Project instructions 设为 claude-md-and-agents-md，让两者都被读取。

深入学习

剪贴板

原文名称 · Clipboard

电脑存放你最近复制内容的地方

你复制文字或图片后，电脑会把它放在剪贴板里，直到你复制别的东西；粘贴时，它就出现在光标所在的位置。网页只有在你允许时才能读取剪贴板，所以浏览器有时会拦住“粘贴”按钮——这时点一下输入框，按 Ctrl+V（Mac 上是 ⌘V）即可。

Ctrl+V（⌘V）

原文名称 · Ctrl+V (⌘V)

粘贴已复制内容的快捷键

Ctrl+V 会把剪贴板里的内容粘贴到光标所在的位置；在 Mac 上，同样的快捷键是 ⌘V（Command+V）。它和负责复制的 Ctrl+C 是一对。在终端里，Ctrl+C 的作用却是停止正在运行的命令，所以很多终端改用 Ctrl+Shift+V 来粘贴。

截图

原文名称 · Screenshot

把屏幕上显示的内容拍成一张图

截图会把屏幕上显示的内容保存成图片。在 Windows 上，Win+Shift+S 可以把选中的区域复制到剪贴板；在 Mac 上，Cmd+Shift+4 会把选中的区域存成文件，再加按 Ctrl 则改为复制。

Ctrl 键

原文名称 · Ctrl key

和其他键一起按、组成快捷键的控制键

Ctrl（Control）是键盘左下角的键。和其他键一起按就成为快捷键：在终端里 Ctrl+C 会停止命令。Mac 上很多应用快捷键改用 Cmd，但终端快捷键在 Mac 上仍然用 Ctrl。

FizzBuzz

边数数边输出 Fizz、Buzz、FizzBuzz 的经典练习题

FizzBuzz 是一道有名的练习题：从 1 开始依次输出数字，但 3 的倍数输出 Fizz，5 的倍数输出 Buzz，同时是两者倍数的输出 FizzBuzz。它可以一起练习循环、if 条件判断和取余运算符 `%`。常见错误是先判断 3 的倍数，结果 15 只输出 Fizz，所以要先判断“两者都是”的情况。

深入学习

TextEdit

macOS 自带的文本编辑器

TextEdit（文本编辑）是每台 Mac 都自带的简单文本编辑器。它默认保存为带格式的文本（RTF），会加入看不见的格式。要写 HTML 或代码，先选择“格式 → 制作纯文本”，让文件里只有你输入的字符。

深入学习

记事本

原文名称 · Notepad

Windows 自带的纯文本编辑器

记事本（Notepad）是 Windows 自带的简单编辑器。它只保存纯文本，这正是 HTML 和代码文件所需要的。保存网页时，把文件类型设为“所有文件”，这样记事本就不会在文件名末尾加上 .txt。

深入学习

os.replace

Python 一步换上写好的文件的方法

os.replace(src, dst) 把文件 src 改名为 dst，如果 dst 已经存在就替换它。在同一个磁盘上，这次替换是原子的（一步完成）：其他程序只会看到旧文件或新文件，绝不会看到写了一半的文件。所以程序会先写入临时文件，再调用 os.replace。

深入学习

浏览器控制台

原文名称 · Browser console

列出网页错误和消息的面板

浏览器控制台是浏览器开发者工具里的一个面板，网页里的 JavaScript 会把错误和消息写在这里。当应用只显示一片空白，或者按钮按了没反应时，控制台里通常写着原因。在 SONUB 的 Vibe 编程里，预览旁边的控制台标签页会帮你把这些消息收集起来。

深入学习

HTML

用来说明网页上有什么的语言

HTML 给页面内容做标记：这是标题、这是段落、这是图片、这是链接。它写的是含义和结构，不是外观——颜色和排版归 CSS 管。你打开的每一个页面，包括眼前这个，都是以 HTML 的形式送到浏览器的。

深入学习

CSS

决定网页长什么样的规则

CSS 把 HTML 描述的那一堆素内容穿上衣服：颜色、间距、字体、版式。两者分开的好处是，不改内容也能换外观，也能让手机和电脑上看起来不一样。网站忽然变成光秃秃的样子，多半是 CSS 没加载上。

深入学习

JavaScript

让网页动起来的语言

如果说 HTML 是内容、CSS 是外观，那么 JavaScript 就是行为：它响应点击、去取新数据，并在你看着的时候改动页面。每个浏览器都能运行它，因此它成了网页的语言。名字虽像，但它和 Java 毫无关系。

深入学习

HTTP

浏览器和服务器之间一问一答的规矩

HTTP 是浏览器向服务器要东西、服务器给出回答时共同遵守的格式。每次往来都是独立的：请求发出去，回复送回来，连接就把你忘了。HTTPS 是给它套上加密，这也是你输入密码时要看那把小锁的原因。

URL

互联网上某样东西的完整地址

URL 就是浏览器地址栏里那串地址，它的每一段都有含义：先是协议，再是站点，然后是通往具体页面的路径。会读地址是一项不起眼却重要的安全本领——第一个单斜杠前面那一段才是真正的站点，冒充银行的假地址就是这样识破的。

浏览器

原文名称 · Browser

把网页取回来并画在屏幕上的程序

Chrome、Safari、Firefox、Edge 都是浏览器：它们向服务器要来页面，再把返回的 HTML、CSS 和 JavaScript 变成你看到的样子。它们还会真的去运行这些代码，所以网页才能像应用一样使唤。在多数人的设备上，浏览器是开得最久的程序，却几乎没人会想起它。

深入学习

域名

原文名称 · Domain name

互联网上服务器地址的易读名字

电脑之间靠数字形式的 IP 地址找到对方，而这些数字很难记。example.com 这样的域名是你向注册商租来的名字，再通过 DNS 让它指向某个 IP 地址。HTTPS 证书也是针对域名签发的，所以真正的证书需要一个真正的域名。

深入学习

DNS

把名字换成 IP 地址的互联网电话簿

DNS（域名系统）回答的问题是「example.com 是哪个 IP 地址？」。浏览器连到任何地方之前，都要先问 DNS。你自己域名的答案，用 A 记录之类的记录来设定。由于答案会在沿途各处被缓存，一次修改传到所有人那里可能要几分钟到几个小时。

深入学习

React

用组件搭建网页的 JavaScript 库

React 让你用叫作组件的可复用小块来搭页面，每个组件有自己的外观和行为；数据一变，它只重画变了的部分。React 项目需要一个构建步骤：Vite 之类的工具会把它变成任何 Web 服务器都能提供的普通 HTML、CSS 和 JavaScript 文件。

深入学习

开发者工具

原文名称 · DevTools

浏览器内置的、用来查看网页内部的面板

开发者工具（DevTools）是 Chrome 等浏览器内置的工具。它能显示网页的 HTML、网页发出的每一条请求及其头部和响应、网页保存的 Cookie 和缓存，以及脚本的错误。按 F12，或者在网页上右键选“检查”就能打开。在里面做的修改不会保存；刷新页面就全部恢复原样。

深入学习

状态码

原文名称 · Status code

表示请求结果如何的三位数字

每个 HTTP 响应都以状态行开头，里面有一个三位数的状态码。第一位数字表示类别：2xx 成功，3xx 去别处找，4xx 请求有问题，5xx 服务器有问题。先看它：404 的意思是路径写错了，而不是服务器挂了。

深入学习

重定向

原文名称 · Redirect

让浏览器转去另一个地址的回复

重定向是一种响应，意思是“你要的东西在那边”。它带着 3xx 状态码，比如表示永久搬迁的 301，新地址写在 Location 头部里。浏览器会自己跟过去，curl 则要加上 -L 才会跟。网站用重定向把 http 的访客送到 https，也用它让旧链接继续有效。

深入学习

Cookie

网站存在你浏览器里的一张小纸条

Cookie 是服务器请浏览器保存的一小段“名字=值”数据。从那以后，浏览器每次向这个网站发请求，都会在 Cookie 头部里把它带回去。虽然每个 HTTP 请求都是各自独立的，网站正是靠它记住你已经登录。你可以在开发者工具里查看和删除 Cookie；删掉之后通常就会退出登录。

深入学习

缓存

原文名称 · Cache

就近保存的副本，不必再去取一次

缓存是把来之不易的东西存一份副本放在近处，下次就能很快拿到。浏览器缓存图片和文件，服务器缓存页面，人工智能模型则把前面词元的结果存成 KV 缓存。麻烦在于副本可能过时：网站改了之后看起来还是旧的，跳过缓存刷新一次往往就好了。

接口（端点）

原文名称 · Endpoint

API 里一个可以调用的地址

端点（endpoint）是 API 里负责一件事的某个具体 URL，比如读取某个用户的信息，中文里也常直接叫“接口”。API 是整份菜单，每个端点是菜单上的一道菜，通常还要配上 GET 或 POST 这样的 HTTP 方法。在写应用代码之前先用 curl 调一下端点，就能确切看到会返回什么。

深入学习

WebSocket

一直开着、双向收发消息的连接

普通的 HTTP 是一个请求、一个响应，然后就结束了。WebSocket 先以 HTTP 请求开始，然后变成一条一直开着的连接，服务器和浏览器都可以随时给对方发消息。这很适合聊天、实时比分和网络游戏，因为服务器得在没人问的时候主动推送更新。

深入学习

流式传输

原文名称 · Streaming

一边生成一边分段送出响应

流式传输是每准备好一小段就马上送出，而不是等整个响应都做完。人工智能聊天服务常通过 HTTP 用 SSE（服务器发送事件）把文字流式送出，所以回答看起来像是自己一个字一个字打出来的。每一段多大是产品的选择 —— 有的服务一次送整句，而不是单个词元 —— 这个节奏并不说明有谁在打字或思考。

深入学习

标签

原文名称 · Tag

用尖括号括起来、标出页面某一部分的记号

HTML 标签是写在尖括号里的记号，比如 <p> 或 <a>，告诉浏览器一段内容是什么。大多数标签成对出现：一个开始标签，一个带斜杠的结束标签，内容放在中间。也有少数像 <img> 和 <br> 这样单独出现。标签是你敲出来的东西；浏览器根据它们搭出元素。

深入学习

元素

原文名称 · Element

页面的一部分，从开始标签到结束标签

元素是页面的一部分：开始标签、结束标签，以及两者之间的一切。元素套在别的元素里面，所以整个页面构成一棵树，开发者工具的 Elements 面板显示的正是这棵树。标签是你敲出来的东西；元素是浏览器根据它搭出来、再画到屏幕上的东西。

深入学习

属性

原文名称 · Attribute

写在开始标签里的额外信息

属性用来补充光靠标签名说不清的信息。它写在开始标签里面，形式是 名字="值"，比如链接的地址或图片的文件。常见的有 href、src、alt、id 和 class。alt 比看上去重要：屏幕阅读器会把它念给看不见图片的人听。

深入学习

HTTP 请求

原文名称 · HTTP request

客户端发给服务器、要东西的消息

HTTP 请求是浏览器或 curl 发给服务器的一段纯文本消息。第一行写着方法、路径和协议版本，比如 GET / HTTP/1.1。接着是头部，一行一个，然后是一个空行，有时还有一段携带数据的正文。服务器读完后会送回一个响应。

深入学习

HTTP 响应

原文名称 · HTTP response

服务器针对请求送回的消息

HTTP 响应是服务器对请求的回答。它以状态行开头，比如 HTTP/1.1 200 OK，接着是 Content-Type 这样说明后面是什么内容的头部，然后是一个空行，最后是内容本身：一个 HTML 页面、一张图片或 JSON 数据。把头部和内容隔开的，只有那一个空行。

深入学习

HTTP 头部

原文名称 · HTTP header

消息里写成“名字: 值”的一行附加信息

头部是 HTTP 请求或响应第一行之后的那些行，每行写成 名字: 值。它们携带的是关于这条消息的信息，而不是内容本身：你要哪个网站（Host）、这是什么类型的内容（Content-Type）、Cookie、你偏好的语言、页面搬到了哪里（Location）。一个空行表示头部结束。

深入学习

HTTP 方法

原文名称 · HTTP method

请求开头的动词，比如 GET 或 POST

方法是 HTTP 请求的第一个词，说明客户端想做什么。GET 是要东西，不应该改动任何内容；POST 是送数据，比如填好的表单或一篇新帖子。其他还有 PUT、PATCH 和 DELETE，多用在 API 里。开发者工具的 Network 面板会显示每条请求用的方法。

深入学习

Laravel

用 PHP 搭建网络服务的流行框架

Laravel 是免费、开源的 PHP 框架。它提供几乎每个网站都需要的部件：把地址对应到代码的路由、数据库层、登录、中间件、邮件和队列，你只需写自己的业务逻辑。SONUB 本身就是用 Laravel 搭的，运行在 Docker 容器里，前面是 Caddy 网页服务器。

GET

请服务器送回某样东西的 HTTP 方法

GET 是最常用的 HTTP 方法：每次打开网页或加载图片，浏览器都会发一个。它只是要数据，不应改动服务器上的任何东西，所以可以放心重复，它的回答也可以缓存。额外的信息放在地址里的问号后面，所以绝不能用 GET 发送密码。

深入学习

POST

把数据送给服务器处理的 HTTP 方法

POST 把数据放在请求的正文里送出：填好的表单、新评论、上传的文件，或发给 API 的 JSON。和 GET 不同，它通常会改动服务器上的东西，比如保存一篇新帖子。所以刷新页面时，浏览器会先提醒你是否要再次提交表单。

深入学习

PUT

把某个地址上的东西整个换掉的 HTTP 方法

PUT 发送某样东西的完整新版本，请服务器把它存到那个地址，替换原来的内容。同样的 PUT 发两次，和发一次结果一样。它主要用在 API 里，普通网页很少用。

深入学习

PATCH

只修改某样东西一部分的 HTTP 方法

PATCH 只发送你想改的部分，比如一个新昵称，其余保持原样。PUT 换掉整个东西；PATCH 是小修小改。和 PUT、DELETE 一样，它主要用在 API 里。

深入学习

DELETE

请服务器删除某样东西的 HTTP 方法

DELETE 请服务器删掉那个地址上的东西，比如一篇帖子或一个文件。是否允许由服务器决定，所以真正的 API 会先要你登录或发送密钥。网页里的普通链接发不了 DELETE；要靠程序代码或 curl 这样的工具。

深入学习

Content-Type

说明后面跟着什么类型内容的头部

Content-Type 是一个 HTTP 头部，告诉接收方如何读取正文：text/html 表示网页，application/json 表示数据，image/png 表示图片。它还可以注明字符编码，比如 charset=utf-8。如果写错了，浏览器可能会把网页当纯文本显示，或者把文字显示成乱码。

深入学习

Host 头部

原文名称 · Host header

说明你想要哪个站点的请求头部

Host 是一个请求头部，带着地址里的站点名，比如 sonub.com。一台服务器在一个 IP 地址上可以运行几百个站点，它就是靠 Host 头部来分辨你要的是哪一个。从 HTTP/1.1 起，每个请求都必须带上它。

深入学习

charset

头部里说明文字编码的部分

charset（字符集）告诉读取方用哪种编码把存下来的字节还原成文字。如今几乎总是 utf-8。如果没写，浏览器只能去猜，中文、韩文等非英文的文字就可能变成乱码。

深入学习

User-Agent

浏览器在里面报出自己名字的请求头部

User-Agent 是一个请求头部，客户端在里面介绍自己：哪个浏览器、哪个版本、哪个操作系统。服务器用它做统计，或绕开某个浏览器的 bug。它很容易伪造，所以服务器绝不能凭它来判断安全。

深入学习

协议

原文名称 · Protocol

两个程序交谈时共同遵守的约定规则

协议是双方事先约好的一套规则：谁先说、用什么格式、每种回复是什么意思。HTTP 是网页的协议，SSH 是远程终端的协议。因为规则是共用的，不同人写的程序也能互相听懂。

深入学习

尖括号

原文名称 · Angle brackets

包住 HTML 标签名的 < 和 > 符号

尖括号就是小于号和大于号，< 和 >。在 HTML 里，每个标签都放在它们中间，这样浏览器就知道那个词是指令，而不是要显示的文字。结束标签会多一个斜杠：</p>。

深入学习

aria-

向辅助工具描述元素的属性

名字以 aria- 开头的属性（比如 aria-label 或 aria-hidden）会告诉屏幕阅读器一个元素是什么，或者处于什么状态。它们不改变屏幕上的任何东西，只是为看不见页面的人补充含义。先用合适的 HTML 标签——aria- 是用来说明标签本身说不清的东西的。

深入学习

alt

用文字描述图片的属性

alt 是 img 标签的一个属性，里面放着对图片的简短文字描述。屏幕阅读器会把它念出来，搜索引擎会用到它，图片加载失败时浏览器会显示它。描述图片里有什么；纯装饰的图片就写一个空的 alt=""。

深入学习

<body>

HTML 页面里访客真正看到的部分

body 是 HTML 文档的两个主要部分之一。窗口里显示的一切——标题、文字、图片、按钮——都放在 <body> 和 </body> 之间。关于页面的信息，比如标题和字符集，则放在 head 里。

深入学习

head

HTML 页面里存放页面信息的部分

在 HTML 文档里，head 位于 body 之前。它放的是关于页面的东西，而不是页面本身：显示在浏览器标签页和搜索结果里的标题、字符集，以及样式文件的链接。head 里的东西都不会画在窗口里。

深入学习

class

给一组元素起名字的属性

class 是一个 HTML 属性，把元素归入一个有名字的组。很多元素可以共用一个 class，一个元素也可以有好几个 class，用空格隔开。CSS 和 JavaScript 用这个名字找到这一组，比如把所有警告都涂成红色。

深入学习

id

给某一个元素起唯一名字的属性

id 是一个 HTML 属性，只给一个元素命名；同一个页面上不应该有两个元素用同一个 id。脚本用它抓住那个元素，CSS 可以给它设置样式，以 #名字 结尾的链接会直接跳到它那里。

深入学习

div

独占一整行的普通盒子标签

div 是一个本身没有任何含义的 HTML 标签。它把其他元素归成一个块，这个块从新的一行开始、横向占满宽度，这样 CSS 就能摆放这一组或给它设置样式。只在没有合适的有含义标签（header、nav、section……）时才用它。

深入学习

span

放在一行文字里面的普通盒子标签

span 是一个本身没有任何含义的 HTML 标签，它在一行里包住几个词，但不会让这一行断开。它的用途是让 CSS 或 JavaScript 只够到那一小段，比如给一个词上色。如果这些词是重要的或要强调的，用 strong 或 em 表达得更好。

深入学习

h1 到 h6

原文名称 · h1 to h6

构成页面大纲的六个标题标签

h1 到 h6 是 HTML 的标题标签。h1 是主标题，h2 是一节，h3 是这一节里的一部分，依此类推，一直到 h6。它们描述文档的大纲，屏幕阅读器和搜索引擎靠它在页面里移动。它们表示的是层级，不是字号——字号用 CSS 来改。

深入学习

href

存放链接要打开的地址的属性

href 是 a 标签的属性，说明链接通向哪里。它可以是完整的地址（https://…），同一个网站上的路径（/about），或者同一个页面上的某个位置（#price）。没有 href，a 标签就只是一段看起来像链接、却哪儿也去不了的文字。

深入学习

src

存放图片或脚本文件位置的属性

src（source 的缩写）是告诉浏览器要往元素里加载哪个文件的属性：img 加载图片，script 加载脚本，video 加载视频。浏览器会为那个文件另外发送一个请求。src 写错了，就会得到一张坏掉的图片，或者一个永远不会运行的脚本。

深入学习

script 标签

原文名称 · script tag

HTML 里放入或加载 JavaScript 的 <script> 部分

script 标签把 JavaScript 放进页面：要么写在 <script> 和 </script> 之间，要么用 src 从文件加载。浏览器在读页面时就会运行它，所以要操作元素的脚本通常放在 body 的末尾，或者使用 defer。

深入学习

style 块

原文名称 · style block

HTML 里放 CSS 的 <style> 部分

style 块是写在页面里 <style> 和 </style> 之间的 CSS，通常放在 head 里。做一个小页面时它很方便；整个网站则把同样的规则放进一个单独的 .css 文件，让每个页面都链接它。删掉它只会改变页面的样子，不会改变页面说什么、做什么。

深入学习

怪异模式

原文名称 · Quirks mode

没有 DOCTYPE 时浏览器使用的老式绘制模式

HTML 页面不以 <!DOCTYPE html> 开头时，浏览器会认为它是一个非常老的页面，切换到怪异模式（quirks mode，也叫兼容模式），模仿 1990 年代浏览器的古怪行为，让老网站看起来仍然正常。这时尺寸和间距就和现代规则不一样了。每个页面都以 DOCTYPE 这一行开头，就能避免它。

深入学习

屏幕阅读器

原文名称 · Screen reader

为看不见屏幕的人把屏幕内容念出来的程序

屏幕阅读器（读屏软件）把屏幕上的内容变成语音或盲文，让盲人和视力弱的人也能使用电脑或手机。它依靠的是 HTML：用标题跳来跳去，用 alt 文字了解图片，用标签了解按钮。只用 div 盒子搭成的页面，它几乎没什么可说的。

深入学习

搜索引擎

原文名称 · Search engine

收集网页、帮你找到它们的服务

搜索引擎（Google、Bing、Naver……）派程序在网上四处读取页面，把找到的东西存进一个巨大的索引，有人搜索时再给页面排序。它读的是 HTML，不是图片：标题、页面标题和 alt 文字告诉它一个页面讲的是什么。

深入学习

HTML 表单

原文名称 · HTML form

页面上收集输入并把它发送给服务器的部分

表单是一个 HTML 元素，它收集访客输入或选择的内容——文本框、复选框、按钮——再把它发送给服务器，通常用 POST 请求。注册、登录和搜索框都是表单。服务器必须检查收到的内容，因为谁都可以发送任何东西。

深入学习

file://

打开自己电脑上文件的地址形式

以 file:// 开头的地址指向你自己磁盘上的文件，而不是服务器，所以浏览器不用任何网络就能打开它。这是试一个 HTML 页面最简单的办法。有些功能需要真正的 http:// 或 https:// 来源，用这种方式就不能工作，比如 JavaScript 发出的很多请求。

深入学习

DOM

浏览器根据 HTML 建起来的元素树

DOM（文档对象模型）是浏览器读完 HTML 后建起来的元素树：html 在根部，下面是 head 和 body，依此类推。屏幕是照着这棵树画出来的，JavaScript 通过改变这棵树来改变页面。开发者工具显示的是实时的 DOM，脚本运行之后，它可能和 HTML 文件不一样。

深入学习

Elements 面板

原文名称 · Elements panel

显示并编辑实时 HTML 和样式的开发者工具面板

浏览器开发者工具的 Elements 面板把页面显示成一棵元素树，并显示你选中的元素所应用的 CSS 规则。你可以当场修改文字、属性或样式，马上看到结果。什么都不会被保存——一刷新就没了，所以这是一个可以放心做实验的地方。

深入学习

Network 面板

原文名称 · Network panel

列出页面发出的每个请求的开发者工具面板

Network 面板列出页面发出的每个请求——页面本身、样式、图片、脚本、API 调用——以及它的方法、状态码、大小和耗时。点一下某个请求，就能看到它的请求头、响应头和正文。大多数 bug 的第一个问题它都能回答：服务器有没有回应，回应了什么？

深入学习

Sources

用来阅读和暂停脚本的开发者工具面板

Sources 面板显示页面加载的文件，主要是 JavaScript。点一下行号就能设置断点：代码下一次运行到那一行时，页面会暂停，你可以一边看着变量的值，一边一行一行地往前走。

深入学习

Application

显示网站在你浏览器里存了什么的开发者工具面板

Application 面板显示网站在你的机器上保存了什么：Cookie、本地存储、缓存存储和 Service Worker。每一项都可以查看、修改或删除。一个网站只在你这里出毛病时，在这里清除它存储的数据，往往就能解决。

深入学习

本地存储

原文名称 · Local storage

网站在你的浏览器里存放数据的小仓库

本地存储（local storage）让网站把一小段一小段的文字以键值对的形式存在你的浏览器里，关掉标签页后也还在。和 Cookie 不同，它不会随每个请求发送给服务器。它只属于同一个网站，而且用这个浏览器的人都能读到，所以密码和密钥不该放在那里。

深入学习

渲染引擎

原文名称 · Rendering engine

浏览器里把 HTML 和 CSS 变成像素的部分

渲染引擎是浏览器的核心：它读取 HTML 和 CSS，建起元素树，算出大小和位置，再把结果画到屏幕上。Chrome 和 Edge 用 Blink，Safari 用 WebKit，Firefox 用 Gecko——所以同一个页面在它们之间看起来可能会略有不同。

深入学习

同源策略

原文名称 · Same-origin policy

不让网站互相读取对方数据的规则

来源（origin）是协议、主机和端口三者合在一起，比如 https://sonub.com。同源策略只允许页面随意读取来自自己来源的数据。另一个网站上的脚本读不到你的邮件或网银页面，即使你的浏览器在那里是登录状态。服务器可以用 CORS 头部允许它选定的其他来源。

深入学习

Chromium

Chrome、Edge 等浏览器的开源基础

Chromium 是由谷歌主导的开源浏览器项目。Chrome、Microsoft Edge、Brave、Opera 和 Arc 都建立在它之上，共用它的 Blink 渲染引擎，所以在其中一个里能用的页面，在其他几个里通常也能用。Safari（WebKit）和 Firefox（Gecko）是不基于它的主要浏览器。

深入学习

伪头部

原文名称 · Pseudo-header

替代第一行和 Host 的 HTTP/2 特殊头部

HTTP/2 没有文本形式的请求行。方法、路径和网站名作为特殊的头部传送，它们的名字以冒号开头：:method、:path 和 :authority（还有 :scheme）。开发者工具把它们显示在请求头的最上面。它们携带的信息，和 HTTP/1.1 里的 GET /path HTTP/1.1 以及 Host: 一样。

深入学习

回车符

原文名称 · Carriage return

HTTP 放在每个换行之前的看不见的字符 \r

回车符（写作 \r）是一个看不见的字符，从前用来把打字机的纸送回行首。HTTP 要求每一行都以 \r 加一个换行符 \n 结束，两者合称 CRLF。很多服务器也接受单独的 \n，但逐行读取 HTTP 的工具常常得把剩下的 \r 去掉。

深入学习

200

表示请求成功（OK）的状态码

200 OK 是一切顺利、响应里装着所要东西（页面、图片、JSON）时服务器发送的状态码。它是最常见的状态码，远远超过其他。200 只说明服务器处理了这个请求——内容本身仍然可能是某人手写的一个错误页面。

深入学习

200 系列

原文名称 · 200s

表示成功的一组状态码

从 200 到 299 的状态码都表示请求成功了。200 OK 是最常见的；201 Created 表示新建了某样东西（比如在 POST 之后），204 No Content 表示成功了，但没有内容要发回。看第一位数字就足以知道结果。

深入学习

301

表示页面已经永久搬走的状态码

301 Moved Permanently 告诉客户端这个地址已经永久改变，新地址在 Location 头部里。浏览器会自动跟过去并记住它；搜索引擎会把记录改到新地址。curl 除非加上 -L，否则不会跟过去，所以你会看到一个几乎是空的回复。

深入学习

308

保留请求方法的永久重定向

308 Permanent Redirect 的意思和 301 一样——地址已经永久搬走——只有一点不同：客户端必须用同样的方法和正文重新发送请求。在 301 下，POST 跟过去时可能会变成 GET。Caddy 把 http 访问者送到 https 时用的就是 308。

深入学习

400 系列

原文名称 · 400s

表示请求本身有问题的一组状态码

从 400 到 499 的状态码说明问题出在客户端：地址错了、没有登录、服务器不接受这个请求。把同一个请求再发一次没有用——请求里的某样东西必须改。最常见的是 400 Bad Request、401、403 Forbidden 和 404 Not Found。

深入学习

404

表示所请求的路径不存在的状态码

404 Not Found 的意思是服务器在正常工作，但那个路径上什么也没有：地址打错了、页面被删了，或者文件放错了文件夹。它是网上最有名的错误代码。在由 Caddy 提供的单页应用里，刷新一个深层链接会得到 404，除非告诉服务器退回到 index.html。

深入学习

500 系列

原文名称 · 500s

表示服务器出错的一组状态码

从 500 到 599 的状态码说明请求没问题，但服务器在处理时出了故障：代码里有 bug、数据库挂了、反向代理后面的程序没有回应。必须由运营服务器的人来修，详细情况在服务器的日志里，而不在浏览器里。

深入学习

头部后的空行

原文名称 · Blank line

把 HTTP 头部和正文隔开的那个空行

一条 HTTP 消息依次是起始行、若干头部行、一个空行，然后是正文。这个空行——单独一个 \r\n——是头部和内容之间唯一的分界，所以忘了它的服务器会发出一个坏掉的回复。相反，在 HTML 文件里，空行什么作用也没有：浏览器会忽略它们。

深入学习

HTTP 压缩

原文名称 · Compression

发送之前把响应缩小，让它更快到达

HTTP 压缩在发送之前把响应——HTML、CSS、JavaScript、JSON——挤小，浏览器收到后再解开。浏览器在 Accept-Encoding 头部里列出它能解开的方式，服务器在 Content-Encoding 里说明它用了哪种方式（gzip、br、zstd）。文字常常能缩到原来的几分之一；图片和视频本来就压缩过了，没什么收益。

深入学习

Location 头部

原文名称 · Location header

存放重定向新地址的响应头部

Location 是携带一个地址的 HTTP 响应头部。在重定向（301、302、307、308）里，它说明客户端应该改去哪里；浏览器会自己跟过去。在新建了某样东西的 POST（201 Created）之后，它可以指向那个新项目。

深入学习

请求行

原文名称 · Request line

HTTP 请求的第一行：方法、路径和版本

每个 HTTP/1.1 请求都以请求行开头，它由空格隔开的三部分组成：方法（GET、POST……）、路径（/learn）和协议版本（HTTP/1.1）。其他一切——头部、正文——都跟在它后面。简单的服务器只要读这一行，就知道该回什么。

深入学习

协议版本

原文名称 · Protocol version

一条消息用的是哪一版 HTTP：HTTP/1.1、2 还是 3

HTTP 有好几个版本。HTTP/1.1（1997 年）发送纯文本的行，你可以手打出来。HTTP/2（2015 年）把同样的意思作为二进制帧发送，并在一个连接上同时发送很多请求。HTTP/3（2022 年）做同样的事，但走的是基于 UDP 的 QUIC，而不是 TCP。方法、头部和状态码在所有版本里含义都一样。

深入学习

消息正文

原文名称 · Message body

HTTP 头部之后真正的内容

正文是 HTTP 消息里空行之后的部分：页面的 HTML、图片的字节、API 回答的 JSON，或者 POST 的表单数据。头部描述它——Content-Type 说明它是什么，Content-Length 说明它有多长。GET 请求通常没有正文。

深入学习

路由

原文名称 · Routing

按地址把每个请求送给对的处理程序

路由根据请求的路径或域名，决定由什么来回答它：/about 返回一个页面，/api/… 交给一个程序，files.example.com 交给一个文件服务器。Web 框架在代码里有一份路由列表；Caddy 这样的服务器在配置里按路径和主机来路由。没有路由的服务器，对每个地址的回答都一样。

深入学习

子域名

原文名称 · Subdomain

加在域名前面的名字，比如 teacher.sonub.com

子域名是加在你拥有的域名前面的额外名字：teacher.sonub.com 和 student.sonub.com 都是 sonub.com 的子域名。每个子域名都可以指向不同的服务器或应用，创建一个除了一条 DNS 记录之外不花任何钱。按照惯例，www 也是一个子域名。

深入学习

连接超时

原文名称 · Timeout

程序停止等待回答的时间上限

超时就是程序放弃之前要等多久——等一个连接、一个回复，或者一整个请求。没有超时，客户端可能会在一台死掉的服务器上永远挂着，服务器也可能被慢吞吞的访问者拖住。时间一到，你得到的是一个错误而不是回答，这通常比永远等下去要好。

深入学习

/health

回答服务器是否正常运行的地址

健康检查是一个很小的地址，常常是 /health，服务器会很快地回答“我在运行”（也许再附上几项信息）。人、脚本和监控工具会调用它，在交给服务器真正的工作之前看看服务是否活着，或者在它不再回应时重启它。

深入学习

数据加密

原文名称 · Encryption

把数据打乱，只有持有密钥的人才能读懂

加密用一把密钥把可读的数据变成打乱的字节；只有持有正确密钥的人才能把它变回来。HTTPS 会加密你的浏览器和服务器之间的一切，所以同一个 Wi-Fi 上或沿途的人看到的只是一堆杂乱的数据。它隐藏的是内容，而不是你访问过这个网站这件事。

深入学习

TLS

加密 HTTPS 并证明服务器身份的那一层

TLS（传输层安全协议）就是 HTTPS 里那个 S。连接开始时，双方核对服务器的证书，商定秘密的密钥，之后传送的一切都会被加密，并防止被篡改。SSL 是它早已退役的前身，所以人们至今还说“SSL 证书”。

深入学习

TCP

让数据完整、按顺序送达的连接规则

TCP（传输控制协议）在两台电脑之间建立一个连接，确保每个字节都按正确的顺序送到，路上丢了的就重新发送。HTTP/1.1 和 HTTP/2 都运行在它之上。这些检查要花一点时间，所以讲究速度的游戏有时会改用 UDP。

深入学习

UDP

不检查是否送达的快速发送数据的方式

UDP（用户数据报协议）不建立连接就发送小数据包，也不检查它们有没有送到、顺序对不对。所以它很快，适合语音通话、视频直播、网络游戏和 DNS。不能丢失的东西，必须由程序自己检查，或者由上面一层（比如 QUIC）来检查。

深入学习

QUIC

HTTP/3 底下、建立在 UDP 之上的传输协议

QUIC 是运行在 UDP 上的传输协议，它把 TLS 加密直接做进了连接本身。建立连接所需的往返次数比 TCP 加 TLS 更少，而且丢一个数据包不会拖住其他所有请求。HTTP/3 就是通过 QUIC 传送的 HTTP。

深入学习

rUDP

可靠 UDP：加上送达检查的 UDP，实时游戏会用到

rUDP（可靠 UDP）补上了普通 UDP 缺少的东西——确认、重发和排序——但只用在需要它的消息上。游戏可以把位置更新作为可能丢失的快速 UDP 数据包发送，同时在同一个连接上可靠地发送“玩家买了一件道具”。它是游戏库里的一类技术，而不是一个固定的标准。

深入学习

网络往返

原文名称 · Network round trip

请求去另一台机器再带着回答回来的一趟

往返是一条消息传到另一台机器、再把回复传回来所用的时间。每一次往返都会增加延迟——近处几毫秒，跨越半个地球就多得多——所以需要很多小回答的程序会显得很慢。让代码靠近它的数据，或者把请求合并成一批，就能减少往返的次数。

深入学习

安全上下文

原文名称 · Secure context

通过 HTTPS 打开、被允许使用强大功能的页面

浏览器只在安全上下文里才允许某些强大的功能：通过 HTTPS 加载的页面（开发时也包括 localhost）。麦克风和摄像头、用于离线游玩的 Service Worker、申请不会被清除的存储空间，都是例子。在普通的 http:// 页面上，这些功能根本不存在。

深入学习

Service Worker

原文名称 · Service worker

在页面背后运行、负责缓存和离线使用的脚本

Service Worker 是浏览器在页面之外单独运行的一个 JavaScript 文件。它位于页面和网络之间，所以能用缓存来回答请求——让网站或游戏离线也能打开——还能接收推送消息。它只能在安全上下文（HTTPS）里工作。

深入学习

Web 应用清单

原文名称 · Web app manifest

让 Web 应用可以安装的 JSON 文件

Web 应用清单是一个 JSON 文件，写着应用的名字、图标、颜色和起始地址。页面链接到它时，浏览器就可以提议把网站安装到主屏幕上，以后它会像应用一样在自己的窗口里打开。在 Cadeplay 上，平台会替你加上它，所以游戏不应该自带一份。

深入学习

PWA

可以像应用一样装到主屏幕上的 Web 应用

PWA（渐进式 Web 应用）是一个做成像已安装应用那样运作的网站：它有 Web 应用清单，可以添加到主屏幕；通常还有 Service Worker，所以打开得快，离线也能用。没有应用商店的审核——玩家直接从浏览器安装它。

深入学习

Web 应用

原文名称 · Web app

在浏览器里运行、像应用一样使用的程序

Web 应用是一个用来做事、而不只是显示页面的网站：邮件、文档、仪表盘、游戏。它在浏览器里运行，所以什么都不用安装，每位访客都能马上用到最新版本。它背后通常有一台存放数据的服务器。

深入学习

WebGL

用 GPU 绘制 2D 和 3D 图形的浏览器技术

WebGL 让网页里的 JavaScript 不用插件就能使用显卡，快速绘制 2D 和 3D 场景。游戏引擎和 Three.js、Babylon.js、PixiJS、Phaser 这样的库在底层都用它，Unity 也能把游戏导出成在浏览器里运行的 WebGL 版本。

深入学习

画布

原文名称 · Canvas

让代码一个像素一个像素地往上画的屏幕区域

画布（canvas）是屏幕上的一个矩形，程序直接在上面画——图形、图片、文字——而不是摆放现成的元素。大多数 2D 网页游戏都把每一帧画到 HTML 画布上，Flutter Flame 这样的游戏框架也把游戏画进一块画布，周围再放上普通的小组件。

深入学习

Cadeplay

上传一个 zip 就能发布游戏的网页游戏平台

Cadeplay（cadeplay.com）是一个 HTML5 游戏门户，游戏直接在浏览器里玩，无需安装。你把游戏作为一个 zip 上传，它会被自动检查，并得到一个自己的永久地址（name.cadeplay.com）。平台还会加上云存档、排行榜和安装用的清单，所以游戏不必自己去做这些。

深入学习

Cadeplay 控制台

原文名称 · Cadeplay console

开发者管理游戏的后台网站

开发者控制台是一个平台的管理网站，你以开发者身份登录，在那里注册游戏或应用、上传构建、阅读报告、创建访问令牌。Cadeplay 控制台和谷歌的 Play Console 都是例子。能在那里点击完成的事，往往也能通过平台的 API 来做。

深入学习

地址名称（主机标签）

原文名称 · Host label

地址最前面的那个名字，比如 name.cadeplay.com 里的 name

主机标签是主机名里用点隔开的一段；这里指的是第一段，也就是你在 name.cadeplay.com 里为游戏选的名字。标签可以用字母、数字和连字符。在 Cadeplay 上，游戏第一次公开时它就永久固定了，所以要在公开之前选好。

深入学习

基础路径

原文名称 · Base path

决定文件地址从哪里开始的构建设置

Vite 这样的构建工具有一个 base 设置，它会加在构建好的游戏或网站里每个文件地址的前面。如果它是 / 这样的绝对路径，文件就会到域名的最顶层去找，游戏放在别的位置时就会出错。相对的 base（./）能让同一份构建在你的电脑上和 Cadeplay 这样的托管平台上都能运行。

深入学习

锁形图标

原文名称 · Padlock

地址栏里表示可信 HTTPS 页面的标志

页面通过 HTTPS、带着有效证书送达时，浏览器会在地址旁边显示一个标志——传统上是一把锁。它表示连接是加密的，网站也确实是那个域名；但它不表示网站是诚实的。新服务器还没有有效证书时，这个标志会变成一个警告。

深入学习

CDN

从附近分发文件副本的服务器网络

CDN（内容分发网络）把网站的文件——图片、脚本、整个页面——的副本放在世界各地的许多服务器上，从离每位访客最近的那一台回答。页面加载得更快，主服务器的工作也更少。Cloudflare、Fastly 和 Amazon CloudFront 都是有名的 CDN。

深入学习

组件

原文名称 · Component

组成页面、可以重复使用的积木块

组件是用户界面的一部分——一个按钮、一张卡片、一个菜单——写一次就能用很多次，有自己的结构、样子和行为。React 这样的库用组件搭出整个页面，把每个组件该显示的数据传给它。修好一个组件，用到它的每个地方都跟着修好了。

深入学习

身份验证

原文名称 · Authentication

确认一个用户或程序是谁

身份验证回答“你是谁？”：密码、用谷歌或苹果账号登录、发到你手机上的验证码，或者程序随每个请求一起发送的令牌。它发生在授权之前，授权决定这个人可以做什么。push 或 API 调用因身份验证被拒绝时，说明凭据缺失、错误或已经过期。

深入学习

布局

原文名称 · Layout

屏幕上各个部分是怎样排列的

布局决定屏幕的每一部分放在哪里：页头、菜单、内容、侧边栏、页脚，以及它们在宽屏和窄屏上怎样移动。在网页上，布局用 CSS 来写。在网站代码里，“布局”也可以指一个共用的模板——每个页面都放进去的、由页头和菜单组成的框架。

深入学习

宽高比

原文名称 · Aspect ratio

图片的宽度和高度之比

宽高比说明一张图片或一块屏幕相对于高度有多宽，写作 宽 : 高。16:9 是宽屏视频，1:1 是正方形，9:16 是竖着拿的手机。不裁剪就改变它，图片会被压扁或拉长，所以让 AI 修改图片时，要说明你想要的比例。

深入学习

全栈

原文名称 · Full-stack

从屏幕到服务器全都包办

全栈指的是覆盖一个产品的每一层：用户看到的部分（前端）、它背后的服务器和数据库（后端），常常还包括部署。全栈开发者一个人就能做出整个应用；全栈项目包含所有这些部分，而不只是其中一个。

深入学习

个人访问令牌

原文名称 · Personal access token

代替密码用来登录 GitHub 的令牌

个人访问令牌是 GitHub 为你生成的一长串秘密字符，用在原本要填密码的地方——比如 git push 要求你登录时。你可以选择它能做什么、什么时候过期，也可以随时作废它。要像对待密码一样对待它：绝不要把它粘贴到聊天里，也不要提交它。

深入学习

握手

原文名称 · Handshake

双方在开头商定怎样交流的那几次往来

握手是一个连接最开始的几条消息，双方在真正开始工作之前互相核对，并商定设置——版本、能力、密钥。TLS 从一次握手开始，MCP 也用过 initialize 请求和回复来握手。握手失败的话，别的什么都不会发送。

深入学习

HTML 验证器

原文名称 · HTML validator

检查 HTML 是否遵守规则的工具

HTML 验证器读取一个页面，列出每一处违反 HTML 规则的地方：从没关闭的标签、放错位置的属性、重复的 id。浏览器会悄悄地猜着绕过这些错误，所以一个页面可能看起来没问题，对屏幕阅读器或另一种浏览器来说却是坏的。W3C 在 validator.w3.org 提供了一个免费的验证器。

深入学习

输入检查

原文名称 · Input validation

使用之前，先检查用户输入的内容是否被允许

输入检查会核对用户发送的每个值——邮箱看起来像不像邮箱，年龄是不是数字，名字是不是太长——并用清楚的提示拒绝不合格的值。浏览器里的检查只是为了方便；服务器必须再检查一遍，因为谁都可以不经过页面直接发送请求。

深入学习

JSON-RPC

通过发送 JSON 消息来调用函数的简单规则

JSON-RPC 是一个用 JSON 写的、关于远程调用的小标准。请求写明一个方法（method）和它的参数（params），并带着一个 id；回复带着同样的 id，以及结果（result）或错误（error）。没有 id 的消息是通知，不会得到回复。MCP 的每条消息都使用 JSON-RPC 2.0。

深入学习

JSON-RPC 通知

原文名称 · Notification

不需要回复的单向 JSON-RPC 消息

在 JSON-RPC 里，通知（notification）是没有 id 的消息。它告诉对方发生了某件事——比如 MCP 里握手之后发送的 notifications/initialized——接收方不能回复它。因为没有回复，发送方永远不知道它有没有被处理。

深入学习

本地 API 服务

原文名称 · Local API

由你自己电脑上的程序提供的 API

本地 API 是你自己机器上的程序在 http://localhost:11434 这样的地址提供的 API。你的应用和它对话的方式，跟和云端 API 对话一模一样，但请求从不离开这台电脑：不需要互联网，也不需要付费的密钥。Ollama 和 llama.cpp 这样的模型运行器就是这样工作的。

深入学习

传输方式

原文名称 · Transport

承载 MCP 消息的通道：stdio 或 HTTP

传输方式是 MCP 消息在客户端和服务器之间传送的方式。用 stdio 时，客户端在同一台电脑上启动服务器程序，双方通过标准输入和标准输出交谈。用 Streamable HTTP 时，服务器在一个网址上运行，很多用户都能连接。两种方式里的消息都一样。

深入学习

移动优先

原文名称 · Mobile first

先为手机屏幕设计，再往宽处扩展

移动优先的意思是，先为窄窄的手机屏幕写布局，再在上面加上给更宽屏幕的规则。大多数访客用手机来访问，而把一个简单的单栏页面加宽，要比把一个拥挤的桌面页面挤窄容易。在 CSS 里，给更宽屏幕的规则写在 min-width 媒体查询里。

深入学习

开放标准

原文名称 · Open standard

谁都可以自由阅读和使用的共同规则

开放标准是公开发布的规范，谁都可以阅读和实现，不用征得许可，也不用付费。HTML、HTTP 和 JSON 都是开放标准，所以任何浏览器都能打开任何网站。Agent Skills 和 MCP 也是开放标准，所以一个技能包或一个服务器可以在很多 AI 工具里使用。

深入学习

技术规范

原文名称 · Specification

准确规定一项技术必须怎样运作的官方文档

规范（spec）是精确定义一项技术的官方文本：有效的消息长什么样，每一部分是什么意思，每种情况下必须发生什么。不同厂商的程序能够协同工作，是因为它们遵循同一份规范。规范会更新，所以要用日期或版本号说明你遵循的是哪一份。

深入学习

静态网站

原文名称 · Static site

由现成的文件组成、原样提供的网站

静态网站就是一些文件——HTML、CSS、JavaScript、图片——服务器原封不动地把它们发出去；不会为每位访客在服务器上运行任何东西。所以它又快又便宜，托管起来也安全，常常还是免费的（Cloudflare Pages、GitHub Pages）。里面的一切谁都能下载，所以绝不能把机密信息放在里面。

深入学习

URI

给资源命名的标识字符串（URL 是其中一种）

URI（统一资源标识符）是一个按标准形状给某样东西命名的字符串：一个协议名、一个冒号，然后是其余部分。每个 URL 都是还说明了去哪里获取那样东西（https://…）的 URI，但 URI 也可以给不是网页的东西命名，比如 mailto:me@example.com，或者 notes://shopping 这样的 MCP 资源。

深入学习

Sign in with Apple

用苹果账号登录应用和网站

Sign in with Apple（通过 Apple 登录）让人们用自己的 Apple 账户登录，而不用再设一个新密码，还能用一个中转地址隐藏真实的邮箱。苹果的 App Store 规则要求：提供其他公司登录方式（比如谷歌）的应用，也要提供这样一个保护隐私的选项，否则应用可能会被拒。

深入学习

仪表盘

原文名称 · Dashboard

把状态和设置集中在一处的界面

仪表盘是把一项服务最重要的数字、列表和设置汇集在一个屏幕上的页面，让你不用在菜单里翻找，就能看清现状并采取行动。托管服务的管理页面和你自己的学习进度页面都是仪表盘。

3D

有宽度、高度和深度、可以绕着看的图形

3D 图形用三个维度——宽度、高度和深度——来描述物体，程序每一帧都从摄像机的视角把它们画出来，通常要用到 GPU。2D 游戏画的则是平面的图片。3D 要花的工夫多得多：模型、光照、摄像机，还有更重的引擎。

深入学习

屏幕共享

原文名称 · Screen sharing

把你的电脑屏幕实时给别人看

屏幕共享会把你屏幕的实时画面——整个屏幕、一个窗口或一个浏览器标签页——发送给视频通话里的其他人。在考试面试中，你要共享整个屏幕，让考官能看到你做的每一件事、打开的每一个程序。

深入学习

密钥

原文名称 · Secret key

绝不能给别人看的钥匙

密钥是证明你是谁、或者把数据锁起来的值：API 密钥、类似密码的令牌、密钥对里的私钥，或者两台电脑为加密连接而商定的钥匙。看到它的人就能冒充你，所以它要放在 .env 文件或专门存放机密的地方——绝不能出现在代码、聊天或截图里。

深入学习

信息安全

原文名称 · Security

保护系统和数据不受攻击和泄露

安全是为了保护系统和数据所做的一切：不让陌生人读取、篡改或让它们停止运行。在日常编程中，它的意思是检查输入、不把密钥写进代码、使用 HTTPS、只给每个程序它需要的权限，以及更新软件。AI 能很快地写出代码，但检查它是否安全，仍然是人的工作。

深入学习

WebAssembly

在浏览器里运行快速程序的紧凑二进制格式

WebAssembly（Wasm）是一种二进制格式，浏览器能在 JavaScript 旁边以接近原生的速度运行它。用 C、C++ 或 Rust 写的程序可以编译成它。整个 Python 解释器（Pyodide）或一个小型 AI 模型能在网页里运行，不用安装，也不用服务器干活，靠的就是它。

深入学习

robots.txt

告诉搜索机器人可以访问网站哪些部分的文件

robots.txt 是放在网站最顶层（/robots.txt）的纯文本文件，告诉网络爬虫哪些路径可以访问、哪些不可以。守规矩的搜索机器人会先读它并照着做。它是一个请求，而不是一把锁——它什么也藏不住，谁都能读它。

深入学习

搜索机器人

原文名称 · Search robot

一个接一个地访问网页、收集它们的程序

搜索机器人（网络爬虫）是一个程序，它抓取一个页面，顺着里面的链接去到更多页面，并把读到的东西存下来——搜索引擎就是这样建立索引的。好的爬虫会先读 robots.txt，访问得也不会太快。AI 公司也运行爬虫来收集训练用的文本。

深入学习

CAPTCHA

用来分辨人和机器人的测试

CAPTCHA 是网站为了确认有人在操作而出的小题目：挑出有红绿灯的图片、输入歪歪扭扭的字母，或者只是勾一个框，同时网站观察你的操作方式。网站用它来对付垃圾信息和自动注册。操作浏览器的 AI 工具遇到它时，应该停下来交给人处理。

深入学习

深色模式

原文名称 · Dark mode

深色背景配浅色文字的配色方案

深色模式用深色背景显示浅色文字，而不是浅色背景上的深色文字。很多人晚上更喜欢它，在 OLED 屏幕的手机上它还能省电。网站可以通过 CSS 跟随设备的设置，所以它用到的每种颜色都需要一个仍然易读的深色版本。

深入学习