网页版:整篇 来源:n8n 官方文档 + 入门课 9 讲 | 逐讲整理,节点名与参数照官方 | 本地源 kb/md/n8n-入门课.md | 【20240619 update - Total 2:10:12 】
主线 把重复工作变成「可维护的自动化」,关键不在节点多少,而在三件事:数据怎么在节点之间流动、错了怎么办、多人怎么协作。
从「会拖节点」到「看懂数据流」——n8n 里每个节点收发的是一组 item(JSON 数组),结构决定下一个节点能不能接。
从「能跑」到「能维护」——错误处理、重试、调试;节点只是零件,工作流的可靠性靠异常分支。
从「个人玩具」到「团队资产」——协作、版本、权限。
层次 从下往上读:
| 层 | 内容 | 本辑对应 | 读它的用处在哪 |
|---|---|---|---|
| 模型层 | 节点、数据、Webhook、API | 第 1–4 讲 | 知道每一步在传什么 |
| 工程层 | 错误处理、调试、重试 | 第 5–7 讲 | 让流程在出错时不静默 |
| 协作层 | 团队与版本 | 第 8–9 讲 | 让别人也能接手 |
怎么打开:抖音/B站/视频号链接直接播放;PDF 与论文链接给原文。本主题每条的深蒸馏都在下方正文,整篇网页版见文末。
基础概念(第 1、2 讲)(2 条 · 已深蒸馏 2)
节点与数据(第 3、4 讲)(2 条 · 已深蒸馏 2)
核心与常用节点(第 5、6 讲)(2 条 · 已深蒸馏 2)
稳定性与协作(第 7、8、9 讲)(3 条 · 已深蒸馏 3)
这一组不碰界面,只讲机制。第 1 讲给「自动化」一个可操作的定义,第 2 讲说清系统之间怎么对话(API 与 Webhook)。两讲合起来回答一个问题:什么事情能被自动化,以及自动化的零件是什么。
12:47 | 系列第 1 / 9 讲 | 看原视频
这一讲的位置:整门课的入门篇,不碰任何 n8n 操作界面,只讲三件事——为什么需要自动化、自动化的定义、以及一条工作流的构成要素(触发器 / 过滤 / 动作)。真正的价值在于它给了一套判断「什么能自动化、什么不能」的标准,这套标准对你本机的 automation 体系直接适用。
讲师的切入点是「决策质量」,不是「省人力」。
对应原片约 00:40 – 03:10
讲师开篇没有讲工具,先讲了为什么。核心论点:自动化的全部意义在于让决策变成 data-driven(数据驱动)。
靠感觉或直觉做决策的问题在于——它主观:结果是可被不同解释的(subject to interpretation),既难以估算、也难以向人证明 ROI,而且常常浪费资源,不管是预算还是时间。
而数据驱动的方式更偏逻辑、更客观:汇报能力更强、ROI 可见度更高,同时所需的人力、预算、时间都更少。所以自动化是「成为数据驱动组织」的那把钥匙,它本身不是目的。
接着他把手工执行的代价列清楚了:大量时间被浪费、重复的低价值任务带来人为错误、人力需求高,最终导致员工幸福感和留存率低——他举的例子很具体:「没人乐意把一个表格的数据复制到另一个表格里」。
接入自动化之后的收益:更强的可预测性和数据可用性、员工效率提升(每个人可以把精力放在更高价值的事上)、ROI 更高、人力需求更少。
这一段的判据可以直接用来审你自己的 automation 清单:哪些是真的在支撑决策,哪些只是在「有个东西每天响一下」。
按讲师的标准,你现在最健康的几条是 11:20 早间合并简报、13:50 投资午报——它们把盘面和持仓变成可比较的数字。而吃药提醒这类,本质是「定时器」不是「自动化」,它不产生任何数据。这不是说要删,而是要知道它不属于这一类,别拿它当 automation 体系建设成果来算。
另一个更尖锐的用法:你之前定的「每天 ≤5 次通知」一直没做到,根子就在这里——那些通知里有一部分是「为了有输出而输出」,并不服务于某个决策。用「这条消息让我做了什么决定」来筛,比用条数来砍更准。
一个定义 + 两个反例,把边界划清楚。
对应原片约 03:10 – 05:20
他先给了书面定义:automation is a predictable set of predetermined actions that transfers data from one point to another(自动化是一组可预测的预定动作,把数据从一个点转移到另一个点)。
然后立刻说这个定义太啰嗦,改用例子讲。例子是一条真实工作流:
表单提交→判断公司类型
├ 找不到公司 → 忽略(结束)
├ 低价值公司 → 加入邮件序列
├ 高价值公司 → 写入 Google Sheet
└ 理想客户 → 立刻通知客户经理(Slack)他指出这条流程恰好满足定义的两个条件:① 动作是可预测、预先确定的(按公司类型走固定分支);② 数据发生了转移(从表单出发,落到邮件工具、Google Sheets 或 Slack)。
反过来推,两个反例说明这两个条件都是必需品:
如果动作不可预测——每个分支都得由人现场判断「这家公司算哪一类」,那就无法自动化,因为永远需要人工介入。如果没有数据传输——那根本什么都没在自动化。
这条定义给了一个非常好用的自检工具:拿任何一个你想自动化的任务,问两句话——「它的每一步是不是预先定死的」「它有没有产出可被下游消费的数据」。
用它检查你自己的体系,会发现一个很值得注意的结论:你昨天做的 Prompt 层改造(把 22:55 那条 1400 字的 prompt 压成 230 字、六步下沉进 publish_reading_html.py),本质就是把一个「动作不可预测」的流程改造成「可预测的预定动作集」。模型每次读 prompt 再拼命令,就是不可预测;脚本固定执行,就是可预测。n8n 这门课的第一讲,刚好把你昨天凭直觉做对的事讲出了原理。
反过来也解释了那个一直修不好的问题:受控路由-dual 报「受控执行上下文核验失败」,退出码 2——它卡在的正是「上下文是否合格」这个需要判断的环节,而这一步没有变成可机检的预定动作,所以每次都要重新判断、每次都可能失败。按这门课的标准,这不叫「配置问题」,叫流程里还留着一块没被定义清楚的动作。
触发器(启动)→ 过滤(分流)→ 动作(产出)。这三个概念构成后面八讲的全部地基。
对应原片约 05:20 – 07:00
Trigger 是启动自动化的东西。回到刚才的表单例子,触发器就是「表单被提交」。
他给了一个画图时的识别技巧:画这些流程时,触发器不会有入口箭头,只有出口箭头——因为没有任何东西在它之前。
触发器分三类:
① 手动触发:人点一下才跑。
② 定时触发:每分钟、每天早 8 点、每月某日 16 点。
③ 应用事件触发:收到 webhook、CRM 里某个属性被更新、表单被提交。
最后给了 n8n 的具体节点作例:n8n Form Trigger,用 n8n 自带的表单,提交就触发工作流。
你的 loops.md 里那张表有「触发」这一列,正好可以按这三类重新归一次:
定时类:08:40 日程阅读、11:20 简报、13:50 午报、22:45 深蒸馏、22:55 精读页发布——对应「每天 X 点」。
事件类:VA7 作者跟读(有新作品才动)、待确认超时提醒(有超时才发)、看门狗(检测到超时任务才发)——这些其实是「条件触发」,比纯定时更健康,因为它们可能什么都不做。
手动类:真正该手动的是那些「你说一句才做」的,比如现在的深蒸馏补跑、精读页重建。
这里有个可以直接用的判断:如果一个 loop 是纯定时、且每次都必然有输出,它大概是在制造噪音;如果是事件型、可能静默,它才是在做正事。你 3 条每小时静默检查就是后者,这也是为什么它们从不烦你。
另外「触发器只有出口没有入口」这个画图规则,可以拿来检查你有没有搞错起点。比如「每日任务总览 22:00」,它的真正起点不是 22 点这个时间,而是「今天有没有任务变化」——如果今天什么都没变,它照样推一条,那它的触发器就设计错了。
对应原片约 07:00 – 07:50
Filtering 是「按条件允许或阻止某类数据走特定路径」。
用前面的例子:按公司类型分成四条路——没有公司、低价值、高价值、理想客户,各自走各自的路径。对应到 n8n 里的是 Filter 节点,顾名思义按预设条件过滤数据。
他补了一个很实际的细节:如果没有公司,工作流就不会继续,因为「没有东西可做」。这听起来是废话,但在真实搭建时,这正是最容易漏掉的一条分支——大多数人只画了「有公司时怎么走」,忘了「什么都没有时怎么停」。
你体系里最标准的一个 Filter 就是 trading-day.py:非交易日直接静默,不发任何东西。这就是「没有东西可做时工作流不继续」的教科书实现——而且比 n8n 里的 Filter 更彻底,因为它连「空跑一次」都省了。
第二个是「今日读一条」那个视图:状态=待读 且 优先级=高,两个条件是 and 关系,等于给自己设了个双闸门。这个设计其实很值得保留——如果只有一个条件(比如只要是待读就推),队列会立刻变成噪音源。
但有一处你的过滤是缺的,值得补:「已归档 / 弃读」这条出口目前只在视图层做了,脚本层没做。也就是说 reading-queue.py 挑条目时,靠的是「状态=待读」这个条件,逻辑上没问题;但如果哪天状态字段被人手工改成别的值,脚本不会报错,只会静默跳过。这跟讲师说的「忘了画什么都没有的分支」是同一类疏忽。
对应原片约 07:50 – 09:00
Actions 让你和 web 上的应用交互,他说这是搭自动化时用得最多的部分。然后按应用逐个举例:
| 应用 | 可以做的事 |
|---|---|
| Google Sheets | 更新行、创建工作表、获取整个表格 |
| Dropbox | 上传文件、下载文件、创建文件夹、把文件从 A 夹移到 B 夹 |
| Slack | 发消息、取消息、取用户、取某个频道的全部消息 |
| Salesforce(CRM) | 取公司、取联系人、创建线索、把线索关联到公司 |
最后一句点题:用什么动作高度取决于你在用什么应用,每个应用的动作集都不一样。——这句话的意思是,动作层没有通用答案,别指望背下来,要按需查。
你的动作层其实已经相当完整,只是散在不同脚本里,没有像 n8n 这样被统一成一个「动作库」。现在实际在用的:
| 类别 | 你的实现 | 对应 n8n 的 |
|---|---|---|
| 发消息 | wecom-send.py(企微 + 飞书双发) | Slack: send message |
| 写表格 | lark-cli base record-batch-update / create | Google Sheets: update row |
| 传文件 | lark-cli drive +upload(--file-token 覆盖) | Dropbox: upload file |
| 取数据 | lark-cli base record-list | Sheets: get spreadsheet |
| 生成内容 | gen_reading_html.py / publish_reading_html.py | —(n8n 里靠 Code 节点) |
讲师那句「每个应用动作集不同、取决于你用的是什么」正好指出你这里的一个真实痛点:命令参数不统一。同样是上传,drive 要用 --file-token 覆盖、不能从 ~/.shared-agent 路径直接传(要先 cp 到 /tmp);同样是发消息,wecom-send.py 走 stdin、lark-cli 走 --file。这就是为什么我昨天建议你做「统一出口 notify.py / 统一上传 publish.py」——n8n 把这件事做成了产品级抽象,你现在还停留在「每次现查命令」。
三段式模板,任何流程都能套。
对应原片约 09:00 – 09:50
他把前面所有概念串成一条模板,说大多数工作流都遵循类似结构:
Trigger→排序 / 过滤 / 格式化 / 转换 / 分段→Actions
启动它 对数据动手(if this then that / 只在…时 / 把 A 改成 B) 更新表格、发邮件、通知人中间那段的说法值得注意:他把数据处理归纳为五类动词——sort、filter、format、transform、segment(排序、过滤、格式化、转换、分段)。逻辑上全是「if this then that」「只在满足条件时才」「把 A 改成 B」这几种。
而 Actions 通常落在最后,是产出面。
拿这条三段式去套你现有的脚本,会发现两个值得注意的现象。
现象一:你的多数脚本是「触发器 + 动作」,中间那段几乎是空的。比如晨报:到点 → 抓数据 → 发出去。中间没有过滤、没有转换、没有分段。这不是错,但它解释了为什么晨报会「不管有没有变化都发一遍」——因为它没有中间判断层。
现象二:你真正做对了中间层的,都是最近才改的。比如 publish_reading_html.py 中间有「检测有没有变化,没变就静默」,schedule-reading.py 中间有「有无日程、有无待读」两种判断。加了中间层的那几条,正好就是不会烦你的那几条。
所以如果要改哪条推送,优先动作不是改 prompt、也不是改时间,而是给它补一个中间层:问一句「今天它有什么理由不发」。这个问题一旦有了答案,噪音自然就降下来了。
整堂课最值得照抄的部分:动手之前先画图。
对应原片约 09:50 – 11:40
他说在开始任何自动化之前,必须先把它画出来(map it out)。当有人跑来说「我想把这个任务自动化」,第一步永远是正确地把流程映射清楚。
他把收益列成五条,条条都很实在:
① 确认你真的理解这个任务——理解它背后那组可预测的预定动作到底是什么。
③ 看清可行性——他的原话是「没什么比花半小时、一小时甚至两小时把自动化搭完,最后发现根本做不到更糟的了」。
④ 估算工作量——这件事到底要花我多久。
⑤ 发现哪里需要人工介入——如果这个任务拆不成一组预定动作,那这个流程里就一定需要人。
然后他补了一句重要的:进阶课会讲怎么用 AI 来减轻对人工介入的需求。
这一段是整堂课最值得照抄的。你的 c/w 七阶段里,S1 拟定要求写清「补什么 / 落在哪 / 格式依据 / 不动什么」,本质就是 map out,只是你把它写成了文字清单而不是流程图。两者是一回事,但流程图多一个好处:分支看得见。
他第③条几乎是你之前的原话复现:「最糟的是花两小时搭完,最后发现做不到」。你这两天踩过两次——D2 知识库结构提案做完被你否掉、DSA 研报重构完最后挂起。如果当时先画图,图上会直接暴露「这个结构的产出对 Ben哥 有没有用」这个无法验证的假设,而不是等做完才发现。
第⑤条更值钱:它给了「为什么该用脚本而不是 prompt」一个理论依据。prompt 里让模型自己判断的地方,就是人工介入点;把它下沉成脚本,就是把人工介入点消掉了。你昨天压 prompt 干的就是这件事,今天可以从「凭经验」升级为「有判据」:凡是 prompt 里出现「确认一下」「检查是否」这类需要模型主观判断的句子,都是一个该被脚本化的信号。
对应原片约 11:40 – 12:40
方法很朴素:用 Miro、FigJam 或任何工具创建流程图;把流程的每一个部分列成独立的方块;然后从左往右,按它们的交互关系用箭头连起来。
回到表单那个例子,画法是这样的:
① 表单提交→② 什么类型的公司
├ 无公司 → 结束
├ 低价值 → 加入邮件序列
├ 高价值 → 写 Google Sheet
└ 理想客户 → 通知客户经理他强调:真实流程可能比这个例子复杂得多,越是复杂,越值得花时间画。而且画的过程中如果发现某个地方说不清楚,那就是必须在上手之前弄明白的地方——否则又是「做到最后才发现不可行」。
你其实缺这一步,而且缺得很具体:现在没有任何一个地方,用一页图看清你有多少条 loop、它们之间有没有依赖。loops.md 是表格,能看到每条单独的信息,但看不到「22:45 深蒸馏 → 22:55 精读页发布」这种前后依赖,也看不到「11:20 简报依赖 08:40 的数据」。
这个依赖关系已经在出事:22:55 那条发布器如果 22:45 没跑成功,它照样会跑一遍、发现「无变化」然后静默——你不会知道是「本来就没变化」还是「上一环失败了」。这就是没有画图、看不见箭头的代价。
如果要补,最小成本的做法不是去开 Miro,而是在 loops.md 每条后面加一列「依赖」,写清它前置需要谁成功。这比画图更轻,效果一样——你能看见整条链。
最后补一句下一讲的内容:Webhooks 与 APIs,讲师说这是「搭第一个工作流之前必须先懂的两个概念」。对你来说这一讲可能会有直接收益——你现在所有 loop 都是定时触发,没有一条是「有事才动」的,而 webhook 正是补这个缺口的工具。
关于字幕与识别误差:本页基于 YouTube 英文自动字幕(非人工字幕)整理。原始 ASR 把「n8n」误识别成 Anan / anidan / inen / nen / naden 等多种写法,已在转述中统一纠正为 n8n;「Miro, FigJam」被识别为「Meo fig Jam」;「webhook」识别为「Webb hook」。讲师所在的法国培训机构名称在音频中未清晰念出,本页按「一家法国培训机构」处理,未作猜测。所有技术叙述均可回到原视频核对。
15:29 | 系列第 2 / 9 讲 | 看原视频
这一讲的位置:讲师说这两个概念是「搭第一个工作流之前必须先懂」的。全片分三块——API 是什么(含四段请求与三段响应)、凭据怎么认证、以及 Webhook 与轮询的根本区别。对你而言第三块最有价值:它解释了你现有 20 条 loop 为什么几乎全是轮询,以及哪些该改、哪些本来就不该改。
一个餐厅比喻贯穿全片,后面所有术语都从这里长出来。
对应原片约 00:30 – 03:20
讲师没有直接抛定义,而是先给了一个比喻,并说这个比喻后面会一路用到底。
你走进餐厅坐下,怎么拿到食物?你叫服务员,服务员记下订单送去厨房;厨房做好,服务员再把菜端回来。
然后才是技术定义:API 是 Application Programming Interface,它暴露(exposes)一个服务,开发者写程序去 consume(消费)它。
用第一讲提到的 Google Sheets 举例:Google Sheets 有一个 API,里面包含多个服务,其中一个服务是「读取某张表里的全部数据」。n8n 就是那个「写程序去消费它」的角色——通过调用不同服务(更新行、读数据)来使用这个 API。
接着他把比喻逐个对上号:
| 餐厅 | API 世界 |
|---|---|
| 你(客人) | client(客户端 / 调用方) |
| 服务员 | interface(接口) |
| 厨房 | application(应用) |
| 菜单 | documentation(API 文档) |
为什么需要这个「服务员」?他的解释是抽象复杂度:想象每次吃饭不是点菜,而是自己冲进厨房跟厨师解释订单、等着做好、再自己端回桌上——那比叫服务员复杂得多。同理,如果每次要读 Google Sheet 都要跑去 Google 的服务器上找到你的那张表再读数据,那也没法用;而 API 给了你一个很抽象、但很方便的入口。
你天天在用 API,只是没这么叫过。lark-cli 就是飞书 API 的服务员:你不需要知道飞书服务器上文档怎么存、权限怎么校验,只要说「列出这个空间的一级节点」,它就端回来。
用这个比喻检查你的体系,能看出一个真实的分层:
| 层级 | 你的现状 |
|---|---|
| 厨房(应用) | 飞书、企业微信、抖音、YouTube |
| 服务员(接口) | lark-cli / wecom-cli / yt-dlp |
| 菜单(文档) | lark-cli skills read lark-base/...、--help |
| 你(客户端) | 你的 automation、我 |
这里有个值得注意的现象:你已经有服务员了,但还没有统一的点菜方式。同样是上传文件,lark-cli drive +upload 要求 --file-token 覆盖、而且不能从 ~/.shared-agent 路径直接传(要先 cp 到 /tmp);同样是发消息,wecom-send.py 走 stdin、lark-cli 走 --file。这在「API 是服务员」的框架里很清楚——不同餐厅的服务员规矩不一样,这正常;但你作为客人,应该有一份自己的点菜单,也就是统一的 notify.py / publish.py。
对应原片约 03:20 – 04:00
API 靠什么工作?documentation(文档)。文档解释了这个 API 怎么用——在餐厅比喻里,文档就是菜单。
然后他一次性把后面会反复出现的术语定了义:
我们通过 interface 向 application 发一个 request(请求);application 通过 interface 送回一个 response(响应)。
而 client / server 的划分是:你是 client,application 加 interface 是 server。
「文档就是菜单」这句对你很实用,因为它给出了一个判断标准:查不到文档的能力,等于不存在。
你昨天那件事正好是反例:我在没有确认 lark-cli 有没有「覆盖上传」这个能力之前,先按「新建文件」的思路做了,结果飞书上堆了重复文件。后来查了 --help 才发现有 --file-token 参数——菜单上一直有这道菜,我没看就自己下厨了。
所以「先看菜单」这件事,在你的 c/w 流程里应该有个明确位置:它就属于 S1 拟定阶段要做的事。S1 要求写「落在哪、格式依据」,其中「格式依据」本质上就是「这道菜的菜单条目是哪一条」。写不出菜单条目,就说明这一步还没查清,不该进 S4 收敛。
四件套 + 凭据。n8n 的 HTTP Request 节点就是这四个字段。
对应原片约 04:00 – 08:10(全片最长的一段)
他说这门课只讲 HTTP 请求(虽然还有 GraphQL 等其他框架,但绝大多数 API 走 HTTP)。而这四件套,在 n8n 里一一对应 HTTP Request 节点里的字段。
① URL —— 资源在网上的唯一位置。可以是网页、图片、PDF 或数据。它由五段组成:
https :// host / path ? query=参数
scheme(协议,必填)· host(域名,必填)· path(路径,必填)· port(端口,可选)· query parameters(查询参数,可选)他特别提醒:查询参数永远以问号开头。
② Method —— 要在该 URL 上做什么动作。两个主力是 GET 和 POST:GET 大部分时候用于接收信息(读表格数据);POST 用于发送信息(提交表单)。其余 DELETE、PUT、PATCH 较少用。
他给了个很好记的说法:method 全是动词。拿不准用哪个,就想动词——你是想「拿」还是想「送」。
③ Header —— 给这次请求补充细节和上下文。常见内容是位置、语言偏好、设备类型。你每次打开网页其实都在发 API 请求,用电脑还是用手机,header 里的信息不一样。例子:Accept: application/json,告诉服务器「我要 JSON 格式的回复」。
④ Body —— 可选,且只存在于 POST 请求。装着你要发给服务器的信息。表单提交的例子:body 里就是名字、姓氏、邮箱。
?list=PLlET... 就是它。这四件套你不用背,因为你写脚本时一直在用,只是没意识到。可以直接对上号:
| 四件套 | 你在哪儿用过 |
|---|---|
| URL + query params | 查腾讯 K 线的 web.ifzq.gtimg.cn/appstock/app/fqkline/get?param=...;你刚给我的播放列表链接 ?list=PLlET0GsrLUL... |
| Method | lark-cli base +record-list 是 GET;+record-batch-update 是 POST |
| Header | 新浪新闻抓取要伪装 UA 和 Referer,那就是 header |
| Body | --json '{"update_records":[...]}' 就是 body |
有一个很实用的判断:如果一次请求「查不到结果」,先看是 URL 错还是 method 错。你之前遇到「lark-cli drive +upload 从 ~/.shared-agent 路径失败、从 /tmp 成功」,这属于 URL/路径层面的问题(对应 404);而「飞书文件超限 234006」是完全不同的一类——那是飞书自己定义的业务错误码,不是 HTTP 状态码。这两类错误的处理方式完全不同,混在一起看就会误判成「飞书坏了」。
对应原片约 08:10 – 09:20
他特意说明:credentials(凭据)没有被列进四件套,因为它不是独立的一部分,但每次请求都要带。
凭据的作用是告诉应用「我有权做这件事」。他给了个很直白的反例:如果任何人都能读你的 Google Sheets、往你的 Slack 发消息,那就太危险了。
三种最常见的方式:
① 塞在查询参数里:?api_key=xxxxx
② 塞在 header 里:Authorization: Bearer xxxxx
③ OAuth:就是你每次点「用 Google 账号登录」时弹出的那个小窗口。
最后补一句:大多数 API 都要求认证,但也有少数不需要。
Authorization: Bearer <token>。你的凭据管理其实已经比很多人规范,因为你有明确的「密钥层」规则:dsa/.env、master.key 绝不进仓库,两台机器各自本地配置。这跟凭据的逻辑完全一致——凭据属于「环境」,不属于「代码」。
但有一处漏洞值得指出:凭据过期这件事,你现在没有任何主动检测。今天最典型的就是飞书/企微的授权——你这几天反复「重新生成二维码 / 已授权」了好几次。这在 API 语言里就是 401 Unauthorized,对应他说的「回去检查你的凭据和权限」。
可以补一个很低成本的检查:在每小时那三条静默巡检里加一步「调一次最轻量的只读接口,看是否返回认证错误」。这样凭据快过期时你会提前知道,而不是等某条该发的推送发不出去才发现。这比每天早上看推送有没有来要可靠。
状态码是整堂课最实用的一张表。
对应原片约 09:20 – 12:10
响应有三个组成部分:status code(状态码)、header、body。
① Status code 是三位数字,告诉你这次请求成没成。他给了四个最常遇到的,并给了一个万能记忆法:
| 码 | 含义 | 是谁的问题 | 怎么办 |
|---|---|---|---|
| 200 | OK,标准成功响应 | — | 不用管 |
| 401 | Unauthorized,未授权 | 你的 | 检查凭据:有没有带、带得对不对、权限够不够 |
| 404 | Not Found,找不到 | 你的 | URL 写错了,你要的页面/数据不在这个地址 |
| 500 | Internal Server Error | 服务器的 | 不是你的错,通常等等重试就好 |
记忆法:2 开头=恭喜成功;4 开头=你搞错了,得改请求;500=服务器的问题,多数情况下等会儿再试。
② 响应 header 提供上下文:内容有多长、是什么类型、什么时候过期(我能访问多久)。
③ 响应 body 是真正返回的数据,格式多样:浏览网页时是 HTML,调 API 时通常是 JSON,也可能是二进制。
这张表对你有一个非常直接的价值:它给了你一套读报错的顺序。
你今天看到的「退出码 2:受控执行上下文核验失败」,本质上就是一次自己定义的「非 2xx」。按这门课的分类法,应该先问一句:这属于「我的请求有问题」还是「对方服务有问题」?——答案是前者,因为核验的是我的上下文是否合格。这就把排查方向从「等它自己好」拉回到「检查我传了什么」。
同样,「飞书 234006 文件超限」也属于 4xx 类,是你的请求带了个太胖的 body,解决方案是压缩或分片(你今天就是这么处理的:55MB 原声给企微、27.7MB 压缩版给飞书)。而如果哪次你在凌晨三点收到一条莫名其妙的失败,多半是 5xx——那时正确动作是重试,不是改代码。
有个现成的改进:你的 automation prompt 里现在写的是「退出码非 0 就重试一次」。按状态码逻辑,这个策略对 5xx 是对的,对 4xx 是浪费——重试一百次也不会成功,应该直接报错并说明是哪个参数不对。这个区分可以直接写进 WORKING-METHODS.md 的失败处理一节。
门铃 vs 不停去门口看。这一段直接对应你现有 loop 的结构性问题。
对应原片约 12:10 – 14:40
Webhook 也叫「反向 API」。他的比喻很干净:
你在家等朋友。你可以每隔几分钟跑去门口看一眼他们到了没;也可以什么都不做,等门铃响。门铃就是 webhook——它在「你等的那件事发生了」时通知你。
具体例子:你用 Stripe(支付平台),需要知道每笔新付款。两个方案:
方案一,polling(轮询):每隔几分钟发一次 API 请求问「有新付款吗」。有就做事,没有就等,过几分钟再问。
方案二,webhook:设一个 webhook,每次有新付款,Stripe 就主动把付款信息推给你。
要设一个 webhook 需要什么?一个 URL——告诉对方「信息往哪儿发」。然后用 n8n 的 Webhook 节点接收、处理,触发工作流。
下一讲预告:3/9 讲 nodes(节点),开始真正搭第一个工作流。
这是整堂课对你最有现实价值的一段,因为它直接命中你体系的一个结构性事实:
| 你的 loop | 实际模式 |
|---|---|
| VA7 作者跟读 10:30 | 轮询:每天去查一次有没有新作品 |
| 看门狗 每 60 秒 | 轮询:不停扫 inflight.json |
| 08:40 日程+阅读 | 轮询:到点去查一次日程 |
| 22:45 深蒸馏 | 轮询:到点看有没有待办 |
| 企微接收器 | 推模式:长连接,企微主动把消息推过来 |
注意最后一行——你唯一一个「推模式」的东西,恰好是体验最好的那个:你在企微发一句话,我立刻就收到了,不需要等到某个整点。这不是巧合,这就是 webhook 与 polling 的差别。
但必须说清代价,否则会得出错误结论。webhook 能不能用,不取决于你想不想,取决于对方愿不愿意推给你。
飞书、企微都有事件订阅,但都要求你提供一个公网可达的回调地址。你本机是内网、没有公网 IP,所以要走这条路得先解决穿透(或者用云函数)。而你唯一那个推模式之所以能成,是因为企微的 aibot 长连接是客户端主动连出去的——方向反过来,就不需要公网地址了。
更关键的一条:抖音不会给你 webhook。所以「VA7 一有新作品就立刻蒸馏」这件事,在现有条件下只能靠轮询。这不是技术选择问题,是对方没开放这个能力。这也解释了为什么你那条 10:30 跟读是对的——它已经是当前条件下最优解,不必再想怎么优化成实时。
综合整理,非原片单节内容
讲师本人没有做这张对照表,但他讲清了两边的机制,剩下的判断可以直接推出来。判断只需要问三个问题:
① 对方支持主动推送吗?不支持,就只能拉。
② 你的机器能被公网访问到吗?不能,就得先解决这个(长连接、穿透或云函数)。
③ 这件事的时效要求是什么?晚几小时无所谓,就别折腾推;必须秒级响应,才值得为推付成本。
用这三个问题把你 20 条 loop 过一遍,结论其实很清晰:
| 场景 | 该推还是该拉 | 理由 |
|---|---|---|
| 企微收消息 | 推(已实现) | 长连接绕开了公网限制,且必须秒级 |
| VA7 跟读 | 拉(现状正确) | 抖音不开放 webhook;晚一天蒸馏没有损失 |
| 日程 / 持仓 / 阅读 | 拉(现状正确) | 本身是「每天早上看一次」的场景,等真有必要实时再说 |
| 看门狗 | 拉(现状正确) | 本机文件变化没有事件源,只能扫 |
| 飞书文档变更 | 可以推 | 飞书有事件订阅,但需要公网回调——成本高于收益 |
我的结论:你不需要为 webhook 做任何改造。现有的轮询设计在这几个场景里都是对的——它们的共同点是「对人的响应时效要求都是小时级,不是秒级」。
真正值得从这一讲拿走的东西不是 webhook 本身,而是那个门铃比喻给的反向启发:你那些轮询到底在「空问」多少次?VA7 跟读每天问一次,大概每 3-5 天才真有一次新作品,也就是 70% 的轮询是白跑的。这不严重(成本几乎为零),但它提醒一件事——轮询型 loop 的「成功率」天然很低,所以不能拿「今天跑了吗」来衡量它有没有用,要看「它抓到了几次真正的变化」。
这个观察可以直接改成一条检查:给每个轮询型 loop 记一个「空跑次数 / 命中次数」。如果一个 loop 连续 30 天命中 0 次,它要么该停,要么该换触发条件。这比按「每天响几次」来砍推送更准。
关于字幕与识别误差:本页基于 YouTube 英文自动字幕(非人工字幕)整理。ASR 把「n8n」误识别为 NN / nen / naden / anded end 等;「JSON」识别为「jjon」;「OAuth」识别为「oo」;「404」识别为「44」。以上均已在转述中纠正。讲师举的姓氏例子原音频为「Poon」,本页按原样保留。所有技术叙述均可回到原视频核对。
这一组是全系列最技术的两讲。第 3 讲把工作流拆成三类节点,第 4 讲说清节点之间传的到底是什么。这两讲是「不理解就永远搭不好」的那部分,也是对你体系诊断力最强的两讲。
YouTube · n8n 官方频道 · 13 分 19 秒 | 系列第 3 / 9 讲 | 看原视频
这一讲的位置:第 3 讲开始动真格的——但它讲的不是「怎么拖拽」,而是整个工具的数据模型:节点是原子,原子只有三类;第一个节点必须是触发器;参数和设置是两件事;凭据存在实例层不在工作流里。这一讲对你的价值在于它给了你一把尺子,可以拿去量自己那 20 条 loop 到底缺了哪一段。
整堂课的骨架。三类节点,对应任何流水线的三段。
对应原片约 00:10 – 02:00
他开门见山给了定义:节点(node)就是 n8n 的「原子」,每一个工作流都是把节点一个个连起来构成的。
然后是按功能分的三类——这个分类比后面的界面操作重要得多:
| 类别 | 作用 | 例子 |
|---|---|---|
| entry points(入口) | 决定工作流什么时候开始跑 | 定时、手动、某个应用发生了事件 |
| functions(加工) | 对数据做转换、过滤、格式化 | 改字段、筛条件、拼文本 |
| exit points(出口) | 把结果送到某个应用 | 写 Google Sheets、发 Slack、发邮件 |
画布上添加节点时,界面也按类型分组:Triggers / Actions in app / Data transformation / Flow / Files / Advanced。他说这个分组方式和前面讲的分类是一回事,只是叫法更细。
这三分类对你不是知识,是诊断工具。把你那 20 条 loop 按这个框架过一遍,问题会立刻显形:
| 你的 loop | entry | function | exit |
|---|---|---|---|
| 08:40 日程+阅读 | 定时 | 有(判断有无日程) | 发企微+飞书 |
| 22:55 精读页发布 | 定时 | 有(检测 [CHANGED]) | 覆盖上传+发通知 |
| 09:00 学习知识点 | 定时 | 无 | 发消息 |
| 18:00 / 21:30 / 22:30 吃药 | 定时 | 无 | 发消息 |
| 16:00 PLM 提醒 | 定时 | 无 | 发消息 |
结论很直接:凡是没有中间层的那几条,都是「不管有没有内容都照发」的,也就是你觉得吵的那几条。而你最近刚改的两条(发布器、日程脚本)恰好都有 function 层,所以不烦人。
这比「把 14 条合并成 6 条」更接近问题本质:合并减少的是条数,补中间层减少的是无效条数。前者是减法,后者是让不该发的自己不发。吃药属于「无论如何都要提醒」的类型,不需要中间层;但 PLM 提醒和学习知识点完全可以在没有新进展时静默。
触发器是强制的,这是单入口原则的强制版。
对应原片约 02:00 – 04:30
从空画布开始。加第一个节点有两个入口:中间的 add first step,或右上角的 +。
他特意点出一件事:因为这是第一个节点,n8n 会要求你选一个触发器(trigger)。——注意这是强制性的,第一个节点不能是普通动作节点。
触发器可选项里,on app event 会列出所有能作为触发源的应用;而在学习阶段,他说直接选 manual trigger(手动触发)就好,方便反复试。
之后的节点就没有这个限制了。这里给了两个实用技巧:
① 别滚列表,直接打字。搜索框输入节点名或应用名,比在一长串列表里翻快得多。
② 选中节点后可能还要选 operation。比如 Google Sheets 节点有多达六七种操作——append or update row、clear sheet、create sheet、delete sheet、get rows……同一个节点,选不同 operation,做的事情完全不同。
「第一个节点必须是触发器」这条限制,在工程上叫单入口原则——它强迫你先回答一个问题:这条流水线到底由谁启动?
你的 loop 现在对这个问题是模糊的。举个具体的:VA7 跟读那条,它同时存在三种启动方式——每天 10:30 定时、你手动叫我跑、以及之前设的「22:45 深蒸馏后顺带补」。三条路进同一个处理逻辑,出问题时你无法判断这次是被谁触发的。
要说明的是:n8n 本身允许一个工作流挂多个触发器(第 5 讲会演示),所以问题不在「多个入口」本身,而在入口无法溯源。n8n 的做法是每个触发器各占一个节点,哪个触发的、执行记录上写得很清楚。换成你的实现,规矩应该改成一条:需要多个入口时,允许,但每次执行必须记下「是谁启动的」。——在脚本里多传一个 --trigger=scheduled|manual|chain 参数就够,日志里带上它,以后排查就不用猜。
第二个可用的判断:如果这个 loop 是被「事件」驱动的,那定时就是错的。比如「飞书阅读队列有新记录就自动打标」,用定时去查是无奈的替代;而「每天 8:40 提醒今天读哪条」本质是时间驱动,定时就是对的。先分清驱动类型,再谈频率。
分不清这两个,就会把业务和策略搅在一个文件里。
对应原片约 04:30 – 06:00
节点放到画布上之后,可以点播放键单独执行它,也能复制、重命名、删除。真正要理解的是两种配置的区别:
| parameters(参数) | settings(设置) | |
|---|---|---|
| 怎么打开 | 双击节点 | 右上角齿轮图标 |
| 管什么 | 这个节点、这个 operation 专属的东西 | 所有节点共用的通用项 |
| 例子 | 读哪张 spreadsheet、哪张 sheet、筛选条件 | notes(备注)、显示设置、执行设置 |
他重复强调了两遍:settings 是节点无关的(node independent)——不管你正在编辑哪个节点,齿轮里看到的东西都一样。而参数恰恰相反,换一个 operation,字段全变。
另外提了一句:参数的最上方是设置凭据(credentials)的地方,他标记这是一个「非常重要的概念」,下一节展开。
这个「参数 / 设置」的二分法,你的脚本里没有。你现在每个脚本都是一个扁平的文件:业务参数(读哪张表、发到哪个群)、行为配置(重试几次、超时多少、日志写哪)混在一起。
后果很具体:reading-queue.py 里既有「飞书 base token / table id」这种业务参数,也有「SEND 脚本路径」这种环境配置,还有「最多回看 40 条历史」这种策略参数。改任何一个都要动同一个文件,而且没法只换环境不改业务。
要改的话不用大动,加一个约定就够:每个脚本顶部单独一段 CONFIG,只放环境相关的(路径、token、收件人),业务参数一律走命令行或参数文件。这样换机器只改 CONFIG,换任务只改参数。
还有一个直接可用的启发:n8n 把「备注(notes)」放在 settings 里而不是参数里,意思是备注是通用能力,任何节点都能写。你现在的注释方式是外置的 loops.md 表格——表格不会跟着代码走,改了脚本忘了改表就会对不上。内嵌注释不容易腐化,外置文档会。
对应原片约 06:00 – 07:20
他明确说:凭据(credentials)保存在实例级别(instance level),不是工作流级别。
为什么这样设计,他给了两个理由:
① 构建效率:配一次,所有工作流都能用,不用每条重配。
② 安全与共享:可以指定哪些用户、哪些工作流能使用某一份凭据,防止特定的人访问特定的凭据。
演示里正好演了一遍:他打开 Google Sheets 节点,发现已经有一份现成的凭据可以直接选;为了演示又新建了一份,选了 OAuth 方式,点「用 Google 登录」,授权完成后 n8n 就拿到了访问他 Google Sheets 账号的权限。
你的凭据是反过来的——散落在各个项目里:dsa/.env 一套、wecom-send.py 自己找环境、lark-cli 用自己的登录态、n8n 装好以后又会多一份。这带来一个你已经反复体验过的问题:
你这几天重扫了三四次飞书二维码。表面看是「授权过期」,根子在没有一处知道「我到底有几份凭据、每份是什么状态」。没有清单,就只能等在某个任务失败时才发现。
n8n 的做法值得抄一半:把凭据收成一份清单,而不是收成一份文件。具体到你这儿,不需要改造成单点凭据库(那是大工程),只需要在每小时那条静默巡检里加一步:分别调一次飞书、企微的只读接口,把成功/失败记进一行日志。这样凭据哪天开始失效,你能提前一天知道,而不是第二天早上发现推送没来。
「谁能用这份凭据」这一层你现在不需要——单机单人,没有权限隔离的需求。但「凭据会过期」这个事实需要监控,而监控的前提是先有清单。
这一节是「可视化」真正值钱的地方。
对应原片约 07:20 – 11:30(含实操演示)
节点的左边是输入数据,右边是输出数据。他给了三种查看方式:
| 视图 | 长什么样 | 什么时候用 |
|---|---|---|
| Table | 表格,列是字段,行是记录 | 读表格数据时最直观 |
| JSON | 键值对,一行一条记录 | 下一讲专门讲,是数据流的真正形态 |
| Schema | 只列所有 key + 一个示例值 | 字段太多、想快速看清结构时 |
演示用的是 Google Sheet:里面有 first name、last name、email、company 四列,且这个文档里有两张 sheet——一张叫 data,一张叫 company info。
操作流程他走得很快:add first step → manual trigger → 点 + 加下一个节点 → 直接打字搜 Google Sheets → 选 get rows(读一行或多行)→ 选凭据 → 选 resource(文档里的某张 sheet)→ 选 document 和 sheet → execute。
执行后有几个细节值得记:
① 输出的每一行多了一个 row_number 列,是 n8n 自动加的;
② 表里原本空着的单元格,在输出里就是空字段,不会被填成 null 或 0;
③ 同一份结果切到 JSON 视图,就是每行一条的键值对;切到 Schema 视图,只剩 key 和示例值。
这三个视图暴露了你体系里一个真实缺口:你能看到的东西只有「最终消息」,看不到「中间数据」。
举个具体的。08:40 那条日程+阅读,如果某天它没推,你要判断是「今天真没日程」还是「日历接口挂了」——现在没有任何办法区分,因为你只看得到「没收到消息」这个结果,看不到中间那句「查到 0 条日程」。
n8n 的解法是把每个节点的输入输出都摊开给你看。你不用照搬界面,但可以照搬这个思路:让关键 loop 在每次跑完时留一行结构化记录——几点跑的、entry 拿到了什么、function 判定成什么、exit 发了没。写进一个 sqlite 或 jsonl 都行,一天几十行。
这样下次「为什么没推」这个问题,答案就在那一行里,不需要我重新跑一次排查。这比接多少可视化工具都实在——可视化解决的是「人看」,结构化日志解决的是「可查」。
稳定性不靠 prompt 写得好,靠这些开关配得对。
对应原片约 11:30 – 13:00
他挨个过了一遍节点设置(齿轮)里的东西,说这些和具体节点无关,任何节点都有:
| 开关 | 作用 |
|---|---|
| Always Output Data | 即使没数据也输出一条空记录,保证后续节点不被「无数据」卡住 |
| Execute Once | 只执行一次,而不是对每条输入数据都执行 |
| Retry On Fail | 失败自动重试。他特别点出:这在调用 API 的应用节点上很有用 |
| Error Settings | 出错时怎么办(继续、停止、还是走另一条路) |
另外两件他实际做了的事:
① 加备注:他给节点写了一条 note 解释这段工作流干什么,并说「这在别人(或未来的自己)理解工作流时帮助很大」。
② 底部还有 additional options:可以加筛选条件(比如只要 email 等于某个值的行)、设置数据位置、输出格式、以及「筛选命中多条时怎么处理」。他一句话带过:很多节点底下都有这块额外设置。
你所有 automation 的 prompt 里都写着一句话:「失败则原样重试一次;连续两次失败则明确报告」。这是整个任务一起重试——重试的时候,前面已经成功的步骤(下载、转写、生成)会被重跑一遍。昨晚 VA7 深蒸馏如果卡在最后一步发送,重试就是连下载一起重来。
按 n8n 的思路应该分开:
| 环节 | 该不该重试 | 理由 |
|---|---|---|
| yt-dlp 下载、lark-cli 上传 | 该(2-3 次) | 网络抖动,属于典型的「一会儿就好」 |
| 字幕解析、HTML 生成 | 不该 | 纯本地计算,失败了重跑也是一样失败 |
| 发送消息 | 看错误码 | 超时该重试;4xx 参数错重试无用(第二讲那张状态码表) |
第二件事:Error Settings 这个概念你没有。你现在只有「成功」和「失败后重试,再失败就报错」两种结局。n8n 提供了第三种:出错时走另一条路——比如 22:45 深蒸馏失败,不该直接终止,而应该通知「今天这讲没做成,明天补」,让 22:55 的发布器知道「上游没产出」而不是误判「无变化」。
这个差别很实在:你昨晚就差点踩到——如果深蒸馏静默失败,发布器会看到「无变化」然后静默,你根本不知道是没新内容还是上游挂了。加一条「失败也要留痕」,就能把这两种情况分开。
关于字幕与识别误差:本页基于 YouTube 英文自动字幕(非人工字幕)整理。ASR 把「n8n」误识别为 nen / naden / niden / Nidan / Anan 等十余种写法;「OAuth」识别为「oo」;「JSON」识别为「jjon」。以上均已在转述中纠正。所有技术叙述均可回到原视频核对。
YouTube · n8n 官方频道 · 15 分 31 秒 | 系列第 4 / 9 讲 | 看原视频
这一讲的位置:第 4 讲是整个系列里最技术的一讲,也是唯一一讲「不理解就永远搭不好工作流」的。它讲的不是界面,是数据模型:JSON 和 list 两种结构、item 是节点间唯一流通的货币、每个节点对每条 item 执行一次、表达式是随 item 变化的取值。对你的直接价值有两处——它解释了为什么你所有脚本都是「一次干一件事」而不是「一批流过」,也给出了「让上游失败可被下游看见」的具体形态。
JSON 装东西,list 装 JSON,嵌套用来分组。
对应原片约 00:20 – 03:00
他一开始就把话说重了:这讲比较长、比较技术,但「非常重要,理解了才能搭出最好的工作流」。整讲只围绕两种结构:
| JSON | List(列表) | |
|---|---|---|
| 长相 | 花括号 { } | 方括号 [ ] |
| 内容 | 键值对(key: value),逗号分隔 | 一组对象,逗号分隔 |
| 约束 | 同一层里 key 不重复 | 可以装不同类型,也可以装 JSON |
他说 JSON 是「数字世界里存数据最常见的方式」,而 list 是「对象的集合」。
然后是嵌套(embedded JSON)——这一节是后面所有表达式的基础:有时候一个 key 的值本身就是另一个 JSON。他给的例子是把「Emily 的位置」整组信息收进一个 location 键里,而这个 location 的值又是一个 JSON,里面装着 country 和 city。
{ "first_name": "Emily", "last_name": "Johnson", "location": { "country": "France", "city": "Paris" } }
location 的值不是字符串,是又一个 JSON——这就是嵌套为什么需要嵌套?他的原话大意是:用来组织复杂数据。当信息分属不同层级时,扁平地摊开会让一堆字段混在一起,嵌套能把它们收成一组。
这个「扁平 vs 嵌套」的取舍,你的数据里天天在遇到,只是一直用文本凑合。
看你自己维护的那张阅读队列就明白:63 条记录里,每条的字段是扁平的——名称、类型、链接、分组、作者、状态、优先级、时长、一句话价值。这里「分组」和「作者」本质上属于两个不同的维度,现在被并排摊在同一层,所以你才有「子主题只对视频有意义、文章天然为空」这个问题。
如果按嵌套来组织,应该是:
{ "title": "...", "source": { "type": "视频", "author": "VA7", "url": "..." }, "classify": { "group": "FDE·人才与角色", "reason": "补盲区" }, "track": { "status": "待读", "priority": "高" } }
按用途分组:来源 / 分类 / 进度。空值只影响一个子组,不影响整条记录但这里要说清取舍:多维表格是给人和视图用的,扁平更好用;JSON 是给程序传的,嵌套更好用。你的阅读队列是前者,不需要改。真正该用嵌套的是脚本之间的数据交换——比如深蒸馏脚本产出给发布器的那份「本讲做了什么」,现在是纯文本,如果改成结构化 JSON,发布器就不用靠字符串匹配判断成功了。
点号记法,以及「JSON 就是表格的一行」这个类比。
对应原片约 03:00 – 04:40
怎么从 JSON 里取出某个值?标准点号记法(dot notation)。
$json 指的是当前这条数据本身;再点 .first_name 就取到那个键的值。
嵌套的话就连点两次:$json.location.country——先拿到 location(它自己又是一个 JSON),再从中取 country。
接下来是整讲最关键的一句类比:
他展示了 Emily 那条数据(first name / last name / email)刚好能严丝合缝地填进表格的一行。如果有三条这样的 JSON,就是三行。他还特意点出:这跟上一讲看到的 table view 是同一件事——数据没变,只是换了个看法。
$json.key。取一层点一次,嵌套就连续点。「JSON 是行、key 是列头」这个对应,能解释你一个长期的小别扭:为什么你在飞书表格里做视图很顺,在脚本里读同一份数据却很笨重。
原因是两边的心智模型不一样。表格那边是「行 + 列」,一列可以统一处理;脚本那边你把整条记录当一个 dict 用 .get() 逐个取,取十个字段写十行。n8n 的表达式让这两边统一了——拖一个 key 就是取那一列的值,视觉上就像操作表格。
有个直接可用的改法:你现在读飞书表格的代码里,那些 x.get("字段名") 重复得很密。可以先把每条记录规范成一个扁平 dict(一次转换),后面全程用 dict 访问,而不是每个取值点都去处理飞书的返回结构(select 字段是 list、URL 字段是 [x](y)、日期是时间戳)。你现在到处在写 first() 这种取第一个元素的小函数,就是缺了这一步规范化。
空输出也要是一条记录——这条约束解决「无结果 vs 没执行」。
对应原片约 04:40 – 06:20(全讲最重要的定义)
一个 list 里的一条 JSON,他给了一个正式名字:item。
然后是这个工具最硬的一条约束:
接着他补了一句极重要的话:
也就是说,一个节点跑完了但没找到数据,它输出的不是「什么都没有」,而是 [ {} ]——一条空记录。这样下游节点仍然会被执行一次(因为有一个 item),只是拿到的内容为空。
这个设计不是啰嗦,它解决了一个真问题:「没有结果」和「没有执行」必须能区分。
这条约束直接命中你昨晚讨论过的一个具体问题:22:45 深蒸馏失败时,22:55 的发布器分不清「没有新内容」和「上游挂了」。
为什么会分不清?因为你的脚本在「没结果」和「没跑成」两种情况下,返回的东西是一样的——都是空、都没有输出、都退出码 0。发布器看到「无变化」就静默,你也就什么都不知道。
n8n 的解法就一句:空输出也要返回一条带标记的空记录。换成你的实现,就是让每个环节都输出一个明确的状态对象:
| 情况 | 现在 | 应该输出 |
|---|---|---|
| 跑了,没新内容 | 无输出 | {"state":"empty","checked":3} |
| 跑了,有新内容 | 无输出(靠文件变化推断) | {"state":"produced","count":2} |
| 没跑成 | 无输出 / 报错退出 | {"state":"failed","error":"...","stage":"download"} |
三种状态都显式写出来,下游才可能做出正确判断。这是「显式优于隐式」在流水线里的具体形态,也是你那些「明明有调度但没收到推送」问题的通用解法。
每个节点对每条 item 执行一次。这决定了工作流的整体形态。
对应原片约 06:20 – 08:20
他给了一条「记住就行」的规则:
每个节点会针对输入里的每一个 item 执行一次。(有例外,进阶课再讲)
举的例子很直观:用 Date & Time 节点格式化三个日期,节点读了每条 item、格式化、再作为独立 item 返回——输入三条,输出还是三条,只是内容变了。
他还提了配套开关:齿轮里的 Execute Once,开了之后节点只对输入的第一条 item 执行。
然后他用一张执行示意图把整条链路走了一遍,这张图值得记住:
Execute Workflow(手动触发)→返回 [{}](一条空记录)
Google Sheets(读 3 行)→输出 3 条 item
Filter(按条件筛)→只有 1 条满足,输出 1 条 item注意第一步:手动触发返回的是一串装着空 JSON 的 list,正因为如此下一个节点才会执行一次。这条链路上,数据条数从 1 → 3 → 1,每一步的「多少个 item」都是可预测的。
「每个节点对每个 item 执行一次」这条规则,解释了你体系里一个结构性事实:你所有脚本都是「一次处理一件事」,从来没有「一批流过」的形态。
具体对照:VA7 剩 24 条要深蒸馏,你的做法是每天固定做 2 条,12 天做完。为什么是 2 条?因为 WorkBuddy 的 automation 是「一次任务」模型,一次任务干一件事,要处理 24 件事就得分 12 次任务。
n8n 的模型不一样:一次性喂进 24 个 item,每个节点对每项执行,一晚上就全跑完了。差别不在算力,在任务模型——你是「定时触发一件事」,它是「一数据流过多道工序」。
这不是说你要改架构(你的定时模型有它的好处:可控、可中断、失败影响面小)。但有一个可以借鉴的点:把「一批」在内部当循环处理,而不是在外部拆成 12 次任务。26 条深蒸馏如果写成一次任务里循环,中途失败只需要重跑失败那一条,而不是「今天那 2 条又要重来」。
第二个可用的判断是 Execute Once 那条。你的脚本有循环时,默认是全跑;如果某一步只想跑第一条(比如只取最新一条新闻做示例),得自己写 break。这个开关提醒你:「只处理第一条」是个需要显式声明的意图,不是默认行为。
拖 key 生成取值,花括号里还能写 JS。
对应原片约 08:20 – 12:40(含实操)
怎么让节点的行为依赖输入数据?做法是从 table / JSON / schema 视图里,把 key 拖到参数框里。n8n 会自动生成一段称为 expression(表达式) 的东西。
表达式的核心语义:对每一条 item,它返回该 item 对应的值。界面会显示第一条 item 的示例值,方便你确认取对了没有。
花括号之间的任何内容都是表达式。能放三种东西:
| 能放什么 | 例子 |
|---|---|
| item 的变量 | {{ $json.first_name }} |
| JavaScript 函数/方法 | {{ $json.last_name.toUpperCase() }} |
| 多个表达式 + 纯文本拼接 | {{ $json.first_name }} {{ $json.last_name }} 刚加入了 Acme |
他给的组合例子很实用:给每个人发一条 Slack,内容是「名 + 空格 + 姓 +(邮箱)+ 一句所有人相同的话」。执行后有 3 条输入 item,就发出 3 条内容各不相同的消息。
实操部分他用了 Edit Fields(Set)节点:加一个新字段叫 full name,把 first_name 拖进来、打一个空格、再把 last_name 拖进来。测试后 JSON 视图里就看到 Paul Harris、Marcus Bennett 这样的结果。接着他又加了一点 JS,把姓转成全大写——输入还是那些姓名,输出变成了名原样 + 姓大写。
「拖动 key 生成表达式」这个交互,本质是把取字段这件事变成了可视的、不用写代码的动作。你现在取字段靠的是 Python 里一遍遍 dict.get(),两者差别不是技术难度,是可读性:
看你的实际代码,取一条飞书记录要过三道:select 字段是 list 要取第一个、URL 字段是 [x](y) 要清洗、日期字段是时间戳要转。这就是为什么你写了 first()、clean_url() 这种小工具函数——你在手工实现 n8n 表达式那一层。
这没问题,但有个更省事的做法可以借鉴他的思路:把「怎么取」和「取什么」分开。先写一个 normalize(record) -> flat_dict 把所有飞书的怪格式统一掉,之后所有业务逻辑只面对干净字段。这样以后加一个字段,只改 normalize 一处,不用在十个地方补 first()。
另一个挺有意思的点:表达式里能直接写 JS。「主语言 + 表达式里塞一小段脚本」这个组合,你在 shell 里其实一直在做($(date +%Y-%m-%d) 就是表达式)。所以这不是新东西,只是 n8n 把它做成了可视化。判断标准可以借用:一段逻辑如果短到一行能写完、且只服务于当前这一步,就写成表达式;一旦要判分支、要循环、要重试,就该是脚本。
数据条数怎么从 1 变 3 又变 1。
综合整理,非原片单节内容
他一整讲其实只在搭一条链路,把它压缩成一张表就清楚了:
| 步骤 | item 数量 | 发生了什么 |
|---|---|---|
| 手动触发 | 1(空 JSON) | 为了让下游能执行一次,必须返回一条空记录 |
| 读 Google Sheets | 1 → 3 | 读了三行,变成三条 item |
| Filter 筛选 | 3 → 1 | 只有一条满足条件,其余被筛掉 |
| Edit Fields 加字段 | 1 → 1 | 加了 full name,条数不变 |
| Slack 发送 | 1 → 1 | 每条 item 触发一条消息 |
他的结束语很实在:如果你在搭工作流时搞不清「为什么我的输入输出长这样」,就回来看这一讲,把 items、lists、JSON 三件事彻底搞清楚。
下一讲开始动手搭第一个完整工作流。
把这张表拿去量你现在的流水线,会看到一个很清楚的差异:
举个具体的。22:55 那套发布器,如果按这张表来表达应该是:
| 步骤 | 你的实际 | 应该有的 |
|---|---|---|
| 扫深蒸馏目录 | 拿到一个数字 6 | 6 条笔记 = 6 个 item |
| 判断有无新增 | 比 state 文件里的 last_deep | 筛出「不在已发布列表里」的 item |
| 重建 HTML | 全新生成一遍 | 把新 item 合并进已有集合 |
| 上传 | 覆盖整个文件 | 同上(HTML 只能整体覆盖,这条没法改) |
差别在第二行:你是「比一个总数」,它是「筛出差的那些」。比总数会漏掉一种情况——如果某天补录了一条旧笔记,总数从 6 变 7 会被发现;但如果同时删了一条又加了一条,总数不变,你就漏了。
这个改法成本很低:state 文件从存一个数字,改成存一个 ID 列表。凡是需要「有没有变化」判断的地方,比集合不要比计数。这条可以直接用到你所有「无变化就静默」的脚本上。
关于字幕与识别误差:本页基于 YouTube 英文自动字幕(非人工字幕)整理。ASR 把「n8n」误识别为 nen / NN / Inn / nadn / ENT / Anan 等十余种写法;「JSON」多次被识别为 jjon / Jason / ajon;「Edit Fields」被识别为 edit fields / set;「toUpperCase」识别为 two uppercase。以上均已在转述中纠正。原文代码示例按语义复原,未逐字照抄。
这一组开始动手。第 5 讲搭出第一个完整工作流,途中踩了两个非常典型的坑(空值、AND/OR);第 6 讲把工具箱补齐——数据整形五件套,以及一个特别清楚的「1 条汇总 vs 5 条逐条」对比实验。
YouTube · n8n 官方频道 · 13 分 37 秒 | 系列第 5 / 9 讲 | 看原视频
这一讲的位置:第 5 讲开始真正动手搭第一个完整工作流。核心概念有三个:激活(保存不等于生效,激活才算上线)、触发器(只有输出没有输入,可以挂多个)、分支(分流与复制是两种完全不同的语义)。后半段是实操,中间踩了两个非常典型的坑——空值不是「不存在」、排除法要用 AND 不能用 OR。这两个坑你的代码里同样存在。
保存 ≠ 生效。这是工程纪律,不是界面知识。
对应原片约 00:20 – 02:20
他先系统过了一遍画布上的元素,位置和用途一一对上:
| 位置 | 是什么 |
|---|---|
| 顶部(左) | 工作流菜单:名称、标签(tags)、所属人 |
| 顶部(中/右) | 激活设置、版本历史、工作流专属设置 |
| 顶部最右 | 可访问性、error workflow、执行记录的保存方式 |
| 中间 | 节点本体 |
| 左下 | 缩放 |
然后是这一讲第一个硬概念:
激活(activating)才真正允许你把工作流推到生产环境、让它自动跑起来。他明说「稍后会专门讲激活」。后面实操时又重复了一次:你点测试可以跑,但要每天 8 点自动跑,就必须激活。
还有一句关键的警告,在激活那一节他说得很直接:每次激活都会自动保存,所以在打开开关之前,先确认这个工作流是准备好的。
工作流菜单里另有一个实用功能:my workflows,只看自己创建的工作流;新建时你自动成为 owner。
「保存 ≠ 生效」这个区分,你的体系里完全没有——这是一个真实的风险点。
你现在的做法是:建 automation = 立刻生效。昨天你让我「把提醒整合」,如果我建错了时间(比如把 11:20 写成 1:20),第二天它就会在凌晨一点开始发,而且不会有人拦——因为「建好了」和「上线了」是同一件事。
n8n 用两道门把这个风险隔开了:① 默认不激活,图纸可以先画;② 激活是一个动作,做的时候它提醒你「这会自动保存并开始跑」。
这个可以低成本搬过来,不需要改工具:新建的 automation 一律先建成 PAUSED,等你确认过一遍时间、内容、失败行为,再改 ACTIVE。今天的 7 讲精读如果要建 automation,我就按这个来——先给你看一遍 prompt 和时间,你说行我再开。
还有一件事值得记:版本历史那一栏你也没有。你的脚本改动没有任何回滚点,改坏了只能靠记忆中「原来那行是什么」。昨天我改 controller.py 时自己做了 .bak 备份——那是我临时想起来的,不是规矩。凡是会碰生产链路的改动,备份应该是规矩而不是记性。
只有输出、带闪电。可以挂多个,但每个都要能溯源。
对应原片约 02:20 – 03:40
怎么在画布上分辨触发器?他给了两个视觉特征:
① 只有输出分支,没有输入(它不接收任何东西,只负责启动);
然后是这条容易被忽略的规则:
一个工作流可以有多个触发器——可以是多个相同的触发器,也可以是多个不同的触发器,用于更复杂的场景。
而触发器只有激活之后才真正工作(测试时除外)。
另有个小技巧:双击任意节点,能看到它的前一个和后一个节点,还有小图标可以在工作流里前后导航。他说这在搭长流程时很有用。
「触发器没有输入」这个视觉特征,其实说明了一个概念:启动条件不接收数据,它只产生一个「开始」信号。
对照你的实现,差距在这里:你的 automation 里,触发时间和业务逻辑是混在一起的。比如 08:40 那条,prompt 第一句是「以笨笨一号身份推送…」,第二句才开始讲逻辑——「什么时候跑」这件事只存在于 automation 的设置里,脚本本身完全不知道自己是定时的还是手动跑的。
这导致一个具体的麻烦:同一个脚本,你手动跑和定时跑,行为完全一样,但期望往往不一样。手动跑的时候你希望它无论有没有内容都输出(好让你看到结果);定时跑的时候你希望没内容就静默。现在没法区分,因为脚本不知道是谁叫它。
这和我刚才在第 3 讲里修正的那条是同一件事:多入口不是问题,入口不可识别才是。如果脚本开头读一个 --trigger scheduled|manual,就能在手动跑时跳过静默逻辑、在定时跑时严格静默。这个改动很小,但能解决一个反复出现的困扰。
分流守恒,复制翻倍。搞混不会报错,只会静默算错。
对应原片约 03:40 – 05:00(这一节最容易被搞错)
他说分支是搭复杂工作流最重要的概念:分支让你能根据不同的条件走不同的路径,这样一个工作流就能覆盖多种情况,而不是只能处理一种。
创建分支有两种方式,而它们的语义完全不一样:
| 方式 | item 去哪 | 结果 |
|---|---|---|
| 用多输出节点(如 IF,有 true / false 两个口) | 每条 item 只走其中一个口 | 3 条进 → 1 条走 true、2 条走 false,总数还是 3 |
| 从同一个节点拖两条输出线 | 每条 item 走所有路径 | 8 条进 → 两条路各 8 条,总数变成 16(被复制) |
他还补了一句:多输出节点的每个口有各自的输出数据——IF 节点里,满足条件的 items 在一个口,不满足的在另一个口,两边的 item 集合是分开的。
「分流是守恒的,复制是翻倍的」——这个区别,你的体系里正好有一个真实例子可以对照。
你的 send_html.py 做的是复制:一个文件同时发企微和飞书,两边各一份。如果哪天某个文件只该发企微(比如超了飞书上限),你现在是在脚本里写 if 大小 > 30MB: 只发企微——这就是把「复制」硬改成了「分流」,但代码上看不出来,下次维护的人(或未来的你)会以为它永远是双发。
n8n 的做法是让两种语义在图上就看得出来:分流用一个判断节点,复制用两根线。一眼就知道「这里是一个分成两类,还是这里是一份复制成两份」。
对你的实用价值是一个提问习惯:写条件之前先问自己「我是在分流还是在复制」。分流意味着两类互斥、加起来等于总数;复制意味着两边都有全部。这两种逻辑写错了不会报错,只会静默地多算或少算——而你那些「为什么两个平台收到的不一样」的问题,多半就出在这。
exists 不等于非空。空有三种形态。
对应原片约 05:00 – 08:30(含实操)
他开始实操。第一步是加 Schedule trigger,设成「每 1 天、上午 8:00」。他还演示了测试可以不等 8 点就跑,但真要自动跑必须激活,激活后手动触发那个节点就可以删掉。
接着加 Filter 节点,目标很明确:把没有邮箱的人筛掉——「如果一个人没有邮箱,我们拿他没办法」,因为后面要给他们发邮件。
第一个坑出现了。他先把条件设成「email 存在(exists)」,测试后发现 10 条进、还是 10 条出——没筛掉任何东西。
原因:空邮箱这一格不是「不存在」,而是「存在但值为空字符串」。所以正确条件不是 exists,而是 不等于空字符串(is not equal to empty string)。
改完之后再测:10 条进 → 8 条留下、2 条被丢弃(那两条邮箱是空的)。
这个「exists 和空串不是一回事」的坑,你在飞书上踩的是同一个形状,而且更严重——因为飞书的空值有三种形态:
| 字段类型 | 空的时候返回什么 | 你的代码怎么处理的 |
|---|---|---|
| 单/多选 | [](空数组,不是 null) | 写 first() 取第一个 → 空数组时返回 None |
| 文本 | "" 或字段不出现 | 两种都得处理 |
| URL | "",有值时是 [x](y) | 写 clean_url() |
你那两个小函数(first()、clean_url())本质就是在抹平这个差异。它们解决得对,但方式是被动的——每个取值点都得记得用。忘一次就出一个「明明有值却读成空」的 bug。
n8n 这一节给的启发是:空值判断要显式说出「你说的空是哪一种」。换成你的实现,就是那个 normalize 函数里每个字段都明确写「这里空意味着什么」——是没填、还是填了但被清空。这两种在业务上的处理不一样:前者可能是还没录入,后者可能是被误删。
第二个直接可用的结论:Filter 是「不往下走」,不是「标记一下继续走」。你的脚本里,条件判断往往是 if 有内容: 发(); else: 什么都不做。这跟 Filter 等价,但有个区别——else 什么都不做的时候,你事后无法知道「今天筛掉了 2 条」。n8n 的 Filter 节点会显示「10 进 8 出」,被筛掉这件事是可见的。这又回到第 4 讲那条:让中间状态可见。
排除法必须用 AND。结果全落一边是典型症状。
对应原片约 08:30 – 12:10
数据筛到 8 条之后,他想再分一层:把工作邮箱和个人邮箱分开(因为接下来要发不同的内容)。用的是 IF 节点。
条件写的是「排除掉 gmail 和 hotmail」——这两类是个人邮箱,剩下的就是工作邮箱。他先用 email 不包含 gmail.com,想了想又把条件简化成不包含 gmail(去掉 .com,这样 gmail.cn 之类也覆盖)。再用同样方式加第二个条件:不包含 hotmail。
第二个坑来了:加了两个条件之后,节点要他选择这两个条件怎么组合。他先选了 OR(「或者」),测试结果——所有 item 都跑到 false 那边去了,true 那边一条都没有。
他自己当场反应过来:应该用 AND。因为「工作邮箱」的定义是既不含 gmail 也不含 hotmail——两个都要满足。
改成 AND 之后再测:8 条进 → 5 条走 true(工作邮箱)、3 条走 false(个人邮箱)。
最后他演示了另一种分支:从同一个节点往下拖两条线,两条线各接一个节点,执行后8 条同时走两条路——这就是复制。
这个错不是他讲错了,而是一个非常真实的思维陷阱,而且你的代码里同样存在这个风险,只是以另一种形式。
「排除 A 和 B」在中文里的说法是模糊的:可以理解成「不同时是 A 和 B」,也可以理解成「既不是 A 也不是 B」,还可以理解成「不是 A 或不是 B」。这三种语义在代码里对应三种完全不同的写法,而自然语言不会告诉你选哪个。
举个你自己体系里的例子。你现在的推送过滤逻辑,如果要表达「这条只在工作日、且非节假日、且不是我自己手动触发的」,三个条件之间必须是 AND。如果哪天有人改成 OR,行为不会报错,只会变成「每天都发」——而且你会以为是定时器坏了。
可以加一条很便宜的防御:凡是多条件组合,在代码或 prompt 里用中文把语义完整写出来一遍。不是写「过滤非工作日」,而是写「A 且 B 且 C:工作日 且 非节假日 且 非手动触发」。含糊的措辞是多条件逻辑出错的第一来源,而把它写成一句话的成本只有一行注释。
另外,他犯这个错时的处理方式值得学:测试 → 看到结果全跑一边 → 立刻怀疑组合方式,而不是怀疑数据。大部分人这时会去查数据是不是有问题,而他的第一反应是「我的逻辑写反了」。「结果全落一边」是多条件逻辑写错的典型症状——记住这个症状,能省很多排查时间。
10 → 8 → 5/3,数据守恒。
综合整理,非原片单节内容
这一讲从头到尾在搭同一个工作流,把它的数据流画出来就明白分支在干什么了:
Schedule Trigger 每天 8:00→启动信号
Google Sheets 读通讯录→10 条
Filter:email ≠ 空串→8 条(丢 2 条)
IF:不含 gmail 且不含 hotmail→true 5 条 / false 3 条
5 + 3 = 8,总量守恒 —— 这是分流对照看,如果最后一层改成「从 IF 节点拖两条线」,那就是 8 条同时走两条路,总量变 16。同样的图,两种画法,语义完全不同。
下一讲讲「常用的节点」,继续在这个工作流上往上加。
把这条链路和你的实际流水线对照,最能看清一个差距:n8n 的每一步都会告诉你「进来几条、出去几条」,而你的每一步只告诉你「跑完了」。
以你昨天的 VA7 深蒸馏为例,如果按这个形式表达:
| 步骤 | n8n 会显示 | 你的实际 |
|---|---|---|
| 扫待蒸馏清单 | 24 条 | 一个数字 |
| Filter:有音轨的可做 | 24 → 22(2 条无音轨被丢) | 事后才发现招人那条没音轨 |
| 每天取 2 条 | 22 → 2 | 「今天做 2 条」 |
| 下载+转写 | 2 → 2 或 2 → 1(失败 1) | 只知道成功或失败 |
差别在第二行:那 2 条无音轨的,在 n8n 里在第一步就被筛掉了,还会显示「筛掉 2 条」;在你这里,是跑到一半才发现,而且要占用一次任务。
这个改法几乎零成本:在任何「批量处理」的脚本开头,先做一次预筛并打印「N 条中 M 条可处理,K 条因 X 原因跳过」。一行输出,就把「哪些做不了、为什么」变成事先知道而不是事后发现。你昨晚交付时那个「29 条 = 24 新下载 + 6 已下载 − 1 无音轨」的说明,其实就是这个信息——只是它是结束后才补的,不是开头就知道的。
关于字幕与识别误差:本页基于 YouTube 英文自动字幕(非人工字幕)整理。ASR 把「n8n」误识别为 nen / nadn / Ann / ENT 等;「gmail.com」识别为 gmail. / do com;「hotmail」识别为 hot mail / PS at Hotmail;「activating」识别为 activation / activating;「IF 节点」的 true/false 两个输出被口播为「up this branch / down this Branch」。以上均已在转述中按语义纠正。数据条数(10→8→5/3)来自原片实测演示。
YouTube · n8n 官方频道 · 16 分 22 秒 | 系列第 6 / 9 讲 | 看原视频
这一讲的位置:第 6 讲是「工具箱」讲——五个常用节点,但真正的主题是数据整形:先削字段(Edit Fields)、再按需聚合或拆开(Aggregate / Split Out)、必要时去重和截断。中间他做了个特别清楚的对比实验:同样 5 条数据,发 1 条汇总 vs 发 5 条单人消息,并给出判断标准——量少无所谓,量多永远优先聚合。另外 Webhook 节点那一段演示了「测试 URL / 生产 URL」分离,正好对应你每次调试都真发到手机这个习惯。
他「每次都推荐」的一步。你的脚本最缺这一层。
对应原片约 00:40 – 02:00(概念),约 04:30 – 07:00(实操)
第一个节点叫 Edit Fields(也叫 Set)。它的定位是管理 item 里的数据:清理、添加、格式化、精简,都可以在这一步做完,好让后续节点面对的数据「干净得多」。
它有一个关键选项:只保留你设置的字段,还是保留全部输入字段再加新的。
然后是这一讲里他说得最重的一句话:
「我一直推荐使用 Edit Fields 节点,确保你只保留对你有用的数据。这能避免你拥有非常复杂的、带着一堆你用不到的字段的 item。」他还补了一句:以后需要什么字段,随时回来加就行。
实操里他把选项设成 no input fields(不保留任何输入字段),然后手工建三个:
| 新字段 | 怎么来的 |
|---|---|
| full name | 先名 + 空格 + 姓,姓用 toUpperCase() 转大写 |
| 从输入拖过来 | |
| company | 从输入拖过来 |
执行后,每个 item 上就只剩这三个字段。他特意验证了一件事:下游节点里 email 这个 key 依然可用——削字段不会削掉下游要用的东西,因为你在这一步已经把它显式列出来了。
「每次都推荐用 Edit Fields」这条,是你所有脚本里最缺的一层。
看你读飞书表格的代码:record-list 返回的一条记录,里面有十几个字段,各种类型(多选是数组、URL 是 [x](y)、日期是时间戳)。你把这个原始 record 一路传下去,每个用到它的人都要自己处理这些怪格式——所以才有 first()、clean_url() 这些函数散落在各处。
Edit Fields 那一步,换成你的实现就是一个 normalize 函数:
飞书原始 record(15 字段、3 种怪格式)→normalize()→{title, group, status, priority, url, minutes}
只留业务真正要的字段,格式全部拉平。之后所有逻辑只面对这 6 个干净键好处有两个,都很具体:① 以后飞书改字段类型,只改 normalize 一处;② 不会出现「某个函数忘了 first(),把一个数组当字符串用」的隐性 bug。
还有一个容易忽略的收益:normalize 逼你说清「这个字段业务上是什么意思」。你现在「状态」字段有三个人类可读值(待读/在读/已精读),还有两个我后加的(弃读/归档)。一旦在 normalize 里列成枚举,就再也不会出现「某条记录的状态是意料之外的值」这种问题。
聚合 / 拆开 / 去重 / 截断——任何流水线都绕不开的四个动作。
对应原片约 02:00 – 03:30(概念),约 07:00 – 09:00(实操)
接下来是处理多个 item 的一组节点。他重点讲了 Aggregate:
它的作用是把所有 item 的数据聚合成一条。例子很清楚:两条输入 item,各自有一个 email,聚合之后变成一条输出 item,里面装着两条的全部 email。
同一组里还有三个兄弟节点,他一句话带过但都是常用件:
| 节点 | 干什么 |
|---|---|
| Remove Duplicates | 去重 |
| Limit | 限制 item 总数(比如只取前 10 条) |
| Split Out | 把一条 item 里的某个 key 拆成多条——Aggregate 的反操作 |
实操里他从 IF 的 true 分支接了 Aggregate,聚合 email 字段,又加了一个 company 字段,然后测试——输出只有 一条 item,里面装着所有符合条件的邮箱和公司。
这里有个很实用的坑:这个节点的「字段」框要的是字段名,不是表达式。他说得很明白:如果你在这里拖一个表达式进去,它给你的会是表达式的文本,而不是那个字段的数据。所以这里要直接打字写 email。
这四个节点(聚合/拆开/去重/截断),其实是任何批量处理都会遇到的四个基本动作。你现在全靠手写循环实现,而且没有名字。
| 动作 | 你在哪儿手写过 | 写对了吗 |
|---|---|---|
| 去重 | VA7 深蒸馏前判断「哪些已经做过」 | 对,但用的是「扫目录对比」而不是显式去重 |
| 截断 | 「每天做 2 条」 | 对 |
| 聚合 | 「今天做完 2 条,剩 22 条」这一条通知 | 对 |
| 拆开 | 一条视频 → 多个章节笔记 | 没做过,一直是 1:1 |
真正值得学的是那个「聚合 vs 逐条」的判断标准,他在后面给了:数据少的时候无所谓;但如果是几十上百条,永远优先聚合成一条汇总。
这条在你身上有个很具体的应用:VA7 深蒸馏每晚做完 2 条,你是发 1 条汇总(对);但如果哪天你让我补 24 条,中间如果每条都发一次进度,那就是 24 条消息——必须聚合。反过来也有个提醒:聚合会丢信息。24 条各自的状态如果都压成一句「已完成 24 条」,你就看不出哪条质量不行。所以聚合之前要先想清:被聚合掉的那些差异,以后还要不要查?要查就别聚合,或者聚合的同时留一份明细文件。
测试 URL 与生产 URL 分离,这是你每次都真发到手机的反面。
对应原片约 03:30 – 04:30(概念),约 09:00 – 12:00(实操)
第 2 讲讲过 webhook 是什么,这一讲是它长什么样。
把 Webhook 节点拖到画布上,你立刻会拿到两个 URL:
| URL | 什么时候收 |
|---|---|
| Test URL | 你点「测试」的时候。用于调试 |
| Production URL | 工作流激活之后一直收 |
两个都可以改。收到请求后,它会把请求带来的数据当作工作流的初始数据,然后往下执行——「这样你就可以从收到 webhook 那一刻开始自动化」。
实操他用 POST 方法,复制 Test URL,然后写了一个小 python 脚本往这个 URL 发一段 body。发完就能在节点里看到标准的四块:headers、parameters、query、body——body 里有 first_name、last_name、company、email、domain、event。
中间他做了一件很实用的事:pin data(把数据固定住)。原话大意是——你可能要到这一步就先停下来、回头再来搭,所以把数据钉住;这样刷新工作流之后,那份数据还在。
「测试 URL 和生产 URL 分开」这一点,正好戳中你体系里一个每次都在冒险的做法。
你现在测试任何推送脚本,都是直接发到真实的企微和飞书。所以每次调试,你手机上就真的会收到一条消息——你甚至会专门跟我说「这条是测试,忽略」。这在 n8n 里是不可能发生的,因为测试走的是 Test URL,根本没碰生产口。
这个可以很低成本地搬过来,改动就一行:给发送脚本加一个 --dry(或 --test)开关,开启时不真发,而是把即将发送的内容写进一个本地文件并打印出来。这样:
| 场景 | 现在 | 加开关后 |
|---|---|---|
| 改完脚本验证格式 | 真发一条到你手机 | --dry,只看文件 |
| 验证真的能发出去 | 真发 | 真发(这时候才该发) |
| automation 定时跑 | 真发 | 真发 |
第二个可搬的是 pin data。你现在调一个脚本,每次都要重新拉真实数据——依赖网络、依赖授权、依赖那个接口今天还正常。如果接口挂了,你连「逻辑对不对」都验不了。修法:让脚本支持「从本地快照文件读输入」,这样调逻辑时数据完全稳定。你把飞书表格导出一份 json 放本地,就是一个现成的 pin。
分支变成一张表,而不是一条长蛇。
对应原片约 12:00 – 15:00
演示的最后一段,他连着做了两条分支:event = invited team member 发一条 Slack,event = account created 发另一条。做法是串联两个 IF 节点:第一个判断「是不是 account created」,不是的话再判断「是不是 invited team member」。
他说这样能跑,但顺口提了更好的做法:
「我们显然可以把这些 IF 节点换成 switch。」(这属于后面的内容,这讲没展开。)
这一讲的结尾他还总结了一句很重要的话,容易被当成客套而忽略:
下一讲预告:n8n 怎么存历史执行记录,以及怎么用它更好地处理错误。
「多个 IF 换成 Switch」这个提醒,你的体系里对应的是prompt 里的 if-else 链。
看你现在那些长 prompt,有不少是这种形状:如果是交易日就…否则…;如果输出含 [OK] 就结束,含 [SKIP] 就静默,其他情况就重试一次,两次失败就报错。三个以上分支串在一起,读的人要在脑子里跑一遍才明白走哪条。
Switch 的思路是:把「判断什么」和「每种情况做什么」摊平成一张表。换成 prompt 的写法,就是不要在正文里写 if-else,而是写一张对照表:
| 退出码 / 输出 | 该做什么 |
|---|---|
0 且含 [OK] | 结束,不重复发 |
0 且含 [SKIP] | 静默结束 |
| 非 0 | 原样重试一次 |
| 重试仍非 0 | 报错并附 [FAIL] 原文 |
对照表比 if-else 好在两点:说不清的情况会暴露(如果某次退出码 0 但输出既不含 OK 也不含 SKIP 呢?表格里没这行,你就知道要补一条);加一种情况只需加一行,不用重新理解整段逻辑。
这条也能直接用到你昨天的经验上:你那些「提醒整合」之所以一再反复,一部分原因就是每个 loop 的失败处理都埋在自己那段 prompt 里,散着五个 if,没有一张统一的表。统一成一张表,才有资格谈「整合」。
全讲最实用的对比实验。
对应原片约 09:00 – 11:30(这是全讲最有价值的一段实操)
他做了同一件事的两种版本,并当场对比:
版本 A(聚合):用 Aggregate 把 5 个人的 email 和 company 合成一条,然后发一条 Slack 消息——「本周注册汇总:邮箱列表…公司列表…」。你收到 1 条消息。
版本 B(逐条):把 Aggregate 节点删掉(n8n 会自动把前后两个节点重新连上),消息内容改成「new sign up from {email}, company: {company}」。因为节点对每条 item 执行一次,结果你收到 5 条消息——每人一条。
然后他给了判断标准,这句话值得原样记下:
这个对比实验,你在两天前的「推送整合」里其实已经自己走了一遍,只是当时没有这个框架。
你当时问的是「14 条推送太多了,砍到 6 条」。按这一讲的框架重新看,你的问题不是推送太多,而是该聚合的没聚合、该逐条的却混在一起:
| 你的推送 | 本质 | 该怎么办 |
|---|---|---|
| 07:55 持仓晨报 + 08:00 A股晨报 | 两件不同的事,但都是「早上该知道的」 | 已合并成 11:20 一条 —— 对的 |
| 08:40 日程 + 阅读 | 两件不同的事,但都是「今天要做什么」 | 已合并 —— 对的 |
| 09:00 / 21:00 学习知识点 | 同一个东西的两次提醒 | 这是复制不是聚合,本质是「重复提醒」 |
| 18:00 / 21:30 / 22:30 吃药 | 三次独立提醒 | 这是刻意重复(怕漏),不是噪音 |
| 22:45 深蒸馏 + 22:55 发布 | 同一件事的上游和下游 | 应当合并成一条结果 |
按这个分类,真正该做的是三件事,而不是「砍条数」:
① 上游下游合并成一条(22:45 和 22:55 现在会各发一次,其实应该是一句「今晚做完 2 条,精读页已更新到 8/30」)。
② 分辨「重复提醒」和「重复噪音」——吃药是前者,学习知识点早晚两次就是后者。
③ 永远不要逐条发批量结果(你这点做对了,值得保持)。
字段维度 × 数量维度,可以拿来自查流水线。
综合整理,非原片单节内容
把这一讲用到的节点按「对数据做了什么」排一下,会发现它们是同一件事的五个方向:
| 节点 | 字段怎么变 | item 数量怎么变 |
|---|---|---|
| Edit Fields | 削/加/改字段 | 不变 |
| Aggregate | 汇成一个列表 | N → 1 |
| Split Out | 数组拆开 | 1 → N |
| Remove Duplicates | 不变 | N → M(M≤N) |
| Limit | 不变 | N → 前 K 条 |
加上讲过的 IF / Filter,你会发现 n8n 的节点库其实是「字段维度」×「数量维度」的一张网格。理解了这张网格,看到一个新节点就能猜到它属于哪一格。
下一讲开始讲错误处理和历史执行记录。
这张表的用处,是给你一个自查清单:任何一条流水线,这五个动作你都做了吗?
拿你的 VA7 深蒸馏流水线走一遍:
| 动作 | 你有吗 | 缺了会怎样 |
|---|---|---|
| 削字段(Edit Fields) | 没有 | 笔记文件里什么都往里塞,格式不统一 |
| 去重(Remove Dup) | 有(扫已蒸馏目录) | — |
| 截断(Limit) | 有(每天 2 条) | — |
| 聚合(Aggregate) | 有(一条汇总通知) | — |
| 拆开(Split Out) | 没有 | 一条视频只能产出 1 篇笔记,无法拆成多章节 |
缺的那两个,正好对应你两个真实的不满意:① 笔记格式不统一(因为没在入口处削字段,六篇深蒸馏里有的有「一句话」,有的没有,有的互证批注写在末尾有的写在中间);② 长视频只能压缩成一篇,而 22 讲的 Loop Engineering 你其实希望它每讲独立成篇(那就是 Split Out)。
最值得先做的是第一个:给深蒸馏产出定一个 schema(固定几个字段:一句话 / 关键概念 / 互证批注 / 原文位置),写的时候按这个填。这样后面无论做精读页、做阅读队列、做语音,都不用再猜格式。
关于字幕与识别误差:本页基于 YouTube 英文自动字幕(非人工字幕)整理。ASR 把「n8n」误识别为 NN / nen / naden / Nidan / Inn 等;「Edit Fields」识别为 edit field / edit fields;「Aggregate」识别为 aggregate / aggregating;「Slack」识别为 slack / stack;「Split Out」被口语描述为「break out one key」;「toUpperCase」识别为 two uppercase。以上均已在转述中按语义纠正。数据条数与节点数量来自原片演示。
这一组对你价值最高。第 7 讲讲错误处理(主动制造失败胜过让脏数据流下去),第 8 讲揭穿「没有节点报错也可能什么都没做成」,第 9 讲讲边界——什么时候不该自己做。
YouTube · n8n 官方频道 · 15 分 23 秒 | 系列第 7 / 9 讲 | 看原视频
这一讲的位置:第 7 讲是整套课里唯一一讲专讲「坏掉之后怎么办」。三件事:执行日志(生产留、手动不留,快照只读)、error workflow(出错就自动拉起另一个工作流报警,但必须逐条绑定)、Stop and Error(主动制造失败,用它挡住不该继续的情况)。这一讲对你价值最高,因为你的体系里「静默失败」和「事后才发现」是最常见的两类损失。
生产留、手动不留。快照只读,所以能当证据。
对应原片约 00:30 – 03:00
他先说清一件之前一直含糊的事:你之前的执行都是「手动执行」(点 execute workflow、点 test step)。而一旦激活工作流,它就在后台自动跑,你看不到过程了。
所以有 execution log(执行日志),入口是「all executions」。默认记什么,他说得很明确:
但可以按工作流单独打开「记录手动执行」。日志支持按工作流、状态、日期范围、执行数据排序和筛选。
点进一次执行,看到的是一份快照:调度触发器触发了、读了 sheet、根据 email 存不存在分别发了 sales 或 marketing。他强调这份快照是静态的、不能改——「这是那次执行所有节点的最终状态」。
用途他说得很直白:调试、修复、检查工作流时非常有用;你可以翻历史执行来理解这个工作流到底怎么跑的。双击节点就能看到那次执行的输入输出、节点设置,如果这个节点出过错,还能看到错误详情。
「生产留痕、手动不留痕」这个默认设定,背后是一个很本质的区分,而你现在恰好把两者混在一起,结果是都没有。
看你的实际:WorkBuddy automation 定时跑脚本,和你自己在会话里让我跑一次,产生的痕迹是一样的——都没有。
| 场景 | 需要留痕吗 | 你现在有吗 |
|---|---|---|
| 定时跑完,发出去了 | 要(证明它真的跑了、发了什么) | 只有发送标记,没有内容快照 |
| 定时跑了,静默(无内容) | 要(证明是「无内容」而不是「没跑」) | 完全没有 |
| 我手动试一次 | 不用(是试验) | — |
| 跑失败了 | 要(要能查为什么) | 偶尔有,格式不统一 |
第二行是最要命的:你的静默型 loop(看门狗、阻塞盘查、待确认提醒)如果哪天真的挂了,你完全无法区分「挂了」和「今天没事」——因为两者都是「没收到消息」。
n8n 的解法很朴素:让「跑过了但没内容」也留一条记录。换成你,就是静默的时候也往日志写一行 {时间, 脚本名, 结果: empty, 原因: 无待处理项}。一行日志的成本,换来「静默可验证」这个能力。
还有一点值得注意:快照是只读的。你现在的 logs/2026-11.md 是 append-only,这个习惯是对的——留痕一旦可以修改,就不再是证据。
出错就拉起另一个工作流报警,但要逐条绑定。
对应原片约 03:00 – 06:30
他先把失败的原因说清:设置不够合理、输入数据格式不对,都会让工作流失败。原因很多,所以关键是理解「有哪几类错误」以及「怎么修」。
第一种处理方法,他强调「非常重要」:error workflow。
定义:它是一个工作流,一旦某个节点出错,它就立刻被执行。作用是报告——告诉你哪个工作流出错了、需要修。
然后是一句容易被忽略的操作细节:这个 error workflow 需要为每一个新工作流单独配置。「所以搭工作流时,记得把 error workflow 设上。」一个实例里可以有多个 error workflow。
他给的例子特别贴合现实:一个每天 8 点跑的工作流,读 Google Sheets 通讯录,然后往 Salesforce 更新客户。而 Salesforce 里 email 是必填字段——所以那些没有 email 的 item,在创建客户时就会报错。这个错就触发了 error workflow,并带上出错节点的信息(这里是 Salesforce 节点)。原片说得很清楚:读了 10 条,其中几条没有 email,于是那个节点报错。
那个 Salesforce 的例子,几乎是你昨晚那次「29 条里有 1 条无音轨」的翻版。
结构完全一样:下游有一个硬性要求(必须有 email / 必须有音轨),而上游的数据里有一部分不满足,于是流程在中途炸掉,而你直到跑完才知道。
区别在两点,都值得改:
① n8n 是「出错就通知」,你是「出错就跳过」。你昨晚的处理是「那条招人的剔除掉」——问题解决了,但它没有留下任何告警。如果哪天有 5 条都无音轨(比如源站换了编码),你会以为「今天只有 3 条更新」,而不是「有 5 条下载失败」。
② n8n 的报警带「出错节点」,你的报警只看得到「失败了」。这个差别在排查时是小时级的:知道是「下载环节」还是「上传环节」坏了,直接决定你去看网络还是看权限。
具体到你的实现,有两条很便宜的改法:
1. 把「跳过」升级成「跳过 + 记账」。被剔除的条目写进一个 skipped.jsonl,字段是 {时间, 条目, 原因}。这样「今天为什么少了 5 条」有据可查。
2. 失败通知固定四要素:哪个脚本、哪一步、原始报错、怎么重跑。现在你的通知常常只有第一项。
对应原片约 06:30 – 08:30
触发 error workflow 的第二种方式,是 Stop and Error 节点:
它每次被执行都会抛出一个错误消息,消息内容可以自己配。默认行为是整个工作流停止、状态设为 failed。
他说这个节点的用途是处理「边缘情况(edge cases)」——在那些「本不该出现的条件」被满足时,主动抛错。他举的例子:一段 webhook 收到的 email 不合法,就 stop and error。
接着是 Error Trigger 节点——error workflow 的第一步。他会输出所有相关信息:
| 输出什么 | 有什么用 |
|---|---|
| 工作流名称、工作流 ID | 知道是哪一个出事了 |
| 执行 ID + 执行链接 | 点一下就跳过去看 |
| 出错节点的信息 | 知道坏在哪一环(普通节点,或 Stop and Error) |
他还给了个「应当成为默认习惯」的建议:永远留一个地方(频道)来接收错误报告——Slack、WhatsApp、Teams,任何沟通工具都行,让团队里能进去看的人知道哪个工作流挂了、赶紧修。他演示的就是:Error Trigger → Slack → 「错误:工作流 {名字},执行链接 {URL},错误消息 {message}」。
「主动制造失败」这个思路,你的脚本里完全没有——这可能是这一讲对你最有用的一条。
你现在遇到「数据不对」时的反应是尽力而为:字段缺了就跳过、字幕短了也照做、抓不到新闻就写「无法确认」。结果是产出了一份看起来完整、实际空洞的东西。你前天让我删掉的那个「消息催化 AI 摘要区」就是典型——它整段在说「无法验证、仅供参考」,因为上游确实没拿到数据,但流程没有停,而是硬生成了一段废话。
如果用 Stop and Error 的思路,应该是:
| 场景 | 你现在的做法 | 该有的做法 |
|---|---|---|
| 字幕只有 200 词(没抓到) | 照做,生成一篇空洞的精读 | 停,报「字幕异常,建议重抓」 |
| 音频文件 0 字节 | 跳过,事后才发现 | 停,报「该条无音轨」(昨晚那条招人视频) |
| 新闻抓取返回空 | 写「无法确认」 | 停那一节,不要让 AI 补空话 |
| 飞书表格查询返回 0 条 | 静默 | 停,报「表可能被清空了」 |
判断标准可以写成一句话:如果「继续下去」的产出会需要加一句免责声明,那就该在那一处停下来。免责声明是「我明知道数据不够还是交付了」的证据。
另外那个「永远留一个频道接收错误」的建议,你其实已经有一个雏形:失败时发企微给我。缺的不是频道,是格式统一——现在每条 automation 各写各的,有的说「已失败」有的说「推送失败」有的干脆静默。
在昂贵动作之前用最便宜的检查挡住。
对应原片约 08:30 – 13:30(含实操)
实操回到上一个工作流。他先做了两处清理:用 Switch 替代了串联的两个 IF,并重命名了所有节点让意图更清楚。
然后他说:这里有两个潜在错误点——① 邮箱是否有效;② 事件类型是否有效。并演示了两种处理方式。
处理一:邮箱校验。「最简单的办法是看这个邮箱里面有没有 @ 符号。更复杂的可以用正则去匹配严格格式,但先就用查 @ 这个最简版。」
IF:email 含 @→true 继续往下走
false→Stop and Error:抛「invalid email」处理二:事件校验。在 Switch 上新增一条规则:event 不存在,或者 等于空字符串——这两种情况都指向 Stop and Error,抛「invalid event」。
他说这样之后:「工作流激活时,它就能同时处理「邮箱无效」和「事件无效」两种情况了。以后 webhook 出问题,会触发 error workflow,我们能进去查为什么没收到邮箱、或者为什么事件无效。」
最后补了一个设置细节:Stop and Error(以及任何普通节点)的「出错时怎么办」可以在设置里改——默认是停止工作流;但如果你处理的是不影响继续的边缘情况,可以选择「继续」或「继续并输出错误」。这是按节点配的。
「查有没有 @ 就够」这个做法,精髓不在简陋,在位置:它在所有昂贵动作之前。
你昨晚的流程顺序是反的:先下载(25MB、几十秒)、再转写(几分钟)、最后才发现没音轨。如果按这一讲的思路,第一步应该是:
取音频直链→校验:时长 > 60s 且 文件 > 500KB→通过才下载/转写
不通过 → 记账 & 跳过,不浪费后面几步这类「廉价前置校验」在你体系里能加的地方不少:
| 环节 | 廉价校验 | 挡住什么 |
|---|---|---|
| 深蒸馏开工前 | 音频 > 500KB 且 时长 > 60s | 纯图文视频(无音轨) |
| 转写完成后 | 词数 > 300 | 转写失败但返回了空结果 |
| 生成 HTML 前 | 每张卡片都有「这一讲在说什么」段 | 内容空洞却发布出去 |
| 发送前 | 文件大小 < 平台上限 且 消息非空 | 发空消息 / 超限报错 |
这四个校验加起来大概二十行代码,但能把「事后才发现」变成「开工前就知道」。你今天这批 7 讲,我其实每个环节都在做这件事(清洗后看词数、生成后数字数、发送前校验大小),只是没有写成固定的校验步骤——靠的是每次想起来。
还有那个「按节点配错误行为」的启发:你的脚本只有「抛异常(停)」和「吞掉(继续)」两种。第三种「继续但把错误传下去」你没有——比如某条新闻抓不到,可以继续生成报告,但把「此条缺失」作为标记传给下一环,让最终产出里明确标出缺口,而不是当没发生过。
分类决定了「该不该重试」。
综合整理,非原片单节内容
他这一讲其实给了三种「错误来源」,只是没有并列起来讲。归一下类就清楚了:
| 类型 | 例子 | 该用什么招 |
|---|---|---|
| ① 配置不对 | 设置没调好、凭据过期、字段映射错 | 修配置。重试无用 |
| ② 数据不合规 | 没有 email、缺必填字段、格式不对 | 前置校验 + Stop and Error 或跳过记账 |
| ③ 外部不稳定 | 接口超时、对方 5xx、网络抖动 | 重试(这正是下一讲要讲的) |
这个分类的价值在于:它直接决定了「该不该重试」。你现在所有 prompt 里统一写的「失败则重试一次」,只对第 ③ 类有效。对第 ①② 类,重试只是把同一个错再犯一遍,还多耗一轮时间。
下一讲讲调试和重试,正好接上第 ③ 类。
用这三类去量你的失败记录,会发现一个很说明问题的事实:你遇到过的失败,绝大多数是 ② 类(数据不合规),但你的处理机制是按 ③ 类设计的(重试)。
| 你的真实失败 | 属于哪类 | 你当时的处理 |
|---|---|---|
| 「受控执行上下文核验失败」 | ① 配置 | 重试 6 次,全失败 |
| 招人视频无音轨 | ② 数据 | 跳过,事后才发现 |
| 飞书 234006 文件超限 | ② 数据(体积不合规) | 压缩后重发(对的) |
| 字幕抓取失败 | ③ 外部 | 重试(对的) |
| RuoYi 相关脚本已删但 CONTEXT 还写着 | ① 配置 | 昨天才发现并修 |
那两条 attempts=6 的 run,就是典型的「用 ③ 的手段治 ① 的病」——重试一百次也不会成功,因为核验逻辑本身是坏的。
可以直接落成一条规矩:重试之前先判类型。判据很简单——如果同一条命令手动跑也会失败,那就不是「不稳定」,是「坏了」,不要重试。这条写进 WORKING-METHODS.md 的失败处理一节,比现在那句「失败重试一次」精确得多。
三件信息,缺一件就得返工。
综合整理,非原片单节内容
他把 error workflow 的演示简化到了极致,只发一条 Slack 消息,内容是三样东西:
① 工作流名称——哪个出事了
② 执行链接——点一下直接跳过去看现场
③ 错误消息——原始报错是什么
他的理由说得很实在:这样「每次出错我们立刻知道是哪个工作流,还有一个能快速进入具体执行的链接,能看到现场,也有错误消息帮助我们判断问题在哪」。
注意他显式提到了「你可能不需要全部三个渠道(Slack + 邮件 + Telegram),但你需要有一个地方能收到错误报告」。
这三件信息,正好可以当成一份检查表,去量你现在的失败通知。结果是不太合格:
| 要素 | 你现在的通知 |
|---|---|
| 哪个脚本 / 哪个环节 | 部分有(「午报失败」),但不说哪一步 |
| 去哪看现场 | 没有。没有日志路径,没有链接 |
| 原始报错 | 有时有,常常被概括成「失败」 |
换成可执行的要求,你的失败通知模板应该是这四行:
❌ 哪个任务:投资午报 13:50
📍 坏在哪一步:抓取基金净值(第 2 步 / 共 5 步)
📄 原始报错:HTTP 403 Forbidden(该接口今天开始要 Referer)
🔁 怎么办:已重试 1 次仍失败;手动重跑 python3 midday-report.py多写三行的成本,换来的是「不用等我排查就知道大概怎么了」。你现在收到的「任务失败」那种通知,实际上等于没通知——你还得回来问我。
这条也能立刻用在这批 n8n 的任务上:这 7 讲如果哪一讲处理失败,我会按这个四行格式报给你,而不是只说「第 6 讲失败了」。
关于字幕与识别误差:本页基于 YouTube 英文自动字幕(非人工字幕)整理。ASR 把「n8n」误识别为 nen / niden / naden / Inn / idend 等;「Salesforce」识别为 sales force / Sales Force;「Slack」识别为 slack / stack;「Stop and Error」被口播为「stop and error node」;「regex」识别为 reg xes。以上均已在转述中按语义纠正。
YouTube · n8n 官方频道 · 16 分 10 秒 | 系列第 8 / 9 讲 | 看原视频
这一讲的位置:第 8 讲(原片标称「最终讲」,实际还有一讲协作)专讲调试。最有价值的一条是它开头就点出的:有些失败不会报错——没有节点抛错,但任务也没做成,状态不是 failed,于是不会有任何告警。后半段两个实操案例分别演示了「有报错怎么修」和「没报错怎么修」,后者正好对应你「静默失败」的老问题。
没有节点报错,但任务没做成。你体系里最常见的一类损失。
对应原片约 00:30 – 01:50(概念),约 12:00 – 14:30(实操案例二)
他先定义了调试:调试不只是「把错误修掉」,而是「修掉 + 确保它不再发生」的过程。
失败原因分三类:配置错了、底层服务不可用(比如 500)、输入数据有问题(比如 webhook 缺字段)。默认行为是停止工作流、状态设为 failed,然后你能从执行日志里找到它们,逐个处理。
然后他说了一句这一讲最重要的话:
后面实操里他真的演示了一个这样的执行:webhook 收到了、去查用户、什么都没发生,没有消息发出。原因:按 ID 查人,这条 ID 在表里不存在,所以查询返回了空——空不算错,流程继续往前走,走到发消息那一步时没有数据可发,于是静默结束。
他说:「这是一个很好的例子:它不会失败,但也不会成功。」
这一条几乎是为你的体系写的。你有过太多次这种「没报错但也没做成」:
| 事件 | 有没有报错 | 你有没有收到东西 |
|---|---|---|
| 午报被调度器 skip | 没有(不是失败,是被跳过) | 没有。你下午才发现 |
| DSA 研报某天没发 | 没有 | 没有 |
| VA7 某条视频无音轨 | 没有(被跳过) | 没有 |
| 看门狗没在跑 | 没有 | 没有 |
这四件事的共同点:系统认为「正常」,你认为「该有东西但没来」。而因为你只会在「该来没来」时才发现,所以每次都滞后半天到一天。
n8n 从这里走出来的方式有两条,都能搬:
① 把「空结果」变成一个显式分支。查询返回空不是「继续往前」,而是走「没找到」那条路,那条路的出口是 Stop and Error 或一条通知。
② 让「本该发生但没发生」变成可判定的事。比如午报:13:50 跑完之后,无论成功与否,都在日志里落一行。至少你能区分「跑了但没内容」和「根本没跑」。
最根本的一条:把「完成任务」当成需要证明的事,而不是「没有报错就等于完成了」。你现在很多脚本的退出码 0,含义是「我没崩」,不是「我把活干完了」。这两件事差得很远。
先看成功的那次,再用失败数据复现。
对应原片约 01:50 – 03:20(概念),约 07:00 – 09:30(实操)
Debug in Editor 是他称为「超强功能」的一个东西:
它把执行历史里某次失败执行的数据,pin 到当前画布上。也就是把那次执行里的 item 原样复制过来,固定住,让你用这份真实数据去调试——和前面 webhook 那讲里的 pin data 是同一件事。
两个要记住的细节:
① pin 住的数据在节点右下角有蓝紫色标记;
② 一个工作流同时只能有一组 pinned data——所以 bug 要一个一个处理完,还要注意「修好这个会不会弄坏那个」。
实操里他先做了一件很关键的事:先打开「成功的执行」,弄清这个工作流本该做什么。
看清了:webhook 收到一个 ID → Google Sheets 按 ID 列筛选 → 拿到那一行全部信息(email、名、姓、公司)→ Slack 发消息。
然后才去看失败的执行,一眼看到错误:cannot read properties of undefined reading toString——它在读 body.ID,而这次 webhook 里根本没有 ID。
接着才点 Debug in Editor,把这份「没有 ID」的数据搬进画布。
「先看成功的那次」这个顺序,是这一讲最实用的一条方法,而且你现在是反着做的。
回想昨天/前天排查午报:我们的做法是先查为什么没有(查调度、查日志、查 PAUSED 状态),绕了一大圈才确认「脚本本身没问题」。如果按他的顺序,第一步应该是打开上一次成功的午报,看它长什么样、什么时间、多少内容——立刻就知道「应该有 6 只基金 + 商品行情」,然后才去比对今天缺了什么。
换成一句话的规矩:排查「为什么没有」之前,先确认「有」的时候是什么样。你有这个条件——报告都落盘在 reports/,翻昨天的文件就行。但你的习惯是直接来问我,而不是先翻昨天那份。
第二条可搬的是 pin data。你调试脚本只能用「今天的真实数据」——而今天的数据明天就变了,甚至接口今天就挂了。这就是为什么你经常陷入「逻辑改了半天,但没有数据能验」的困境。
很便宜的改法:每次成功跑完,把输入数据存一份快照(飞书表格导出成 json、webhook payload 存文件)。调试时用 --from-snapshot=xxx.json 读快照而不是重新拉。这样数据固定,改一行跑一次,几十秒就能验证一次逻辑。
retry 从出错节点开始——这条细节很关键。
对应原片约 03:20 – 04:40
修好之后,可以把一批失败执行一起重试。两个选项:
| 选项 | 含义 |
|---|---|
| 用当前保存的版本 | 按你刚改完的工作流重跑 |
| 用执行当时的原始版本 | 按那一刻的工作流重跑(用于验证「真的是工作流的问题」) |
然后是他特意强调的一句机制细节:
含义很直接:如果错误来源于「出错节点之前的某个配置」,那 retry 没用,必须用 copy to editor 重新执行整条。因为前面那些节点不会被重跑,它们仍然是错的结果。
他还补了另一个调试工具 Edit Output:可以手动改某个节点的输出。适用场景很具体——用 webhook 时你不想反复发各种测试事件,直接改输出更快。但他明确说了要慎用、不可扩展,只在「没法 retry」时用来快速清理几次积压。
还有一个配套的:workflow version history。改坏了能看到所有历史保存版本,回退或查看结构。他说这个可以和 retry 配合——先回退到旧版本,再用当前版本重试。
「retry 从出错节点开始」这条,暴露了你的重试机制一个纯浪费的设计。
你的办法是整条重跑。看昨天 VA7 的实际流程:下载音频(30 秒)→ 转写/清洗(20 秒)→ 写笔记(分钟级,人/AI)→ 同步知识库(10 秒)→ 通知。如果最后一步通知失败了要重试,前四步全部白跑一遍——而写笔记那一步的代价是最大的。
n8n 之所以能从出错节点开始,是因为它每一步的输入输出都留了。你没有留,所以没法从这里继续。这是个架构差异,改起来不小。但有个折中方案很划算:
给耗时步骤加「产物缓存」。下载完的 m4a 存在 audio/p06.m4a、清洗完的文本存在 distilled/p06.clean.txt——这些其实已经存在了!问题只是脚本没有「检测到已存在就跳过」的逻辑。今天早上我跑 7 讲时,fetch_ep.sh 里恰好写了 if [ -f "audio/p$n.m4a" ]; then echo 已存在,跳过——那就是最简版的「从断点继续」,成本只有一行 if。
建议把这条变成规矩:任何超过 10 秒的步骤,产物先落盘;脚本开头检测已有产物并跳过。这样重跑自动变成「从断点继续」,不需要任何框架。
第二条可搬的是 version history。你的脚本没有版本。今天我给 controller.py 改代码时手动做了 .bak——那是我临时想起来,不是规矩。会碰生产链路的改动,备份应该是规矩而不是记性。今天就有一条现成的反例:如果你把 send_html.py 改坏了,你现在没有任何回滚点。
查不到也要给一条空记录,否则流程静默断掉。
对应原片约 14:30 – 17:00(案例二的修法)
回到案例二(没报错也没成功)。修法分两步,都很值得记。
他的原话意思:这样即使没查到联系人,我们也会拿到一条空 item 的信息。——空 item 让下游还能继续执行、还能做判断,而不是整条链在这里断掉。
IF:json.email 存在→true:发 Slack 消息
false→Stop and Error:抛「contact not found in database」第三步,他做了一次重构——这段很有教育意义:既然前面几个分支最后做的都是同一件事(判断邮箱 + 发消息 / 抛错),那就别复制三份,把所有的「查不到」都接到同一个 Stop and Error 上,只留一个 IF。
他说这样之后:「下次如果找不到用户,我们就会有错误,有人能进来处理这个情况。如果这是常见情况,就换一种方式处理;如果不常见,就去查哪里错了。」
「查不到也要输出一条空记录」这一条,直接对应你昨晚的一个真实问题:飞书表格查 0 条时,你的脚本会怎样?
大概率是:rows = [] → 循环不执行 → 什么都不发 → 退出码 0 → 看起来「成功」。而如果那时是因为 base token 错了、表被删了、权限掉了,你永远不会知道,只会觉得「今天队列里没东西」。
按这一讲的修法,应该是:
读表→0 条?→IF:0 条 且 表本应有数据→报警「表可能异常」
0 条本身不是错,但「一直是 63 条,今天突然 0 条」是错关键是引入「记忆」:跟上次比。0 条本身无法判断对错,但「从 63 掉到 0」一定是异常。这跟我讲解第 4 讲时说的「比集合不要比计数」是同一个思路的延伸——有个基准,异常才有定义。
还有一个很实际的点:「contact not found」这类错误命名值得抄。你的错误消息现在是「失败」「错误」,而好的错误消息是一句话说清「什么没找到」——「用户表里没有这个 ID」「深蒸馏队列里 24 条全部无音轨」。这种消息拿到手就知道下一步查什么。
三个分支做同一件事,就合成一个。
对应原片约 16:00 – 17:30
这是他演示里唯一一次「顺手优化」,但很典型:
原始写法是三个分支各自处理——有 ID 走一条路、有 email 走一条路、都没有再抛错。每条路都各自接一个 Stop and Error。
然后他说:「这些其实做的都是同一件事,我们可以稍微整理一下——用一个 IF 和一个 throw error,把这里的都接过去。」
整理之后:所有的「查不到」都汇到同一个出口,只有一个错误节点、一种错误消息。
这一讲的结尾他说了这套课后半段的安排:进阶课会讲更高级的构建、复杂数据流、以及更复杂的错误处理与调试。
「三个分支做同一件事 → 合成一个」这个动作,在你这边对应的是那些重复的失败处理代码。
你现在每条 automation 的 prompt 末尾都写着几乎一样的一段:「失败则原样重试一次;连续两次失败则明确报告错误,绝不静默当作已发送。」这段逻辑在 20 条 automation 里重复了 20 次——每次新建一条就复制一遍,改一次口径要改 20 处。
正确的做法就是他的「扇入」:把失败处理收进一个地方。具体到你,可以是发送脚本内部统一处理(成功/失败都按固定格式记一笔并发通知),prompt 里只剩一句「跑它,看退出码」。这样「失败怎么办」只有一份定义,不会出现「有的静默有的报错」这种不一致。
这也解释了你昨天为什么要「整合提醒」——20 条各自为政的 prompt,本质上就是 20 份重复的错误处理被复制了 20 遍,它们迟早会不一致。整合的正确方向不是砍条数,而是把重复的部分收成一份。
可以固定下来的排查顺序。
综合整理,非原片单节内容
把他两段实操的步骤抽出来,就是一套可复用的流程:
| # | 做什么 | 为什么 |
|---|---|---|
| 1 | 先看成功的那次 | 知道「正常该输出什么」,才有比对基准 |
| 2 | 再看失败的那次,读原始错误 | 错误消息往往直接指出字段名(body.ID 不存在) |
| 3 | 把失败数据 pin 进画布 | 用真实数据复现,不用重造 |
| 4 | 改完用这份数据验证 | 数据固定,改一行验一次 |
| 5 | 批量 retry 历史失败 | 但注意:只从出错节点开始,前面错的不行 |
另外要记住那个「没报错也没成功」的类别——它不会被这套流程覆盖,因为它没有 error 可看。这一类要靠主动设置检查点(Always Output Data + 显式判空 + Stop and Error)把它变成「有错可看」。
这五步可以直接变成你以后排查的固定开场,省掉来回绕。
拿「午报没发」演练一遍,按这个顺序应该是:
| 步骤 | 具体动作 | 昨天实际怎么做的 |
|---|---|---|
| 1 | 打开昨天成功的午报,看内容结构 | 跳过 |
| 2 | 看今天的执行有没有报错 | 查了调度,发现是被 skip |
| 3 | 用今天的数据复现 | 手动跑脚本 |
| 4 | 验证修好 | 手动跑通、补发 |
| 5 | 把错的调度修好,避免明天再犯 | 迁到 WorkBuddy 调度 |
少了第 1 步的代价是:我们绕了一圈才确认「脚本本身没问题」——而如果你一开始就知道「正常应该有 6 只基金 + 商品行情」,那么「今天完全没有这份文件」这个事实立刻就把问题定位到「没跑」而不是「跑错了」。
一句话总结这一讲对你的价值:调试不是修 bug,是让「坏了」这件事在第一时间被发现。你现在的系统最缺的不是修复能力,是发现能力——它坏了不吭声,等你想起来问才发现。
关于字幕与识别误差:本页基于 YouTube 英文自动字幕(非人工字幕)整理。ASR 把「n8n」误识别为 nen / nadn / Ann / Nidan 等;「Slack」识别为 slack / stack;「Debug in Editor」被口播为 debug in editor / debuging editor;「Always Output Data」被口语描述为「always output data」;「Stop and throw error」被口播为 stop and throw error。以上均已在转述中按语义纠正。
YouTube · n8n 官方频道 · 11 分 28 秒 | 系列第 9 / 9 讲 | 看原视频
这一讲的位置:第 9 讲是收尾,主题是协作:模板库、三级权限、工作流分享、凭据分享、n8n 自己的 API。它跟前八讲风格不同——前面讲「怎么搭」,这一讲讲「什么时候不该自己搭、以及多人用的时候边界在哪」。对你这个单人单机场景,直接可用的是两处:模板库那条「先看有没有现成的」,和 API 那条「用一条流程管其他流程的开关」。
动手之前先看一眼,可能整段活都不用干。
对应原片约 00:40 – 03:00
他先说社区,理由很实在:n8n 的社区活跃度和响应速度是它区别于其他自动化平台的地方——公告、即将发布的功能、提需求、问工作流问题、报 bug 都在那儿;支持通常回得很快,避免搭工作流时的停机。他还劝人别客气,想要什么功能就去提。
然后重点讲模板库(templates):它覆盖了大量「常见的自动化问题」。
他举的例子都很具体:
| 你想做什么 | 模板库里 |
|---|---|
| 搭一个 API endpoint | 已有现成模板,不用从零开始 |
| 把全部 n8n 工作流备份到 GitHub | 已有现成工作流 |
| 搭聊天机器人 | 有 |
| 从 PDF 里提取文本 | 有 |
他的总结:「这会帮你省很多时间,甚至可能省掉你专门为某件事投入的全部时间——因为那件事在模板库里已经有人做过了。」
查找方式:按分类排序、按名称或节点类型搜索。比如你想用 OpenAI,就直接搜 openAI,看看有哪些现成模板。入口在 n8n.io/workflows 或界面内。「所以建工作流之前,记得先来这里看看。」
另外可以反向往回贡献:自己搭了有用的也能提交成模板。他特意补了一句让人放心的:提交时不会共享任何凭据,所以不用担心安全问题。
「动手之前先看有没有现成的」这条,是这一讲对你最省钱的一句——而你现在正好是反着做的。
你交给我一件事,我的默认动作是从零写一个脚本。这两天写了几十个:读飞书表格、发企微消息、转码音频、清洗字幕、生成 HTML、发布覆盖。其中相当一部分本来就有成熟轮子:
| 你让我从零做的 | 其实有现成的 |
|---|---|
| YouTube 字幕清洗(rolling 去重算法) | yt-dlp --write-auto-subs 配 youtube-transcript-api,或 whisper 自带的分段输出 |
| 音频转码与拼接(ffmpeg 一堆参数) | 常用参数组合已被封装成脚本;拼接用 concat demuxer 是标准做法 |
| Markdown → HTML 精读页 | 各种 md 渲染器 + 模板 |
但这里要说清一个取舍:「有现成的」不等于「该用现成的」。你的场景很多是定制化的(比如「中文精读 + 对你体系的应用」这种版式),现成轮子接不上。所以正确的判断标准不是「有没有人做过」,而是——
这件事的核心难点是「业务判断」还是「技术实现」?技术实现类的(转码、清洗、抓取、渲染),优先找现成;业务判断类的(这讲该提炼什么、该怎么映射你的体系),只能自己做。
按这个标准,今天这 7 讲里下载和清洗该用轮子,写卡片不该——而实际是我两样都自己写了。以后接任务先分这一刀,能省掉不少重复劳动。
能授权 ≠ 能读取。这是凭据系统的关键设计。
对应原片约 03:00 – 05:20(这一节是全讲最有设计味道的)
三种用户角色:owner / admin / member,对工作流和凭据的访问级别不同。目的是确保没有人能获得不该有的访问权——不管是工作流、API key 还是任何具体工具。
owner:每个实例只有一个,权限最全。但他强调了一个反直觉的点:
他的原话总结:这是「对分享的访问权」,不是「对底层潜在敏感信息的访问权」。
admin:和 owner 很像,但没有 cloud dashboard 的权限,也不能管理 owner 这个角色本身。
member:普通用户,能管理自己的账号和工作流——标签、分配、分享、自己的密码等设置。
「能授权,但不能读取」这条规则,把凭据系统的设计意图说透了,也正好能解释你体系里的一个隐患。
你现在的凭据是明文散落在文件里:dsa/.env 里是 DeepSeek key,lark-cli 是登录态,wecom-send.py 靠环境变量。任何能读这些文件的东西,都能直接拿走 key 并用在别处——它们不区分「使用」和「查看」。
n8n 的做法是把这两件事拆开:凭据是个黑盒,工作流只能「引用」它,人只能「管理」它,但没有任何角色能「查看」它。好处很具体:
| 场景 | 你现在 | n8n 的做法 |
|---|---|---|
| 要换个 key | 改 .env 文件 | 在凭据里更新,所有引用它的工作流自动生效 |
| 想给别人用又不给 key | 做不到,只能直接给 key | 分享凭据,对方能用不能看 |
| 想知道哪些地方用了这个 key | 得全盘搜 | 凭据详情里能看到引用它的工作流 |
单机单人,你不需要完整实现这套。但「哪些地方用了哪个凭据」这个清单,成本很低、价值很高——你昨天刚因为「RuoYi 脚本已删但 CONTEXT 还写着」这件事,浪费了排查时间,本质就是这类清单缺失。
还有一个直接相关的:你反复重扫飞书二维码。如果有一处「凭据清单 + 上次验证时间」,你就能提前一天知道快过期,而不是等某条推送没发出去才发现。
分享工作流会隐式分享凭据使用权。取舍要看清。
对应原片约 05:20 – 08:40
建工作流时可以分享给成员,或限制访问。他的建议很明确:只让相关的人访问相关的工作流,避免「不懂这条工作流的人做出改动、引入 bug」。
默认行为:没被分享的 member 访问不了那个工作流。分享入口在画布右上角。工作流里有两个角色:Creator(创建者)和 Editor(编辑者)。
然后是一条容易被忽略、但影响安全边界的规则:
他解释了这个设计的理由:只是为了让被分享的人能进来改、能测试。——如果分享了一条用 Slack 凭据的工作流,但对方没权限用这个凭据,那他就没法测。
接着讲 credential sharing(凭据分享):可以把凭据分享给同实例的其他用户,对方能在自己的工作流里用它,但看不到也改不了凭据详情。他再次强调这是为了安全:没人能提取 app token / API key 拿去别处用。
入口:打开凭据 → 左侧菜单的 sharing 设置 → 加人 / 撤权。
「分享工作流等于隐式分享凭据使用权」这条,看起来是 n8n 的细节,其实是一个普遍的权限设计取舍,而且你的 c/w 双 Agent 体系正好是同一个形状。
Codex 和我共用同一套凭据池:同一份 DeepSeek key、同一个 lark-cli 登录态、同一个企微 chat_id。所以——你把一个任务交给 Codex,等于把「我们两个能碰到的所有东西」都交给了它,哪怕那个任务只需要读一个文件。
讲师的选择是「为了能测试,接受这个扩大」。你的情况要不要接受,取决于一个问题:这些凭据里,有没有哪个「被误用一次就会造成不可逆损失」的?
| 凭据 | 误用后果 | 可逆吗 |
|---|---|---|
| DeepSeek key | 多花钱 | 可逆(删 key) |
| 飞书文档读写 | 改坏知识库 | 可逆(有版本) |
| 企微发消息 | 发错消息给你 | 可逆(解释一下) |
删除操作(如 delete_method) | 删掉数据 | 不可逆 |
前三项都在可逆范围内,所以「共用一个凭据池」这个方便值得要。真正该单独设门禁的是第四类——你已经有这个门禁了:删除类操作我都要逐条问你确认。这条规矩的价值,比任何权限系统都直接。
对应原片约 08:40 – 11:20
他先自问了一句:「我们在 n8n 里已经在用 API 了,为什么 n8n 自己还有 API?」然后给了两个用例:
**① 用 n8n 节点去管理其他 n8n 工作流;
② 从外部程序访问、创建、编辑 n8n 工作流。**
用法:设置 → n8n API → 生成新 key。它是 REST API,端点包括:获取/删除执行日志、创建工作流/更新/删除、激活/停用工作流、创建/删除凭据等。用 n8n 节点做也行,功能基本一样。
他说最有用的是「程序化地更新工作流」,并举了一个很具体的例子:
假设某个工作流只想在工作时间跑(早 8 点到晚 6 点),可以用一条辅助工作流在 18:00 把它停用、8:00 重新启用。他说这件事也能在工作流内部做,但用 API 是一种方式。
最后提了 security audit 功能:可以拉出所有执行日志等做安全审计。
「用一条流程管其他流程的开关」这个用法,你恰好有一个很贴切的需求场景——而且你现在是完全缺的。
你昨天让我做的事就是:把 20 条 automation 关掉一部分、合并一部分。这个动作现在只能靠我一条条手动执行:找到 id、改成 PAUSED、再找下一条。20 条改完花了不少轮次,而且没法复用。
如果按这一讲的思路,应该是:一个统一的状态管理入口——一张表(或者一个 json)定义每条 loop 的期望状态(ACTIVE / PAUSED / 只在交易日 / 只在工作时间),然后一条脚本去对齐。要「全部静音三天」,改一个字段就行。
这件事对你已经有现成的落点:loops.md 那张注册表。它现在只是文档,如果给它加一列「期望状态」,再配一个同步脚本,它就变成了唯一的事实源——这正好符合你「任务唯一源 = tasks.md」那个习惯:loop 的唯一源 = loops.md。
第二个可用的:「只在工作时间跑」这个例子,直接对应你的提醒噪音问题。你现在 18:00 / 21:30 / 22:30 吃药、22:00 后连发 4 条,全在晚上。如果有一条按时间段自动静默的机制,你不需要删任何一条 loop,只要定义「22:00 后只允许 P0 级别通过」——用规则代替逐条删减,可逆得多。
这套课真正给的三件东西,与对你真正有用的四条。
综合整理,非原片单节内容
把九讲串起来看,它其实只教了三件事,而第三件是最容易被当成「工具技巧」而忽略的:
| 内容 | 对应讲次 | |
|---|---|---|
| ① 概念 | 触发器 / 数据 / 节点 / item / 表达式 | 1-4 讲 |
| ② 方法 | 分支 / 数据整形 / 错误处理 / 调试 | 5-8 讲 |
| ③ 边界 | 权限、分享、API、模板——什么时候不该自己做 | 9 讲 |
第三件是他放在最后讲的,但它其实是整套课最贵的一课:知道模板库里有现成的、知道权限该怎么分、知道什么时候用 API 而不是手工改——这三件事都不产生新功能,但它们决定了你建十件事还是一个下午搭完。
他在这一讲的结尾说了句大白话:「视频九结束了,讲了工作流分享、凭据和很多有用的技巧。」然后就结束了——没做总结,也没画大饼。这套课的风格一直是这样:不承诺能力,只讲清机制。
九讲里,我认为对你真正有增量的只有四条,其余是「知道就好,不用动」:
| # | 这条 | 对你的具体动作 |
|---|---|---|
| 1 | 节点分三类,你的 loop 缺中间层 | 给需要判断的 loop 补 function 层,比砍推送条数更有效 |
| 2 | 空输出也必须是显式记录 | 让「静默」也留一行日志——你的静默型 loop 现在挂了无法被发现 |
| 3 | 没报错也可能没做成 | 午报 skip、DSA 没发,都是这一类。加「本该发生」的检查点 |
| 4 | 测试口与生产口分离 | 发送脚本加 --dry,不再每次都真发到你手机 |
剩下的(webhook、权限、模板库、n8n API)对你有参考价值,但不是现在该做的事——它们要么需要公网、要么需要多人协作、要么需要先有十件以上的自动化才值得管。这个判断很重要:学了不等于要做。
还有一件值得说清的事:你这套体系不需要 n8n。九讲的价值不在「教会你用这个工具」,而在它给了你一套术语,能用来描述你自己系统里本来存在但没名字的问题——「缺中间层」「静默失败」「没有测试口」,这些词现在你可以直接用来指挥我,比「推送太多了帮我砍几条」精确得多。
关于字幕与识别误差:本页基于 YouTube 英文自动字幕(非人工字幕)整理。ASR 把「n8n」误识别为 nen / naden / Ann / anyen 等;「Glossary / credentials」识别为 credential / credent;「community.n8n.io」被口播为 community. nan;「security audit」被口语描述为 generate security audit。以上均已在转述中按语义纠正。
| 这套内容里的什么 | 对应你手上的什么 | 具体怎么用 |
|---|---|---|
| 错误处理分支 | receiver.py 的异常兜底 | 关键节点都要有失败出口,别只写 happy path |
| 重试与幂等 | midday-send.py 三层重试 | 重试要判重,否则重复推送 |
| item / JSON 结构 | 报告数据结构(概览数、卡片、表格) | 先定结构再写渲染 |
| 调试与执行日志 | logs/ | 每次失败留可复现的输入 |
| Webhook 触发 | 企微回调入口 | 外部触发要有签名校验 |
| 团队与版本 | kb/ 与脚本的 git 化 | 版本化之后再谈协作 |
9 讲全部完成。后续 n8n 大版本更新时补差异。