1. 项目概述：为什么打字机效果值得一做？

在Unity里做UI，尤其是做剧情对话、任务提示或者开场白的时候，你肯定不想让一大段文字“唰”地一下全蹦出来。那种感觉太生硬，玩家还没看清第一句，后面的话就挤上来了，阅读体验很差。这时候，一个逐字显示的打字机效果就成了刚需。它模拟了老式打字机或者逐字打印的节奏，让文本以一种可控的、带有叙事感的方式呈现出来。

听起来好像很简单，不就是让Text组件里的字一个个往外蹦吗？但真动手做，你会发现里面门道不少。比如，播放速度怎么控制？需不需要支持富文本（比如颜色、加粗）？播放过程中能不能暂停、跳过？播放完了要不要回调事件？这些细节处理得好不好，直接决定了这个功能是“玩具”还是能真正用在项目里的“工具”。我见过不少新手写的打字机，要么卡顿，要么富文本显示错乱，要么逻辑耦合太紧没法复用。今天，我就结合自己踩过的坑，带你从零实现一个简单、健壮、可扩展的Unity打字机效果，不仅把核心功能跑通，还要把那些容易出问题的地方都讲明白。

2. 核心思路拆解：两种主流方案与选型

实现打字机效果，核心思路就一个：每隔一段时间，向一个公开的字符串变量追加一个字符，并把这个字符串赋值给UI Text组件进行显示。听起来简单，但具体实现路径主要有两条，它们各有优劣。

2.1 方案一：基于字符串索引的Substring截取

这是最直观、最容易理解的方法。我们准备两个字符串：fullText（完整的文本内容）和currentText（当前已显示的文字）。在一个计时循环中（比如Coroutine协程），我们每次将fullText的索引向前推进一位，然后用Substring方法截取从开头到当前索引的子串，赋值给currentText并更新UI。

优点：

• 逻辑清晰：代码直白，一看就懂，非常适合理解和学习原理。
• 对简单文本友好：处理纯文本速度很快。

缺点与坑点：

• 富文本（Rich Text）的噩梦：这是此方案最大的软肋。Unity的富文本标签，比如，它本身是多个字符（`<color=#ff0000>`），但最终只渲染为一个有颜色的字符。如果你用`Substring`机械地按字符数截取，很可能把标签从中间切断，变成，这会导致标签解析失败，整段文本的样式都可能错乱。
• 性能隐患：频繁使用Substring会创建大量新的字符串对象，虽然对于短文本影响微乎其微，但在极高频更新或文本极长时，可能带来不必要的GC（垃圾回收）压力。

2.2 方案二：基于StringBuilder的字符追加

StringBuilder是C#中专门用于高效构建和修改字符串的类。在这个方案里，我们不再截取，而是准备一个StringBuilder实例作为“字符缓冲区”。在计时循环中，我们从fullText中按索引取出下一个字符，Append到StringBuilder里，然后将其ToString()结果赋值给UI。

优点：

• 性能更优：StringBuilder在频繁修改字符串时性能远优于直接进行字符串拼接或截取，因为它内部维护了一个字符数组，避免了大量临时字符串的创建。
• 为处理富文本留出空间：虽然直接使用依然无法解决富文本标签被切断的问题，但由于我们是以“追加”为核心操作，可以在此基础上引入更复杂的逻辑来判断当前字符是否属于一个标签，从而决定是跳过快进还是整体追加。

选型结论：对于学习和快速实现一个基础、稳定的打字机效果，我推荐从方案二（StringBuilder）入手。它不仅性能更好，代码结构也更适合后续扩展。我们今天的实现也将以此为基础。至于富文本这个“大BOSS”，我们会在核心流程稳定后，专门拿出一节来攻克它。

3. 基础实现：构建一个可用的打字机协程

让我们先抛开富文本，实现一个最核心的、能处理纯文本的打字机。我们会创建一个名为TypewriterEffect的MonoBehaviour脚本。

3.1 脚本结构与公共参数

首先，定义控制打字机行为的关键参数，并将它们暴露在Inspector面板上，方便调试和配置。

using UnityEngine; using UnityEngine.UI; // 如果是UGUI Text using TMPro; // 如果是TextMeshPro using System.Text; using System.Collections; public class TypewriterEffect : MonoBehaviour { [Header("目标文本组件")] [SerializeField] private Text targetText; // 传统UGUI Text // [SerializeField] private TMP_Text targetTMPText; // 如果使用TextMeshPro [Header("播放设置")] [SerializeField] private float charactersPerSecond = 30f; // 每秒显示字符数 [SerializeField] private bool playOnAwake = true; // 是否唤醒时自动播放 [Header("高级设置")] [SerializeField] private bool ignoreTimeScale = false; // 是否忽略Time.timeScale [SerializeField] private string startSoundName; // 开始播放音效名（需搭配音频系统） [SerializeField] private string typeSoundName; // 打字音效名 [SerializeField] private float typeSoundInterval = 0.1f; // 打字音效间隔 // 内部状态变量 private string fullText; private StringBuilder currentTextBuilder; private Coroutine typeCoroutine; private bool isPlaying = false; private float timerForSound = 0f; // 公开事件，用于外部监听 public System.Action OnTypingStarted; public System.Action OnTypingCompleted; public System.Action<char> OnCharacterTyped; // 每打一个字触发 private void Awake() { // 获取目标文本组件，如果没手动赋值，尝试从自身或子物体获取 if (targetText == null) targetText = GetComponent<Text>(); // 对于TextMeshPro，取消下行注释 // if (targetTMPText == null) targetTMPText = GetComponent<TMP_Text>(); // 初始化时保存完整文本，并清空显示 if (targetText != null) { fullText = targetText.text; targetText.text = ""; } currentTextBuilder = new StringBuilder(); } private void Start() { if (playOnAwake) { StartTyping(); } } }

参数解析与注意事项：

• charactersPerSecond (CPS)：这是控制速度的核心。值越大打字越快。通常对话20-40 CPS比较舒适，代码注释或快速提示可以调到60以上。注意：不要直接使用“每字符间隔时间”并在协程里WaitForSeconds，因为如果间隔是0.01秒（100 CPS），协程调度本身的开销可能造成不稳定。更推荐用“累计时间”来判断，如下文所示。
• ignoreTimeScale：这是一个非常实用的选项。如果你的游戏有暂停功能（Time.timeScale = 0），勾选此项后打字机效果会继续播放，适合用在暂停菜单的提示文字上。
• 音效集成：这里预留了音效接口。在实际项目中，你需要根据项目使用的音频管理系统（如AudioSource、FMOD、Wwise）来替换播放逻辑。typeSoundInterval可以防止每个字符都播放音效导致的嘈杂感。

3.2 核心协程的实现

接下来是心脏部分——打字协程。我们将使用基于增量时间的循环，而不是嵌套WaitForSeconds，这样控制更精确，也更容易实现暂停、加速等功能。

public void StartTyping(string newText = null) { // 如果正在播放，先停止之前的协程 if (isPlaying && typeCoroutine != null) { StopCoroutine(typeCoroutine); } // 重置状态 isPlaying = true; currentTextBuilder.Clear(); // 更新文本内容 if (!string.IsNullOrEmpty(newText)) { fullText = newText; } if (targetText != null) { targetText.text = ""; } // 触发开始事件 OnTypingStarted?.Invoke(); // 播放开始音效 if (!string.IsNullOrEmpty(startSoundName)) { // AudioManager.Instance.PlaySFX(startSoundName); } // 启动打字协程 typeCoroutine = StartCoroutine(TypeTextCoroutine()); } private IEnumerator TypeTextCoroutine() { int currentIndex = 0; float timePerChar = 1f / charactersPerSecond; float accumulatedTime = 0f; timerForSound = 0f; while (currentIndex < fullText.Length) { // 计算增量时间 float deltaTime = ignoreTimeScale ? Time.unscaledDeltaTime : Time.deltaTime; accumulatedTime += deltaTime; timerForSound += deltaTime; // 判断是否到了该显示下一个字符的时间 while (accumulatedTime >= timePerChar && currentIndex < fullText.Length) { // 追加下一个字符 char nextChar = fullText[currentIndex]; currentTextBuilder.Append(nextChar); // 更新UI显示 if (targetText != null) { targetText.text = currentTextBuilder.ToString(); } // 对于TextMeshPro: targetTMPText.text = currentTextBuilder.ToString(); // 触发单字事件（可用于屏幕震动、局部特效等） OnCharacterTyped?.Invoke(nextChar); // 播放打字音效（控制频率） if (timerForSound >= typeSoundInterval && !string.IsNullOrEmpty(typeSoundName)) { // AudioManager.Instance.PlaySFX(typeSoundName); timerForSound = 0f; } currentIndex++; accumulatedTime -= timePerChar; // 减去一个字符的时间 } // 重要：每帧只yield一次，避免死循环 yield return null; } // 循环结束，打字完成 CompleteTyping(); } private void CompleteTyping() { isPlaying = false; typeCoroutine = null; // 确保文本完全显示，避免因计时误差少字 if (targetText != null) { targetText.text = fullText; } // 触发完成事件 OnTypingCompleted?.Invoke(); } // 提供一个外部跳过的接口 public void Skip() { if (isPlaying && typeCoroutine != null) { StopCoroutine(typeCoroutine); CompleteTyping(); } }

核心要点与避坑指南：

1. yield return null的位置：这是协程的关键。我们必须把yield return null放在while循环的末尾，确保每帧只执行一次循环体。如果错误地放在内层while里，在高速（CPS值很大）情况下，可能会在一帧内耗尽所有字符，失去了“逐字”的效果，甚至可能因为循环过深导致卡顿。
2. 时间累计方式：使用accumulatedTime累加增量时间，再与timePerChar比较。这种方式比在循环里yield return new WaitForSeconds(timePerChar)更稳健，因为它不受协程恢复调度延迟的影响，并且能更自然地与游戏时间系统（包括Time.timeScale）结合。
3. 完成时的保障：在CompleteTyping中，直接将targetText.text设置为fullText。这是一个安全措施，防止因为浮点数精度问题导致最后一个字符未能显示。
4. 跳过功能：Skip方法直接停止协程并调用完成逻辑，这是玩家体验的重要一环。通常可以绑定到鼠标点击或某个按键上。

4. 攻克难关：完美支持Unity富文本

现在，我们来解决最棘手的问题——富文本。Unity UGUI Text和TextMeshPro都支持类似HTML的标签来定义样式，例如、、``等。我们的目标是：在打字过程中，这些标签本身不应该被逐个字符“打”出来，而应该在被其包裹的内容字符开始显示前就生效。

4.1 问题分析与解决策略

假设全文是：“这是<color=red>红色</color>文字。”

• 错误过程：会显示<、c、o、l... 直到把整个标签显示完，才显示“红”，这显然不对。
• 正确过程：在显示“红”这个字之前，<color=red>标签就应该已经应用到文本组件上。也就是说，在打字机逻辑里，我们需要识别并“跳过”标签，但要将标签的样式信息“应用”上去。

策略：预处理与状态机我们无法在显示过程中动态改变已显示文本中某个范围的样式。因此，主流解决方案是：在打字开始前，对全文进行预处理，将文本拆解成一个包含“普通字符”和“标签”的序列。播放时，遇到标签立即将其追加到构建字符串中（因为它对UI是透明的，但又是文本的一部分），遇到普通字符则按计时器追加。

4.2 实现富文本感知的打字机

我们需要修改协程前的准备工作和协程内的逻辑。这里引入一个“文本元素”的概念。

using System.Collections.Generic; public class TypewriterEffect : MonoBehaviour { // ... 保留之前的变量 ... private List<TextElement> textElements = new List<TextElement>(); private int elementIndex = 0; private class TextElement { public string content; // 可能是单个字符，也可能是一个完整的标签如“<color=red>” public bool isTag; // 标记是否是标签 } private void ParseFullText() { textElements.Clear(); elementIndex = 0; bool insideTag = false; string tagBuffer = ""; for (int i = 0; i < fullText.Length; i++) { char c = fullText[i]; if (c == '<') { // 遇到'<'，开始进入标签 insideTag = true; tagBuffer = "<"; } else if (c == '>' && insideTag) { // 遇到'>'且之前在标签内，标签结束 tagBuffer += '>'; textElements.Add(new TextElement { content = tagBuffer, isTag = true }); insideTag = false; tagBuffer = ""; } else if (insideTag) { // 在标签内部，积累字符 tagBuffer += c; } else { // 普通字符 textElements.Add(new TextElement { content = c.ToString(), isTag = false }); } } // 注意：这里没有处理标签不闭合的异常情况，实际项目可加强健壮性 } private IEnumerator TypeTextCoroutine() { // 在开始打字前解析文本 ParseFullText(); float timePerChar = 1f / charactersPerSecond; float accumulatedTime = 0f; timerForSound = 0f; currentTextBuilder.Clear(); while (elementIndex < textElements.Count) { float deltaTime = ignoreTimeScale ? Time.unscaledDeltaTime : Time.deltaTime; accumulatedTime += deltaTime; timerForSound += deltaTime; bool typedThisFrame = false; // 关键：使用while循环处理本帧内可能触发的多个元素（尤其是连续的标签） while (accumulatedTime >= timePerChar && elementIndex < textElements.Count) { var element = textElements[elementIndex]; currentTextBuilder.Append(element.content); // 只有非标签字符才触发“打字”事件和音效 if (!element.isTag) { OnCharacterTyped?.Invoke(element.content[0]); if (timerForSound >= typeSoundInterval && !string.IsNullOrEmpty(typeSoundName)) { // AudioManager.Instance.PlaySFX(typeSoundName); timerForSound = 0f; } typedThisFrame = true; } // 更新UI显示 if (targetText != null) { targetText.text = currentTextBuilder.ToString(); } elementIndex++; accumulatedTime -= timePerChar; } // 如果这一帧打出了至少一个“可见字符”，才等待下一帧 // 如果只是处理了标签，可以继续循环，避免因等待一帧而卡顿 if (typedThisFrame) { yield return null; } else if (elementIndex < textElements.Count) { // 如果下一个元素还是标签，立即处理，不要yield // 这里简单处理，直接继续while循环。更精细的控制可以检查下一个元素是否为标签。 continue; } else { yield return null; } } CompleteTyping(); } }

实现解析与注意事项：

1. 解析器（ParseFullText）：这是一个简单的状态机，遍历每个字符，用insideTag标志记录是否在标签内。它将“Hello<color=red>World</color>!”解析为：[H, e, l, l, o, <color=red>, W, o, r, l, d, </color>, !]。
2. 协程逻辑调整：循环不再基于字符索引，而是基于textElements列表的索引。当遇到isTag=true的元素时，我们直接将其content（整个标签字符串）追加到StringBuilder，但不触发打字音效和OnCharacterTyped事件，因为标签不是“打”出来的字。
3. 性能优化点：注意内层while循环后的yield逻辑。如果一帧内连续处理了好几个标签（比如嵌套样式），我们不应该每处理一个标签就yield return null一次，那样会无谓地浪费帧时间。我们通过typedThisFrame标志来判断这一帧是否有“实质”的字符输出，如果没有，就继续处理下一个元素，直到遇到一个普通字符或者所有元素处理完为止。这确保了标签的添加几乎是瞬间完成的。

注意：这个解析器是基础版本，对于复杂的嵌套标签或像``这样可能包含>字符的标签支持不好。生产环境建议使用正则表达式进行更健壮的解析，或者直接处理TextMeshPro，因为它提供了TMP_Text.GetParsedText()等API来获取更结构化的文本信息。

5. 功能增强与实战技巧

基础功能和富文本支持都有了，现在我们来给它添砖加瓦，让它更实用、更强大。

5.1 速度动态控制与暂停

让打字速度可以动态变化，比如在紧张剧情时加快，或者实现“长按加速”功能。

[Header("动态速度")] [SerializeField] private float speedMultiplier = 1f; // 速度乘数，默认为1 private float GetCurrentTimePerChar() { return 1f / (charactersPerSecond * speedMultiplier); } // 在协程中，将原来的 timePerChar 替换为 GetCurrentTimePerChar() // while (accumulatedTime >= GetCurrentTimePerChar() && ...) public void SetSpeedMultiplier(float multiplier) { speedMultiplier = Mathf.Max(0.1f, multiplier); // 防止除零或负值 } // 暂停与恢复 public void Pause() { if (isPlaying && typeCoroutine != null) { StopCoroutine(typeCoroutine); typeCoroutine = null; // isPlaying 仍然为 true，表示处于暂停状态 } } public void Resume() { if (isPlaying && typeCoroutine == null) { typeCoroutine = StartCoroutine(TypeTextCoroutine()); } }

技巧：speedMultiplier大于1会加速，小于1会减速。你可以将其绑定到一个滑块上，或者在玩家按住某个键时临时设置为3.0来实现“快进”效果。

5.2 与Unity事件系统（EventTrigger）集成

我们通常希望点击对话框时，如果打字未完成则快速完成，如果已完成则触发下一句。这需要与UI事件结合。

using UnityEngine.EventSystems; // 需要引入命名空间 public class TypewriterEffect : MonoBehaviour, IPointerClickHandler { // ... 其他代码 ... public void OnPointerClick(PointerEventData eventData) { if (isPlaying) { Skip(); // 如果正在播放，点击则跳过 } else { // 如果播放完毕，点击可以触发下一个对话或关闭窗口 // 例如：DialogueManager.Instance?.ShowNextSentence(); } } }

将这个脚本挂在你的对话框Text对象上，并确保该对象有Image或CanvasRenderer组件以接收点击事件。你也可以添加EventTrigger组件来响应更多事件。

5.3 适配TextMeshPro

现在很多项目使用TextMeshPro（TMP）以获得更佳的字体渲染效果。适配TMP非常简单。

1. 引用切换：将脚本中Text类型的targetText改为TMP_Text类型，并引用TMPro命名空间。
2. 文本赋值：将targetText.text = ...的赋值操作改为对TMP_Text的赋值。
3. 潜在优势：TMP有更丰富的文本信息接口。例如，你可以利用TMP_Text.textInfo来获取每个字符的网格、顶点位置，从而实现更酷炫的逐字特效，比如每个字弹出、旋转、变色等。这超出了基础打字机的范围，但为你打开了新世界的大门。

// 示例：简单的TMP适配 [SerializeField] private TMP_Text targetTMPText; // 在Awake中获取组件，在更新文本时使用 targetTMPText.text = currentTextBuilder.ToString();

5.4 一个常见的坑：与动画系统（Animator）的冲突

有时你会发现，挂在有Animator的物体上的打字机效果不播放，或者播放异常。这可能是因为Animator在每帧覆盖了Text组件的text属性。

解决方案：

1. 检查动画轨道：在Animator Controller中，检查是否有关联此GameObject的动画剪辑，并且该剪辑是否包含了对你这个Text组件text属性的关键帧动画。如果有，需要删除这些关键帧。
2. 使用代码控制：确保打字机脚本在控制文本时，Animator没有同时通过动画来干预。可以通过在打字期间禁用特定的动画层或参数来避免冲突。
3. 执行顺序：在Unity的Project Settings -> Script Execution Order中，可以尝试将你的TypewriterEffect脚本的执行顺序设为在动画系统之后，但这通常是最后的手段。

6. 完整脚本示例与使用总结

将以上所有功能整合，下面是一个相对完整的基础版TypewriterEffect脚本（未包含TMP和高级富文本解析）：

using UnityEngine; using UnityEngine.UI; using UnityEngine.EventSystems; using System.Text; using System.Collections; using System.Collections.Generic; public class TypewriterEffect : MonoBehaviour, IPointerClickHandler { [Header("基础设置")] [SerializeField] private Text targetText; [SerializeField] private float charactersPerSecond = 30f; [SerializeField] private bool playOnAwake = true; [SerializeField] private bool ignoreTimeScale = false; [SerializeField] private bool supportRichText = true; // 新增开关 [Header("音效")] [SerializeField] private string typeSoundName; [SerializeField] private float typeSoundInterval = 0.1f; [Header("动态控制")] [SerializeField, Range(0.1f, 10f)] private float speedMultiplier = 1f; private string fullText; private StringBuilder currentTextBuilder; private Coroutine typeCoroutine; private bool isPlaying = false; private float soundTimer = 0f; private List<TextElement> textElements; private int elementIndex; public System.Action OnTypingStarted; public System.Action OnTypingCompleted; public System.Action<char> OnCharacterTyped; private class TextElement { public string content; public bool isTag; } void Awake() { if (targetText == null) targetText = GetComponent<Text>(); if (targetText != null) { fullText = targetText.text; targetText.text = ""; } currentTextBuilder = new StringBuilder(); } void Start() { if (playOnAwake) StartTyping(); } public void StartTyping(string newText = null) { StopAndReset(); if (!string.IsNullOrEmpty(newText)) fullText = newText; if (supportRichText) { ParseFullText(); } OnTypingStarted?.Invoke(); typeCoroutine = StartCoroutine(TypeTextCoroutine()); } private void ParseFullText() { textElements = new List<TextElement>(); elementIndex = 0; bool inTag = false; string tagBuffer = ""; for (int i = 0; i < fullText.Length; i++) { char c = fullText[i]; if (c == '<') { inTag = true; tagBuffer = "<"; } else if (c == '>' && inTag) { tagBuffer += '>'; textElements.Add(new TextElement { content = tagBuffer, isTag = true }); inTag = false; tagBuffer = ""; } else if (inTag) tagBuffer += c; else textElements.Add(new TextElement { content = c.ToString(), isTag = false }); } } private IEnumerator TypeTextCoroutine() { isPlaying = true; float accTime = 0f; soundTimer = 0f; currentTextBuilder.Clear(); int idx = 0; int len = supportRichText ? textElements.Count : fullText.Length; while (idx < len) { float delta = ignoreTimeScale ? Time.unscaledDeltaTime : Time.deltaTime; accTime += delta; soundTimer += delta; float currentDelay = 1f / (charactersPerSecond * speedMultiplier); bool typedChar = false; while (accTime >= currentDelay && idx < len) { string toAppend; bool isTagElement = false; if (supportRichText) { var elem = textElements[idx]; toAppend = elem.content; isTagElement = elem.isTag; } else { toAppend = fullText[idx].ToString(); isTagElement = false; } currentTextBuilder.Append(toAppend); targetText.text = currentTextBuilder.ToString(); if (!isTagElement) { OnCharacterTyped?.Invoke(toAppend[0]); if (soundTimer >= typeSoundInterval && !string.IsNullOrEmpty(typeSoundName)) { // Play sound soundTimer = 0f; } typedChar = true; } idx++; accTime -= currentDelay; } if (typedChar || idx >= len) yield return null; } CompleteTyping(); } private void CompleteTyping() { isPlaying = false; if (targetText != null) targetText.text = fullText; OnTypingCompleted?.Invoke(); } public void Skip() { if (isPlaying && typeCoroutine != null) { StopCoroutine(typeCoroutine); CompleteTyping(); } } public void Pause() { if (isPlaying) StopCoroutine(typeCoroutine); } public void Resume() { if (isPlaying && typeCoroutine == null) typeCoroutine = StartCoroutine(TypeTextCoroutine()); } public void SetSpeed(float multiplier) { speedMultiplier = Mathf.Max(0.1f, multiplier); } public void OnPointerClick(PointerEventData eventData) { if (isPlaying) Skip(); // else: 触发下一步对话 } private void StopAndReset() { if (typeCoroutine != null) StopCoroutine(typeCoroutine); isPlaying = false; typeCoroutine = null; if (targetText != null) targetText.text = ""; currentTextBuilder.Clear(); } }

使用总结与最终建议：

1. 组件化：将这个脚本挂载到任何一个有Text或TMP_Text组件的GameObject上，配置参数即可使用。
2. 事件驱动：善用OnTypingCompleted事件。这是解耦的关键，比如打字结束后自动激活一个“继续”按钮，或者播放角色立绘动画，都通过监听这个事件来实现，而不是在打字机脚本里写死。
3. 性能：对于绝大多数剧情对话，这个性能完全足够。如果遇到极端情况（比如每秒更新上百次的长文本），可以考虑使用StringBuilder的容量预分配（new StringBuilder(fullText.Length)），并审视是否真的需要如此高的刷新率。
4. 扩展性：这个框架很容易扩展。你可以修改OnCharacterTyped事件，让它传递更多信息（比如字符索引），然后配合TMP的textInfo，实现每个字符的抖动、渐入、高亮等高级视觉效果。
5. 测试：务必用包含多种富文本标签（颜色、大小、加粗、斜体、下划线）的长文本进行测试，确保解析和显示正确。

实现一个打字机效果，从简单的Substring到支持富文本的解析器，再到集成事件、音效和动态控制，是一个典型的“从功能实现到工程化组件”的过程。它涉及了Unity的协程、字符串处理、UI更新、事件系统等多个核心知识点。希望这篇详细的拆解能帮你不仅做出效果，更能理解背后的设计思路和避坑方法，从而写出更优雅、更健壮的Unity代码。