1. 各种笔记种「线索太多」容易遗忘正在做的事情，例如未完成的摘要、写一半的博客、定期整理的「闪念胶囊」等。
2. 各种相关 Todo 散落在笔记中，记不清也找不全，导致许多任务无法完成或推进。

• 进行中的Blog
• 未完成的摘录
• 未进行的稍后读
• 最新的「间歇式日记」
• 最近改过的文章
• ...

使用 Dataview 可以从 Obsidian 的文件库中查询内容（标题/正文/Todo）并可将内容应用于新的文件。

• Enable JavaScript Queries：启用或禁用执行 DataviewJS 代码进行查询。
• Enable Inline JavaScript Queries：启用或禁用执行内联DataviewJS查询。要求启用「Enable JavaScript Queries」。
• Enable Inline Field Highlighting：启用或禁用内联字段的视觉高亮显示以及渲染。

• HomePage-Left
• HomePage-Right

• 未完成的 Blog
• 未完成的摘录
• 所有归档

• tags: 可以设置笔记的「标签」，多个标签用逗号分割。
• genre: 标记文章的类型我用到的包括少数派专栏、Podcast、Newsletter。大家记住这个字段，后边会用到。
• Link：将来文章发布了，可以将链接补充到这里。

---
alias: "document"
last-reviewed: 2021-08-17
thoughts:
  rating: 8
  reviewable: false
---

Obsidian 支持标签嵌套，例如标签 Blog 代表这篇笔记是一篇「博客」，标签 Done 代表这篇博客已经完成并且发布了。通常情况下我们给一篇「已经发表的博客笔记」设置两个标签 Blog 和 Done，而嵌套标签就很简单，只需要设置 Blog\Done 这一个标签即可。

• let：关键字，表示在其后要声明一个变量。
• pages：变量名，其值为「所有包含 #Blog 但是不包含 #Blog\Done 的笔记」，即未完成的 Blog。
• dv.pages：函数名，此函数将执行括号中的「查询语句」，查询结果为「符合语句的所有笔记数组」。
• "#Blog and -#Blog/Done"：查询语句，可以按照 and 拆成两部分看。
  • #Blog：左侧查询条件，即查询所有包含标签 #Blog的笔记。
  • and：「逻辑与」，代表查询条件同时满足左边 #Blog 和右边 -#Blog\Done。
  • -#Blog\Done：右侧查询条件，代表所有「不包含」标签 #Blog\Done 的笔记。注意 - 代表不包含。

dv.pages 是一个 JavaScript 函数，它的用法是查询「符合条件」的笔记，最终返回包含所有笔记的数组。

• dv.pages() => 「文件仓库」中所有笔记，以下默认都是在「文件仓库」中查询。
• dv.pages("#books") => 所有标签是 #books 的笔记。
• dv.pages('"folder"') => 所有在名为 folder 的文件夹下的笔记。
• dv.pages("#yes or -#no") => 所有包含 #yes 但是不包含 #no的笔记。
• dv.pages('"folder" or #tag') => 所有在 folder文件夹下的笔记「或者」标签包含 #tag 的笔记。

• dv.table：函数名，此函数会在笔记中输出一张表格。
• ["Name","genre"]：函数 dv.table 的第一个参数，指定了表格的两个字段，分别是笔记标题（双向链接的形式）和笔记类型（即前文中提到的「元数据」中的 'genre' 字段，忘记了可以返回去看一下）。
• pages.sort：函数名，即将变量 pages （所有未完成的 Blog 笔记）中的笔记进行排序，排序规则在下文。
  • b=> 这里的 b 可以用任何字母代替，它有一些抽象，实际上 b 所指代的就是 pages 中的「每一篇笔记」。大家理解了这一点大家往下看就清晰了。
  • b.file.mtime：指定使用「每一篇笔记」的 file.mtime 字段进行排序，b.file.mtime 指的事笔记的「最后修改时间」。这里用到了 dataview 插件中的「隐式字段」下文有详细介绍。
  • desc：指定「排序规则」为「倒排」或者「降序」。具体到当前就是指按照 b.file.mtime 「每篇笔记的最后修改时间」倒排，最新修改的笔记在表格最上边。
• .map：函数名，它等同于 pages.sort(b=> b.file.mtime,"desc").map()，即对上一步「排序后」的所有笔记进行「重组」，只返回每篇笔记的「指定字段」（见下文）。
  • b=> 这里的 b 可以用任何字母代替，它依然代表 pages 中的「每一篇笔记」。其后的数组 [b.file.link,b.genre] 代表重组后的字段。
  • b.file.link：它的意思是「指向笔记的链接」，即返回「排序后」的笔记中的每一个笔记的「双向链接」值（类似 [[笔记1]]）。它对应的就是表格中的第一个字段 Name  。
  • b.genre：它的意思是笔记的「元数据」中的 genre 字段，即返回「排序后」的笔记中的每个笔记的「元数据」中 genre 字段的值，它对应的事表格中的第二个字段 genre。
  • 综合看 .map(b=> [b.file.link,b.genre) 就相当于 pages.sort(b=> b.file.mtime,"desc").map(b=> [b.file.link,b.genre)，其意思将「排序后」的笔记变量 pages进行「重组输出」并与 dv.table 指定的两个字段对应，即返回笔记的「双向链接」和笔记「元数据」中的 genre值。

Dataview 会自动向每个页面添加大量「元数据」，这些「元数据」就是「隐式字段」。即虽然在笔记中看不到它们，但它们确实一直在笔记的「元数据」中。点此查看详情。

• file.name：笔记的标题。
• file.folder：此文件所属文件夹的路径。
• file.path：完整文件路径（字符串）。
• file.link：指向文件的链接（链接）。
• file.size：文件的大小（字节）（数字）。
• file.ctime：创建文件的日期（日期+时间）。
• file.cday：创建文件的日期（只是一个日期）。
• file.mtime：上次修改文件的日期（日期+时间）。
• file.mday：上次修改文件的日期（只是一个日期）。
• file.tags：笔记中所有独特的标签的数组。副标签按级别细分，所以#Tag/1/A 将以[#Tag, #Tag/1, #Tag/1/A] 的形式存储在数组中。
• file.etags：笔记中所有显式标签的数组；与 file.tags 不同，不包括副标签。
• file.inlinks：包含当前笔记「双向链接」的其他笔记。
• file.outlinks：笔记中所有包含的双向链接、附件。
• file.aliases：当前笔记的所有「别名」，结果是数组形式。
• file.tasks：当前笔记所有「任务」组成的数组。例如 - [ ] blah blah blah。

• 第一部分：获取「所有标签为 #Blog 但同时不包含 #Blog\Done 的笔记」，并赋值给变量 pages。
• 第二部分：循环数组变量 pages，并输出「每一篇笔记」的「双向链接」和「元数据」中的 genre 字段值，组成一张表格。

---
author : "Kostas Farkonas"

link : "https://medium.com/geekculture/an-ipad-pro-pro-mode-may-sound-nice-but-it-all-depends-5262aa882f23"

publisher : "medium" 

date :  "2022.05.12"

tags : ["waiting","iPadpro"]

type: "Extracts"
---

• author：文章作者。
• link：原文 URL 地址。
• publisher：原文发行机构。
• date：文章摘录日期。
• tags：设置笔记的标签
  • waiting：代表文章摘录中。
  • Done：代表文章摘录完成。
• type：笔记类型， "Extracts" 代表这是一篇「摘录笔记」。

• dv.table：函数名，此函数会在笔记中输出一张表格。
• ["Name","author","publisher","Create Time"]：函数 dv.table 的第一个参数，指定表格的字段名，分别是笔记标题（双向链接的形式）、文章作者、发布平台、创建笔记的时间。
• dv.pages("#waiting")：这部分相当于获得了一个笔记数组变量，其内容是所有包含标签 #waiting 的笔记。
• .where：函数名，它等同于 dv.pages("#waiting").where，即在上一步dv.pages("#waiting") 得到的「数组变量」基础上，再按照指定的「条件」进行查询，其条件就是函数的参数：.where(b=> b.type=="Extracts")。
  • b=>：这里的 b 可以用任何字母代替，实际上 b 所指代的就是 pages 中的「每一篇笔记」。
  • b.type=="Extracts"：指定了 .where 的查询条件，其中 b.type 代表笔记「元数据」中 type 的值，这里的意思是查询条件为「笔记的元数据中 type 值等于 Extracts 」。
  • 综合看 .where(b=> b.type=="Extracts") 就相当于 dv.pages("#waiting").where(b=> b.type=="Extracts")，其意思就是在所有包含标签 #waiting 的笔记中，查询所有「元数据」中 type 等于 Extracts 的笔记。
• .sort：函数名，它等同于 dv.pages("#waiting").where(b=> b.type=="Extracts").sort()，即将上一步查询后后得到的「数组变量」按照一定规则进行排序。
  • b=>：这里的 b 可以用任何字母代替，它依然代表「数组变量」中的「每一篇笔记」。
  • b.file.mtime：它的意思是「笔记的最后修改时间」，这里代表使用「笔记的最后修改时间」进行排序。这里依然用到了 dataview 中的「隐式字段」。
  • desc：指定「排序规则」为「倒排」或者「降序」。具体到当前就是指按照 file.mtime 「笔记的最后修改时间」倒排，最新的修改的笔记在表格最上边。
  • 综合看 .sort(b=> b.file.mtime,"desc") 就相当于 dv.pages("#waiting").where(b=> b.type=="Extracts").sort(b=> b.file.mtime,"desc")，其意思就是在所有包含标签 #waiting 的笔记中，查询所有「元数据」中 type 等于 Extracts 的笔记，并且按照「笔记的最后修改时间」b.file.mtime 倒序排序。
• .map：函数名，它等同于 dv.pages("#waiting").where(b=> b.type=="Extracts").sort(b=> b.file.mtime,"desc").map()，即对上一步「排序后」的所有笔记进行「重组」，只返回每个笔记的「指定字段」（见下文）。
  • b=>：这里的 b 可以用任何字母代替，它依然代表 pages 中的「每一篇笔记」。
  • b.file.link：它的意思是「指向笔记的链接」，即返回「排序后」的「数组变量」中的每一篇笔记的「双向链接」值（类似 [[笔记1]]）。它对应的就是表格中的第一个字段 Name 。
  • b.author：它的意思是笔记的「元数据」中的 author 字段值（作者），即返回「排序后」的每一篇笔记的「元数据」中的 author 字段的值。它对应的事表格中的第二个字段 author。
  • b.publisher：它的意思是笔记的「元数据」中的 publisher 字段值（发行机构），即返回「排序后」的每一篇笔记的「元数据」中 publisher 字段的值。它对应的事表格中的第三个字段 publisher。
  • b.file.ctime：它的意思是笔记的「创建时间」，即返回「排序后」的每一篇笔记的「创建时间」。它对应的事表格中的第四个字段 Create Time。
  • 综合看，.map(b => [b.file.link,b.author,b.publisher,b.file.ctime]) 的意思就是将上一步「排序后」的「数组变量」进行「重组输出」并与 dv.table 指定的四个字段对应，即返回笔记的双向链接、原文的作者、原文发行机构、笔记的创建时间。

• 第一部分，执行函数 dv.table ，并设定函数「输出表格」的字段。
• 第二部分，得到 dv.pages 数组变量，其值等于所有标签为 #waiting 的笔记。
• 第三部分，按照条件 b.type=="Extracts" ，进一步查询 dv.pages 数组变量中笔记的「元数据」中的 type 值等于 Extracts 的笔记。
• 第四部分，按照「笔记的最后修改时间」 b.file.mtime 进行「倒序」。
• 第五部分，重组 dv.pages 数组变量，只输出指定的四个字段 b.file.link,b.author,b.publisher,b.file.ctime。

• dv.table：函数名，此函数会在笔记中输出一个表格。
• ["Name","Modified Date"]：指定表格的字段名，分别是笔记的「双向链接」和笔记的「修改时间」。
• dv.pages("#Done")：查询所有包含标签 #Done 的笔记。
• .sort(b => b.file.mtime,"desc")：排序函数，将上一步获得的「数组变量」按照「笔记最后修改时间」b.file.mtime 进行「倒排」。
• .map(b => [b.file.link,b.file.mtime])：重组函数，将上一步排序后的「数组变量」重组，只返回笔记的「双向链接」和笔记的「最后修改时间」。
• .limit(10)：限制返回行数，指定「排序」并「重组」后的「数组变量」返回的行数，这里限制只返回 10 条数据。

• 第一部分，执行函数 dv.table，并设定函数「输出表格」的字段。
• 第二部分，得到 dv.pages 数组变量，其值等于所有标签为 #Done 的笔记。
• 第三部分，按照「笔记的修改时间」 b.file.mtime 进行「倒序」。
• 第四部分，重组排序后的 dv.pages 数组变量，只输出指定的两个字段 b.file.link，b.file.mtime。
• 第五部分，设置数组变量的返回值数量为 10 条。

• Daily
• 最近修改
• 稍后读
• 闪念胶囊 Todo
• 其他未完成任务

• LIST：关键字，指的是查询一段内容，并按照列表进行展示（注意列表并不是表格，他没有表头等信息）。
• From "Daily"：指定「查询源」，例如本例中 From "Daily"，即「查询名为 Daily 的文件夹下的所有笔记」。
• sort：排序关键字
  • file.mtime：指定排序字段，本例中指的是按照「文件的最后修改时间」排序。
  • desc：排序关键字，desc 指的是「倒排」，本例中指的是按照「文件最后修改时间倒排」，即最新修改的在最上边。
• limit (5)：指定返回列表的数量，本例中指的是在所有符合条件的笔记中（文件夹 Daily 下所有按照「最后修改时间倒排」后的笔记列表）只返回5条。
• 综合看，整个语句的意思是「查询 Daily 文件夹下所有笔记，只返回最新修改的5篇笔记」。

• LIST：关键字，指的是查询一段内容，并按照列表进行展示。
• WHERE：关键字，代表其后的内容就是查询条件。这次没有 From 关键字，代表这次是从「所有笔记」中查询。
  • file.mtime >= date(today) - dur(10 day)：此段语法指明了「文件最后修改时间」要在10天内（注意代码中的 >=）。
• sort：排序关键字
  • file.mtime：指定排序字段，本例中指的是按照「文件的最后修改时间」排序。
  • desc：排序关键字，desc 指的是「倒排」，本例中指的是按照「文件最后修改时间倒排」，最新修改的在最上边。
• limit (5)：指定返回列表的数量。
• 综合看，整个语句的意思是「查询所有最后修改时间在10天内的笔记，并且只返回5条」。

• dv.pages().file.tasks.where(t => !t.completed)

• 条件1：在所有包含标签 #稍后读 的笔记中查询，语句：dv.pages("#稍后读")。
• 条件2：循环每一篇笔记，找到所有未完成的任务，语句：file.tasks.where(t => !t.completed)。

• dv.table：函数名，此函数会在笔记中输出一个表格。
• ["Task","Name"]：指定表格的字段名，分别是任务标题和笔记的「双向链接」。
• dv.pages("#稍后读")：查询所有包含标签 #稍后读 的笔记。
• file.tasks：这是个新的语法，它返回当前笔记的「所有任务」（也就是 Todo），跟在 dv.pages("#稍后读") 后，代表我们将得到一个「数组变量」，其中每一条就是一条「任务」，通俗的说这将得到「所有包含 #稍后读 的笔记中的所有任务」。
• .where：函数名，它等同于 dv.pages("#稍后读")file.tasks.where，即在上一步得到的「所有包含 #稍后读 的笔记中的所有任务」基础上，再按照指定的「条件」进行查询。
  • t=>：这里的 t 可以用任何字母代替，它代指上文中「所有包含 #稍后读 的笔记中的所有任务」中的「每一条任务」。
  • !t.completed：第一个查询条件也成为「表达式」， !t.completed 代表查询条件为「未完成的任务」，我们拆开看 t.completed 属于 JavaScript 的简写语法，写全了就是 t.completed == true，在语句前加上 ! ，代表对 t.completed == true 「取反」，写全了相当于 t.completed == false，即任务完成状态是「未完成」。
  • &&：关键字「逻辑与」，代表 && 左边 !t.completed 和右边 t.text.indexOf("#稍后读")>0 两个查询条件必须同时满足（即两个表达式得到 true)，与之相反的还有 || 「逻辑或」，即左边和右边满足任意一边即可(即两个表达式任意一个得到 true）。
  • t.text.indexOf("#稍后读")>0：第二个查询条件，它代表查询条件为「任务标题包含关键字#稍后读」，其中 t.text 代表「任务详情」，.indexOf("#稍后读")>0 就是典型的 JavaScript 语法，代表「任务详情中包含关键字#稍后读。
  • .map(b => ["[ ] - " + b.text,b.link])：重组函数，将上一步符合条件的笔记中的任务重组，分为两部分：
    • 有一点特别注意，此处是按照「每条任务」进行输出，而不是之前的「每篇笔记」，原因是这些语句都在 .file.tasks 之后。
    • "[ ] - " + b.text：在任务标题前加上 [ ] -这样输出的时候样式看起来更像一条任务。此表达式对应表格的第一个字段。
    • b.link：笔记的链接，此表达式对应表格的第二个字段。
• 综合看，语句查询所有包含 #稍后读 标签的笔记，并过滤笔记中的「所有任务」，只输出状态是「未完成」且「任务标题包含 稍后读 关键字」的 Todo。最后输出到表格中，第一列展示任务的标题，第二列展示任务所在的笔记的「双向链接」。

1. 其他任务指的是除了「闪念胶囊」和「稍后读」之外的 Todo，可以使用「不包含某标签」的查询语句。
2. 代码上可以参考「未完成的 Blog」部分。

• 问题1：各种笔记种「线索太多」容易遗忘正在做的事情，例如未完成的摘要、写一半的博客、定期整理的「闪念胶囊」等。
• 问题2：各种相关 Todo 散落在笔记中，记不清也找不全，导致许多任务无法完成或推进。

• 少数派专栏 - 知识管理之术
• 闲者时间博客
• 闲者时间 Medium

• 《玩转 Obsidian 01：用 Obsidian 打造「知识循环」利器》
• 《玩转 Obsidian 02：基础设置篇》
• 《玩转 Obsidian 03：如何记录「间歇式日记」》
• 《玩转 Obsidian 04：为什么推荐使用 Obsidian 做知识管理》
• 《玩转 Obsidian 05：如何进行阅读及摘要》
• 《玩转 Obsidian 06：如何用 Obsidian 进行渐进式总结》
• 《玩转 Obsidian 07 ：自动化「间歇式日记」》
• 《玩转 Obsidian 08：利用 Dataview 打造自动化 HomePage》