一文让你理解什么是块，及具体如何记笔记有利于块链接（呕心沥血之作）

Guts · 2023 年6 月 17 日 09:07

本文是个人对OB中的块的研究，涵盖着个人对OB中的“块"理解，及如何记笔记有利于块链接。
由于官方的的介绍文档只是简单的介绍下了块，但本人在时候用时遇到了很多问题，网上并没有介绍相关的文章，于是进行了研究，并在此文汇总，希望对萌新有所帮助，有点长，希望能耐心观看，并给出意见。
注：建议在OB中将此文分屏观看，一遍观看正文，一篇查看最下方的结构示范，有助于理解。

什么是“块”？“标题(#)“与”块“的关系？“块”的隔断规则？
- 将OB仓库内的所有文件，比作是一座座独栋的别墅，每栋别墅都是互相独立、界限分明的，只需要找到门牌号（文件名）就能找到相对应的别墅（文件），而对于一栋别墅内（一篇文章内）的区域划分，如何划分哪里是卫生间？哪里是厨房？哪里是带卫生间的主卧？一篇md文章内用于划分区域的“墙壁”是什么？
 - 划分区域的“墙壁”
 1. 具有层级关系、所属关系的结构，自带分隔的墙壁，如，标题(# )、列表【含：有序列表(1. )和 无序列表(- )】等。 ^20230502141429-01
 - 也就是点击左侧的尖角图标，可以展开、折叠其下属内容的结构，结构是占据的区域周边，就是自带的“墙壁”。
 1. 非嵌套（平级）状态下，即顶行首输入的文字的前后分别至少有一行"行首开始的空行(enter)"，空行就是分隔的墙壁。
 简略版：文字上下都有行首开始的空行，空行就是分隔的墙壁→前后有行首开始空行包围的字段
 无论是一个字还是一段字都是如此，总之就是“普通字段”都是如此。"表格"也是如此，尽管渲染后是表格，其源代码是一段文字。“表格”的规则=“普通字段”的规则，其中“普通字段”的规则见[[#标题AA]]的图片。但对于非嵌套（平级）状态下，“普通字段”、“表格”、“列表“、“缩进”、“代码块”等，其块ID可放置的区域有所不同，详情见[[#标题AA]]的说明的第2点。 ^20230502141429-04
 - “普通字段”的定义：^k-A、 ^K-B所链接的块为“普通字段”——非嵌套（平级）状态下，即顶行首输入的文字，无缩进、无列表等，就是单纯的一段文字
 - 空行的特例：
 
 一定要是按Enter产生的空行、 产生的空行不算，可通过“源码模式”观察。
 
 光标不在一行的最开头的空行，即缩进的空行——列表中（即具有层级关系、所属关系的结构）用"shift+enter换行显示"产生的缩进空行、"Tab或ctrl+]缩进“产生的缩进空行。此时的空行不作为分隔的墙壁。但放置缩进的空行，如[[#标题O]]所示，此时可增加块ID可放置位置。
 
 md文档的始与末=空行，不必加空行。文档的始与末相当于别墅的最外墙，也就是在文章的最开头、最末尾不需要加空行，此时已存在分隔
 
 PS："shift+enter换行显示“和”enter换行“的含义不同。”enter换行“中，生成的下一行字段与上一行字段是并列关系，属于同级，而"shift+enter换行显示“，生成的下一行字段属于上一行字段，具有所属关系，不是同级。 ^20230502141429-03
 - 区域的层级结构
 - 层级结构按由大到小排序，分两种情况：
 1. 一篇文档有标题：md文档→某一标题(# )下→块{前后有空行包围的字段、列表【有序列表(1. ) 和 无序列表(- )】}
 2. 一篇文档无标题：md文档→块{前后空行包围的字段、列表【有序列表(1. ) 和 无序列表(- )】}
 - 说明：
 - 对于md标准语法中，标题(# )是可以链接的最小结构。块是OB独有的语法，是比标题(# )还要小的可以链接的最小结构。
 - 在一篇文档有标题(# )的前提下，块是一个标题(# )下的前后行首开始空行包围的字段、列表【含：有序列表(1. ) 和无序列表(- )】，因此块无法跨越标题(# )的界限，也就是如果要引用的内容，一些在标题A的上方，一些在下方，那么就是两个“块”，是没法办法一起引用的，要解决此问题把内容放在一起，不要跨越标题，或者分别引用两个块。
 - 在一篇文档无标题(# )的前提下，块也是前后空行包围的字段、列表【含：有序列表(1. ) 和无序列表(- )】，只不过是少标题(# )这一更大的结构。可以理解，此时的无标题md文档=有标题的某一标题(# )下，两者层级关系相同
 - 块结构存在嵌套的层级关系，此处比较复杂，见后面
块链接的使用 （整理自官网教程）——块链接与块引用 - Obsidian 中文帮助 - Obsidian Publish
- 块链接非 Markdown 标准语法，只能在OB中使用。其他软件打开文档后，无法像OB一样直接点击跳转，但可通过搜索块 ID 来查找相应位置。
- 链接某个笔记文件中的块，你首先需要输入 [[文件名 来唤起弹窗，在选择相应的文件后，通过输入 ^ 进入块选择界面。随后，你需要继续输入关键词来选择你所需要链接的块。
- 选择好了以后，按下回车键，对于该块的链接就创建好了。块链接会以 [[filename#^dcf64c]] 的形式出现，其中 dcf64c 则是你所链接的块的 ID。并可以通过在块链接前加上 ! 来显示块的内容，即块的嵌入.
- 如果你忘了想链接的块在哪个文件里，你可以通过输入 [[^^ 在库的所有笔记文件中查找该块。由于这种查找方式涉及库中所有笔记文件，当你的库很大时，查找就需要花费一些时间。
- 如果你想手动创建可读性强的块 ID，你可以在块的末尾手动加上 ^你的-id 这样的语法。需要注意的是，对于一般的段落，手动创建的 ID 和块最后一个字符（即段落最后一个字符）间需要有一个或多个空格。
如何编辑文档有利于文本块链接？ 总而言之，要养成空行分割段落的习惯，且后面示范的前后空行包围的字段

文章的最开头、最末尾不需要加空行。
- 说明：md文档的始与末，就是分隔的最外墙。如果使用YMAL，顶行输入YMAL，不需要在—前面输入空行**，回车换行后再输入正文。
标题(# )与上下文之间要有空行（enter）。
- 说明：此处编辑模式有没有空行，不影响块的链接（标题已经进行了区域分隔），阅览模式（渲染后）结果都一样，没加空行会自动加空行。但是这样的话会使实时阅览、源码模式排版一致，更为直观，并保证了文字的前后都有空行。
块之间不嵌套，即块都在行首输入，块之间要用空行（enter）分隔。由此延伸[[#^20230502141429-04]]的加粗的第一句
如要使用<\b\r>，<\b\r>前后各用enter输入一行空行，详情见此[[#^20230502141429-02]]
- 说明：块都在行首输入，即前后空行包围的字段、列表【有序列表(1. ) 和 无序列表(- )】之间处不存在嵌套关系，都是平级关系，如[[#标题A]]所示区域。不要如[[#标题B]]所示，尽管同级关系下列表之间，加不加空行都一样，即便没加空格，阅读模式（渲染）下列表之间也会自动填入空行。但如果是普通的文字段，在阅览模式（渲染状态）下，由于没有enter分隔，普通的文字段会被判定为属于无序列表B。^W-B所在的位置不属于无序列表B的最后，无法正确的进行块链接。
块之间嵌套（具体结构，参考[[#标题G]]）
- 块要嵌套，为了方便块链接，要使用列表和列表嵌套，尽量不要嵌套shift+enter换行显示输入的字段，但有特殊情况，如[[#标题O]]，此时可增加块ID放置位置
- **最末级列表在划分每一点的内容时，也就是在划分最小块时，要保证每一点的内容，是将要最小被链接的内容，并不会继续再对此点内容拆分——引用此点内部分内容。如果出现需要继续拆分引用，那么换行显示（shift+enter）,对此点再往下分一级列表。
- 如要对换行显示（shift+enter）的内容进行块链接，将其转化为列表，一般开头加-+space
- 由此延伸[[#^20230502141429-01]]，嵌套时，某一级列表下的同级列表之间可以不必输入空行（enter）分隔，即便输入阅览模式（渲染）也不会有空行，即列表间不必使用空行（enter）分隔，其他（标题、普通的字段、 ）每个之间都要使用空行（enter）分隔。
 - 对列表有特殊情况，如[[#标题Q]]所示，建议在源码模式下观看，尽管自带分隔的墙壁，当在列表附近使用 用于增加空行，不正确添加enter空行，会导致墙壁失效。要保证块ID既能识别，<\b\r>也能正常使用，<\b\r>前后各用enter输入一行空行。 ^20230502141429-02
- 得出以上结论说明：在块之间存在嵌套关系，前后空行包围的字段、列表【有序列表(1. ) 和 无序列表(- )】之间互相嵌套，如果嵌套shift+enter换行显示，的字段，如[[#标题C]]所示，有以下几点发现。
 1. 会发现^Y-C链接的不是^Y-C之前的有序列表C的内容，而是有序列表C及其所属下的前后空行包围的字段C、无序列表C，因为"shift+enter换行显示“和”enter换行“的含义不同，"shift+enter换行显示“，生成的下一行字段属于上一行字段，具体见[[#^20230502141429-03]]。如果想要链接^Y-C之前的有序列表C的内容，且还要保持这样的层级结构，建议改成[[#标题D]]的形式。D中要链接全部，建立列表进行嵌套后，父ID放在第一行的父列表末尾来链接全部，子ID放在每个子列表的末尾——可单独链接每个子列表。D中每个列表加是否加enter（空行）都一样，阅读模式（渲染）下都一样。
 2. 并在[[#标题C]]中发现，^K-C是无法正常链接的，但通过“源码模式”观察，字段被两个空行夹住，应该是可以被链接的，原因是什么？注意观察，字段其实是被带缩进的空行分隔——“换行显示（shift+enter）”，此时空行不算“墙壁”，并不是从行首开始的空行，因此此处不能判定为一个块，且[[#标题C]]中，“前后空行包围的字段C”属于“有序列表C”（详情见[[#^20230502141429-03]]），且^Y-C，^K-E都是块的末尾，同时放置时，靠前的ID优先度大于靠后的，也就是^Y-C优先于^K-E识别为块ID。如果像[[#标题E]]，删去^Y-E，此时^K-E会被判定为块的末尾，识别正常。总之，如[[#标题C]]所示的”有序列表C的内容“和”前后空行包围的字段C的内容“的拼合块。
 如果想块链接有序列表C的内容及其所属下的内容，且保留^Y-C的块ID位置。一定要像[[#标题C]]一样，有序列表C 和前后空行包围的字段C，之间要有换行显示（shift+enter）产生的空行，此时会判定 ^Y-C所在的位置为块的末尾。而[[#标题F]]是反例，虽然也实现了块链接有序列表C的内容及其所属下的内容，由于没有"换行显示（shift+enter）"，^Y-F无法正常识别为块ID，^K-F会被判定为块的末尾，此时的块ID要放在^K-F的位置。
 PS: 前后空行包围的字段F和无序列表F之间加不加换行显示（shift+enter）产生的空行，阅览模式（渲染）结果都一样。
 总之，具有层级的结构，如"列表"，若使用“换行显示（shift+enter）”产生的空行，会影响“拼合块”的块末尾位置，产生多个“块末尾”，增加块ID可放置位置。多个列表嵌套也适用，详情见[[#标题C]]中间部分。且多个块末尾同时放置时块ID时，块ID优先度不同，靠前的块ID优先度大于靠后的——就前原则，并使靠后的块ID失效，详细规律总结见[[#标题C]]后半部分，概括性的总结见[[#标题O]]^20230502141429-05
块ID使用规则
- 块ID结构： 块的末尾+空格+^+块ID编码
- 说明：
  1. 块ID正确识别的前提：是正确的把内容分隔成块，块分隔的不正确，即便放在要引用的段落后，也无法正常识别。
  2. OB可自动生成块ID编码，也支持自定义块ID编码，仅可输入字母、数字、英文的破折号，不区分大小写。
    且OB识别的块ID会再键入ID结束后，发生变化，在官方默认主题下，“实时阅览”、“源码模式”下，ID会缩小，并变灰；“阅读视图”（渲染状态）会隐藏。块ID所放置的位置若不正确，是无法被识别从而被链接，无法发生上述的变化，如同普通的文本一样显示
  3. 块ID的位置：
    - 块ID的抓取块的规则，也就是块ID是哪个块的——遵循就近、就前原则，ID会抓取最近、且在输入在ID前面的块，也就是，块ID要放在块的末尾。
    - 换行显示（shift+enter）会影响拼合块的块末尾位置，进而影响块ID放置位置。规律总结见[[#标题O]]
    - 块是否嵌套，会导致块的末尾的位置不同，甚至会出现多个块的末尾。
      如嵌套结构会出现多个块的末尾，例如[[#标题G]]的^0-G是块的一个末尾，[[#标题H]]的^0-H是块的另个一个末尾。并且由于嵌套的块之间末尾会存在重叠，导致情况复杂，如[[#标题H]]的^0-H-1，难道不该算是块0的末尾吗？但实际判断是块3的末尾，块0的末尾应该再加一行空行输入，也就是^0-H。
  4. 块ID 和块的末尾（即段落最后一个字符）间需要至少要有一个空格。块ID 和块的末尾建议只隔一个空格，这样方便查找ID属于哪个块，保持原来的排版。如[[#标题I]]、[[#标题M]]中的块ID进行了多加空格、换行显示（shift+enter）等操作，虽然阅览模式（渲染）下结果一样，但是编辑状态排版混乱，不易阅读。推荐放置位置实例见[[#^20230502141429-06]]所推荐的
  5. 建议自定义块ID编码及其位置：先根据文章时间戳（UID）建立ID并确定放置位置，再进行块链接的链接，这样便于后续如果ob无法使用，块ID的编码规则、排版位置，是有迹可循。如果一开始不知道怎么放置块ID，可以通过[[]]先链接，确定大致确定位置，再修改ID编码、移动位置。其中自定义块ID编码结构为：UID+ID创建顺序编码，例如本文的：20230502141429-01、20230502141429-02、20230502141429-03，依照创建顺序排序，来建立编码，新建就按照上一个建立的编码依次排序。一般如-01、-02、-03这样两位数即可，最多可建立99个，如果不够的可以增加位数。或者采用十六进制编码，可建立256-1=255个，如：-0B、-0E、-1F等。也可以采用纯字母编码，可建立26×26=676个，如-AA、-BG、-FZ等结构
如果是大块内容被引用，能使用标题(#)引用，就不要使用块ID，有利于利于其他软件打开
其他：
- 文章中插入、嵌入的附件，如图片，附件在源码模式下，是一行链接地址，属于文字，可以进行单独的块链接，也可以放在字段里，一同被块链接，只要块分隔的正确、块ID放置的正确。
- 如果是引用，也就是字段前有>，即便其下有两个、三个>，渲染模式下会显示层级结构，但是其自身只能作为一个整体的大块，被链接，无法如同列表一样，单独链接二级结构——两个\、三级结构——三个>，具体见[[#标题N]]。
1. 总之。在使用引用时，不尽量要建立多层级结构，不好进行块链接，并将块ID放置在如 [[#^N-B]] 所示的引用的末尾
2. 特例：如[[#标题P]]所示，将[[#标题N]]的一整块引用嵌套在一父列表下。之前单独在引用中的无法被链接列表（如^N-5、^N-6、^N-7），由于被嵌套，变子列表，被成功链接，但其他的块ID存在问问题。
  - 观察[[#标题P-0]]~[[#标题P-5]]，未加空行，且从前到后剃掉块ID，有以下观察结果：
    - 对于列表下嵌套的引用，多个块末尾同时放置时块ID时，块ID优先度不同，靠前的块ID优先度大于靠前的——就前原则（与列表用“换行显示（shift+enter）”相似，详情见[[#^20230502141429-05]]），但有所不同的是，未添加（shift+enter）产生的空行，一些块ID也生效，但是有的块ID无法生效，如^P-2-2。
    - 注意观察，生效的块ID，往往是某一个结构的末尾（结束），^P-0是父列表的末尾；^P-1是引用的层级1的末尾； ^P-3是引用的层级2的末尾；^P-4处于层级3中普通字段的末尾，下一行是层级3的列表；^P-B是整个列表+引用的末尾；无法生效的^P-2不是某一个结构的末尾（结束）。当然此处的生效，要遵循就前原则，如[[#标题P-0]]~[[#标题P-5]]所示，从前到后依次剃掉靠前的块ID，后面的块ID才能生效。但无论是上述的哪个生效的块ID，都是对整体进行的块链接。
    - 如果想让无法生效的^P-2变为生效，如[[#标题P-6]]所示，在不是某一个结构的末尾（结束）的下一行，用“换行显示（shift+enter）”增加空行，使其强制生成块末尾，增加可放置块ID位置（与列表用“换行显示（shift+enter）”相似，详情见[[#^20230502141429-05]]下的实例[[#标题O]]）
  - 结论：
    - 如果是列表下嵌套的引用，且含有子列表，子列表可以如同无引用一样的父子列表进行单独链接。
      （父子列表指的是如[[#标题C]]、[[#标题E]]、[[#标题F]]结构）。
    - 而引用中除子列表以外的其他部分，跟无列表嵌套的、单独的引用一样，无法被单独链接，只能整体一起被链接，整体被链接推荐块ID位置为^P-0。
      （与列表用“换行显示（shift+enter）”相似，详情见[[#^20230502141429-05]]下的实例[[#标题O]]）。
综上：
推荐实例：块之间不嵌套参考 [[#标题A]]——“普通字段”、[[#标题L]]——“表格”、[[#标题AA]]——“缩进”、“代码块”，块之间嵌套参考[[#标题D]]、[[#标题G]]（标题G是标题D的高度概括版本）。
推荐的范例中块ID位置能够直观的指明ID指向哪个块。先确定块的ID的编码位置 ^20230502141429-06

PS：列表、引用自身具有层级结构，除了两者以外普通的字段shift+enter和enter阅览模式（渲染）结果是一样的，因为其没有层级关系。

标题AA

非嵌套（平级）状态下，即顶行首输入的“普通字段”、“表格”、“列表“的底层、通用结构：
PS:“列表“尽管自带墙壁（缘由：[[#^20230502141429-01]])，也可以采用如下结构

![[assets/20230502141429-块链接/20230502141429_块链接_第一版 1.png]]

说明：

推荐的样式：“行n+2”~“行n+m”（都含自身）可删除，"块ID可放置位置"只留下"行n+1"的空白区域，"行n-1"和"行n+m+1"的"行首开始的空行(enter)“不能删除——顶行首输入的文字的前后分别至少有一行"行首开始的空行(enter)”，实例见[[#标题A]]。
图中“字段”指的是，非嵌套（平级）状态下，即顶行首输入的“普通字段”、“表格”、“列表“，实例见[[#标题A]]、[[#标题L]]。
不包含非嵌套（平级）状态下的“缩进”、“代码块”，两者结构与下图所示结构不同。相同的是“缩进”、“代码块”前后分别至少有一个"行首开始的空行(enter)"，但是“块ID可放置位置”有所不同，具体如下文所示

缩进的字段，缩进的字段，缩进的字段，缩进的字段，缩进的字段，缩进的字段，缩进的字段，缩进的字段，缩进的字段，缩进的字段，缩进的字段，缩进的字段，缩进的字段，缩进的字段，缩进的字段，缩进的字段，缩进的字段，缩进的字段，缩进的字段，缩进的字段，缩进的字段，缩进的字段，缩进的字段，缩进的字段。

^S-AA

代码块的字段，代码块的字段，代码块的字段，代码块的字段，代码块的字段，代码块的字段，代码块的字段，代码块的字段，代码块的字段，代码块的字段，代码块的字段，代码块的字段，代码块的字段，代码块的字段，代码块的字段，代码块的字段，代码块的字段，代码块的字段，代码块的字段，代码块的字段。

^D-AA

标题A测试区域（行首输入，按照此结构）
[[#^S-AA]] [[#^D-AA]]

[!FAQ]- Q：非嵌套（平级）状态下，块若要正确链接，以下两个条件是否缺一不可? ①至少两行"行首开始的空行(enter)"前后夹住字段，进行分隔。②被夹住的字段顶行首输入
A:

“普通字段"和“表格”，自身必须顶行首输入（条件②），“普通字段"的定义是字段顶行首输入，“表格”如果不顶行输入，使用空格产生缩进，表格无法正确渲染。且两者要求字段前后分别至少有一行"行首开始的空行(enter)"（条件①），否则无法正确识别为块

“列表”如果不是搭配 等特殊结构，①可以没有

“缩进”、“代码块”比较特殊，他们并不是字段顶行首输入，②不满足。

标题A

有序列表A的内容，有序列表A的内容，有序列表A的内容，有序列表A的内容，有序列表A的内容，有序列表A的内容，有序列表A的内容，有序列表A的内容，有序列表A的内容，有序列表A的内容。 ^Y-A

无序列表A的内容，无序列表A的内容，无序列表A的内容，无序列表A的内容。 ^W-A

前后空行包围的字段A的内容，前后空行包围的字段A的内容，前后空行包围的字段A的内容，前后空行包围的字段A的内容，前后空行包围的字段A的内容，前后空行包围的字段A的内容，前后空行包围的字段A的内容，前后空行包围的字段A的内容，前后空行包围的字段A的内容，前后空行包围的字段A的内容，前后空行包围的字段A的内容，前后空行包围的字段A的内容。 ^K-A

标题A测试区域（行首输入，按照此结构）
[[#^y-A]] [[#^w-A]] [[#^k-A]]

标题B

有序列表B的内容，有序列表B的内容，有序列表1的内容，有序列表1的内容，有序列表1的内容，有序列表1的内容，有序列表1的内容，有序列表1的内容，有序列表1的内容，有序列表1的内容。 ^Y-B

无序列表B的内容，无序列表B的内容，无序列表B的内容，无序列表B的内容。 ^W-B
前后空行包围的字段B的内容，前后空行包围的字段B的内容，前后空行包围的字段B的内容，前后空行包围的字段B的内容，前后空行包围的字段B的内容，前后空行包围的字段B的内容，前后空行包围的字段B的内容，前后空行包围的字段B的内容，前后空行包围的字段B的内容，前后空行包围的字段B的内容，前后空行包围的字段B的内容，前后空行包围的字段B的内容。 ^K-B

标题B测试区域
[[#^y-B]] [[#^w-B]] [[#^k-B]]

标题C

有序列表C的内容，有序列表C的内容，有序列表C的内容，有序列表C的内容，有序列表C的内容，有序列表C的内容，有序列表C的内容，有序列表C的内容，有序列表C的内容，有序列表C的内容。 ^Y-C

前后空行包围的字段C的内容，前后空行包围的字段C的内容，前后空行包围的字段C的内容，前后空行包围的字段C的内容，前后空行包围的字段C的内容，前后空行包围的字段C的内容，前后空行包围的字段C的内容，前后空行包围的字段C的内容，前后空行包围的字段C的内容，前后空行包围的字段C的内容，前后空行包围的字段C的内容，前后空行包围的字段C的内容。 ^K-C
- 无序列表C的内容，无序列表C的内容，无序列表C的内容，无序列表C的内容。 ^W-C

标题C测试区域
[[#^Y-C]] [[#^K-C]] [[#^w-C]]

注：标题C与标题A不同，标题C中前后空行包围的字段、无序列表属于有序列表。标题A中前后空行包围的字段、无序列表、有序列表三者同级，无并列关系。且对于前后空行包围的字段、无序列表、有序列表三者，标题E的关系=标题F的关系=标题C的关系

中间部分

有序列表C-1的内容，有序列表C-1的内容，有序列表C-1的内容，有序列表C-1的内容， ^C-1

有序列表C-1的内容，有序列表C-1的内容，有序列表C-1的内容，有序列表C-1的内容。
- 无序列表C-2的内容，无序列表C-2的内容，无序列表C-2的内容，无序列表C-2的内容， ^C-2
  
  无序列表C-2的内容，无序列表C-2的内容，无序列表C-2的内容。
- 无序列表C-3的内容，无序列表C-3的内容，无序列表C-3的内容，无序列表C-3的内容，
  
  无序列表C-3的内容，无序列表C-3的内容，无序列表C-3的内容。 ^C-3
  1. 有序列表C-4的内容，有序列表C-4的内容，有序列表C-4的内容，有序列表C-4的内容， ^C-4
    
    有序列表C-4的内容，有序列表C-4的内容，有序列表C-4的内容，有序列表C-4的内容。

[[#^C-1]] [[#^C-2]] [[#^C-3]] [[#^C-4]]

后半部分——块ID优先度不同——就前原则

有序列表C-5的内容，有序列表C-5的内容，有序列表C-5的内容，有序列表C-5的内容。 ^C-5

有序列表C-5的内容，有序列表C-5的内容，有序列表C-5的内容，有序列表C-5的内容。 ^C-6

有序列表C-5的内容，有序列表C-5的内容，有序列表C-5的内容，有序列表C-5的内容。 ^C-7

有序列表C-5的内容，有序列表C-5的内容，有序列表C-5的内容，有序列表C-5的内容。

有序列表C-5的内容，有序列表C-5的内容，有序列表C-5的内容，有序列表C-5的内容。 ^C-8

有序列表C-5的内容，有序列表C-5的内容，有序列表C-5的内容，有序列表C-5的内容。 ^C-9

[[#^C-5]]——有效 [[#^C-6]]——无效 [[#^C-7]] ——无效
[[#^C-8]]——有效 [[#^C-9]]——无效
PS: 中间一定要有（shift+enter）产生的空行，否则^C-5、^C-6、^C-8无法被识别为“块末尾”

标题D

XXXXXXXX（简单的词作为概括） ^0-D
- 有序列表D的内容，有序列表D的内容，有序列表D的内容，有序列表D的内容，有序列表D的内容，有序列表D的内容，有序列表D的内容，有序列表D的内容，有序列表D的内容，有序列表D的内容。 ^Y-D
- 前后空行包围的字段D的内容，前后空行包围的字段D的内容，前后空行包围的字段D的内容，前后空行包围的字段D的内容，前后空行包围的字段D的内容，前后空行包围的字段D的内容，前后空行包围的字段D的内容，前后空行包围的字段D的内容，前后空行包围的字段D的内容，前后空行包围的字段D的内容，前后空行包围的字段D的内容，前后空行包围的字段D的内容。 ^K-D
- 无序列表D的内容，无序列表D的内容，无序列表D的内容，无序列表D的内容。 ^W-D

标题D测试区域（嵌套结构，按照此结构）
[[#^0-D]] [[#^y-D]] [[#^k-D]] [[#^w-D]]
建立列表进行嵌套后，引用第一行的父无列表——链接全部
建立列表进行嵌套后，引用第一点的子列表——链接原来的有序列表内容

标题E

有序列表E的内容，有序列表E的内容，有序列表E的内容，有序列表E的内容，有序列表E的内容，有序列表E的内容，有序列表E的内容，有序列表E的内容，有序列表E的内容，有序列表E的内容。

前后空行包围的字段E的内容，前后空行包围的字段E的内容，前后空行包围的字段E的内容，前后空行包围的字段E的内容，前后空行包围的字段E的内容，前后空行包围的字段E的内容，前后空行包围的字段E的内容，前后空行包围的字段E的内容，前后空行包围的字段E的内容，前后空行包围的字段E的内容，前后空行包围的字段E的内容，前后空行包围的字段E的内容。 ^K-E
- 无序列表E的内容，无序列表E的内容，无序列表E的内容，无序列表E的内容。 ^W-E

标题E测试区域
[[#^K-E]] [[#^w-E]]

标题F

有序列表F的内容，有序列表F的内容，有序列表F的内容，有序列表F的内容，有序列表F的内容，有序列表F的内容，有序列表F的内容，有序列表F的内容，有序列表F的内容，有序列表F的内容。 ^Y-F
前后空行包围的字段F的内容，前后空行包围的字段F的内容，前后空行包围的字段F的内容，前后空行包围的字段F的内容，前后空行包围的字段F的内容，前后空行包围的字段F的内容，前后空行包围的字段F的内容，前后空行包围的字段F的内容，前后空行包围的字段F的内容，前后空行包围的字段F的内容，前后空行包围的字段F的内容，前后空行包围的字段F的内容。 ^K-F
- 无序列表F的内容，无序列表F的内容，无序列表F的内容，无序列表F的内容。 ^W-F

编辑模式下前后空行包围的字段F和无序列表F之间加换行显示（shift+enter）产生的空行，阅览模式（渲染）结果都一样

有序列表F的内容，有序列表F的内容，有序列表F的内容，有序列表F的内容，有序列表F的内容，有序列表F的内容，有序列表F的内容，有序列表F的内容，有序列表F的内容，有序列表F的内容。 ^Y-F-1
前后空行包围的字段F的内容，前后空行包围的字段F的内容，前后空行包围的字段F的内容，前后空行包围的字段F的内容，前后空行包围的字段F的内容，前后空行包围的字段F的内容，前后空行包围的字段F的内容，前后空行包围的字段F的内容，前后空行包围的字段F的内容，前后空行包围的字段F的内容，前后空行包围的字段F的内容，前后空行包围的字段F的内容。 ^K-F-1
- 无序列表F的内容，无序列表F的内容，无序列表F的内容，无序列表F的内容。 ^W-F-1

标题F测试区域
[[#^Y-F]] [[#^K-F]] [[#^W-F]]
[[#^Y-F-1]] [[#^K-F-1]] [[#^w-F-1]]

标题O

对[[#标题E]]、[[#标题F]]中使用“shift+enter换行显示输入“的规律总结，换行显示（shift+enter）会影响拼合块的块末尾位置，进而影响块ID放置位置。

增加“shift+enter换行显示输入”前：

块0的内容（简单的词作为概括）
块0的进一步解释 ^0-O

增加“shift+enter换行显示输入”产生的空行后,新增块ID放置位置（块末尾）：

位置1

块0的内容（简单的词作为概括） ^1-O

块0的进一步解释

位置2

块0的内容（简单的词作为概括）

块0的进一步解释 ^2-O

PS:

如果同时在位置1、位置2插入块ID，位置1的优先于位置2，判别为块的末尾，推荐使用位置1
中间一定要有（shift+enter）产生的空行，否则^1-O无法生效

标题O测试区域
[[#^0-O]]
[[#^1-O]]
[[#^2-O]]

标题G

块0的内容（简单的词作为概括） ^0-G
- 块1的内容 ^1-G
- 块2的内容 ^2-G
  1. 块2-1的内容 ^2-1-G
  2. 块2-2的内容 ^2-2-G
  3. 块2-3的内容 ^2-3-G
- 块3的内容 ^3-G

标题G测试区域（嵌套结构，按照此结构）

说明：标题G是标题D的高度概括版本
- 对于标题G的结构，块0包含块1、2、3，三者同级；块2包含块2-1、2-2、2-3，三者同级。
- ^0-G是块0的ID，链接块0的内容及其所属下的内容，^2-G同理，链接块2的内容及其所属下的内容。
  [[#^0-G]]
  [[#^1-G]]
  [[#^2-G]] [[#^2-1-G]] [[#^2-2-G]] [[#^2-3-G]]
  [[#^3-G]]

标题H

块0的内容（简单的词作为概括）
- 块1的内容 ^1-H
- 块2的内容 ^2-H
  1. 块2-1的内容 ^2-1-H
  2. 块2-2的内容 ^2-2-H
  3. 块2-3的内容 ^2-3-H
- 块3的内容 ^3-H

^0-H

块0的内容（简单的词作为概括）
- 块1的内容 ^1-H
- 块2的内容 ^2-H
  1. 块2-1的内容 ^2-1-H
  2. 块2-2的内容 ^2-2-H
  3. 块2-3的内容 ^2-3-H
- 块3的内容 ^3-H
  ^0-H-1

标题G测试区域（标题G移动^0-G实验）
[[#^0-H]]
[[#^0-H-1]]
[[#^1-H]]
[[#^2-H]] [[#^2-1-H]] [[#^2-2-H]] [[#^2-3-H]]
[[#^3-H]]

标题I

块0的内容（简单的词作为概括）
^0-I
- 块1的内容 ^1-I
- 块2的内容 ^2-I
  1. 块2-1的内容 ^2-1-I
  2. 块2-2的内容
    ^2-2-I
  3. 块2-3的内容
    ^2-3-I
- 块3的内容
  ^3-I

标题I测试区域（标题G的块ID多加空格、换行显示（shift+enter）等实验）
[[#^0-I]]
[[#^1-I]]
[[#^2-I]] [[#^2-1-I]] [[#^2-2-I]] [[#^2-3-I]]
[[#^3-I]]

标题L

table-L1	table-L1
L1	L1

table-L2	table-L2
L2	L2

前后空行包围的字段L的内容，前后空行包围的字段L的内容 ^K-L

table-L3	table-L3
L3	L3

这是一段前后空行包围的字段

标题L测试区域（行首输入，涉及到表格，按照此结构）
[[#^table-L1]]
[[#^table-L2]]
[[#^K-L]]
[[#^table-L3]]

标题M

table-M1	table-M1
M1	M1

table-M2	table-M2
M2	M2
^table-M2

前后空行包围的字段M的内容，前后空行包围的字段M的内容
^K-M

table-M3	table-M3
M3	M3

^table-M3

这是一段前后空行包围的字段

标题M测试区域（标题M的块ID多加空格、换行显示（shift+enter）等实验）
[[#^table-M1]]
[[#^table-M2]]
[[#^K-M]]
[[#^table-M3]]

标题N

引用字段N的层级1内容，引用字段N的层级1内容，引用字段N层级1内容，引用字段N的层级1内容，引用字段N的层级1内容，引用字段N的层级1内容。 ^N-1

引用字段N的层级2-段落1内容，引用字段N的层级2-段落1内容，引用字段N的层级2-段落1内容。 ^N-2
引用字段N的层级2-段落2内容，引用字段N的层级2-段落2内容，引用字段N的层级2-段落2内容。 ^N-3

引用字段N的层级3内容 ^N-4

无序列表1的内容 ^N-5

无序列表2的内容 ^N-6

有序列表1的内容 ^N-7

有序列表2的内容 ^N-8

有序列表3的内容 ^N-9

无序列表3的内容 ^N-A

引用字段N的层级1内容，引用字段N的层级1内容，引用字段N层级1内容，引用字段N的层级1内容，引用字段N的层级1内容，引用字段N的层级1内容。 ^N-B

标题N测试区域
[[#^N-1]] [[#^N-2]] [[#^N-3]] [[#^N-4]] [[#^N-5]] [[#^N-6]] [[#^N-7]] [[#^N-8]] [[#^N-9]] [[#^N-A]] [[#^N-B]]
如上放置了多个块ID，但是并未生效，对于单独的引用，多个块末尾同时放置时块ID时，块ID优先度不同，靠后的块ID优先度大于靠后的——就后原则，只有最靠后块ID，也就是^N-B是生效的，且链接的是全部，删除^N-B，^N-A便生效。

标题P

标题N的接续

[[#标题P-0]]~[[#标题P-5]]，未加空行，从前到后依次剃掉靠前的块ID

标题P-0

有序列表P的内容，有序列表P的内容，有序列表P的内容，有序列表P的内容，有序列表P的内容，有序列表P的内容，有序列表P的内容，有序列表P的内容，有序列表P的内容，有序列表P的内容。 ^P-0
引用字段P的层级1内容，引用字段P的层级1内容，引用字段P层级1内容，引用字段P的层级1内容，引用字段P的层级1内容，引用字段P的层级1内容。 ^P-1
引用字段P的层级2-段落1内容，引用字段P的层级2-段落1内容，引用字段P的层级2-段落1内容。 ^P-2
引用字段P的层级2-段落2内容，引用字段P的层级2-段落2内容，引用字段P的层级2-段落2内容。 ^P-3
引用字段P的层级3内容 ^P-4
- 无序列表1的内容 ^P-5
- 无序列表2的内容 ^P-6
1. 有序列表1的内容 ^P-7
2. 有序列表2的内容 ^P-8
3. 有序列表3的内容 ^P-9
- 无序列表3的内容 ^P-A
引用字段P的层级1内容，引用字段P的层级1内容，引用字段P层级1内容，引用字段P的层级1内容，引用字段P的层级1内容，引用字段P的层级1内容。 ^P-B

标题P测试区域
[[#^P-0]] [[#^P-1]] [[#^P-2]] [[#^P-3]] [[#^P-4]] [[#^P-5]] [[#^P-6]] [[#^P-7]] [[#^P-8]] [[#^P-9]] [[#^P-A]] [[#^P-B]]

标题P-1

有序列表P的内容，有序列表P的内容，有序列表P的内容，有序列表P的内容，有序列表P的内容，有序列表P的内容，有序列表P的内容，有序列表P的内容，有序列表P的内容，有序列表P的内容。
引用字段P的层级1内容，引用字段P的层级1内容，引用字段P层级1内容，引用字段P的层级1内容，引用字段P的层级1内容，引用字段P的层级1内容。 ^P-1-1
引用字段P的层级2-段落1内容，引用字段P的层级2-段落1内容，引用字段P的层级2-段落1内容。 ^P-2-1
引用字段P的层级2-段落2内容，引用字段P的层级2-段落2内容，引用字段P的层级2-段落2内容。 ^P-3-1
引用字段P的层级3内容 ^P-4-1
- 无序列表1的内容 ^P-5-1
- 无序列表2的内容 ^P-6-1
1. 有序列表1的内容 ^P-7-1
2. 有序列表2的内容 ^P-8-1
3. 有序列表3的内容 ^P-9-1
- 无序列表3的内容 ^P-A-1
引用字段P的层级1内容，引用字段P的层级1内容，引用字段P层级1内容，引用字段P的层级1内容，引用字段P的层级1内容，引用字段P的层级1内容。 ^P-B-1

标题P-1测试区域
[[#^P-1-1]] [[#^P-2-1]] [[#^P-3-1]] [[#^P-4-1]] [[#^P-5-1]] [[#^P-6-1]] [[#^P-7-1]] [[#^P-8-1]] [[#^P-9-1]] [[#^P-A-1]] [[#^P-B-1]]

标题P-2

有序列表P的内容，有序列表P的内容，有序列表P的内容，有序列表P的内容，有序列表P的内容，有序列表P的内容，有序列表P的内容，有序列表P的内容，有序列表P的内容，有序列表P的内容。
引用字段P的层级1内容，引用字段P的层级1内容，引用字段P层级1内容，引用字段P的层级1内容，引用字段P的层级1内容，引用字段P的层级1内容。
引用字段P的层级2-段落1内容，引用字段P的层级2-段落1内容，引用字段P的层级2-段落1内容。 ^P-2-2
引用字段P的层级2-段落2内容，引用字段P的层级2-段落2内容，引用字段P的层级2-段落2内容。 ^P-3-2
引用字段P的层级3内容 ^P-4-2
- 无序列表1的内容 ^P-5-2
- 无序列表2的内容 ^P-6-2
1. 有序列表2的内容 ^P-7-2
2. 有序列表2的内容 ^P-8-2
3. 有序列表3的内容 ^P-9-2
- 无序列表3的内容 ^P-A-2
引用字段P的层级1内容，引用字段P的层级1内容，引用字段P层级1内容，引用字段P的层级1内容，引用字段P的层级1内容，引用字段P的层级1内容。 ^P-B-2

标题P-2测试区域
[[#^P-2-2]] [[#^P-3-2]] [[#^P-4-2]] [[#^P-5-2]] [[#^P-6-2]] [[#^P-7-2]] [[#^P-8-2]] [[#^P-9-2]] [[#^P-A-2]] [[#^P-B-2]]

标题P-3

有序列表P的内容，有序列表P的内容，有序列表P的内容，有序列表P的内容，有序列表P的内容，有序列表P的内容，有序列表P的内容，有序列表P的内容，有序列表P的内容，有序列表P的内容。
引用字段P的层级1内容，引用字段P的层级1内容，引用字段P层级1内容，引用字段P的层级1内容，引用字段P的层级1内容，引用字段P的层级1内容。
引用字段P的层级2-段落1内容，引用字段P的层级2-段落1内容，引用字段P的层级2-段落1内容。
引用字段P的层级2-段落2内容，引用字段P的层级2-段落2内容，引用字段P的层级2-段落2内容。 ^P-3-3
引用字段P的层级3内容 ^P-4-3
- 无序列表1的内容 ^P-5-3
- 无序列表2的内容 ^P-6-3
1. 有序列表3的内容 ^P-7-3
2. 有序列表3的内容 ^P-8-3
3. 有序列表3的内容 ^P-9-3
- 无序列表3的内容 ^P-A-3
引用字段P的层级1内容，引用字段P的层级1内容，引用字段P层级1内容，引用字段P的层级1内容，引用字段P的层级1内容，引用字段P的层级1内容。 ^P-B-3

标题P-3测试区域
[[#^P-3-3]] [[#^P-4-3]] [[#^P-5-3]] [[#^P-6-3]] [[#^P-7-3]] [[#^P-8-3]] [[#^P-9-3]] [[#^P-A-3]] [[#^P-B-3]]

标题P-4

有序列表P的内容，有序列表P的内容，有序列表P的内容，有序列表P的内容，有序列表P的内容，有序列表P的内容，有序列表P的内容，有序列表P的内容，有序列表P的内容，有序列表P的内容。
引用字段P的层级1内容，引用字段P的层级1内容，引用字段P层级1内容，引用字段P的层级1内容，引用字段P的层级1内容，引用字段P的层级1内容。
引用字段P的层级2-段落1内容，引用字段P的层级2-段落1内容，引用字段P的层级2-段落1内容。
引用字段P的层级2-段落2内容，引用字段P的层级2-段落2内容，引用字段P的层级2-段落2内容。
引用字段P的层级3内容 ^P-4-4
- 无序列表1的内容 ^P-5-4
- 无序列表2的内容 ^P-6-4
1. 有序列表3的内容 ^P-7-4
2. 有序列表3的内容 ^P-8-4
3. 有序列表3的内容 ^P-9-4
- 无序列表3的内容 ^P-A-4
引用字段P的层级1内容，引用字段P的层级1内容，引用字段P层级1内容，引用字段P的层级1内容，引用字段P的层级1内容，引用字段P的层级1内容。 ^P-B-4

标题P-4测试区域
[[#^P-4-4]] [[#^P-5-4]] [[#^P-6-4]] [[#^P-7-4]] [[#^P-8-4]] [[#^P-9-4]] [[#^P-A-4]] [[#^P-B-4]]

标题P-5

有序列表P的内容，有序列表P的内容，有序列表P的内容，有序列表P的内容，有序列表P的内容，有序列表P的内容，有序列表P的内容，有序列表P的内容，有序列表P的内容，有序列表P的内容。
引用字段P的层级1内容，引用字段P的层级1内容，引用字段P层级1内容，引用字段P的层级1内容，引用字段P的层级1内容，引用字段P的层级1内容。
引用字段P的层级2-段落1内容，引用字段P的层级2-段落1内容，引用字段P的层级2-段落1内容。
引用字段P的层级2-段落2内容，引用字段P的层级2-段落2内容，引用字段P的层级2-段落2内容。
引用字段P的层级3内容
- 无序列表1的内容 ^P-5-5
- 无序列表2的内容 ^P-6-5
1. 有序列表3的内容 ^P-7-5
2. 有序列表3的内容 ^P-8-5
3. 有序列表3的内容 ^P-9-5
- 无序列表3的内容 ^P-A-5
引用字段P的层级1内容，引用字段P的层级1内容，引用字段P层级1内容，引用字段P的层级1内容，引用字段P的层级1内容，引用字段P的层级1内容。 ^P-B-5

标题P-5测试区域
[[#^P-5-5]] [[#^P-6-5]] [[#^P-7-5]] [[#^P-8-5]] [[#^P-9-5]] [[#^P-A-5]] [[#^P-B-5]]

让无法生效的^P-2变为生效

标题P-6

有序列表P的内容，有序列表P的内容，有序列表P的内容，有序列表P的内容，有序列表P的内容，有序列表P的内容，有序列表P的内容，有序列表P的内容，有序列表P的内容，有序列表P的内容。
引用字段P的层级1内容，引用字段P的层级1内容，引用字段P层级1内容，引用字段P的层级1内容，引用字段P的层级1内容，引用字段P的层级1内容。
引用字段P的层级2-段落1内容，引用字段P的层级2-段落1内容，引用字段P的层级2-段落1内容。 ^P-2-6

引用字段P的层级2-段落2内容，引用字段P的层级2-段落2内容，引用字段P的层级2-段落2内容。 ^P-3-6
引用字段P的层级3内容 ^P-4-6
- 无序列表1的内容 ^P-5-6
- 无序列表2的内容 ^P-6-6
1. 有序列表2的内容 ^P-7-6
2. 有序列表2的内容 ^P-8-6
3. 有序列表3的内容 ^P-9-6
- 无序列表3的内容 ^P-A-6
引用字段P的层级1内容，引用字段P的层级1内容，引用字段P层级1内容，引用字段P的层级1内容，引用字段P的层级1内容，引用字段P的层级1内容。 ^P-B-6

标题P-6测试区域
[[#^P-2-6]] [[#^P-3-6]] [[#^P-4-6]] [[#^P-5-6]] [[#^P-6-6]] [[#^P-7-6]] [[#^P-8-6]] [[#^P-9-6]] [[#^P-A-6]] [[#^P-B-6]]

标题Q

错误示例Q-1： 前后无enter产生的空行

无序列表Q-1的内容，无序列表Q-1的内容，无序列表Q-1的内容，无序列表Q-1的内容。 ^Q-1
无序列表Q-2的内容，无序列表Q-2的内容，无序列表Q-2的内容，无序列表Q-2的内容。 ^Q-2
无序列表Q-3的内容，无序列表Q-3的内容，无序列表Q-3的内容，无序列表Q-3的内容。 ^Q-3

错误示例Q-2： 部分前后有enter产生的空行，注意在渲染模式（实时阅览）下，无序列表Q-3受未正确使用的 影响，并未渲染成功。

无序列表Q-1的内容，无序列表Q-1的内容，无序列表Q-1的内容，无序列表Q-1的内容。 ^Q-1-1
无序列表Q-2的内容，无序列表Q-2的内容，无序列表Q-2的内容，无序列表Q-2的内容。 ^Q-2-1

- `无序列表`Q-3的内容，`无序列表`Q-3的内容，`无序列表`Q-3的内容，`无序列表`Q-3的内容。 ^Q-3-1

正确示例：

无序列表Q-3的内容，无序列表Q-3的内容，无序列表Q-3的内容，无序列表Q-3的内容。 ^Q-1-3

无序列表Q-2的内容，无序列表Q-2的内容，无序列表Q-2的内容，无序列表Q-2的内容。 ^Q-2-3

无序列表Q-3的内容，无序列表Q-3的内容，无序列表Q-3的内容，无序列表Q-3的内容。 ^Q-3-3

标题O测试区域
[[#^Q-1]] 渲染模式（阅读视图）下，此ID会显示——未正确识别
[[#^Q-2]] 渲染模式（阅读视图）下，此ID会显示——未正确识别
[[#^Q-3]]

[[#^Q-1-1]] 渲染模式（阅读视图）下，此ID会显示——未正确识别
[[#^Q-2-1]]
[[#^Q-3-1]] 渲染模式（阅读视图）下，此ID会显示——未正确识别

[[#^Q-1-3]]
[[#^Q-2-3]]
[[#^Q-3-3]]

bedrock · 2023 年6 月 17 日 11:49

很详细很有用的内容

Guts · 2023 年6 月 24 日 04:13

感谢你的观看，如果错误记得提出哈

OAoQbT7sclzqmoF7 · 2023 年7 月 6 日 02:47

楼主分享一个示例库，万分感激

Guts · 2023 年7 月 6 日 03:19

用蓝奏云分享了下，其实就是这篇文章，记得放到OB的库中打开
https://wwqd.lanzoul.com/i8q1t11g54oh

Tommy1 · 2024 年4 月 30 日 09:40

请问引用块链接的时候能展示为链接的名字吗，现在展示为链接的id很不直观

比如如下标题为"自我介绍"的文章，引用的时候会展示为 “自我介绍^2323433”, 有没有办法展示为 “自我介绍^职业经历”

标题为"自我介绍"的文章内容：

职业经历

^2323433

Tommy1 · 2024 年4 月 30 日 09:59

我的问题解决了，我应该使用链接到标题。而不用块

单独#连接标题
单独^链接块

不使用#^，你试试