字体与中文排版

先看 Typst 能看见哪些字体#

写 set text(font: ...) 之前，先问 Typst 它手里有什么。typst fonts 列出所有家族名，每行一个。我先在仓库的 nix develop 里跑加了 --ignore-system-fonts 的版本，这也是 scripts/chapter.sh 编译每个 lab 文件时用的参数：

1
$ typst fonts --ignore-system-fonts
2
DejaVu Sans Mono
3
Libertinus Serif
4
Maple Mono NF
5
New Computer Modern
6
New Computer Modern Math
7
Noto Sans CJK HK
8
Noto Sans CJK JP
9
Noto Sans CJK KR
10
Noto Sans CJK SC
11
Noto Sans CJK TC
12
Noto Sans Mono CJK HK
13
Noto Sans Mono CJK JP
14
Noto Sans Mono CJK KR
15
Noto Sans Mono CJK SC
16
Noto Sans Mono CJK TC
17
Noto Serif CJK HK
18
Noto Serif CJK JP
19
Noto Serif CJK KR
20
Noto Serif CJK SC
21
Noto Serif CJK TC
22
$ typst fonts --ignore-system-fonts | wc -l
23
20

20 个家族，来源有两处：

• DejaVu Sans Mono、Libertinus Serif、New Computer Modern、New Computer Modern Math 这 4 个嵌在 Typst 可执行文件里，不用装任何东西就能用。
• 其余 16 个来自 TYPST_FONT_PATHS：flake.nix 的 shellHook 把 Noto Serif CJK、Noto Sans CJK 和 Maple Mono NF CN 三个目录用 : 拼起来导出，其中 15 个是 Noto 家族，1 个是 Maple Mono NF。Maple Mono 只给第 1 篇的基准测试用，xuan 自己只点名大约 6 个家族：Libertinus Serif、Noto Serif CJK SC、Noto Sans CJK SC、DejaVu Sans Mono、Noto Sans Mono CJK SC、New Computer Modern Math。

不加限制会怎样？我在同一个 shell 里直接跑 typst fonts | wc -l，得到 284，因为这台机器的系统字体里已经有 229 个 Noto 家族（env -u TYPST_FONT_PATHS typst fonts | grep -c Noto 的输出）。同一份源文件在另一台机器上会看见另一批字体，编译结果可能不一样。仓库里每个编译命令都带 --ignore-system-fonts，原因就在这里：让字体集合只由嵌入字体加 flake 提供的字体决定，你和我编出来的 PDF 用的是同一批字体。

CLI 上和字体有关的开关就这几个，我把每一个都跑了一遍：

--font-path 和环境变量 TYPST_FONT_PATHS 等价，后者用 : 分隔多个目录。官方文档写的优先级是 --font-path 高于系统字体，系统字体高于嵌入字体。

--ignore-embedded-fonts 值得单独做个实验，因为它会让一个常见的“找不到字体”变得很安静。我写了个只有一行的文件，要求 Libertinus Serif，再把嵌入字体关掉：

1
$ typst compile --ignore-system-fonts --ignore-embedded-fonts emb.typ emb.pdf
2
warning: unknown font family: libertinus serif
3
  ┌─ emb.typ:1:16
4
  │
5
1 │ #set text(font: "Libertinus Serif")
6
  │                 ^^^^^^^^^^^^^^^^^^
7

8
$ echo $?
9
0

警告，不是错误，退出码 0。文件只有两行：#set text(font: "Libertinus Serif") 加一行 Typst 排版。看 pdffonts 画了什么：

1
$ pdffonts emb.pdf
2
name                                 type              encoding         emb sub uni object ID
3
------------------------------------ ----------------- ---------------- --- --- --- ---------
4
GZMBIX+NotoSerifCJKjp-ExtraLight     CID TrueType      Identity-H       yes yes yes      8  0

Typst 悄悄换了一个字体，连 Typst 这几个拉丁字母都由 NotoSerifCJKjp 画。这是下一节要讲的“最后兜底”：指定的字体不存在，就去所有可用字体里找一个最像的。注意它挑的是日文版本的 Noto Serif，而不是你想要的简体版。

字体列表：每个字符各找各的#

text 的 font 参数接受三种东西：一个字符串，一个字符串数组（优先级列表），或者数组里夹着带 covers 的字典。lab/ch05/fonts.typ 的前半（源文件，文件分两段引用，中间没有改动）：

1
#set page(width: 14cm, height: auto, margin: 1cm)
2

3
// A font list is a fallback chain: Typst picks the first family covering
4
// each character. Latin falls to Libertinus, Chinese to Noto Serif CJK SC.
5
#set text(font: ("Libertinus Serif", "Noto Serif CJK SC"), size: 12pt)
6

7
Fallback：Typst 排版 abc 123。
8

9
// `covers` restricts a family to a set of characters.
10
#let latin-only = (
11
  name: "Noto Serif CJK SC",
12
  covers: regex("[\u{4e00}-\u{9fff}]"),
13
)
14
#text(font: (
15
  latin-only,
16
  "Libertinus Serif",
17
))[Han 走 Noto，English 走 Libertinus。]

列表的语义不是“选第一个存在的字体”，而是“对每个字符，选第一个包含这个字符的字形的字体”。 这像 shell 查 $PATH：每个命令独立地从左往右找第一个可执行文件，一个目录里没有，就看下一个目录（这个类比我只用这一次）。所以 ("Libertinus Serif", "Noto Serif CJK SC") 的意思是：Latin 字母和数字由 Libertinus 画，Libertinus 里没有的汉字由 Noto Serif CJK SC 画。

顺序为什么重要？Noto Serif CJK 自带一套 Latin 字母，所以把两个字体颠倒过来，Latin 也会被 Noto 抢走。更隐蔽的是标点：Libertinus 有 U+201C 和 U+201D（弯引号），Noto 也有。我写了一个实验 order.typ，同一句话用三种字体列表各排一遍：

1
#set page(width: auto, height: auto, margin: 12pt)
2
#set text(size: 14pt, lang: "zh", region: "cn")
3
#let sample = [Typst 2026 (括号) “引号”，句号。]
4
#let a = ("Libertinus Serif", "Noto Serif CJK SC")
5
#let b = ("Noto Serif CJK SC", "Libertinus Serif")
6
#let c = (
7
  (name: "Libertinus Serif", covers: "latin-in-cjk"),
8
  "Noto Serif CJK SC",
9
)
10
#grid(
11
  columns: 2,
12
  gutter: 0.8em,
13
  align: left + horizon,
14
  [`A`], text(font: a, sample),
15
  [`B`], text(font: b, sample),
16
  [`C`], text(font: c, sample),
17
)

这三行的区别，用 pdffonts 看得更直接：A 用了 LibertinusSerif-Regular 和 NotoSerifCJKsc 两个字体，B 只用了 NotoSerifCJKsc 一个，C 又是两个。我还量了 “引号” 四个字符在 A 和 C 下的宽度（quote-width.typ，a 和 c 与上面 order.typ 里的定义相同）：

1
#set text(size: 14pt, lang: "zh", region: "cn")
2
#let a = ("Libertinus Serif", "Noto Serif CJK SC")
3
#let c = (
4
  (name: "Libertinus Serif", covers: "latin-in-cjk"),
5
  "Noto Serif CJK SC",
6
)
7
#context {
8
  let w(font) = measure(text(font: font)[“引号”]).width.pt()
9
  [A：#w(a) pt，C：#w(c) pt]
10
}

1
A：38.5 pt，C：42 pt

两枚引号加起来，A 占 10.5 pt，C 占 14 pt，宽度差了 3.5 pt，眼睛也看得出来。看图：

• A（朴素写法）：字母和数字是 Libertinus，窄而紧凑，但 “引号” 的弯引号也来自 Libertinus，是西文那种窄引号，比汉字小一圈。
• B：一切都由 Noto 画，字母明显变宽，弯引号是全角占位的，符合中文习惯。
• C：给 Libertinus 加了 covers: "latin-in-cjk"。官方文档对这个预设的描述是：覆盖所有码点，除了那些“在 Latin 字体里也有，但最好取自 CJK 字体”的（原文 covers all codepoints except for those which exist in Latin fonts, but should preferably be taken from CJK fonts）。结果是字母和数字仍然来自 Libertinus，引号和括号交给了 Noto。

A 是最朴素的写法，也是最容易踩的坑，C 是 xuan 用的。 A 行的引号和 B 行的肉眼可见地不一样，我跑了 pdffonts 和上面的宽度测量来确认原因：Libertinus 里有 U+201C 和 U+201D，A 的列表里它排在 Noto 前面，所以引号归它。C 给 Libertinus 加 covers: "latin-in-cjk"，把这类字符让给 Noto，引号就是全角的。后面显示的 fonts.typ 用的就是 C。

covers：给一个家族划定职责#

covers 也可以是一个正则，官方文档说只能是“一个点、一个字母或一个字符类”。上面 fonts.typ 里的 latin-only 就是一个字符类：Noto Serif CJK SC 只负责 U+4E00 到 U+9FFF 的汉字，其他码点直接跳过。渲染出来：

注意，名字叫 latin-only 不准确，它其实是“汉字只用 Noto”。更值得看的是这行里的逗号和句号 ，。。这两个字符不在 Libertinus 里，Noto Serif CJK SC 又被 covers 限定在汉字区间，两个字体都跳过了它们。这时 Typst 的行为是“最后兜底”：从所有可用字体里找一个有这个字形的。我对这行单独跑了 pdffonts：

1
$ pdffonts cov.pdf
2
name                                 type              encoding         emb sub uni object ID
3
------------------------------------ ----------------- ---------------- --- --- --- ---------
4
KFQELT+LibertinusSerif-Regular-Identity-H CID Type 0C       Identity-H       yes yes yes      8  0
5
TPBOKN+NotoSerifCJKsc-ExtraLight     CID TrueType      Identity-H       yes yes yes     11  0
6
OXUTFP+NotoSansCJKjp-Thin            CID TrueType      Identity-H       yes yes yes     14  0

第三行就是它：Noto Sans CJK JP，一个无衬线的日文字体，被拿去画两个全角标点。lab/ch05/fonts.typ 里的整页渲染里也有同样的字体，因为这个文件的 latin-only 例子就是这样写的。解法是在列表末尾再追加一次不带 covers 的 "Noto Serif CJK SC" 作为兜底。我在 cov2.typ 里这样写：

1
#set page(width: auto, height: auto, margin: 12pt)
2
#set text(size: 14pt)
3
#let han = (name: "Noto Serif CJK SC", covers: regex("[\u{4e00}-\u{9fff}]"))
4
#text(font: (
5
  han,
6
  "Libertinus Serif",
7
  "Noto Serif CJK SC",
8
))[Han 走 Noto，English 走 Libertinus。]

pdffonts 里 NotoSansCJKjp-Thin 消失了，只剩 Libertinus 和 NotoSerifCJKsc 两行。（实验文件在 /tmp/p5，没有放进仓库，代码就在文中。）

找不到、不兜底、没字体#

lab 里有两个文件专门看“字体找不到”。第一个是 unknown-font.warn.typ（源文件）：

1
// A family that no font provides only produces a warning; text falls back.
2
#set text(font: ("No Such Font", "Libertinus Serif"))
3
Typst falls back to the next family.

make ch05 会检查它退出码为 0 且 stderr 非空，stderr 存在 out/ch05/unknown-font.stderr：

1
warning: unknown font family: no such font
2
  ┌─ lab/ch05/unknown-font.warn.typ:2:16
3
  │
4
2 │ #set text(font: ("No Such Font", "Libertinus Serif"))
5
  │                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

Typst 把家族名转成小写再报告，警告针对的是整个列表（指向整个数组，不是单个名字）。文字照样排出来，用的是列表里的下一个。

第二个是 missing-glyph.typ（源文件），演示 fallback 参数：

1
// With fallback off, a missing character is drawn as a tofu box and Typst
2
// stays silent. Compare with the default.
3
#set text(font: "Libertinus Serif")
4
默认：Latin 与 汉字 \
5
#text(fallback: false)[关闭：Latin 与 汉字]

（这张图是同一份文件，我把页面设成了自动大小以便截图。）fallback: true 是默认值，Typst 会翻遍所有可用字体找一个有这个字符的。关掉它之后，汉字和全角冒号变成豆腐块，而且没有任何警告，out/ch05/missing-glyph.stderr 是空的，这也是为什么 missing-glyph.typ 不是 .warn.typ。官方文档也写了这一点：目前没有“字体缺字”的警告。结论是：排版出豆腐块时，Typst 不会告诉你，只能靠肉眼检查，或者配合 pdffonts 看用了哪些字体。

把这两个“静默”场景合起来，再看一个更极端的：不设 TYPST_FONT_PATHS，也不装任何 CJK 字体，编译同一份 emb.typ：

1
$ env -u TYPST_FONT_PATHS typst compile --ignore-system-fonts emb.typ emb3.pdf
2
$ echo $?
3
0
4
$ pdffonts emb3.pdf
5
name                                 type              encoding         emb sub uni object ID
6
------------------------------------ ----------------- ---------------- --- --- --- ---------
7
MOITFO+LibertinusSerif-Regular-Identity-H CID Type 0C       Identity-H       yes yes yes      8  0

退出码 0，stderr 空，PDF 里只有 Libertinus。没有任何字体能画“排版”两个字，汉字渲染成什么我没有逐像素看，但 Typst 没有提醒你一个字。中文文档一定要让你的构建环境显式提供 CJK 字体，这就是 flake.nix 里 noto-fonts-cjk-serif 的意义。

字重、字形与 0.15 的 variations#

lab/ch05/fonts.typ 的后半：

1
// Weight, style, tracking, spacing.
2
#text(weight: "bold")[粗体 bold] #text(style: "italic")[italic 斜体]
3
#text(tracking: 2pt)[字距 tracking] #text(spacing: 200%)[词距 word spacing]
4

5
// 0.15: variable fonts expose axes through `variations`.
6
#text(weight: 300)[Light 300 轻] \
7
#text(weight: 900)[Black 900 黑] \
8
#text(variations: (wght: 600))[wght=600 手动指定]
9

10
// OpenType features and number styles.
11
#text(features: ("smcp",))[Small caps via feature] \
12
#text(number-type: "old-style")[0123456789] vs
13
#text(number-type: "lining")[0123456789]
14
#smallcaps[smallcaps] #upper[upper] #lower[LOWER]

整个文件编出来是这样：

前面几个参数逐个过：

• weight：整数 100 到 900 或名字（"bold" 是 700，"light" 是 300，"regular" 是 400）。
• style："normal"、"italic"、"oblique"。图里 italic 斜体 一行，italic 是斜的，斜体 两个字仍是直立的：Noto CJK 没有斜体，Typst 找不到斜体字形就退回 normal，不会把汉字强行倾斜（官方文档写的是 When neither an italic nor an oblique style is available, Typst selects the normal style，这张图是它的实例）。
• tracking：字符之间额外加的距离。图里 t r a c k i n g 被撑开了，汉字“字距”也跟着撑开。
• spacing：词间距，只影响空格，所以 word spacing 里两个单词隔得很远，中间没有空格的汉字不受影响。它可以是绝对长度，也可以是相对于该字体空格宽度的百分比。
• size：第 4 篇已经讲了 em 相对继承字号。

1
$ typst fonts --ignore-system-fonts --variants
2
...
3
Noto Serif CJK SC
4
  └ /nix/store/4gqvskjagg0w5zs36y6dg7h0nzinh1ci-noto-fonts-cjk-serif-2.003/share/fonts/opentype/noto-cjk/NotoSerifCJK-VF.otf.ttc (Variable)
5
      Style: Normal
6
      Stretch: 100%
7
      Weight: 200-900 (Default: 200)
8
...

1
Libertinus Serif
2
  ├ (Embedded)
3
  │   Style: Normal, Weight: 400, Stretch: 100%
4
  ├ (Embedded)
5
  │   Style: Normal, Weight: 700, Stretch: 100%
6
  ├ (Embedded)
7
  │   Style: Italic, Weight: 400, Stretch: 100%
8
  ├ (Embedded)
9
  │   Style: Italic, Weight: 700, Stretch: 100%
10
  ├ (Embedded)
11
  │   Style: Normal, Weight: 600, Stretch: 100%
12
  └ (Embedded)
13
      Style: Italic, Weight: 600, Stretch: 100%

1
#set text(font: "Noto Serif CJK SC")
2
#text(weight: 400)[常规]
3
#text(weight: 700)[粗体]
4
#text(weight: 900)[黑体]

1
$ pdffonts var-names.pdf
2
name                                 type              encoding         emb sub uni object ID
3
------------------------------------ ----------------- ---------------- --- --- --- ---------
4
YDGOLY+NotoSerifCJKsc-ExtraLight     CID TrueType      Identity-H       yes yes yes      8  0
5
YEUBDD+NotoSerifCJKsc-ExtraLight     CID TrueType      Identity-H       yes yes yes     11  0
6
BINIWB+NotoSerifCJKsc-ExtraLight     CID TrueType      Identity-H       yes yes yes     14  0

1
#text(weight: 600)[手动指定 wght]
2
// var-b.typ
3
#text(variations: (wght: 600))[手动指定 wght]
4
// var-c.typ
5
#text(weight: 400, variations: (wght: 900))[手动指定 wght]

1
$ md5sum var-?.png
2
f300a241cae78175ce1a0ac8b6d8a88a  var-a.png
3
f300a241cae78175ce1a0ac8b6d8a88a  var-b.png
4
348adae211869a8a34c3bc488febd2b2  var-c.png

OpenType 特性与数字#

字体里除了字形还有大量“特性”（feature），text 给常用的几个单独开了参数，其余走 features。features.typ 这个实验在 /tmp/p5，没有放进仓库：

1
#set page(width: 12cm, height: auto, margin: 8pt)
2
#set text(font: ("Libertinus Serif", "Noto Serif CJK SC"), size: 12pt)
3

4
默认数字：1234567890 \
5
#text(number-type: "old-style")[old-style：1234567890] \
6
#text(number-type: "lining")[lining：1234567890] \
7
#text(slashed-zero: true)[slashed-zero：0O0] \
8
#text(fractions: true)[fractions：1/2 3/4] \
9
#text(features: ("smcp", "c2sc"))[features: Small Caps] \
10
#text(features: (smcp: 1))[dict form: Small Caps] \
11
#smallcaps[smallcaps 函数] #upper[upper 大写] #lower[LOWER 小写]

这几个我都在图里看到了效果：

• number-type："old-style" 数字像小写字母一样高低错落（适合正文），"lining" 一样高（适合表格）。Libertinus 默认就是 lining，所以第一行和第三行看着一样。
• slashed-zero：0 带斜线，和字母 O 区分。
• fractions：把 1/2 排成分数形。
• features：直接给 OpenType 特性标签，数组形式（("smcp", "c2sc")）开启一组，字典形式（(smcp: 1)）可以指定特性取值。smcp 把小写换成小型大写字母，c2sc 把大写也换成小型大写；#text(features: ("smcp",)) 与 #smallcaps[...] 是同一个效果的两种写法，后者作为元素函数可以被 show smallcaps 单独设计。
• upper、lower、smallcaps：这三个是函数，不是字体特性，upper 和 lower 把文字转成大写和小写。
• 汉字不受这些特性影响：图里 函数、大写、小写 都没变。

text 还有 ligatures、kerning、number-width、stylistic-set 等参数。我在 12pt 的 Libertinus 上试了开关，渲染图里我看不出肉眼可辨的差别，所以这里不下结论，需要的话去官方文档的 text 页查。

lang 与 region：不只是语言标签#

lang 官方文档列的用途是连字符断词规则、智能引号和“其他语言相关的事”。region 呢，只有一句“让文本处理管线做出更明智的选择”。对中文，这个“更明智”体现在字形上。我写了个实验，同一串文字用五种语言设置各排一遍，并用 measure 量宽度：

1
#set page(width: auto, height: auto, margin: 12pt)
2
#set text(font: ("Libertinus Serif", "Noto Serif CJK SC"), size: 16pt)
3
#let s = [“你好”，直（括号）。门户：「引」]
4
#let w(lang, region) = context measure(text(
5
  lang: lang,
6
  region: region,
7
  s,
8
)).width
9
#grid(
10
  columns: 3,
11
  gutter: 0.6em,
12
  [`en`], text(lang: "en", s), [#w("en", none)],
13
  [`zh`], text(lang: "zh", s), [#w("zh", none)],
14
  [`zh-cn`], text(lang: "zh", region: "cn", s), [#w("zh", "cn")],
15
  [`zh-tw`], text(lang: "zh", region: "tw", s), [#w("zh", "tw")],
16
  [`ja`], text(lang: "ja", s), [#w("ja", none)],
17
)

数字：en、zh、zh-cn、ja 的宽度都是 228 pt，zh-tw 是 244 pt，宽了 16 pt。图里 zh-tw 一行的 ， 。 ： 位置和其他几行明显不同，“户”字在 tw 和 ja 下也写成了另外的字形。官方文档说 lang 和 script 一起决定“字体特性（如字形替换）怎么实现”，我猜这里的区别来自 Noto 字体里按语言区分的字形替换表，但我没有去核对字体内部的特性表，只是观察结果。

这对 xuan 的意义是：简体中文我写 lang: "zh", region: "cn"。图里 zh 一行不写 region 看起来和 zh-cn 一样，所以光看这一串字，region: "cn" 不是必需的；我写它是为了明确选了简体，不依赖字体的默认字形，也能和 tw 区分开。xuan-cjk 对英文文档把 region 设成 none，只给 lang: "zh" 设 "cn"。

顺便说 smartquote。它把输入的直引号 " ' 换成弯引号，换成哪种由 lang 决定，set smartquote(enabled: false) 关掉，set smartquote(quotes: ...) 自定义。直角引号的实验放在下面的装饰一节里一起跑。

cjk-latin-spacing：汉字和字母之间的四分之一#

中文排版有个老习惯：汉字和拉丁字母、数字之间留一点空隙。Typst 默认就会加，参数是 text.cjk-latin-spacing，取 auto（默认）或 none。lab/ch05/cjk-latin-spacing.typ（源文件）把两种设置的宽度量出来，直接印进 PDF：

1
#set page(width: 14cm, height: auto, margin: 1cm)
2
#set text(font: ("Libertinus Serif", "Noto Serif CJK SC"), lang: "zh")
3

4
// Typst inserts a quarter-em gap between Chinese and Latin/digits by default.
5
#let sample = [中文Typst排版2026年]
6

7
#context {
8
  let width(spacing) = {
9
    measure(
10
      text(cjk-latin-spacing: spacing, size: 12pt, sample),
11
    ).width
12
  }
13
  let on = width(auto)
14
  let off = width(none)
15
  [
16
    - `auto`：#on.pt() pt
17
    - `none`：#off.pt() pt
18
    - 差值：#(on - off).pt() pt，共 #((on - off) / (0.25 * 12pt)) 处缝隙
19
  ]
20
}
21

22
#text(size: 12pt, cjk-latin-spacing: auto, sample) \
23
#text(size: 12pt, cjk-latin-spacing: none, sample)

measure 和 context 第 7 篇才讲，这里只借用：measure 返回内容的实际尺寸。pdftotext 读出来的结果：

1
• auto：121.776 pt
2
• none：109.776 pt
3
• 差值：12 pt，共 4 处缝隙
4
中文 Typst 排版 2026 年
5
中文 Typst 排版 2026 年

样本 中文Typst排版2026年 里汉字和字母之间有 4 处交界：文|T、t|排、版|2、6|年。12 pt 下差值正好 12 pt，每处 3 pt，也就是 0.25em。这就是“默认插入四分之一个字宽”的实测值。

问题来了：我在源文件里手敲空格，会不会和自动空隙叠加？我又写了个实验 space.typ（/tmp/p5），分别量 中文Typst 和 中文 Typst：

1
#set text(
2
  font: ("Libertinus Serif", "Noto Serif CJK SC"),
3
  size: 12pt,
4
  lang: "zh",
5
  region: "cn",
6
)
7
#context {
8
  let w(x, spacing) = {
9
    measure(text(cjk-latin-spacing: spacing, x)).width.pt()
10
  }
11
  for s in (auto, none) {
12
    let tight = w([中文Typst], s)
13
    let spaced = w([中文 Typst], s)
14
    [#repr(s)：无空格 #tight pt，有空格 #spaced pt \ ]
15
  }
16
}

1
auto：无空格 54.456 pt，有空格 54.456 pt
2
none：无空格 51.456 pt，有空格 54.456 pt

auto 下有没有空格宽度一样（54.456 pt），没有叠加；none 下才是纯粹的“一个空格”宽度 3 pt。结论：用 auto 的话，写不写那个空格结果相同，不用在源文件里为排版好看再敲空格。

lab/ch05/fig-cjk.typ 把四种设置并排放，产出 out/figures/ch05-cjk.png：

1
#set page(width: auto, height: auto, margin: 12pt)
2
#set text(font: ("Libertinus Serif", "Noto Serif CJK SC"), size: 12pt)
3

4
#let sample = [中文Typst排版2026年，数字100%。]
5

6
#grid(
7
  columns: 2,
8
  gutter: 1em,
9
  row-gutter: 0.8em,
10
  align: left + horizon,
11
  [`auto`], text(cjk-latin-spacing: auto, sample),
12
  [`none`], text(cjk-latin-spacing: none, sample),
13
  [`strong`], text(weight: "bold", sample),
14
  [`light`], text(weight: 300, sample),
15
)

strong 一行说明可变字体的粗体是真粗体：汉字和字母一起变粗（这里的“字母”来自 Libertinus Bold，是另一个字体文件）。light 一行用的是 Noto 的 300 实例，汉字比 auto 行略轻。Libertinus 只有 400、600、700 三档（见上面的 --variants），请求 300 时取最近的一档：我另外把 Abc 用 weight: 300 和 weight: 400 各编成 PNG，两张图字节完全相同，所以字母没变。

文字装饰、引号与换行#

这一节把还没出场的 text 周边函数一起过一遍。实验文件是 /tmp/p5/deco.typ：

1
#set page(width: 12cm, height: auto, margin: 8pt)
2
#set text(
3
  font: ("Libertinus Serif", "Noto Serif CJK SC"),
4
  size: 12pt,
5
  lang: "zh",
6
  region: "cn",
7
)
8

9
#highlight[高亮]
10
#highlight(fill: yellow.lighten(50%), extent: 2pt)[带扩展的高亮] \
11
#underline[下划线 underline]
12
#underline(offset: 2pt, stroke: 1pt + blue)[偏移的蓝色下划线]
13
#underline(evade: false)[不避让 gjpqy] #underline[避让 gjpqy] \
14
#strike[删除线 strike] #overline[上划线 overline] \
15
H#sub[2]O 与 x#super[2] \
16
#text(baseline: 3pt)[手动基线 baseline] \
17
"smart" 与 'single'，英文里 #text(lang: "en")["smart" and 'single'] \
18
#[
19
  #set smartquote(enabled: false)
20
  "关闭后" 保持直引号
21
] \
22
#[
23
  #set smartquote(quotes: (double: ("「", "」"), single: ("『", "』")))
24
  "直角引号" 与 'nested'
25
] \
26
第一行 \ 第二行 #linebreak() 第三行 \
27
#lorem(12)

• highlight：给内容加背景色，fill 改颜色，extent 让背景向两侧多伸出一段，图里第二个高亮比第一个宽一圈。
• underline、strike、overline：下划线、删除线、上划线。offset 调离基线的距离，stroke 调线型，evade（默认 true）让线条在遇到字母下伸部分（g、j、p、q、y）时绕开，图里 evade: false 的那一条直接穿过了字母。对中文来说汉字没有下伸，evade 只在夹杂英文时可见。
• sub、super：下标和上标，缩小字号并移动基线。这里排版用的是文字，公式里的上下标是第 8 篇的内容。
• baseline：手动抬升或降低基线，是 text 的参数。
• smartquote："smart" 与 'single' 在 zh 下得到的是 “smart” 与 ‘single’，弯引号。set smartquote(enabled: false) 保留直引号；set smartquote(quotes: (double: (...), single: (...))) 换成别的引号，我换成了直角引号 「」 『』，中文排版中偶尔需要。
• linebreak：\ 是 #linebreak() 的简写，强制换行，图里“第一行 第二行 第三行”各占一行。
• lorem(n)：生成 n 个词的 lorem ipsum 占位文字。注意它只会生成拉丁文，想要中文占位文字得自己写一段。

upper、lower、smallcaps 在上一节已经出现。第 9 篇会再用到 highlight、underline 等，在表格和引用里。

中文编号："一" 和 "壹"#

第 4 篇的 set heading(numbering: "一、") 用的就是中文数字。numbering 的模式字符串里，1、a、A、i、I 是拉丁系，一 和 壹 是中文系，我对 n = 1, 10, 11, 21, 100, 1234 各跑一遍。实验文件 /tmp/p5/numbering.typ：

1
#set page(width: 14cm, height: auto, margin: 8pt)
2
#set text(
3
  font: ("Libertinus Serif", "Noto Serif CJK SC"),
4
  size: 12pt,
5
  lang: "zh",
6
)
7

8
#for n in (1, 10, 11, 21, 100, 1234) {
9
  [#n：#numbering("一", n)，#numbering("壹", n) \ ]
10
}
11
#numbering("①", 21)，#numbering("①", 50) \
12

13
#set heading(numbering: "一、")
14
= 概述
15
== 小节
16
#set heading(numbering: "第一章")
17
= 另起
18
#set heading(numbering: (..n) => "第" + numbering("一", ..n.pos()) + "节")
19
= 函数形式
20

21
#set enum(numbering: "（一）")
22
+ 条目
23
+ 条目

pdftotext 读出来：

1
1：一，壹
2
10：十，拾
3
11：十一，拾壹
4
21：二十一，贰拾壹
5
100：一百，壹佰
6
1234：一千二百三十四，壹仟贰佰叁拾肆
7
㉑，㊿

• "一" 给小写中文数字，"壹" 给大写（财务用），两者都能处理到 1234，都是完整的“十、百、千”读法，没有位数限制的错误。
• "①" 只覆盖 1 到 50，到 100 时我在这个版本里得到的是一条警告 the number 100 is too large to be represented with the arabic.o numeral system，附带 this will become a hard error in the future，输出退化成阿拉伯数字 100。用圈号数字要注意不超过 50。
• 标题的 "一、" 在二级标题上变成 一、一、。我猜是模式只有一个计数符号，第二级的计数器按同一个模式再追加一次，没有去查源码。多级标题要么只给一级设中文，要么用函数形式。
• 把模式换成 "第一章" 时，计数器并没有重置：接着上面的 概述 变成 第二章，因为 numbering 只是改了显示，计数器是标题自己的。
• 函数形式 (..n) => "第" + numbering("一", ..n.pos()) + "节" 可以随意拼装，..n.pos() 把收到的计数器值展开成 numbering 的参数。
• 列表同理：set enum(numbering: "（一）") 用的是全角括号，条目内容紧接其后。

段落：par 的几个参数#

lab/ch05/par.typ（源文件）：

1
#set page(width: 12cm, height: auto, margin: 1cm)
2
#set text(
3
  font: ("Libertinus Serif", "Noto Serif CJK SC"),
4
  lang: "zh",
5
  size: 11pt,
6
)
7

8
// Chinese convention: indent every paragraph by two characters.
9
// `all: true` also indents the first paragraph after a heading.
10
#set par(
11
  justify: true,
12
  leading: 0.9em,
13
  spacing: 1.2em,
14
  first-line-indent: (amount: 2em, all: true),
15
)
16
#set heading(numbering: "1.")
17

18
= 缩进
19

20
排版中文时，每段首行缩进两个汉字宽，行距比西文略大。段落之间不需要额外空行，但这里用 `spacing` 留了一点。
21

22
// 0.15: first-line-indent folds, so a later rule can change one key.
23
#set par(first-line-indent: (amount: 0pt))
24
这一段把 amount 改成了 0，`all` 仍然继承自上面的规则。
25

26
// Hanging indent for references.
27
#set par(first-line-indent: 0pt, hanging-indent: 2em)
28
[1] Knuth, D. E. _The TeXbook_. Addison-Wesley, 1984. 这条参考文献的第二行会整体悬挂缩进。
29

30
// Line breaking: optimized (default) vs simple.
31
#set par(hanging-indent: 0pt, linebreaks: "simple")
32
简单断行直接贪心填满每一行，不做全段落优化，所以右边缘的空白更不均匀一些。

逐个说。

justify、leading、spacing。 justify: true 两端对齐。leading 是行与行之间的距离（不含字体本身的行高），spacing 是段与段之间的距离。我读了这些默认值（#context 里把 par.leading、par.spacing、par.first-line-indent、text.lang 等打印出来）：

1
默认 leading 0.65em，spacing 1.2em，行首缩进 (amount: 0pt, all: false)，字号 11pt，lang en，
2
region none，cjk-latin-spacing auto

xuan-cjk 把 leading 提到 0.9em。我的感觉是汉字方块占满整个字面，同样的行距看起来比拉丁文更挤，所以多给一点。

first-line-indent 与它的 all。 中文习惯每段缩进两个汉字，即 2em。first-line-indent 接受一个长度，也接受 (amount: ..., all: ...) 的字典。all 默认为 false，意思是只给“紧跟在其他段落后面”的段落缩进，标题后第一段不缩进，这是西文习惯。我用并排实验确认了：

1
#set par(first-line-indent: 2em)
2
// vs
3
#set par(first-line-indent: (amount: 2em, all: true))

左边（all 缺省）标题“标题”后面的“标题后的第一段。”是顶格的，右边（all: true）也缩进了。中文排版要求每段都缩，所以 xuan-cjk 用 all: true。（这个并排实验是 /tmp/p5/indent-all.typ，每列里就是上面这条 set par 加几段文字。）

折叠（fold）。 第 4 篇讲过 set 规则会折叠，0.15 起 first-line-indent 也折叠，所以 lab 里 #set par(first-line-indent: (amount: 0pt)) 只写了 amount，按 lab 注释的说法 all 仍然继承。图里这一段确实不缩进了，all 继承与否单看这张图分辨不出来。

hanging-indent。 悬挂缩进，是第一行以外的所有行缩进。参考文献和术语表用得到。图里 [1] Knuth... 的第一行顶格，续行缩进了 2em。lab 里先把 first-line-indent 设回 0pt 再设悬挂，免得两个缩进叠在一起。

linebreaks。 "optimized" 是默认的整段最优断行算法，"simple" 是逐行贪心填满。最后一段用的是 "simple"。我没有量化这两种方式的区别，在 12 厘米宽的段落里肉眼几乎看不出来；这个参数对长段落、窄栏、拉丁文混排的差别更大一些。

收进 xuan：fonts.typ 与 cjk.typ#

前面所有结论，在 xuan 里就是这两个文件。src/fonts.typ（源文件），13 行，最终版：

1
// Font stacks. Libertinus, DejaVu and New Computer Modern ship inside the
2
// Typst binary; the Noto CJK families come from the flake (TYPST_FONT_PATHS).
3
// `latin-in-cjk` keeps Libertinus away from CJK punctuation such as “”, so
4
// those fall through to the full-width glyphs of Noto Serif CJK SC.
5
#let fonts = (
6
  serif: (
7
    (name: "Libertinus Serif", covers: "latin-in-cjk"),
8
    "Noto Serif CJK SC",
9
  ),
10
  sans: ("Noto Sans CJK SC",),
11
  mono: ("DejaVu Sans Mono", "Noto Sans Mono CJK SC"),
12
  math: ("New Computer Modern Math",),
13
)

一个字典，四个键，都是字体列表（sans 后面的逗号让它是一个元素的数组，而不是字符串）：

• serif：正文。Latin 与数字走 Libertinus，汉字走 Noto Serif CJK SC。covers: "latin-in-cjk" 让 Libertinus 不碰引号这类中文标点，它们落到 Noto 的全角字形上，前面的实验已经讲过。
• sans：无衬线，第 13 篇的幻灯片用。
• mono：代码。同样的思路，DejaVu Sans Mono 排字母符号，Noto Sans Mono CJK SC 补汉字。
• math：公式字体。第 8 篇会讲，这里只有一项，因为数学字体要有 OpenType math 表，普通字体用不了。

注释里已经把来源写明：Libertinus、DejaVu 和 New Computer Modern 是嵌在 Typst 里的，Noto CJK 来自 flake。所以你要在别的环境用 xuan，必须自己保证 Noto CJK 系列在字体路径里，否则就是前面那个“静默豆腐块”场景。

src/cjk.typ（源文件），21 行，最终版：

1
#import "fonts.typ": fonts
2

3
/// Typography defaults for Chinese (`lang: "zh"`) or English body text.
4
#let xuan-cjk(body, lang: "zh") = {
5
  let zh = lang == "zh"
6
  set text(
7
    font: fonts.serif,
8
    lang: lang,
9
    region: if zh { "cn" } else { none },
10
    cjk-latin-spacing: auto,
11
  )
12
  set par(
13
    justify: true,
14
    leading: 0.9em,
15
    spacing: 1.2em,
16
    first-line-indent: if zh { (amount: 2em, all: true) } else { 0pt },
17
  )
18
  show raw: set text(font: fonts.mono)
19
  show math.equation: set text(font: fonts.math)
20
  body
21
}

它的形状就是第 4 篇讲的模板：(body, lang:) 参数，最后返回 body，前面登记一串规则。拆开看：

• let zh = lang == "zh"：后面三处要分语言，先算一次。
• set text(...)：字体列表、lang、按语言选 region（中文 "cn"，其他 none）、cjk-latin-spacing: auto。auto 就是默认值，我显式写出来是让读这个文件的人不必去查默认值。
• set par(...)：中文缩进两个字，英文不缩进（0pt）。其余三项两种语言共用：两端对齐，行距 0.9em，段距 1.2em。first-line-indent 值是 if 表达式，分支结果是一个字典或一个长度，两者都合法。
• show raw: set text(font: fonts.mono)：行内和块级的 raw 都换成等宽栈。这是 show ... : set 形式，第 4 篇讲过，它不产生嵌套。
• show math.equation: set text(font: fonts.math)：公式用数学字体。这里不用 set text(font:)，因为那会影响正文，只想让公式变。

我用这个模板编了一份很小的文档，看它实际用了哪些字体。use.typ（/tmp/p5）：

1
#import "@local/xuan:0.1.0": *
2

3
#set page(width: 12cm, height: auto, margin: 1cm)
4
#show: xuan-cjk
5

6
= 使用 xuan-cjk
7

8
正文用 Libertinus 排西文，用 Noto Serif CJK SC 排汉字：Typst 0.15.1 的 `raw` 与公式 $x^2 + y^2$ 各有自己的字体。
9

10
第二段缩进两个汉字宽，*加粗* 取的是可变字体 wght 轴上 700 的那个实例。
11

12
```rust
13
fn main() { println!("你好"); }
14
```

1
$ typst compile --root / --ignore-system-fonts use.typ use.pdf
2
$ pdffonts use.pdf
3
name                                 type              encoding         emb sub uni object ID
4
------------------------------------ ----------------- ---------------- --- --- --- ---------
5
BJAXUM+NotoSerifCJKsc-ExtraLight     CID TrueType      Identity-H       yes yes yes     19  0
6
CXRIIC+LibertinusSerif-Bold-Identity-H CID Type 0C       Identity-H       yes yes yes     22  0
7
ZLKZTV+NotoSerifCJKsc-ExtraLight     CID TrueType      Identity-H       yes yes yes     25  0
8
PQNDLO+LibertinusSerif-Regular-Identity-H CID Type 0C       Identity-H       yes yes yes     28  0
9
WWBOFQ+DejaVuSansMono                CID TrueType      Identity-H       yes yes yes     31  0
10
HJDJUN+NewCMMath-Book-Identity-H     CID Type 0C       Identity-H       yes yes yes     34  0
11
GGUNCA+NotoSansMonoCJKsc-Regular     CID TrueType      Identity-H       yes yes yes     37  0

（--root / 是因为文件放在 /tmp 下，Typst 要求源文件必须在项目根目录里。）七个字体对象，对得上：两个 NotoSerifCJKsc（常规加标题或加粗两个字重），Libertinus 的 Bold 和 Regular，DejaVu Sans Mono 画代码里的 fn main 等拉丁字符，NewCMMath-Book 画 $x^2 + y^2$，NotoSansMonoCJKsc-Regular 画代码里的“你好”。

跑一遍#

1
$ nix develop --command make ch05
2
./scripts/chapter.sh ch05
3
ok   lab/ch05/cjk-latin-spacing.typ
4
ok   lab/ch05/fig-cjk.typ
5
ok   lab/ch05/fonts.typ
6
ok   lab/ch05/missing-glyph.typ
7
ok   lab/ch05/par.typ
8
ok   lab/ch05/unknown-font.warn.typ (warned as expected)

六个文件，五个正常输出，一个按预期给出警告。

一个新坑：这一篇的小实验放在 /tmp 下，我一开始给 typst compile 传了 --root ~/Projects/typst-lab，得到 error: source file must be contained in project root，因为源文件必须在根目录之内。改成 --root / 才编过。仓库里的 lab 文件本来就在仓库根下，--root . 就够了。

接下来#

字体和段落解决了“字怎么排”，下一步是“字放在哪里”：页面大小、页边距、盒子、网格、浮动。第 6 篇讲 page、block、box、grid、place 和 layout，并把 xuan 的 page.typ 写出来。想先动手的话，lab/ch05/ 里的字体列表还是 A 的写法，可以把它换成 fonts.typ 里 serif 的写法，自己对比引号的变化：lab/ch05。下一篇：页面与布局：盒子、网格与浮动。