普通视图

发现新文章,点击刷新页面。
昨天 — 2026年1月13日iOS

ET,福尔摩斯,马尔科维奇,爱迪生:四种思维训练法

2026年1月13日 08:00

关于好奇心的重要性,怎么强调都不为过。尤其是在工作了一段时间之后,好奇心往往最先被消磨:流程变得熟悉、问题开始重复、注意力被琐碎事务和压力不断切割,慢慢地,我们便不再追问「为什么」。

为了对抗这种精神熵增,我总结了一套简单易行的思维训练法。通过四种「角色扮演」模式,强制切换视角,外加一个通用框架作为辅助工具,帮助我们找回对世界的敏锐度。


1. ET 模式(外星人视角):对抗「习以为常」

核心理念:去熟悉化(Vuja De)

我们常说 Déjà vu(既视感),即对陌生环境感到熟悉;而 ET 模式追求的是完全相反的状态——Vuja De(未视感)。即:面对最熟悉的事物,强迫自己把它当成第一次见到,甚至完全不理解其用途。

  • 「火星人观察报告」:尝试描述一件日常小事,但不使用约定俗成的名词。以「开会」为例,如果剥离掉「会议」这个概念,在 ET 眼中看到的是:一群碳基生物围坐在一张木板旁,地位最高的雄性发出声波,其余低阶生物低头在发光的玻璃板上快速移动手指。洞察:这种视角的价值在于剥离了社会强加给事物的「功能固着」。当不再把「低效的会议」理所当然地看作「工作流程」,才更有可能发现其本质——比如「信息传递效率极低」,进而思考:为什么不直接进行脑电波传输(发文档)?
  • 「为什么追问链」:因为 ET 从没见过地球的物品,所以一切都值得质疑。顺着这个逻辑链条深挖:为什么手机屏幕是长方形的?(为了适应手掌抓握);为什么一定要手持?(因为要随时观看);为什么一定要用眼睛看?(目前的信息交互受限于视觉)。这种像孩子一样的连续追问(比如我小时就很好奇,为什么大人们打招呼通常都是「饭吃了吗」),往往能带我们穿透表象,触达事物的底层逻辑或生理极限。

2. 福尔摩斯模式(侦探视角):对抗「视而不见」

核心理念:观察而非仅仅「看见」

福尔摩斯有一句名言:「你只是在看,你没有在观察。」 (You see, but you do not observe.) 这个模式要求我们将模糊的现状清晰化,寻找因果链条和逻辑漏洞。

  • 从废弃中寻找线索:最近在看《黑白大厨》时,注意到一个细节:评审白钟元注意到角落里有一碟被回收的、只吃了一半的牛肉。其他选手都没有注意到,他还拿起其中一块没被吃过的牛肉品尝,发现牛肉过于干柴。 这就是侦探视角——从被忽略的细节(剩菜)中反推过程(烹饪失误),进而挖掘出被掩盖的真相。
  • 关注「沉默的证据」:除了看到的,还要关注没发生的。比如在福尔摩斯的《银色马》一案中,关键线索是「那只在晚上没有叫的狗」。因为狗没叫,所以牵走马的人一定是熟人。在工作中,如果能注意到「谁没有发声」、「哪个数据没有变化」,有时能发现比喧嚣表面更重要的信息。

3. 马尔科维奇模式(体验视角):对抗「自我中心」

核心理念:深度沉浸与换位思考

概念源自电影《成为马尔科维奇》,主角通过一道暗门能直接进入马尔科维奇的大脑,透过他的眼睛看世界。在生活中,这个模式几乎随处可用。

比如在咖啡馆里,可以尝试切换视角:

  • 作为店员:

    • 为什么选择这家店?
    • 需要哪些技能?
    • 如果跳槽,可能会去哪里?
  • 作为老板:

    • 为什么选址在这里?
    • 与周围咖啡馆的差异是什么?
    • 收入、成本、利润结构大概如何?
    • 哪些地方还有改进空间?

看剧时同样适用。比如:如果我是《绝命毒师》里的老白,在被 Tuco 掳走、Tuco 又被杀之后,该如何解释自己的失踪,既合情合理,又不引起怀疑?

4. 爱迪生模式(实验视角):对抗「光想不做」

核心理念:假设与验证

爱迪生代表的是实干派与实验精神。当对某个现象产生好奇,比如「为什么这类小红书帖子会火?」不只停留在分析。试着提出假设(可能是封面图夸张,也可能是标题引发焦虑),然后设计一个低成本的实验——发几篇不同风格的帖子去验证你的假设。在产品领域,这就是先做 Demo 验证可行性。唯有实验,才能将好奇心转化为确定的认知。

一个通用框架:3W2H

最后分享一个我自己经常使用的框架:3W2H。它是在黄金圈法则(Why–How–What)基础上的扩展,更适合日常思考。

以「电视」这个习以为常的物品为例:

  • What(本质):它是什么?是显示屏,还是家庭娱乐中心?
  • Why(根源):为什么我们需要电视?是为了获取信息,还是为了背景噪音?
  • How(机制):它的运作原理和组成是什么?
  • How much(量化):它的价格构成是怎样的?覆盖了多少人群?
  • What if(假设):如果世界上没有电视会怎样?有完美的替代品吗?

这套组合拳能迅速将一个单薄的概念拆解得立体而丰满,在短时间内建立对陌生领域的深度认知。


好奇心不仅是一种能力,更是一种对抗平庸的武器。当我们开启 ET 的眼睛,用福尔摩斯的大脑思考,钻进马尔科维奇的躯壳,并像爱迪生一样去动手实验时,原本枯燥乏味的世界就会立刻生动起来。

世界没有变,变的是我们看待世界的分辨率。希望这四种模式和工具,能帮你擦亮积灰的镜头,重新发现那个充满惊奇的「新世界」。

Capacitor + React 的 iOS 侧滑返回手势

作者 liusheng
2026年1月13日 14:00

Capacitor + React 的 iOS 侧滑返回手势

适用对象:用 Capacitor 把 React SPA 打包成 iOS App,二级页面希望支持系统左侧边缘右滑返回(侧滑返回手势)。

问题的背景

在 WKWebView(Capacitor iOS 容器)里跑 React Router 这类 SPA,经常会遇到:

  • 二级页面无法侧滑返回;
  • 能侧滑但上级页面预览是白屏/黑屏(看不到上一页内容);
  • 自己实现手势(截图 + 叠层 + history.back())会引入大量时序/兼容性坑。

解决的结论:优先用系统能力,而不是自研手势

核心思路:让 WebView 直接启用 WebKit 自带的交互式返回手势。

在 iOS 上,这个开关就是:

webView.allowsBackForwardNavigationGestures = true

这比“自研 edge-pan + snapshot”可靠得多:交互曲线、阈值、上一页预览快照、渲染时机都由系统处理。

最小可用改动(3 步)

下面这 3 步就是本次修复能通过验收的关键(其余优化都可以后放)。

1) 用自定义 CAPBridgeViewController 子类接管 WKWebView 配置

文件:ios/App/App/AppDelegate.swift

  • 新增 AppViewController: CAPBridgeViewController
  • viewDidLoad() 里统一设置背景色(减少“闪白/闪黑”)并启用系统手势:
@objc(AppViewController)
class AppViewController: CAPBridgeViewController {
  override func viewDidLoad() {
    super.viewDidLoad()

    // 设置背景(防止任何空白闪现)
    self.view.backgroundColor = UIColor.systemBackground
    self.webView?.isOpaque = true
    self.webView?.backgroundColor = UIColor.systemBackground
    self.webView?.scrollView.backgroundColor = UIColor.systemBackground

    // 永久启用系统原生侧滑返回手势(最简单、最可靠)
    self.webView?.allowsBackForwardNavigationGestures = true
  }
}

2) storyboard 把初始 VC 指向你的自定义 VC(否则上一步永远不会生效)

文件:ios/App/App/Base.lproj/Main.storyboard

把初始控制器从 Capacitor 的 CAPBridgeViewController 改成你自己的:

  • customClass="AppViewController"
  • customModule="App"

完整示例:

<viewController id="BYZ-38-t0r" customClass="AppViewController" customModule="App" sceneMemberID="viewController"/>

3) Web 侧配合(强烈建议):禁用浏览器自动滚动恢复(减少“返回预览白屏/错位”)

文件:src/App.tsx

useEffect(() => {
  if ('scrollRestoration' in history) {
    history.scrollRestoration = 'manual'
  }
}, [])

原因很简单:系统侧滑返回预览依赖 WebKit 的历史快照,但 SPA 在返回时的“自动滚动恢复”会让快照捕获到不一致/空白的中间态(尤其是列表页、滚动后返回最明显)。

Web 端跳转配置的配合(建议)

  • Tab 根页面之间(例如首页/我的)建议用 replace,避免把 Tab 切换写入回退栈,出现“Tab 之间也能侧滑回退”的反直觉体验。
    • <Link to="/home" replace />navigate('/home', { replace: true })
  • 二级页面(例如设置/资料)保持默认的 push,让它进入历史栈,从而可被系统侧滑返回。

一句话:该 push 的 push,该 replace 的 replace。这决定了 iOS 系统手势到底会回到哪里。

经验与踩坑

  • 优先使用系统 API:自研手势要处理快照时机、渲染竞态、手势冲突、webView.isHidden 黑屏等问题,成本和风险都很高。
  • Native 与 Web 必须联动:WKWebView 的历史栈 + SPA 的路由栈 + 滚动恢复,是同一个系统。
  • 真机 + 滚动场景必测:很多“预览白屏”只有在页面滚动后才会暴露。
  • 背景色是兜底不是解法:它只能减少“闪一下”的主观感受,核心仍是让系统正确拿到历史快照。

keywords

Capacitor iOS swipe back、WKWebView allowsBackForwardNavigationGestures、React Router iOS 手势返回、history.scrollRestoration manual、CAPBridgeViewController 自定义、iOS WebView 返回白屏、Capacitor 返回手势

Swift 6.2 列传(第十七篇):钟灵的“雷电蟒”与测试附件

2026年1月13日 13:28

在这里插入图片描述

摘要:一个失败的测试报告,如果只写着“某某参数错误”,那和一张“失物招领”有什么区别?Swift Testing 新增的 Attachments(附件)功能(ST-0009),就像是给失败的测试现场,打上了一个**“现场取证包”**,直接将调试日志和关键数据附着在报告上,让 Bug 无所遁形。

0️⃣ 🐼 序章:万劫谷的“失灵”现场

万劫谷,一个充满了陷阱和奇门遁甲的虚拟测试环境。

大熊猫侯佩正在谷中寻找他那四根宝贝竹笋的踪迹(它们现在安全地储存在 InlineArray 里),一路上他习惯性地摸了摸头顶,确认自己的黑毛依然茂密,头绝对不秃

他身边站着一个活泼可爱的绿衫少女,正是钟灵。钟灵的特点是天真烂漫,喜欢饲养各种“小宠物”,尤其是她那条能放出电流的“雷电蟒”(现在是她编写的 Character Struct 数据模型)。

在这里插入图片描述

“侯大哥,你看!”钟灵指着屏幕上的测试报告,气得直跺脚,“我的测试又失败了!它明明应该生成一个名为 Rem 的角色,结果生成了 Ram!报告上只写了预期值和实际值,可是这个失败的 Ram 角色内部状态到底是什么?它的 UUID 是多少?我完全不知道!”

侯佩叹了口气:“这就是测试的黑箱困境。失败的报告,就像是你看到一只断了腿的兔子,但不知道它是在哪条路上、被谁咬伤的。我们得找到现场遗留的物证。”

在本次大冒险中,您将学到如下内容:

  • 0️⃣ 🐼 序章:万劫谷的“失灵”现场
  • 1️⃣ 📦 驯服数据:Attachable 协议的契约
  • 2️⃣ 📝 现场取证:Attachment.record() 的铁律
  • 3️⃣ 🚧 侠客的遗憾:现阶段的不足
  • 4️⃣ 🐼 尾声:条件判断的“外功”与“内力”

钟灵急道:“对!我要把我的‘雷电蟒’(数据模型)的全部信息,直接打包塞进这个失败报告里!(Swift Testing: Attachments)”

在这里插入图片描述


1️⃣ 📦 驯服数据:Attachable 协议的契约

要让数据能够被 Swift Testing 系统识别并打包,它必须遵守新的“江湖规矩”:Attachable 协议。

侯佩指导钟灵,将她那可爱的“雷电蟒”数据模型进行武装升级:

import Foundation
import Testing 

// 钟灵的角色结构体,它就是那条“雷电蟒”
struct Character: Codable, Attachable { 
    var id = UUID() // 关键的内部状态,比如角色的唯一标识符
    var name: String
}

在这里插入图片描述

侯佩解释道:“Attachable 协议就像是你给你的宠物签订了一份‘随行契约’。只要有了这个契约,系统就知道在关键时刻,应该如何‘捕捉’和‘打包’它。”

🔑 技术关键点:Codable 的加持 注意,这个 Character 结构体不仅遵循了 Attachable,还遵循了 Codable。对于像结构体这样的自定义数据类型,Swift Testing 会利用 Codable 的能力,将其实例自动编码DataString 格式,然后再进行附加。这样才能确保数据是有头有脸、完整地出现在报告中。

2️⃣ 📝 现场取证:Attachment.record() 的铁律

在这里插入图片描述

现在,钟灵只需要在她的生产代码(Production Code)中生成她的角色:

// 生产代码:生成一个新角色
func makeCharacter() -> Character {
    // 默认生成一个名叫 "Ram" 的角色
    Character(name: "Ram")
}

然后,在测试代码中,无论测试是成功还是失败,她都要确保这个角色的所有状态,都被系统记录下来:

@Test func defaultCharacterNameIsCorrect() {
    let result = makeCharacter()
    
    // 💔 测试失败断言:预期 Rem,实际 Ram
    #expect(result.name == "Rem") 

    // 🎒 关键步骤:记录附件!
    // 将整个 result 实例附着到本次测试结果中,并命名为 "Character"
    Attachment.record(result, named: "Character") 
}

“太神了!”钟灵惊呼道,“当这个测试运行失败时,Xcode 就会自动将这个 result 实例的 JSON 编码数据,直接显示在测试报告的旁边!我一眼就能看到这个失败的 Ram 角色的 UUID 是多少,它的内部状态是不是被某个毒药(Bug)污染了!”

在这里插入图片描述

侯佩点头:“这就叫 ‘证据确凿’。以前你只能 望洋兴叹,现在你可以 一目了然。”

3️⃣ 🚧 侠客的遗憾:现阶段的不足

侯佩作为精通技术的工程师,也指出了这一功能在 Swift 6.2 版本的些许遗憾。

  • 🚫 图像缺失症: “目前,Swift Testing 尚不支持附加图像(Image),”侯佩遗憾地说,“这就像你抓到了一个间谍,却不让你拍下他的照片。如果我做 SwiftUI 界面测试,失败了却不能附上截图,那会让人非常抓狂。”
  • ♻️ 生命周期控制的缺席: “另一个遗憾是,它不像 XCTest 的同类功能那样,支持生命周期控制(Lifetime Controls)。”

“生命周期控制是什么?”钟灵好奇地问。

在这里插入图片描述

“就是如果你的测试成功了,系统可以自动删除你附加的这些日志文件和数据。这样可以保持测试环境的轻量化。现在嘛,你成功了,这些文件还是会留在那,徒增烦恼。”

4️⃣ 🐼 尾声:条件判断的“外功”与“内力”

在这里插入图片描述

解决了附件问题,钟灵的测试调试效率提升了百倍。但她很快又遇到了新的困惑。

“侯大哥,我的宠物‘雷电蟒’需要在不同的硬件环境(例如 M1 芯片和 Intel 芯片)上运行不同的代码。Swift Testing 有一个很方便的功能叫做 ConditionTrait,可以用来定义‘只在 M1 上运行’的测试条件。”

在这里插入图片描述

侯佩点头:“是的,ConditionTrait 是测试的‘内功’,决定测试是否应该被执行。”

钟灵苦恼道:“但是,我能不能在非测试函数(Non-test function),比如我的生产代码里,也引用和判断这个‘内功’?比如,我想写一段普通的函数,判断‘我现在是不是在 M1 芯片上运行?’,并根据结果调整代码逻辑。”

在这里插入图片描述

侯佩眼中闪过一丝精光,他知道,钟灵提出的需求,已经触及到了 Swift Testing 的深层奥秘。

“钟灵姑娘,你提出了一个跨越测试与生产代码边界的哲学问题。你需要的不是附件,而是将测试的‘内功心法’,转化为人人可用的‘外功’招式。”

在这里插入图片描述

(欲知后事如何,且看下回分解:Swift Testing: Public API to evaluate ConditionTrait —— 如何在普通函数中,运用测试框架的‘条件判断’心法。)

在这里插入图片描述

App 暴毙现场直击:如何用 MetricKit 写一份完美的“验尸报告”

2026年1月13日 13:26

在这里插入图片描述

引子

在新深圳(Neo-Shenzhen)第 42 区阴雨连绵的夜晚,王代码(Old Wang)坐在全息屏幕前,手里捏着半截早已熄灭的合成烟草。作为一名在赛博空间摸爬滚打二十年的“数字清道夫”,他见过各种各样的 App 暴毙现场。

“又是 OOM(内存溢出)?”旁边的全息 AI 助手艾达(Ada)一边修剪着并不存在的指甲,一边冷嘲热讽,“你的代码就像这该死的天气一样,总是漏个不停。”

王代码没有理会她的挖苦,只是死死盯着那个被称为 Xcode Organizer 的官方监控面板。它就像个只会打官腔的衙门老头,告诉你结果,却永远不告诉你原因。

在这里插入图片描述

“这老东西只告诉我 App 死了,”王代码指着屏幕上毫无生气的图表骂道,“却不告诉我它是怎么死的。是被系统暗杀了?还是自己吃太饱撑死的?Xcode Organizer 简直就是个‘庸医’。”

在本篇文章中,您将学到如下内容:

  • 引子
  • 🕵️‍♂️ 第 1 幕:告别那个只会报丧的 Xcode Organizer
  • 🧱 第 2 幕:搭建秘密情报网
  • 🩸 第 3 幕:植入间谍(AppDelegate 集成)
  • 💀 第 4 幕:解读死因(Payload 的奥秘)
  • ⏳ 第 5 幕:耐心的猎人
  • 🎬 终章:真相大白

要想在这个代码丛林里活下去,光靠那个“庸医”是不够的。王代码从加密硬盘里掏出了他的秘密武器——MetricKit

“看来,我们得给自己找点更猛的药了。”

在这里插入图片描述


🕵️‍♂️ 第 1 幕:告别那个只会报丧的 Xcode Organizer

我们要承认,Xcode Organizer 确实提供了不少有用的情报:Crashes(崩溃)、Energy Impact(电量消耗)、Hangs(卡顿)、Launch Time(启动时间)、Memory Consumption(内存消耗)以及 App Terminations(App 终止)。

在这里插入图片描述

但是,它就像是那个只会在案发现场画白线的警察,对于某些棘手案件——特别是 App Terminations(App 莫名其妙被杀掉),它总是显得“智商捉急”。它能告诉你 App 挂了,但无法提供足够的细节来破案。

在这里插入图片描述

为了不让我们的 App 死不瞑目,Apple 上帝发了慈悲,赐予我们 MetricKit 框架。这玩意儿就像是法医手里的解剖刀,能让我们收集全面的诊断数据,构建一个详尽的“验尸报告”仪表盘。


🧱 第 2 幕:搭建秘密情报网

“要抓鬼,先得撒网。”王代码一边敲击键盘,一边嘟囔。

监控 App 性能的最直观方法,就是收集数据并将其导出以供分析。我们不能指望系统自动把凶手送到面前,我们得建立自己的 Analytics(分析)协议。

protocol Analytics {
    // 记录普通事件,比如“这破 App 又重启了”
    func logEvent(_ name: String, value: String)
    // 记录崩溃详情,这是法医鉴定的关键
    func logCrash(_ crash: MXCrashDiagnostic)
}

接下来,我们需要引入 MetricKit 并签署一份“灵魂契约”——设置订阅以接收数据。

在这里插入图片描述


🩸 第 3 幕:植入间谍(AppDelegate 集成)

王代码熟练地在 AppDelegate 中植入了监听器。这就像是在系统的血管里装了一个纳米机器人。

// 别忘了继承 MXMetricManagerSubscriber,这是入场券
final class AppDelegate: NSObject, UIApplicationDelegate, MXMetricManagerSubscriber {
    private var analytics: Analytics?

    func applicationDidFinishLaunching(_ application: UIApplication) {
        // 向组织(MXMetricManager)注册自己,有消息第一时间通知我
        MXMetricManager.shared.add(self)
    }

    // 重点来了:这是系统把“尸检报告”丢给你的时候
    // 注意:这个方法是非隔离的 (nonisolated),因为它可能在任意线程被调用
    nonisolated func didReceive(_ payloads: [MXMetricPayload]) {
        for payload in payloads {
            // 让我们看看它是怎么退出的... 
            // applicationExitMetrics 是关键证据
            if let exitMetrics = payload.applicationExitMetrics?.backgroundExitData {
                
                // 异常退出计数:是不是有什么不可告人的秘密?
                analytics?.logEvent(
                    "performance_abnormal_exit",
                    value: exitMetrics.cumulativeAbnormalExitCount.formatted()
                )
                
                // CPU 资源超限:是不是算力过载,脑子烧坏了?
                analytics?.logEvent(
                    "performance_cpu_exit",
                    value: exitMetrics.cumulativeCPUResourceLimitExitCount.formatted()
                )
                    
                // 内存压力退出:这就是传说中的“被系统嫌弃占地儿太大而清理门户”
                analytics?.logEvent(
                    "performance_memory_exit",
                    value: exitMetrics.cumulativeMemoryPressureExitCount.formatted()
                )
                
                // OOM(内存资源限制)退出:吃得太多,直接撑死
                analytics?.logEvent(
                    "performance_oom_exit",
                    value: exitMetrics.cumulativeMemoryResourceLimitExitCount.formatted()
                )
            }
        }
    }

    // 这里接收的是诊断信息,比上面的指标更硬核
    nonisolated func didReceive(_ payloads: [MXDiagnosticPayload]) {
        for payload in payloads {
            // 如果有崩溃诊断信息
            if let crashes = payload.crashDiagnostics {
                for crash in crashes {
                    // 把崩溃现场记录在案
                    analytics?.logCrash(crash)
                }
            }
        }
    }
}

“看到了吗,艾达?”王代码指着屏幕上的 applicationExitMetrics,“这才是我们要的真相。”

在这里插入图片描述

技术扩展说明: 如代码所示,我们利用 MXMetricManager 的共享实例来添加订阅者。我们的 AppDelegate 必须遵守 MXMetricManagerSubscriber 协议。这个协议提供了两个可选的“接收器”函数,让我们能够分别捕获 metrics(指标)和 diagnostics(诊断)。

在这里插入图片描述


💀 第 4 幕:解读死因(Payload 的奥秘)

艾达投影出一道蓝光,扫描着数据结构:“这两个 Payload 看起来很有料。”

MXMetricPayload 类型包含了一系列扩展自 MXMetric 抽象类的属性。其中最让王代码兴奋的是 applicationLaunchMetrics(应用启动指标)和 applicationExitMetrics(应用退出指标)。

在这里插入图片描述

在上面的代码中,王代码重点记录了几个引人注目的“后台终止”数据:

  • Cumulative Memory Pressure Exit Count:系统内存紧张时,你的 App 因为是个“显眼包”而被优先处决了。
  • Cumulative CPU Resource Limit Exit Count:你的 App 在后台偷偷挖矿或者死循环,耗尽了 CPU 配额,被系统当场击毙。

这些数据能让我们深刻理解——为什么系统觉得你的 App 不配活下去。

在这里插入图片描述

MXDiagnosticPayload 类型则包含扩展自抽象类 MXDiagnostic 的属性集合。例如 cpuExceptionDiagnostics(CPU 异常诊断)和 crashDiagnostics(崩溃诊断)。通过 logCrash 函数,我们能提取出极具价值的堆栈信息和元数据。

更妙的是,这两个 Payload 都能轻松转化为 JSONDictionary。这意味着我们可以毫不费力地把这些“罪证”上传到我们自定义的 API 端点,然后在后端慢慢审讯它们。

在这里插入图片描述


⏳ 第 5 幕:耐心的猎人

“现在我们只需要等待。”王代码靠在椅背上。

“等多久?现在的客户可没有耐心。”艾达提醒道。

“这是 MetricKit 的规矩。”王代码叹了口气。

关键点注意: MXMetricManager 并不会像喋喋不休的推销员一样实时给你推送数据。系统非常“鸡贼”,为了省电和性能,它会把数据聚合起来,通常按每天一次的频率投递。

在这里插入图片描述

也就是说,你今天埋下的雷,可能明天才能听到响。在极少数情况下,它可能会发得频繁点,但你千万别把身家性命压在这个“特定时间表”上。

不过好在,这两个 Payload 都提供了 timeStampBegintimeStampEnd 属性。这就好比尸检报告上的死亡时间推断,让我们能精准地确定这些数据覆盖的时间范围。


🎬 终章:真相大白

窗外的雨停了,新深圳的霓虹灯映在王代码疲惫但兴奋的脸上。

通过 MetricKit,他终于填补了 Xcode Organizer 留下的巨大空白。这不仅仅是看几个数字那么简单,这是对 App 在真实世界(Real-World Conditions)中行为的系统级洞察。

在这里插入图片描述

通过订阅 MXMetricManager 并处理 MXMetricPayloadMXDiagnosticPayload,王代码获得了关于 App 启动、终止、崩溃和资源使用的“上帝视角”。而在过去,想要搞清楚 App 是怎么在后台悄无声息死掉的,简直比让产品经理承认需求不合理还难。

“案子破了,艾达。”王代码站起身,披上风衣,“是内存泄漏导致的 OOM,凶手就在那个循环引用的闭包里。”

在这里插入图片描述

艾达关掉了全息投影,嘴角露出一丝不易察觉的微笑:“干得不错,老王。但别高兴得太早,下周还有新的 Bug 等着你。”

在这里插入图片描述

感谢阅读这篇来自赛博边缘的性能监控指南。如果你觉得这次冒险有点意思,或者对抓 Bug 有什么独到的见解,欢迎关注我的博客并向我提问。

咱们下周见,祝宝子们的代码永远不做“内存刺客”,棒棒哒!👋

在这里插入图片描述

一款轻量、低侵入的 iOS 新手引导组件,虽然大清都亡了

作者 noodles1024
2026年1月13日 09:44

PolarisGuideKit:轻量、低侵入的 iOS 新手引导组件(遮罩挖孔 + Buddy View + 插件化)

关键词:UIKit · 新手引导 · 低侵入 · 插件扩展

GitHub:github.com/noodles1024…

demo_cn_tiny.webp


背景:我为什么做这个组件?

可能是新手引导这个功能太小,随便实现一下也能用,导致没有人愿意认真写一个iOS下的新手引导组件,搜遍整个github也找不到一个在现实项目中能直接拿来用的。如果只考虑某一个具体的新手引导界面,实现起来很容易(特别是现在在AI的加持下,UI仔都不需要了)。但在不同项目、不同场景下,经过和和产品经理&设计师的多次沟通中,我发现了做“新手引导/功能提示”时的一些令人头疼的问题:

  • 需要高亮某个控件,但布局变化、屏幕旋转后挖孔(高亮)位置容易偏
  • 指引说明(箭头/气泡/按钮)形态不固定,可能还伴随着音频播放等附加功能,复用困难
  • 点击高亮区域时,难以做到不侵入原有点击业务逻辑
  • 显示新手引导时难以在不改变原有逻辑的情况下阻止NavigationController的滑动返回
  • UITableView/UICollectionView reloadData 后高亮经常失效

于是我做了 PolarisGuideKit:一个基于 UIKit 的轻量新手引导组件,主打低侵入 + 可扩展 + 动态高亮


PolarisGuideKit 能解决什么?

能力 说明 带来的价值
高亮遮罩 遮罩挖孔高亮 focusView 高亮区域自动跟随,内置高亮效果,可自定义
Buddy View 说明视图可自由定制 文案、箭头、按钮任意组合
步骤编排 多步骤引导流程 支持下一步、跳过、完成
动态 focusView reloadData 后自动修正 TableView/CollectionView场景稳定
插件化扩展 Audio/埋点/持久化 可插拔、解耦

快速上手(3 分钟接入)

import UIKit
import PolarisGuideKit

final class MyViewController: UIViewController {
    private var guide: GuideController?

    override func viewDidAppear(_ animated: Bool) {
        super.viewDidAppear(animated)

        let step = GuideStep()
        step.focusView = myButton
        step.buddyView = MyBuddyView()
        step.forwardsTouchEventsToFocusView = true
        step.completer = ControlEventCompleter(control: myButton, event: .touchUpInside)

        let controller = GuideController(hostView: view, steps: [step])
        controller.onDismiss = { _, context in
            print("引导结束,原因 = \(context.reason)")
        }

        _ = controller.show()
        guide = controller
    }
}

核心概念一图速览

  • GuideController:流程编排器,负责 show/hide/切换步骤
  • GuideStep:一步引导配置(focus、buddy、style、completer)
  • FocusStyle:高亮形状(矩形/圆形/圆角/无高亮)
  • GuideBuddyView:说明视图(可继承自定义)
  • GuidePlugin:生命周期扩展(音频/埋点/持久化)

重点能力拆解

1) FocusStyle:高亮样式可拔插

内置样式包含:

  • DefaultFocusStyle(矩形)
  • RoundedRectFocusStyle(圆角矩形)
  • CircleFocusStyle(圆形)
  • NoHighlightFocusStyle(全屏遮罩)
let step = GuideStep()
step.focusView = someCard
step.focusStyle = RoundedRectFocusStyle(
    focusCornerRadius: .followFocusView(delta: 2),
    focusAreaInsets: UIEdgeInsets(top: -6, left: -6, bottom: -6, right: -6)
)

2) 动态 FocusView:Table/CollectionView不卡壳

UITableView / UICollectionView 复用导致高亮错位?
使用 focusViewProvider 动态获取最新 cell:

let step = GuideStep()
step.focusViewProvider = { [weak self] in
    guard let self else { return nil }
    var cell = self.tableView.cellForRow(at: targetIndexPath)
    if cell == nil {
        self.tableView.layoutIfNeeded()
        cell = self.tableView.cellForRow(at: targetIndexPath)
    }
    return cell
}

3) 触摸转发 + 自动完成

在不侵入原有业务逻辑的前提下,高亮按钮依然能触发业务逻辑,同时自动关闭引导:

let step = GuideStep()
step.focusView = myButton
step.forwardsTouchEventsToFocusView = true
step.completer = ControlEventCompleter(control: myButton, event: .touchUpInside)

✅ 设置forwardsTouchEventsToFocusView和completer保证了“引导不侵入原有业务逻辑”。


4) Buddy View:说明视图随便做

继承 GuideBuddyView,自定义 UI + 布局:

final class MyBuddyView: GuideBuddyView {
    override func updateLayout(referenceLayoutGuide layoutGuide: UILayoutGuide, focusView: UIView) {
        super.updateLayout(referenceLayoutGuide: layoutGuide, focusView: focusView)
        // 根据 layoutGuide 布局你的文案 / 按钮 / 箭头
    }
}

5) 插件系统:音频 / 埋点 / 持久化

内置 AudioGuidePlugin,可在显示引导时播放音频文件,且可在BuddyView中配合显示音频播放动画(可选功能):

let step = GuideStep()
step.focusView = myCard
step.addAttachment(GuideAudioAttachment(url: audioURL, volume: 0.8))

let controller = GuideController(
    hostView: view,
    steps: [step],
    plugins: [AudioGuidePlugin()]
)

如果想要加埋点、标记“引导是否已显示”,可通过自定义 GuidePlugin 实现。


Demo 示例一览

  • 圆角矩形高亮 + 圆角模式切换
  • 圆形高亮 + 半径缩放
  • 多步骤引导 + 平滑转场
  • 触摸转发 + 自动完成
  • 点击外部关闭(dismissesOnOutsideTap)
  • 音频 + Lottie 同步演示
  • UITableView 动态高亮

架构 & 视图层级

flowchart TB
    subgraph Core["核心组件"]
        GuideController["GuideController<br/>(流程编排器)"]
        GuideStep["GuideStep<br/>(步骤配置)"]
    end

    subgraph ViewHierarchy["视图层级"]
        GuideContainerView["GuideContainerView<br/>(透明容器)"]
        GuideOverlayView["GuideOverlayView<br/>(遮罩 + 触摸转发)"]
        MaskOverlayView["MaskOverlayView<br/>(遮罩基类)"]
        GuideBuddyView["GuideBuddyView<br/>(说明视图)"]
        GuideShadowView["GuideShadowView<br/>(焦点追踪器)"]
    end

    subgraph Extensions["扩展机制"]
        FocusStyle["FocusStyle<br/>(高亮形状)"]
        GuideAutoCompleter["GuideAutoCompleter<br/>(完成触发器)"]
        GuidePlugin["GuidePlugin<br/>(生命周期钩子)"]
        GuideStepAttachment["GuideStepAttachment<br/>(插件数据)"]
    end

    GuideController -->|"管理"| GuideStep
    GuideController -->|"创建并承载"| GuideContainerView
    GuideController -->|"派发事件"| GuidePlugin
    
    GuideContainerView -->|"包含"| GuideOverlayView
    GuideContainerView -->|"包含"| GuideBuddyView
    
    GuideOverlayView -.->|"继承"| MaskOverlayView
    GuideOverlayView -->|"创建"| GuideShadowView
    GuideOverlayView -->|"使用"| FocusStyle
    
    GuideStep -->|"配置"| GuideBuddyView
    GuideStep -->|"使用"| FocusStyle
    GuideStep -->|"通过...触发"| GuideAutoCompleter
    GuideStep -->|"携带"| GuideStepAttachment

view_hierarchy.png


安装

Swift Package Manager

  1. Xcode → File → Add Packages…
  2. 输入仓库地址:https://github.com/noodles1024/PolarisGuideKit
  3. 选择 PolarisGuideKit

CocoaPods

pod 'PolarisGuideKit'
import PolarisGuideKit

注意事项(踩坑清单)

  • focusView 必须是 hostView 的子视图
  • 多 Scene / 多 Window 建议显式传 hostView
  • GuideAutoCompleter 触发后会结束整个引导(建议用于最后一步)
  • 动画转场在复杂形状下可关闭动画:animatesStepTransition = false

项目地址 & 交流

AT 的人生未必比 MT 更好 -- 肘子的 Swift 周报 #118

作者 东坡肘子
2026年1月13日 07:47

issue118.webp

AT 的人生未必比 MT 更好

学车时我开的是手动挡,起初因为技术生疏,常搞得手忙脚乱,所以第一台车就直接选了自动挡。但开了几年,我开始追求那种完全掌控的驾驶感,于是又增购了一台手动挡。遗憾的是,随着交通日益拥堵,换挡的乐趣逐渐被疲惫抵消,最终这台车也被冷落。算起来,我已经快二十年没认真开过手动挡了,但内心深处,我仍会时不时地怀念那段“人车合一”的时光。

随着 AI 深度介入我的工作与生活,我感觉自己的人生正从 MT 转向 AT。毫无疑问,AI 助我突破了许多能力瓶颈,也在熟悉领域带来了巨大的效率提升。但奇怪的是,我对它的“惊叹”却在与日俱减。看似它节省了我的时间,但我并未从这些“多出来的时间”里获得预期的满足感。也许是我对它的期望阈值不断提高,但一个不争的事实是:我已经有一段时间没有在学习和开发过程中,体会到那种单纯的快乐了。

幸好,几天前我又找回了这种久违的开心。在准备 iOS Conf SG 的 Keynote 时,由于 Keynote 在动画构建上相对“原始”且缺乏 AI 辅助,我难得地拥有一段完整的时间,去纯手工地尝试和修改。哪怕只是一个简单的并行动画,究竟是用转场、普通动画还是“神奇移动”,我都玩得不亦乐乎。那些在专家手里可能两三分钟搞定的设置,我折腾了大半天。尽管毫无效率可言,但我乐在其中。看着最终那个略显“简陋”的效果,我竟被自己感动了。

对于职场中人,效率和完成度固然是硬指标;但能否体会到过程带来的“实感”,或许才是作为“人”最朴素的追求。

我大概率不会再买 MT 的车了,但在我还能握紧方向盘的时候,也不会轻易让“智能驾驶”代劳。写代码也是如此,当初爱上它,正是因为它能给我带来纯粹的快乐。当所有工具都在催促我们变得更快更好时,我想应该给自己留一点变慢、变“笨”的空间——毕竟,AT 的人生未必比 MT 更好。

本期内容 | 前一期内容 | 全部周报列表

🚀 《肘子的 Swift 周报》

每周为你精选最值得关注的 Swift、SwiftUI 技术动态

近期推荐

告别“可移植汇编”:我已让 Swift 在 MCU 上运行七年

从 2024 年开始,Swift 官方正式提供了对嵌入式系统的支持,但要在这个领域获得显著份额,仍有很长的路要走。其实,早在官方下场之前的 2018 年,Andy Liu 和他的 MadMachine 团队就开始在探索和实践将 Swift 应用于嵌入式领域,并陆续推出了相关硬件。他们坚信,在功能日益复杂的开发场景中,Swift 的现代语言特性将展现出巨大的优势。在本文中,Andy 分享了过去几年中在该领域的探索历程。我真心希望,Swift 能够在更多的场景中,展现其魅力。


在 SwiftUI 中构建基础拨号滑块组件 (Building a Base DialSlider Component in SwiftUI)

在 AI 功能越来越强大的今天,看到一个动效,让 AI 帮你实现已经越来越容易了。但每当看到开发者凭借自己的"奇思妙想"不断探索实现方式并打磨效果时,我仍会由衷赞叹。codelaby 在这篇复刻"老式电话拨号盘"的文章中,巧妙运用 SwiftUI 的 .compositingGroup().blendMode(.destinationOut) 实现了动态"镂空"效果,使旋转层下的静态数字清晰显现,相比单纯旋转图片更具灵活性和原生质感。此外,文章对环形手势处理、角度计算(atan2)以及限位逻辑(Stopper)的阐述也十分透彻清晰。


CKSyncEngine 答疑与实战经验分享 (CKSyncEngine Questions and Answers)

不少开发者对 Core Data 的 NSPersistentCloudKitContainer 颇有诟病,认为其不透明且缺乏定制性。但真正想自己着手解决 CloudKit 的数据同步问题时,才发现需要考虑的地方实在太多,难度远超想象。苹果在几年前推出的 CKSyncEngine 彻底打破了这个困境,提供了更清晰的状态管理和错误处理,并自动处理了诸多复杂的边缘情况,让开发者可以专心构建数据同步逻辑。

Christian Selig 通过自问自答的方式,分享了他在使用 CKSyncEngine API 时的经验,详细拆解了 CKSyncEngine 如何作为一个完美的中间层,在保留数据存储灵活性(你可以继续用 SQLite、Realm 或 JSON)的同时,接管了最令人头疼的同步状态管理。


我对 iOS 26 Tab Bar 的吐槽 (My Beef with the iOS 26 Tab Bar)

SwiftUI 在 iOS 18 中对 Tab Bar 的调整,其影响几乎堪比当年 NavigationStack/NavigationSplitView 取代 NavigationView,不仅改变了设计语言,对应用的实现方式和数据流走向都产生了颠覆性影响。而为 iOS 26 Liquid Glass 风格引入的"搜索标签"功能进一步推进了这种变革。Ryan Ashcraft 在这篇文章中直言不讳地指出了新 Tab Bar 设计的诸多问题:默认的浮动样式在某些界面中显得突兀,与应用整体视觉风格难以协调;新的边距和间距规则打破了长期以来的设计惯例,让开发者需要重新调整大量现有界面;更重要的是,这些改动并未明显提升用户体验,反而增加了适配成本。

我个人对新 Tab 的最大感受是,它会显著影响开发者在开发应用时对最低系统版本的决策。为 Tab 维护两套代码是否值得?如果为了简化实现而不得不将最低版本提高到 iOS 18,这或许正是 SwiftUI 团队的另一个设计意图?


Dia:深度剖析 The Browser Company 的 macOS 浏览器架构 (Dia: A Technical Deep Dive into The Browser Company's macOS Browser)

Arc 是第一个使用 Swift 构建的大型 Windows 平台应用,而且 The Browser Company 也因此为 Swift 社区的 Windows 工具链做出了突出贡献。在从 Arc 转型到 Dia 后,开发团队并没有放弃使用 Swift,那么 macOS 端的 Dia 具体使用了哪些开发框架呢?

Everett 在本文中揭示了 Dia 独特的技术架构:这是一个基于 AppKit + SwiftUI 的原生 macOS 应用,但其核心渲染引擎并非 WebKit,而是嵌入了自行修改的 Chromium(ArcCore)。此外,在 Dia 的二进制文件中发现了大量与本地 AI 相关的库(如 Apple MLX 和 LoRA 适配器),这预示着 Dia 并非只是为了"快",而是已经为设备端 AI 推理做好了底层工程准备。


关于罗技开发者证书过期的迷思 (Myths about Logitech Developer ID certificate expiration)

几天前,不少 macOS 用户发现罗技鼠标的自定义按钮失效。由于控制台日志中充斥着代码签名(Code Signing)相关的报错,不少用户和媒体将其归咎于"苹果撤销了证书"。Jeff Johnson 通过分析系统日志为苹果在本次事件中的角色进行了平反:这并非苹果的证书服务故障,而是罗技自身软件工程问题导致的。Logi Options+ 的后台进程在更新后,未能通过 macOS taskgated 的代码签名有效性验证,从而被系统直接终止。这篇文章不仅是一份故障分析报告,更提醒开发者:在 macOS 严格的安全机制下,应用更新的签名验证流程容不得半点马虎。

“如果你的证书过期了,用户仍然可以下载、安装和运行用该证书签名的 Mac 应用程序版本。但是,你需要一个新的证书来签署更新和新申请。” —— 苹果官方文档


拒绝 LLM 生成的平庸代码 (Stop Getting Average Code from Your LLM)

不可否认,在人类长久以来累积的信息海洋中,高质量的数据与信息只占少数。对于个体来说,我们完全可以有目的地去甄别和学习这些优质内容。但是,受限于机制,LLM 默认倾向于训练数据的“平均值”,这就导致它生成的内容在各个方面都显得比较平庸。具体到 Swift 开发领域,这往往意味着它会生成大量旧版的、非结构化的代码。

要想获得高质量、符合 Swift 6 标准甚至特定架构风格的代码,关键在于对抗这种“回归均值”的本能。Krzysztof Zabłocki 详细介绍了如何利用 Few-Shot Prompting(少样本提示)和上下文注入技术,通过提供具体的代码范例和架构规范,强迫 LLM “忘记”平庸的默认设置,转而生成精准匹配项目标准的高质量代码。

工具

swift-effect: 一种基于类型驱动的副作用处理方案

Alex Ozun 长期关注 Swift 中的 类型驱动设计,这个库是他对“代数效应(Algebraic Effects)+ 处理器(Effect Handlers)”在 Swift 里的实践。 swift-effect 不是把副作用变成“数据结构再解释”,而是将副作用建模为可拦截的全局操作(@Effect),通过 handler 在运行时组合和替换行为,让业务代码保持线性/过程式风格,同时又能精细控制 I/O、并发等行为。

核心亮点:

  • 保持代码线性:调用 Console.print 等 effect 就像普通函数,但行为可由 handler 动态决定。
  • 无 Mock 的行为测试:用 withTestHandler 逐步拦截/断言 effect 序列,像“交互式脚本”一样测试流程。
  • 并发可控:支持对 Task/AsyncSequence 的确定性测试,解决并发顺序不稳定的问题。

Codex Skill Manager: 一款面向众多 CLI 的 macOS 工具

很多开发者都会同时使用多种 AI 编程服务,尽管它们拥有类似的概念、设定和工具类型,但在具体设置和细节描述上仍有差异,这导致开发者很难对所有服务进行统一管理。Thomas Ricouard 开发的 Codex Skill Manager 将 Codex、Claude Code(以及 OpenCode、Copilot)的技能集中在一个 UI 里查看、搜索、删除和导入,避免在多个隐藏目录中手动寻找。

核心功能

  • 本地技能:扫描 ~/.codex/skills/public~/.claude/skills 等路径,展示列表与详情
  • 详情渲染:Markdown 视图+引用预览
  • 远程 Skill:Clawdhub 搜索/最新列表、详情拉取与下载
  • 导入/删除/自定义路径:支持从 zip 或文件夹导入、侧边栏删除、添加自定义路径
  • 多平台安装状态:为不同平台标记已安装状态

活动

LET'S VISION 2026|邀请你与我们同行!

✨ 大会主题:Born to Create, Powered by AI

  • 📍 地点:上海漕河泾会议中心
  • 时间:2026 年 3 月 27 日 - 3 月 29 日
  • 🏁 重点:汇聚顶尖创作者与 AI 技术大咖,共同探索 AI 应用的未来边界
  • 🌍 官网letsvision.swiftgg.team

别走开!请关注官方账号和主理人 SwiftSIQI,我们将持续放送更多精彩内容!


Swift Student Challenge 2026

每年一度的学生挑战赛再次登场。挑战赛为数以千计的学生开发者提供了展现创造力和编程能力的机会,让他们可以通过 App Playground 呈现自己的作品,并从中学习在职业生涯中受用的实际技能。

今年作品提交通道将于 2026 年 2 月 6 日至 2 月 28 日开放。

往期内容

💝 支持与反馈

如果本期周报对你有帮助,请:

  • 👍 点赞 - 让更多开发者看到
  • 💬 评论 - 分享你的看法或问题
  • 🔄 转发 - 帮助同行共同成长

🚀 拓展 Swift 视野

iOS日志系统设计

作者 伟兮
2026年1月12日 16:34

1 为什么需要日志

软件系统的运行过程本质上是不可见的。绝大多数行为发生在内存与线程之中。在本机调试阶段,我们可以借助断点、内存分析、控制台等手段直接观察系统状态;而一旦进入生产环境,这些能力几乎全部失效。此时,日志成为唯一能够跨越时间和空间的观测手段

但如果进一步追问:日志究竟解决了什么问题? 这个问题并没有那么简单。日志的核心价值并不在于文本本身,而在于可见性。它最基础的作用,是让这些不可见的行为“显影”。一次简单的日志输出,至少隐含了三类信息:时间、位置、描述。

这也是我们不建议使用简单 print 的原因:结构化日志在每次记录时,都会自动携带这些关键信息,从而形成稳定、可检索的观测数据。

之后当系统规模变大、异步逻辑增多时,单条日志已经很难解释问题。真正有价值的,是一组日志所呈现出的因果关系. 在这一层面上,日志更像是事件证据,用于在事后还原一段已经发生过的执行流程。

接下来,我们将从这些问题出发,逐步讨论一套面向真实生产环境的日志与可观测性设计。

2 日志系统

尽管日志在实践中无处不在,它本身仍然存在天然局限:日志是离散的事件,而不是连续的流程;日志天然是“事后信息”,而不是实时状态;在客户端等受限环境中, 如 应用可能随时被杀掉, 各种网络情况不稳定, 隐私与安全限制,日志可能丢失、不可获取、不可上报。

这意味着,日志并不是系统真相本身,它只是我们理解系统的一种工具。当系统复杂度继续提升,仅靠“多打日志”往往无法解决根本问题。

2.1 范围与功能

这样我们应该勾勒出日志系统的一些边界范围.

  1. 不必要求日志的「绝对可靠上报」
  2. 不通过日志修复「系统设计问题」(业务依赖、生命周期、指责转移错误)
  3. 不将日志系统演化成「消息系统」(不持久化、不通过日志兜底)

所以我们通过边界范围基本确定了我们日志系统的一些要求:

  • 结构化并非文本化: 日志首先应该是结构化数据,而不是简单字符串。文本只是表现形式,结构才是核心价值.每条日志必须具备稳定的时间、位置、级别与上下文.日志应当天然支持检索、过滤与关联.
  • 本地优先, 而非远端依赖: 本地记录必须是同步、低成本、稳定的.远端上报只能是 best-effort 行为.系统不能因为远端日志失败而影响主流程

2.2 系统架构

LoggerSystemArchitectureDiagram.svg

我们刻意限制了日志系统的职责范围,使其始终作为一个旁路的、可退化的基础设施存在。这些约束并非功能缺失,而是后续实现能够保持稳定与可演进的前提。所有依赖关系均为单向:日志系统不会反向调用业务模块或基础设施。

3 本地日志

在整体架构中,本地日志被视为整个日志系统中最基础、也是最可靠的一环。无论远端日志是否可用、网络环境是否稳定,本地日志都必须能够在任何情况下正常工作。

因此,在实现层面,我们选择优先构建一套稳定、低成本、符合平台特性的本地日志能力,而不是从远端导出反推本地设计。

3.1 为什么是os.Logger

在 iOS 开发里,print 很直观,但它更像调试手段:没有结构、难以检索、性能成本不可预测,也无法进入系统日志体系。进入生产环境后,这些缺点会被放大。

os.Logger 是系统级日志通道,它的设计目标本身就面向“可长期运行”的生产场景。本文中,os.Logger 指 Apple 的系统日志实现,Logger 指本文封装的对外 API。我们选择它,主要基于这些原因:

  • 低成本写入:日志被拆分为静态模板与动态参数,格式化发生在读取阶段,而非写入阶段
  • 系统工具链一致性:天然接入 Console、Instruments 与系统日志采集工具
  • 隐私与合规能力:原生支持隐私级别控制
  • 结构化上下文:时间戳、级别、分类、源码位置可以稳定保留

因此,日志可以作为“长期存在的基础能力”,在核心路径中持续开启,而不是仅限于调试阶段。需要说明的是,系统日志在生产环境的获取也受平台权限与采集策略限制,所以它是“本地可靠”,但并不是“远端万能”。

在使用层面,Logger API 保持简单直接:

let logger = Logger(subsystem: "LoggerSystem")
logger.info("Request started")
logger.error("Request failed", error: error)

3.2 附加功能

除了系统日志的即时写入,我们还提供了几个本地诊断能力:通过 LogStore / OSLogStore 进行日志检索(按时间、级别、分类)并支持导出为文本或 JSON;同时集成 OSSignpost / OSSignposter 作为性能事件记录方式,用于衡量关键路径耗时。这些能力不进入主写入路径,只在排查与分析时启用。

4 远端日志与 OpenTelemetry

4.1 OpenTelemetry 在客户端日志系统中的位置

OpenTelemetry 由 CNCF 托管,起源于 2019 年 OpenCensus 与 OpenTracing 的合并,并于 2021 年成为 CNCF 顶级项目。它并不是某一个具体 SDK,而是一套用于描述可观测性数据的开放标准,定义了日志、指标与链路追踪的统一语义与数据模型,并配套给出了标准化的传输协议(OTLP)。

在本章中,我们并不试图完整覆盖 OpenTelemetry 的体系,而是聚焦于其中与远端日志相关的部分:

日志数据在 OTel 语义下如何被结构化、如何被分组、以及如何被导出。

认证、上下文传播等问题会显著影响系统依赖关系,本文刻意将其延后,在下一章单独讨论。

4.1.1 Remote Logger 的最小闭环

下图展示了在 OTel 语义下,客户端远端日志链路的最小可用闭环

这一闭环的目标并非“可靠投递”,而是在客户端约束条件下,提供一条可控、可退化的日志导出路径

从数据流动的角度看,这条链路可以被抽象为:

LogRecord[]
  → LogRecordAdapter
  → ResourceLogs / ScopeLogs / LogRecords
  → ExportLogsServiceRequest (OTLP)
  → OTLP Exporter (HTTP / gRPC)

在这一结构之上,可以按需叠加增强能力,例如批处理、失败缓存或延迟调度,但这些能力不会改变日志的协议语义

4.1.2 结构化与分组:从 LogRecord 到 OTel Logs

在 OTel 模型中,LogRecord 仍然是最小的事件单元,用于描述“发生了什么”。

但真正的上传结构并不是一组扁平的日志列表,而是按以下层级组织:

  • ResourceLogs:描述日志产生的资源环境(设备、系统、应用)
  • ScopeLogs:描述产生日志的逻辑作用域(模块、库)
  • LogRecords:具体的日志事件

这一分组方式的意义在于:

  • 避免重复携带环境信息
  • 明确日志的来源与归属
  • 为后端聚合与分析提供稳定结构

在客户端侧,这一阶段通常通过一个 Adapter 或 Mapper 完成,其职责只是语义映射,而非业务处理。

4.1.3 批处理与调度:Processor 的职责边界

在日志被结构化之后,下一步并不是立刻发送,而是进入处理阶段。

LogRecordProcessor 位于这一阶段的入口位置。以 BatchLogRecordProcessor 为例,它负责:

  • 将多条日志聚合为批次
  • 控制发送频率
  • 降低网络与系统调用成本

需要注意的是,Processor 层体现的是策略位置,而不是协议逻辑。

它不关心日志如何被编码,也不关心最终通过何种方式发送,只负责决定什么时候值得尝试导出

4.1.4 导出边界:Exporter 作为协议适配层

LogRecordExporter 是远端日志链路中的协议边界

在这一层中,结构化日志会被转换为 OTLP 定义的 ExportLogsServiceRequest,并通过具体传输方式发送。常见实现包括:

  • OTLP/HTTP
  • OTLP/gRPC

无论采用哪种方式,Exporter 的核心职责都是一致的:

编码日志结构,并完成协议级发送。

它不感知业务上下文,也不参与重试策略之外的系统决策。

4.2 RemoteLogger 架构图

下面这张图是 RemoteLogger 在 OTel 语义下的最小闭环:

RemoteSinkSystem.svg

5 上下文边界

从 RemoteLogger 开始真正发日志的那一刻,日志系统就第一次碰到外部依赖:鉴权。它不是“可选附加项”,而是远端链路的必经之门。

5.1 鉴权

日志端点是基础设施入口(infra endpoint),它的目标是控制写入来源,而不是验证用户身份。因此更合理的鉴权方式是:IP allowlist、mTLS、ingestion key、project‑level key,配合采样与限流。这些机制与用户态解耦、无需刷新、不参与业务控制流,且失败也不会影响客户端主流程。

在这种模型下,日志系统只做一件事:携带已准备好的凭证。它不维护鉴权状态,也不触发刷新,更不等待鉴权完成。

5.1.1 当鉴权被卷入业务流程

问题发生在日志复用业务鉴权体系时:access token 短期、频繁刷新、刷新依赖网络与生命周期,而鉴权失败本身又需要被记录。直觉做法是“刷新后重试”,但这会形成典型的依赖循环:

Logger
  → RemoteExporter
     → AuthManager
        → RefreshToken
           → Network
              → Logger

这不是实现复杂的问题,而是依赖方向错误的问题:日志系统依赖了本应被它观测的系统,直接造成 auth blind zone(鉴权失败本身无法被观测的区域)

现实里,很多团队不得不复用业务鉴权,但这时唯一能做的是“隔离副作用”:不触发刷新、不重试鉴权、失败即丢弃,并保持凭证只读与短生命周期缓存。这样做无法消灭问题,却能把依赖循环缩到最小。

结论只有一句:日志系统只能消费鉴权结果,不能成为鉴权流程的一部分。

5.2 Traceparent

traceparent 是 W3C Trace Context 标准里的核心头部,用于跨进程传播 Trace。它不是日志系统的一部分,而是“流程上下文”的载体。日志系统只负责把它携带出去,而不负责生成、维护或推进它。

它的基本结构非常固定:

traceparent: {version}-{trace-id}-{parent-id}-{trace-flags}
  • version:版本号,当前常见为 00
  • trace-id:16 字节(32 hex)的全局 trace 标识
  • parent-id:8 字节(16 hex)的当前 span 标识
  • trace-flags:采样与调试标记(如 01 表示采样)

这四个字段共同决定“这条日志属于哪条 trace、处于哪一段 span 上下文”。

5.2.1 构造与传递

在客户端日志系统中,traceparent 应当被视为外部上下文

  • 它由业务流程或 tracing 系统生成
  • 它随着请求/事件生命周期变化
  • 它不由日志系统创建,也不由日志系统维护

日志系统只做一件事:在日志生成或导出时附带 traceparent,让后端能够把日志与 Trace 对齐。

这也意味着:日志系统不能尝试“修复” traceparent,也不能在缺失时伪造它。缺失就缺失,伪造会制造错误的因果链。

traceparent 的构造来自 tracing 系统(SDK 或上游服务),它会在一次请求开始时生成新的 trace-id,并在 span 变化时更新 parent-id。日志系统只需在“生成日志的瞬间”读取当前上下文并携带即可。

换句话说,traceparent 的生命周期与日志系统无关,而与业务流程一致。日志系统需要尊重这个边界,否则它会再次变成主流程的一部分。

5.3 Context 的角色

如果说 traceparent 是“具体的上下文载体”,那么 Context 是“上下文在系统里的容器与作用域”。它回答的不是“字段长什么样”,而是“这份上下文从哪来、到哪去、何时结束”。

在日志系统里,Context 只应当承担两件事:

  1. 携带流程信息,让日志具备可关联性
  2. 限定生命周期,避免上下文在系统内滞留

这意味着 Context 的设计重点不是“存什么”,而是“何时注入、如何传播、何时释放”。

更宽泛地看,Context 的生命周期其实是一种“作用域建模”。它既像 tracing 里的 active span,也像 DI 里的 scope:谁负责创建、谁负责结束、跨线程如何继承,这些都会直接决定 traceparent 的 parent-id 何时变化。换句话说,Context 的问题往往不是协议问题,而是作用域与生命周期策略的问题。

Context 最难的部分其实是作用域与注入方式:

  • 它和依赖注入(DI)的关系应该是什么
  • 在多线程/异步场景中,Context 的边界如何定义
  • Context 是否应该是显式传参,还是隐式绑定

这些问题没有一个完美答案,需要团队给出清晰的工程约定。

5.4 结语

这套日志系统的核心不是“更多日志”,而是“正确的边界”:本地优先、远端旁路、结构化可关联、上下文可控。真正决定系统稳定性的,不是某一个 API,而是你如何定义依赖方向与生命周期。最后想留下的一句话是:可观测性不是无限的,它永远受平台约束。

昨天以前iOS

AT 的人生未必比 MT 更好 - 肘子的 Swift 周报 #118

作者 Fatbobman
2026年1月12日 22:00

学车时我开的是手动挡,起初因为技术生疏,常搞得手忙脚乱,所以第一台车就直接选了自动挡。但开了几年,我开始追求那种完全掌控的驾驶感,于是又增购了一台手动挡。遗憾的是,随着交通日益拥堵,换挡的乐趣逐渐被疲惫抵消,最终这台车也被冷落。算起来,我已经快二十年没认真开过手动挡了,但内心深处,我仍会时不时地怀念那段“人车合一”的时光。

Agent 模型的思维链是什么

作者 bang
2026年1月12日 16:45

关于 Agent 模型的思维链,之前被几个高大上的词绕晕了,claude 提出 Interleaved Thinking(交错思维链),MiniMax M2 追随和推动标准化,K2 叫 Thinking-in-Tools,Deepseek V3.2 写的是 Thinking in Tool-Use,gemini 则是 Thought Signature(思考签名)。了解了下,概念上比较简单,基本是一个东西,就是定义了模型思考的内容怎样在 Agent 长上下文里传递。

是什么

在25年年初 deepseek 的轰炸下,思考模型大家都很熟悉了,在 Chatbot 单轮对话中,模型会先输出思考的内容,再输出正文。再早的 GPT-o1 也一样,只不过 o1 不把完整的思考内容输出。

在 Chatbot 进行多轮对话时,每一次思考的内容是不会再带入上下文的。每次到下一轮时,思考的内容都会被丢弃,只有用户 prompt 和模型回答的正式内容会加到上下文。因为在普通对话的场景下没必要,更倾向于单轮对话解决问题,长上下文会干扰模型,也会增加 token 消耗。

这些思考模型用到 Agent 上,就是下图这样,每次模型输出工具调用,同时都会输出 thinking 内容,思考应该调什么工具,为什么调,但下次这个思考内容会被丢弃,不会带入上下文:

Agent 的 loop 是:用户输入 → 模型输出工具调用 → 调用工具得出结果 → 模型输入下一步工具调用 → 调用工具得出结果 → …. 直到任务完成或需要用户新的输入。

这不利于模型进行多轮长链路的推理,于是 claude 4 sonnet 提出把 thinking 内容带入上下文这个事内化到模型,以提升 Agent 性能,上下文的组织变成了这样:

就这样一个事,称为 Interleaved Thinking,其他的叫法也都是一样的原理。

为什么要带 thinking

面向 Chatbot 的模型,倾向于一次性解决问题,尽量在一次 thinking 一次输出解决问题。

Agent 相反,倾向于多步不断跟环境( tool 和 user )交互解决问题。

Agent 解决一个复杂问题可能要长达几十轮工具调用,如果模型对每次调用工具的思考内容都抛弃,只留下结果,模型每次都要重新思考每一轮为什么要调这个工具,接下来应该调什么工具。这里每一次的重新思考如果跟原来的思考推理有偏移,最终的结果就会有很大的出入和不稳定,这种偏移在多轮下几乎一定会发生。

如果每一轮调用的思考内容都放回上下文里,每次为什么调工具的推理逻辑上下文都有,思维链完整,就大大减少了模型对整个规划的理解难度和对下一步的调用计划的偏差。

有没有带 thinking 内容,对效果有多大差别?MiniMax-M2 提供了他们的数据,在像 Tau 这种机票预订和电商零售场景的任务 benchmark 提升非常明显,这类任务我理解需要操作的步数更多(比如搜索机票→筛选过滤→看详情→下单→支付),模型在每一步对齐前面的思路很重要,同一个工具调用可能的理由随机性更大,每一步的思考逻辑带上后更稳定。

工程也能做?

这么一个简单的事,不用模型支持,直接工程上拼一下给模型是不是也一样?比如手动把思考内容包在一个标签(<think>)里,伪装成 User Message 或 ToolResult 的一部分放在里面,也能达到保留思考的效果。

很多人应该这样做过,但跟模型原生支持还是有较大差别。

工程手动拼接,模型只会认为这部分仍是用户输入,而且模型的训练数据和流程没有这种类型的用户输入和拼接,效果只靠模型通用智能随意发挥。

模型原生支持,训练时就可以针对这样规范的上下文训练,有标注大量的包含思考过程的 trajectory 轨迹数据训练,响应的稳定性必然会提升,这也是 Agent 模型的重点优化点之一。

签名

上述工具调用的 thinking 内容带到下一轮上下文,不同的模型做了不同额外的处理,主要是加了不同程度的签名,有两种:

thinking 内容原文,带签名校验

claude 和 gemini 都为 thinking 的内容加了签名校验,带到下一轮时,模型会前置判断思考内容有没有被篡改。

为什么要防 thinking 内容被篡改?毕竟 prompt 也可以随便改,同样是上下文的 thinking 内容改下也没什么。

主要应该是篡改了模型的 thinking 内容会打乱模型的思路,让效果变差,这也是需要避免的。

另外模型在训练和对齐时,已经默认 thinking 是模型自己的输出,不是用户随意的输入,这是两个不同类型的数据,如果实际使用时变成跟Prompt一样可随意篡改,可能有未知的安全问题。

不过国内模型目前没看到有加这个签名校验的。

thinking 内容加密

claude 在一些情况下不会输出自然语言的 thinking 内容,而是包在redacted_thinking里,是一串加密后的数据。

而 gemini 2.5/3.0 的 Agent 思维链没有明文的 thinking 字段,而是 thought_signature,也是一串加密后的数据。

用这种加密的非自然语言数据,一个好处是,它可以是对模型内部更友好、压缩率更大的数据表述方式,也可以在一些涉及安审的场景下内容不泄露给用户。

更重要的还是防泄漏,这就跟最开始 GPT o1 不输出所有思考内容一样,主要是为了不暴露思考过程,模型发布后不会太轻易被蒸馏。

最后

目前 claude 4 sonnet、gemini 3 在 Agent 工具调用的场景下,都强制要求带工具调用的思考内容和签名,这个链路正常是能很大程度提升整体的推理执行效果,是 Agent 多步骤推理的必需品。

但目前 Agent 模型的稳定性还是个问题,例如在某些场景下,业务逻辑明确需要下一步应该调工具 A,但模型思考后可能就是会概率性的调工具B,在以前是可以直接 hack 替换调工具调用,或手动插入其他工具调用,没有副作用。

但在思维链这套机制下比较麻烦,因为没法替模型输出这个工具调用的思考内容,一旦打破这个链,对后续推理的效果和稳定性都会有影响。

可能模型厂商后续可以出个允许上层纠错的机制,例如可以在某个实际告诉函数工具选择错误,重新思考,原生支持,弥补模型难以保障稳定的不足。

深入理解 Swift Concurrency:从 async/await 到隔离域

作者 皇上o_O
2026年1月12日 16:02

在 Swift 并发系统(Swift Concurrency)诞生之前,iOS 开发者的日常被回调(Callbacks)、代理(Delegates)和 Combine 填满。我们用这些工具来处理应用中大量的等待时间:网络请求、磁盘 I/O、数据库查询。它们虽然能解决问题,但代价是代码的可读性——嵌套的回调地狱(Callback Hell)和陡峭的 Combine 学习曲线让代码维护变得艰难。

Swift 的 async/await 引入了一种全新的范式。它允许开发者用看似同步的顺序代码来编写异步逻辑。底层运行时高效地管理着任务的暂停与恢复,而不再需要开发者手动在回调中穿梭。

但 async/await 只是冰山一角。Swift 并发模型的真正核心,在于它如何从根本上改变了我们对“线程安全”的理解——从管理线程(Threads)转向管理隔离(Isolation)。

本文将深入探讨这一体系,从基础语法到隔离域模型,再到实际开发中的最佳实践。

基础:暂停与恢复

异步函数(Async Function)  是这一模型的基础构建块。通过 async 标记,函数声明了它具有被“挂起”的能力。在调用时,await 关键字则是一个明确的标记,表示“在此处暂停,直到任务完成”。

func fetchUser(id: Intasync throws -> User {
    let url = URL(string"https://api.example.com/users/(id)")!
    // 执行权在此处交出,当前函数挂起
    let (data, _) = try await URLSession.shared.data(from: url)
    return try JSONDecoder().decode(User.self, from: data)
}

// 调用示例
let user = try await fetchUser(id: 123)
// fetchUser 完成后,代码才继续向下执行

这里的关键在于 挂起(Suspension)  而非 阻塞(Blocking) 。当代码在 await 处暂停时,当前线程并不会被锁死,Swift 运行时会利用这段空闲时间去处理其他工作。当异步操作完成,函数会从暂停的地方恢复执行。

并行:结构化并发

顺序执行 await 虽然直观,但在处理多个独立任务时效率低下。如果我们需要同时获取头像、横幅和简介,逐个等待会导致不必要的串行延迟。

async let 允许我们以声明式的方式并行启动任务:

func loadProfile() async throws -> Profile {
    // 三个任务立即同时启动
    async let avatar = fetchImage("avatar.jpg")
    async let banner = fetchImage("banner.jpg")
    async let bio = fetchBio()

    // 在需要结果时才进行 await
    return Profile(
        avatar: try await avatar,
        banner: try await banner,
        bio: try await bio
    )
}

这种方式既保留了代码的整洁,又实现了并行的高效。

如果任务数量是动态的(例如下载一个数组中的所有图片),则应使用 TaskGroup。它将任务组织成树状结构,父任务会等待组内所有子任务完成或抛出错误。这种层级关系被称为 结构化并发(Structured Concurrency) ,其最大优势在于生命周期管理:取消父任务会自动传播给所有子任务,且错误处理更加可预测。

任务管理:Task 的正确用法

编写了异步函数后,我们需要一个上下文来运行它们。Task 就是这个异步工作单元。它提供了从同步代码进入异步世界的桥梁。

视图层面的管理

在 SwiftUI 中,最推荐的方式是使用 .task 修饰符。它自动管理任务的生命周期:视图显示时启动,消失时自动取消。

struct ProfileViewView {
    var userIDString
    @State private var avatarImage?

    var body: some View {
        // 当 userID 变化时,旧任务取消,新任务启动
        Image(systemName"person")
            .task(id: userID) {
                avatar = await downloadAvatar(for: userID)
            }
    }
}

常见的反模式:不受管理的 Task

开发者常犯的一个错误是滥用 Task { ... } 或 Task.detached { ... }。这种手动创建的任务是“非托管”的。一旦创建,你就失去了对它的控制权:无法自动随视图销毁而取消,难以追踪执行状态,也难以捕获其中的错误。

这就像把漂流瓶扔进大海,你不知道它何时到达,也无法在发出去后撤回。

最佳实践

    1. 优先使用 .task 修饰符或 TaskGroup
    1. 仅在确实需要(如点击按钮触发)时使用 Task { },并意识到其生命周期的独立性。
    1. 极少使用 Task.detached,除非你明确知道该任务不需要继承当前的上下文(如优先级、Actor 隔离)。

核心范式转变:从线程到隔离

在 Swift 并发出现之前,不管是 GCD 还是 OperationQueue,我们关注的核心是 线程(Thread) :代码在哪个队列跑?是否在主线程更新 UI?

这种模型极其依赖开发者的自觉性。一旦忘记切换线程,或者两个线程同时访问同一块内存,就会导致 数据竞争(Data Race) 。这是未定义行为,可能导致崩溃或数据损坏。

Swift 并发模型不再询问“代码在哪里运行”,而是问:“谁有权访问这块数据?

这就是 隔离(Isolation)

Swift 通过编译器在构建阶段强制执行隔离规则,而不是依赖运行时的运气。底层依然是线程池在调度,但上层的安全由 Actor 模型保证。

1. MainActor:UI 的守护者

@MainActor 是一个全局 Actor,代表主线程的隔离域。它是 UI 框架(SwiftUI, UIKit)的领地。

@MainActor
class ViewModel {
    // 编译器强制要求:访问 items 必须在 MainActor 上
    var items: [Item] = [] 
}

标记了 @MainActor 的类,其属性和方法默认都在主线程隔离域中。这意味着你不需要手动 DispatchQueue.main.async,编译器会确保外部调用者必须通过 await 来跨越隔离边界。对于大多数应用,将 ViewModel 标记为 @MainActor 是默认且正确的选择。

2. Actor:数据孤岛

actor 是一种引用类型,它像类一样,但有一个关键区别:它保护其可变状态。Actor 保证同一时间只有一个任务能访问其内部状态,从而从根本上消除了数据竞争。

actor BankAccount {
    var balance: Double = 0
    
    func deposit(_ amountDouble) {
        balance += amount // 安全:Actor 内部串行访问
    }
}

// 外部调用必须等待,因为可能需要排队
await account.deposit(100)

可以将 Actor 想象成办公楼里的独立办公室,一次只能进一个人处理文件。

3. Nonisolated:公共走廊

标记为 nonisolated 的代码显式退出了 Actor 的隔离保护。它可以被任何地方调用,不需要 await,但也因此不能访问 Actor 的内部受保护状态。

数据的跨域传递:Sendable

隔离域保护了数据,但数据总需要在不同域之间传递。当一个对象从后台 Actor 传递到 MainActor 时,Swift 必须确保这一传递是安全的。

Sendable 协议就是这个通行证。它告诉编译器:“这个类型可以安全地跨越隔离边界”。

  • • 值类型(Struct, Enum) :通常是 Sendable,因为传递的是拷贝,互不影响。
  • • Actor:也是 Sendable,因为它们自带同步机制。
  • • 类(Class) :通常 不是 Sendable。除非它是 final 的且只有不可变属性。

如果试图在并发环境中传递一个普通的类实例,编译器会报错,因为它无法保证两个线程不会同时修改这个类。

隔离的继承与流转

理解 Swift 并发的关键在于理解 隔离继承

在启用了完整并发检查(Swift 6 / Approachable Concurrency)的项目中,代码执行的上下文通常遵循以下规则:

  1. 1. 函数调用:继承调用者的隔离。如果在 @MainActor 的函数中调用另一个普通函数,后者也在 MainActor 上运行。
  2. 2. Task { } :继承创建它的上下文。在 ViewModel(MainActor)中创建的 Task,其中的代码默认也在 MainActor 上运行。
  3. 3. Task.detached:斩断继承,在一个没有任何特定隔离的上下文中运行。

这也是为什么不要迷信 async 等于后台线程。

@MainActor
func slowFunction() async {
    // 错误:这虽然是 async 函数,但依然在 MainActor 运行
    // 这里的同步计算会卡死 UI
    let result = expensiveCalculation() 
    data = result
}

async 只意味着函数 可以 暂停,并不意味着它会自动切到后台。如果是 CPU 密集型任务,你需要显式地将其移出主线程(例如使用 Swift 6.2 的 @concurrent 标记或放入 detached task)。

常见误区与避坑指南

  1. 1. 过度设计 Actor:不要为每个数据源都创建一个 Actor。大多数时候,将状态隔离在 @MainActor 的 ViewModel 中已经足够。只有当确实存在跨线程共享的可变状态时,才引入自定义 Actor。
  2. 2. 滥用 @unchecked Sendable:不要为了消除编译器警告而随意使用 @unchecked Sendable。这相当于告诉编译器“闭嘴,由于我自己负责”,一旦出错就是难以调试的竞争问题。
  3. 3. 阻塞协作线程池:永远不要在 async 上下文中使用信号量(Semaphore)或 DispatchGroup.wait()。Swift 的底层线程池容量有限(通常等同于 CPU 核心数),阻塞其中一个线程可能导致死锁或饥饿。
  4. 4. 无脑 MainActor.run:很多开发者习惯在获取数据后写 await MainActor.run { ... }。更好的做法是直接将更新数据的函数标记为 @MainActor,让编译器自动处理上下文切换。

总结

Swift 的并发模型建立在三个支柱之上:

  1. 1. async/await:处理控制流,让异步代码线性化。
  2. 2. Task:结构化地管理异步工作的生命周期。
  3. 3. Actor & Isolation:通过隔离域在编译时消除数据竞争。

对于大多数应用开发,遵循简单的规则即可:默认使用 @MainActor 保护 UI 状态,使用 async/await 处理 I/O,利用 .task 管理生命周期。只有在遇到真正的性能瓶颈或复杂的共享状态时,才需要深入自定义 Actor 和细粒度的隔离控制。

编译器是你的向导,而非敌人。当它报出并发错误时,它实际上是在帮你规避那些曾在旧时代导致无数崩溃的隐形 Bug。

1月10日用户隐私保护新规出炉,政策解读

作者 CocoaKier
2026年1月12日 14:08

2026年1月10日,国家互联网信息办公室发布了《互联网应用程序个人信息收集使用规定(征求意见稿)》,进一步优化了个人隐私保护法案内容。

政策原文:mp.weixin.qq.com/s/epF6mh-Oc…

原文.png

一句话总结:这次的新政细化了隐私合规规则,堵住了一些规则漏洞,进一步保护用户隐私。对于大部分开展正规业务的开发者来说,无需特别的改动。后续可按渠道平台(华为、小米等)要求,做进一步调整

内容概览
1、明确禁止“无关场景调用相机/麦克风”,直击“偷听偷拍”乱象。——旧规:仅原则性要求“不得超范围收集”,但未明确哪些行为算违规。
2、位置权限分级管理:区分“实时定位”与“单次定位” ——旧规:仅笼统要求“最小必要”。
3、进一步强化了不允许获取用户全部相册权限,必须使用系统系框架Android SAF,只能获取用户授权后的部分照片。
4、操作系统厂商,需提供“精细化授权”选项,如 “仅本次允许”“仅今天允许”。
5、生物识别信息(人脸、指纹等)原则上只能本地存储,不能上传。除非法律允许或用户单独同意。
6、App运营者对第三方SDK负连带审核义务。用户向App提出对SDK的数据权利请求(如删除),App必须转达并督促SDK响应,不能再以“这是第三方SDK行为,与我无关”推责。
7、账号注销流程进一步简化:不得强制用户提供额外身份证明(如手持身份证、学历证明等)。堵住了一些App以“安全验证”为名设置注销门槛的做法。

下面是详细介绍

一、首次 明确禁止“无关场景调用相机/麦克风” —— 直击“偷听偷拍”乱象

  • 旧规:仅原则性要求“不得超范围收集”,但未明确哪些行为算违规。
  • 新规(第14条)
    • 必须“用户主动选择使用拍照、语音、录音录像等功能时”才能调用相机/麦克风
    • 禁止在用户停止使用相关功能后继续调用
    • 禁止在无关场景(如浏览商品页、看新闻)调用音视频权限

实质变化:这是首次以部门规章形式将“后台静默调用麦克风/摄像头”直接定性为违规。此前企业常以“预加载”“性能优化”为由辩解,今后不再成立。


二、位置权限分级管理:区分“实时定位”与“单次定位”

  • 旧规:仅笼统要求“最小必要”。
  • 新规(第14条)
    • 实时定位类(导航、外卖) → 调用频率必须“限于业务最低频度”;
    • 单次定位类(搜索、推荐、广告)仅允许调用一次,且需用户进入界面或主动刷新;
    • 原则上禁止申请“后台持续获取位置”权限(除非法律另有规定或确需)。

实质变化:终结了“只要用户开了定位,App就可高频后台上报位置”的灰色操作。例如,电商App在首页展示附近门店,只能触发一次定位,不能持续追踪。


三、强制使用系统级存储访问框架(如Android SAF)

  • 新规(第14条)
    • 用户上传图片/文件时,若系统提供标准存储访问框架(如Android的Storage Access Framework),App 不得再索要“相册”“存储”全权限
    • 即使因文件编辑/备份获得存储权限,也不得访问用户未主动选择的其他文件

实质变化:推动从“粗放式读取整个相册”转向“按需访问单个文件”,大幅降低隐私泄露面。这要求开发者重构文件上传逻辑。


四、操作系统需提供“精细化授权”选项(开发者需适配)

  • 新规(第14条)
    • 操作系统在弹窗征得用户同意时,应提供基于时间、频度、精度的授权选项(如“仅本次允许”“仅今天允许”“模糊位置”)。

实质变化:虽然责任在OS厂商,但开发者需确保App能兼容这些细粒度授权(例如用户选择“仅本次允许位置”,下次使用需重新申请)。否则功能将异常。


五、生物识别信息默认本地处理,禁止网络传输

  • 新规(第15条)
    • 人脸、指纹等生物特征信息,默认应在终端设备本地处理和存储
    • 不得通过网络传输至服务器,除非:
      • 法律法规明确允许;或
      • 用户单独书面同意(且目的充分必要)。

实质变化:许多App当前将人脸照片上传服务器进行比对(如刷脸登录),今后必须评估是否真有必要。若非必要,必须改为本地验证(如Face ID/指纹API)。


六、SDK责任穿透:App运营者对第三方SDK负连带审核义务

  • 新规(第19条)
    • App运营者必须审核嵌入的SDK,确保其行为符合公示规则;
    • 用户向App提出对SDK的数据权利请求(如删除),App必须转达并督促SDK响应

实质变化:不能再以“这是第三方SDK行为,与我无关”推责。开发者需建立SDK准入机制,并保留沟通记录。


七、账号注销流程进一步简化(禁止设置障碍)

  • 新规(第18条)
    • 注销后15个工作日内必须删除或匿名化数据
    • 不得强制用户提供额外身份证明(如手持身份证、学历证明等);
    • 若使用统一账号体系(如微信/QQ登录),必须支持单App注销,不影响其他服务。

实质变化:堵住了一些App以“安全验证”为名设置注销门槛的做法。

01-📝物联网组网 | 各类通信协议-知识体系导论

**物联网通信协议**是指在物联网系统中,用于实现`设备之间`、`设备与云端之间`数据传输和通信的标准化规则和约定。这些协议定义了`数据格式`、`传输方式`、`错误处理`、`安全机制`等技术规范,确保

老司机 iOS 周报 #362 | 2026-01-12

作者 ChengzhiHuang
2026年1月11日 20:07

ios-weekly
老司机 iOS 周报,只为你呈现有价值的信息。

你也可以为这个项目出一份力,如果发现有价值的信息、文章、工具等可以到 Issues 里提给我们,我们会尽快处理。记得写上推荐的理由哦。有建议和意见也欢迎到 Issues 提出。

文章

🐎 我们如何使用 Codex 在 28 天内构建 Android 版 Sora

@Crazy:本篇文章简略的讲述了 OpenAI 的工程师团队是如何利用 CodeX 在 28 天内开发 Sora 的 Android 版本,主要可以分为以下四个部分

  1. 在 Codex 在整个代码库中创建和维护大量 AGENT.md 来引导新的开发工程师,减少重复的沟通和模版代码,增加测试量,让团队专注于架构、用户体验、系统性变更和最终质量。
  2. 利用项目的整体规则,编写部分具有代表性的端到端功能。通过将 Codex 指向具有代表性的功能,让 AI 在一个标准范围内工作,提高 AI 的生成准确性与工作效率。
  3. 在编写代码前使用 Codex 进行规划,利用相关文件并总结该功能的运作原理,即了解 CodeX 是如何从 API 到用户界面的生成过程,并且在生成后进行对应的架构纠正,利用这种可分享的动态策略让 CodeX 生成更加符合架构的代码。
  4. 同时运行多个 Codex 会话,一个会话负责回放,一个负责搜索,一个负责错误处理,还有一个则负责测试或重构。多会话会大大提高整体开发效率,并让开发人员处在审核的位置上,而不是开发的位置上。

最后是利用 CodeX 的上下文来让他发挥到最佳水平,也可以跨平台进行上下文分析,但没有上下文就是盲目猜测。

🐕 Tracking renamed files in Git

@Barney:本文聚焦 Git 不直接追踪文件重命名的核心特性,解析其通过文件内容相似度启发式算法推测重命名的逻辑。为确保历史追踪准确,核心建议将重命名单独提交,推荐借助 git mv 命令(暂存重命名操作、保留文件编辑未暂存状态)实现。同时提供替代脚本方案,解决无法使用 git mv 时,重命名与编辑同步进行导致的追踪难题,助力高效管理文件版本历史。

🐕 Replay

@Smallfly:这篇文章介绍了 Swift 生态中解决网络测试痛点的工具 Replay,通过记录与重放真实 HTTP 流量,为测试提供高效、稳定的解决方案。核心亮点包括:

  • 痛点解决:针对网络测试慢、依赖第三方服务不稳定、手动维护 JSON 响应文件易过时的问题,Replay 实现「记录一次,永久重放」,避免测试受网络波动影响。
  • 技术优势:采用行业标准 HAR(HTTP Archive)格式存储流量,兼容浏览器开发者工具、Charles 等工具;结合 Swift 6.1 的 TestScoping 协议与包插件,实现声明式测试配置。
  • 工作流程:首次运行测试时提示记录,后续自动使用本地 HAR 文件,测试速度从分钟级降至秒级。
  • 灵活配置:支持过滤敏感数据、自定义请求匹配规则,并提供内联存根功能,适配错误处理等边缘场景。

文章通过代码示例与实践建议,展示了 Replay 如何让网络测试更可靠、高效,是 Swift 开发者优化测试流程的实用参考。

🐎 Flutter 官方正式解决 iOS 26 上的 WebView 有点击问题

@david-clang:对于 Flutter WebView 在 iOS 26 点击失效和触摸穿透的问题,官方技术文档详细阐述了问题原因和解决方案,最终方案是 Flutter Engine + iOS embedder 新增 “同步 hitTest 回调” 能力,将手势决策从“异步协同”改为“同步拦截”,在触点处直接判断是否应拦截手势,从根本解决 WebView、AdMob 等 PlatformView 的手势冲突问题。

因为底层的重构方案还需要上层插件进行适配,官方又合入了个无需插件适配的临时方案作为补充:在 FlutterPlatformViews.mm 中实现了针对 WKWebView 手势识别器的递归搜索和“重启”机制,并在 blockGesture 中针对 iOS 26+ 启用了这个机制。

代码

React Native for macOS

@EyreFree:微软 react-native-macos 仓库值得关注!作为 Facebook React Native 的开源分支(MIT 许可),它支持用 React 快速构建原生 macOS 应用,兼容 macOS 11+。具备声明式 UI、组件化开发、热重载等优势,还能跨 iOS、Android 复用代码,配套完善文档与贡献指南,更新维护活跃,是 macOS 原生应用开发的高效选择,感兴趣的同学可以试试。

Skills Public

@含笑饮砒霜:这是一个聚焦于 SwiftUI UI 设计模式的代码仓库,核心围绕 SwiftUI 框架提供各类实用的 UI 实现方案、设计最佳实践和代码示例,面向 iOS/macOS 等平台开发者,旨在解决 SwiftUI 开发中常见的 UI 构建问题、统一设计范式。适合 iOS/macOS 开发者(尤其是 SwiftUI 初学者 / 进阶者),可作为 SwiftUI UI 模式的参考手册,快速复用成熟的设计和代码方案,避免重复踩坑。

内推

重新开始更新「iOS 靠谱内推专题」,整理了最近明确在招人的岗位,供大家参考

具体信息请移步:https://www.yuque.com/iosalliance/article/bhutav 进行查看(如有招聘需求请联系 iTDriverr)

关注我们

我们是「老司机技术周报」,一个持续追求精品 iOS 内容的技术公众号,欢迎关注。

关注有礼,关注【老司机技术周报】,回复「2024」,领取 2024 及往年内参

同时也支持了 RSS 订阅:https://github.com/SwiftOldDriver/iOS-Weekly/releases.atom

说明

🚧 表示需某工具,🌟 表示编辑推荐

预计阅读时间:🐎 很快就能读完(1 - 10 mins);🐕 中等 (10 - 20 mins);🐢 慢(20+ mins)

Claude Code 四大核心技能使用指南

作者 tiantian_cool
2026年1月11日 16:52

本文详细介绍 Superpowers、Feature-Dev、UI/UX Pro Max 和 Ralph Wiggum 四个强大技能的使用方法,帮助开发者充分发挥 Claude Code 的潜力。


目录

  1. 技能系统概述
  2. Superpowers:完整开发工作流
  3. Feature-Dev:功能开发指南
  4. UI/UX Pro Max:设计智能系统
  5. Ralph Wiggum:迭代循环开发
  6. 技能选择指南
  7. 总结

技能系统概述

Claude Code 的技能系统是一套可组合的专业工作流,它们在特定场景下自动激活,帮助开发者以系统化的方式完成复杂任务。

核心原则

如果你认为某个技能有哪怕 1% 的可能适用于当前任务,
你就必须调用它。这不是建议,而是强制要求。

技能优先级

当多个技能可能适用时,按以下顺序使用:

  1. 流程技能优先(brainstorming、debugging)- 决定如何处理任务
  2. 实现技能其次(frontend-design、mcp-builder)- 指导具体执行

Superpowers:完整开发工作流

什么是 Superpowers?

Superpowers 是一套完整的软件开发工作流,基于可组合的"技能"构建。它从你启动编程代理的那一刻开始工作,不是直接跳入编码,而是先退一步理解你真正想要做什么。

安装方式

Claude Code 用户:

# 注册 marketplace
/plugin marketplace add obra/superpowers-marketplace

# 安装插件
/plugin install superpowers@superpowers-marketplace

# 验证安装
/help

核心工作流

Superpowers 包含七个阶段的完整开发流程:

1. Brainstorming(头脑风暴)

在编写代码之前激活,通过问答细化粗略想法,探索替代方案,分段展示设计供验证。

关键原则:

  • 一次只问一个问题
  • 优先使用选择题
  • 无情地应用 YAGNI(你不会需要它)
  • 总是提出 2-3 种方案后再定案

流程:

理解项目状态 → 逐个提问细化想法 → 提出2-3种方案
→ 分段展示设计(每段200-300字)→ 验证后保存设计文档

2. Git Worktrees(Git工作树)

设计批准后激活,在新分支上创建隔离的工作空间,运行项目设置,验证干净的测试基线。

3. Writing Plans(编写计划)

将工作分解为小任务(每个2-5分钟),每个任务都有:

  • 精确的文件路径
  • 完整的代码
  • 验证步骤

4. Subagent-Driven Development(子代理驱动开发)

这是 Superpowers 的核心机制:

每个任务分派新的子代理 → 两阶段审查:
  1. 规格合规审查(代码是否符合规格)
  2. 代码质量审查(代码是否写得好)

优势:

  • 每个任务有新鲜的上下文(无污染)
  • 自动审查检查点
  • 子代理可以在工作前后提问

示例流程:

读取计划 → 提取所有任务 → 创建TodoWrite

任务1[分派实现子代理] → 子代理实现、测试、提交
  [分派规格审查子代理] → 确认代码符合规格
  [分派代码质量审查子代理] → 批准代码质量
  [标记任务完成]

任务2: ...

所有任务完成后 → 最终代码审查 → 完成开发分支

5. Test-Driven Development(测试驱动开发)

Superpowers 强制执行 RED-GREEN-REFACTOR 循环:

写失败测试 → 观察失败 → 写最小代码 → 观察通过 → 提交

铁律:

没有先失败的测试,就没有生产代码

在测试之前写了代码?删除它。从头开始。

常见借口及真相:

借口 真相
"太简单不需要测试" 简单代码也会出错,测试只需30秒
"我之后会测试" 立即通过的测试什么也证明不了
"删除X小时的工作太浪费" 沉没成本谬误,保留未验证的代码才是技术债务
"TDD太教条" TDD才是务实的,"务实"的捷径=生产环境调试=更慢

6. Code Review(代码审查)

在任务之间激活,根据计划审查代码,按严重程度报告问题。关键问题会阻止进度。

7. Finishing Branch(完成分支)

任务完成时激活,验证测试,提供选项(合并/PR/保留/丢弃),清理工作树。

核心哲学

  • 测试驱动开发 - 始终先写测试
  • 系统化优于临时 - 流程优于猜测
  • 降低复杂性 - 简单是首要目标
  • 证据优于声明 - 在宣布成功前验证

Feature-Dev:功能开发指南

什么是 Feature-Dev?

Feature-Dev 是一个系统化的功能开发技能,帮助开发者深入理解代码库、识别并询问所有不明确的细节、设计优雅的架构,然后实现。

七个阶段

Phase 1: Discovery(发现)

目标: 理解需要构建什么

操作:

  1. 创建包含所有阶段的 todo 列表

  2. 如果功能不清晰,询问用户:

    • 要解决什么问题?
    • 功能应该做什么?
    • 有什么约束或要求?
  3. 总结理解并与用户确认

Phase 2: Codebase Exploration(代码库探索)

目标: 在高层和底层理解相关现有代码和模式

操作:

  1. 并行启动 2-3 个 code-explorer 代理,每个代理:

    • 全面追踪代码,专注于理解抽象、架构和控制流
    • 针对代码库的不同方面
    • 包含 5-10 个关键文件列表

示例代理提示:

  • "找到与 [功能] 类似的功能并全面追踪其实现"
  • "映射 [功能区域] 的架构和抽象"
  • "分析 [现有功能/区域] 的当前实现"
  1. 代理返回后,阅读所有识别的文件以建立深入理解
  2. 呈现发现和模式的综合摘要

Phase 3: Clarifying Questions(澄清问题)

目标: 在设计前填补空白并解决所有歧义

这是最重要的阶段之一,不能跳过。

操作:

  1. 审查代码库发现和原始功能请求
  2. 识别未明确的方面:边缘情况、错误处理、集成点、范围边界、设计偏好、向后兼容性、性能需求
  3. 以清晰、有组织的列表向用户呈现所有问题
  4. 等待答案后再进行架构设计

Phase 4: Architecture Design(架构设计)

目标: 设计具有不同权衡的多种实现方案

操作:

  1. 并行启动 2-3 个 code-architect 代理,关注不同方面:

    • 最小变更:最小变化,最大复用
    • 清洁架构:可维护性,优雅抽象
    • 务实平衡:速度 + 质量
  2. 审查所有方案,形成哪个最适合此特定任务的意见

  3. 向用户呈现:

    • 每种方案的简要摘要
    • 权衡比较
    • 你的推荐及理由
    • 具体实现差异
  4. 询问用户偏好哪种方案

Phase 5: Implementation(实现)

目标: 构建功能

未经用户批准不要开始

操作:

  1. 等待用户明确批准
  2. 阅读前几个阶段识别的所有相关文件
  3. 按选定架构实现
  4. 严格遵循代码库约定
  5. 编写干净、文档完善的代码
  6. 随着进展更新 todos

Phase 6: Quality Review(质量审查)

目标: 确保代码简单、DRY、优雅、易读且功能正确

操作:

  1. 并行启动 3 个 code-reviewer 代理,关注不同方面:

    • 简单性/DRY/优雅
    • 缺陷/功能正确性
    • 项目约定/抽象
  2. 整合发现,识别你建议修复的最高严重性问题

  3. 向用户呈现发现并询问他们想怎么做(现在修复、稍后修复或按原样进行)

  4. 根据用户决定处理问题

Phase 7: Summary(总结)

目标: 记录完成的工作

操作:

  1. 将所有 todos 标记为完成

  2. 总结:

    • 构建了什么
    • 做出的关键决策
    • 修改的文件
    • 建议的下一步

UI/UX Pro Max:设计智能系统

什么是 UI/UX Pro Max?

UI/UX Pro Max 是一个可搜索的 UI 设计数据库,包含 50+ 种 UI 风格、21 种调色板、50 种字体配对、20 种图表类型、8 种技术栈的最佳实践。

前提条件

确保已安装 Python:

python3 --version || python --version

使用方法

当用户请求 UI/UX 工作(设计、构建、创建、实现、审查、修复、改进)时,按以下工作流程:

步骤 1:分析用户需求

从用户请求中提取关键信息:

  • 产品类型:SaaS、电商、作品集、仪表盘、着陆页等
  • 风格关键词:极简、活泼、专业、优雅、深色模式等
  • 行业:医疗、金融科技、游戏、教育等
  • 技术栈:React、Vue、Next.js,或默认使用 html-tailwind

步骤 2:搜索相关领域

使用 search.py 多次搜索以收集全面信息:

python3 .claude/skills/ui-ux-pro-max/scripts/search.py "<关键词>" --domain <领域> [-n <最大结果数>]

推荐搜索顺序:

顺序 领域 用途
1 product 获取产品类型的风格推荐
2 style 获取详细风格指南(颜色、效果、框架)
3 typography 获取字体配对和 Google Fonts 导入
4 color 获取配色方案(主色、辅色、CTA、背景、文字、边框)
5 landing 获取页面结构(如果是着陆页)
6 chart 获取图表推荐(如果是仪表盘/分析)
7 ux 获取最佳实践和反模式
8 stack 获取技术栈特定指南

步骤 3:可用技术栈

关注点
html-tailwind Tailwind 工具类、响应式、无障碍(默认)
react 状态、hooks、性能、模式
nextjs SSR、路由、图片、API 路由
vue Composition API、Pinia、Vue Router
svelte Runes、stores、SvelteKit
swiftui 视图、状态、导航、动画
react-native 组件、导航、列表
flutter Widgets、状态、布局、主题

示例工作流

用户请求: "做一个专业护肤服务的着陆页"

# 1. 搜索产品类型
python3 .claude/skills/ui-ux-pro-max/scripts/search.py "beauty spa wellness service" --domain product

# 2. 搜索风格
python3 .claude/skills/ui-ux-pro-max/scripts/search.py "elegant minimal soft" --domain style

# 3. 搜索字体
python3 .claude/skills/ui-ux-pro-max/scripts/search.py "elegant luxury" --domain typography

# 4. 搜索配色
python3 .claude/skills/ui-ux-pro-max/scripts/search.py "beauty spa wellness" --domain color

# 5. 搜索着陆页结构
python3 .claude/skills/ui-ux-pro-max/scripts/search.py "hero-centric social-proof" --domain landing

# 6. 搜索 UX 指南
python3 .claude/skills/ui-ux-pro-max/scripts/search.py "animation" --domain ux
python3 .claude/skills/ui-ux-pro-max/scripts/search.py "accessibility" --domain ux

# 7. 搜索技术栈指南
python3 .claude/skills/ui-ux-pro-max/scripts/search.py "layout responsive" --stack html-tailwind

专业 UI 通用规则

这些是经常被忽视但会让 UI 看起来不专业的问题:

图标和视觉元素

规则 正确做法 错误做法
不使用 emoji 图标 使用 SVG 图标(Heroicons、Lucide) 使用 emoji 作为 UI 图标
稳定的悬停状态 使用颜色/透明度过渡 使用会移动布局的缩放变换
一致的图标尺寸 使用固定 viewBox(24x24)配合 w-6 h-6 随意混合不同图标尺寸

交互和光标

规则 正确做法 错误做法
光标指针 给所有可点击元素添加 cursor-pointer 交互元素保持默认光标
悬停反馈 提供视觉反馈(颜色、阴影、边框) 元素交互时无任何指示
平滑过渡 使用 transition-colors duration-200 瞬间状态变化或太慢(>500ms)

亮/暗模式对比度

规则 正确做法 错误做法
亮模式玻璃卡片 使用 bg-white/80 或更高透明度 使用 bg-white/10(太透明)
亮模式文字对比 使用 #0F172A(slate-900)作为文字 使用 #94A3B8(slate-400)作为正文
边框可见性 亮模式使用 border-gray-200 使用 border-white/10(不可见)

交付前检查清单

视觉质量

  • 没有使用 emoji 作为图标
  • 所有图标来自一致的图标集
  • 品牌 logo 正确
  • 悬停状态不会导致布局偏移

交互

  • 所有可点击元素有 cursor-pointer
  • 悬停状态提供清晰的视觉反馈
  • 过渡平滑(150-300ms)
  • 键盘导航的焦点状态可见

亮/暗模式

  • 亮模式文字有足够对比度(最少 4.5:1)
  • 玻璃/透明元素在亮模式下可见
  • 边框在两种模式下都可见

布局

  • 浮动元素与边缘有适当间距
  • 内容不会隐藏在固定导航栏后面
  • 响应式适配 320px、768px、1024px、1440px
  • 移动端无水平滚动

Ralph Wiggum:迭代循环开发

什么是 Ralph Wiggum?

Ralph Wiggum 是一种基于持续 AI 代理循环的开发方法。正如 Geoffrey Huntley 所描述的: "Ralph 是一个 Bash 循环" - 一个简单的 while true,重复给 AI 代理喂入提示文件,让它迭代改进工作直到完成。

这个技术以《辛普森一家》中的 Ralph Wiggum 命名,体现了不顾挫折持续迭代的哲学。

核心概念

这个插件使用 Stop hook 实现 Ralph,拦截 Claude 的退出尝试:

# 你只运行一次:
/ralph-loop "你的任务描述" --completion-promise "DONE"

# 然后 Claude Code 自动:
# 1. 处理任务
# 2. 尝试退出
# 3. Stop hook 阻止退出
# 4. Stop hook 喂入相同的提示
# 5. 重复直到完成

循环发生在你当前会话内 - 你不需要外部 bash 循环。

这创建了一个自引用反馈循环

  • 迭代之间提示不变
  • Claude 之前的工作保留在文件中
  • 每次迭代看到修改的文件和 git 历史
  • Claude 通过读取文件中自己过去的工作自主改进

快速开始

/ralph-loop "构建一个 todos 的 REST API。要求:CRUD 操作、输入验证、测试。完成后输出 <promise>COMPLETE</promise>。" --max-iterations 50 --completion-promise "COMPLETE"

Claude 将:

  • 迭代实现 API
  • 运行测试并看到失败
  • 根据测试输出修复 bug
  • 迭代直到满足所有要求
  • 完成后输出完成承诺

命令

/ralph-loop

在当前会话中启动 Ralph 循环。

/ralph-loop "<提示>" --max-iterations <n> --completion-promise "<文本>"

选项:

  • --max-iterations <n> - N 次迭代后停止(默认:无限)
  • --completion-promise <text> - 表示完成的短语

/cancel-ralph

取消活动的 Ralph 循环。

/cancel-ralph

提示编写最佳实践

1. 清晰的完成标准

错误示例:

构建一个 todo API 并让它好用。

正确示例:

构建一个 todos 的 REST API。

完成条件:
- 所有 CRUD 端点工作正常
- 输入验证就位
- 测试通过(覆盖率 > 80%)
- 带 API 文档的 README
- 输出:<promise>COMPLETE</promise>

2. 增量目标

错误示例:

创建一个完整的电商平台。

正确示例:

阶段 1:用户认证(JWT、测试)
阶段 2:产品目录(列表/搜索、测试)
阶段 3:购物车(添加/删除、测试)

所有阶段完成后输出 <promise>COMPLETE</promise>。

3. 自我纠正

错误示例:

为功能 X 写代码。

正确示例:

使用 TDD 实现功能 X:
1. 写失败测试
2. 实现功能
3. 运行测试
4. 如果失败,调试并修复
5. 需要时重构
6. 重复直到全部通过
7. 输出:<promise>COMPLETE</promise>

4. 安全阀

始终使用 --max-iterations 作为安全网,防止在不可能的任务上无限循环:

# 推荐:始终设置合理的迭代限制
/ralph-loop "尝试实现功能 X" --max-iterations 20

哲学

Ralph 体现几个关键原则:

原则 说明
迭代 > 完美 不要追求第一次就完美。让循环细化工作。
失败是数据 "确定性的失败"意味着失败是可预测的和有信息量的。
操作员技能很重要 成功取决于写好提示,不只是有好模型。
坚持获胜 持续尝试直到成功。循环自动处理重试逻辑。

适用场景

适合:

  • 有明确成功标准的定义良好的任务
  • 需要迭代和细化的任务(如让测试通过)
  • 你可以走开的绿地项目
  • 有自动验证的任务(测试、linter)

不适合:

  • 需要人类判断或设计决策的任务
  • 一次性操作
  • 成功标准不清楚的任务
  • 生产环境调试(使用针对性调试代替)

真实世界成果

  • 在 Y Combinator 黑客马拉松测试中一夜成功生成 6 个仓库
  • 一份 50k合同以50k 合同以 297 API 成本完成
  • 用这种方法在 3 个月内创建了整个编程语言("cursed")

技能选择指南

场景对照表

场景 推荐技能
构建新功能 Feature-Dev → Superpowers
UI/UX 设计实现 UI/UX Pro Max
长时间自主任务 Ralph Wiggum
完整项目开发 Superpowers(完整工作流)
修复 bug Superpowers(systematic-debugging)
代码审查 Superpowers(code-reviewer)

组合使用

这些技能可以组合使用:

  1. Feature-Dev + UI/UX Pro Max:开发带 UI 的新功能
  2. Ralph Wiggum + Superpowers:自主完成带 TDD 的长任务
  3. Superpowers + Feature-Dev:完整的企业级功能开发

总结

技能 核心价值 最佳场景
Superpowers 完整的 TDD 工作流 项目开发全流程
Feature-Dev 系统化功能开发 新功能实现
UI/UX Pro Max 设计智能数据库 UI 设计和前端开发
Ralph Wiggum 自主迭代循环 长时间自动化任务

黄金法则

如果你认为某个技能有哪怕 1% 的可能适用,就必须使用它。
这不是可选的,这是强制的。你不能为绕过它找理由。

iOS实现 WKWebView 长截图的优雅方案

2026年1月11日 00:26

在 iOS 开发中,为 WKWebView 实现长截图功能是一个常见且棘手的需求。开发者通常会遇到以下几个痛点:

  • 网页内容高度不确定
  • 滚动区域难以完整截取
  • 截图过程中的界面闪烁影响用户体验

本文将介绍一种高效、稳定的解决方案,通过分段渲染图像拼接,完美捕获整个网页内容,并提供可直接集成的完整代码。


🎯 核心思路

我们的方案主要分为三个清晰的步骤:

  1. 布局调整:将 WebView 移至临时容器,为完整渲染做准备。
  2. 分段渲染:按屏幕高度分段捕获内容,生成多张切片图像。
  3. 图像拼接:将所有切片图像无缝拼接成一张完整的长图。

这种方法巧妙地绕过了直接截取 UIScrollView 的局限性,同时通过遮罩视图,保证了用户界面的视觉稳定性,避免闪烁。


💻 完整实现代码

WKWebView分类中添加长截图方法

  • WKWebView+Capture.h
#import <WebKit/WebKit.h>
#import <UIKit/UIKit.h>

NS_ASSUME_NONNULL_BEGIN

@interface WKWebView (Capture)

/**
 * 捕获 WKWebView 的完整内容并生成长截图
 * @param completion 完成回调,返回拼接好的长图(失败则返回 nil)
 */
- (void)captureEntireWebViewWithCompletion:(void (^)(UIImage * _Nullable capturedImage))completion;

@end

NS_ASSUME_NONNULL_END


  • WKWebView+Capture.m
#import "WKWebView+Capture.h"

@implementation WKWebView (Capture)

/**
 * 捕获 WKWebView 的完整内容并生成长截图
 * @param completion 完成回调,返回拼接好的长图(失败则返回 nil)
 */
- (void)captureEntireWebViewWithCompletion:(void (^)(UIImage *capturedImage))completion {

    // ⚠️ 关键:确保在主线程执行
    if (![NSThread isMainThread]) {
        NSLog(@"错误:WebView 截图必须在主线程执行");
        if (completion) completion(nil);
        return;
    }

    // 步骤1: 检查父视图并保存原始状态
    UIView *parentView = self.superview;
    if (!parentView) {
        if (completion) completion(nil);
        return;
    }

    CGRect originalFrame = self.frame;
    CGPoint originalContentOffset = self.scrollView.contentOffset;

    // 步骤2: 创建遮罩视图,保持界面"静止"的视觉效果,可以额外添加loading
    UIView *snapshotCoverView = [self snapshotViewAfterScreenUpdates:NO];
    snapshotCoverView.frame = self.frame; // 确保遮罩视图位置与 WebView 完全一致
    [parentView insertSubview:snapshotCoverView aboveSubview:self];

    // 步骤3: 创建隐藏的临时窗口和容器
    UIWindow *temporaryWindow = [[UIWindow alloc] initWithFrame:self.bounds];
    temporaryWindow.windowLevel = UIWindowLevelNormal - 1000; // 置于底层
    temporaryWindow.hidden = NO;
    temporaryWindow.alpha = 0;
    temporaryWindow.userInteractionEnabled = NO;

    UIView *captureContainerView = [[UIView alloc] initWithFrame:self.bounds];
    captureContainerView.clipsToBounds = YES;

    // 将 WebView 移入临时容器
    [self removeFromSuperview];
    [captureContainerView addSubview:self];
    [temporaryWindow addSubview:captureContainerView];

    // 步骤4: 获取完整内容高度并调整布局
    CGFloat fullContentHeight = self.scrollView.contentSize.height;
    self.frame = CGRectMake(0, 0, originalFrame.size.width, fullContentHeight);
    self.scrollView.contentOffset = CGPointZero;

    __weak typeof(self) weakSelf = self;

    // ⭐ 延迟执行,确保 WebView 内容布局与渲染完成
    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(0.5 * NSEC_PER_SEC)),
                   dispatch_get_main_queue(), ^{
        __strong typeof(weakSelf) strongSelf = weakSelf;
        if (!strongSelf) {
            if (completion) completion(nil);
            return;
        }

        // 步骤5: 分段截图核心逻辑
        CGFloat pageHeight = captureContainerView.bounds.size.height; // 单屏高度
        CGFloat totalHeight = fullContentHeight; // 总内容高度

        NSMutableArray<UIImage *> *imageSlices = [NSMutableArray array];
        CGFloat offsetY = 0;

        while (offsetY < totalHeight) {
            CGFloat remainingHeight = totalHeight - offsetY;
            CGFloat sliceHeight = MIN(pageHeight, remainingHeight);

            // 处理最后一段高度不足一屏的情况
            if (remainingHeight < pageHeight) {
                CGRect containerFrame = captureContainerView.frame;
                containerFrame.size.height = remainingHeight;
                captureContainerView.frame = containerFrame;
            }

            // 移动 WebView,将当前要截取的区域"暴露"出来
            CGRect webViewFrame = strongSelf.frame;
            webViewFrame.origin.y = -offsetY;
            strongSelf.frame = webViewFrame;

            // 渲染当前分段到图像上下文
            UIGraphicsBeginImageContextWithOptions(
                CGSizeMake(originalFrame.size.width, sliceHeight),
                NO,
                [UIScreen mainScreen].scale
            );

            CGContextRef context = UIGraphicsGetCurrentContext();
            CGFloat scaleX = originalFrame.size.width / captureContainerView.bounds.size.width;
            CGFloat scaleY = sliceHeight / captureContainerView.bounds.size.height;
            CGContextScaleCTM(context, scaleX, scaleY);

            [captureContainerView.layer renderInContext:context];
            UIImage *sliceImage = UIGraphicsGetImageFromCurrentImageContext();
            UIGraphicsEndImageContext();

            if (sliceImage) {
                [imageSlices addObject:sliceImage];
            }

            offsetY += sliceHeight; // 移动到下一段
        }

        UIImage *finalImage = nil;

        // 步骤6: 图像拼接
        if (imageSlices.count == 1) {
            finalImage = imageSlices.firstObject;
        } else if (imageSlices.count > 1) {
            UIGraphicsBeginImageContextWithOptions(
                CGSizeMake(originalFrame.size.width, totalHeight),
                NO,
                [UIScreen mainScreen].scale
            );

            CGFloat drawOffsetY = 0;
            for (UIImage *slice in imageSlices) {
                [slice drawInRect:CGRectMake(0,
                                             drawOffsetY,
                                             slice.size.width,
                                             slice.size.height)];
                drawOffsetY += slice.size.height;
            }

            finalImage = UIGraphicsGetImageFromCurrentImageContext();
            UIGraphicsEndImageContext();
        }

        // 步骤7: 恢复原始状态
        [strongSelf removeFromSuperview];
        [captureContainerView removeFromSuperview];
        temporaryWindow.hidden = YES;

        strongSelf.frame = originalFrame;
        strongSelf.scrollView.contentOffset = originalContentOffset;
        [parentView insertSubview:strongSelf belowSubview:snapshotCoverView];
        [snapshotCoverView removeFromSuperview];

        // 步骤8: 在主线程回调最终结果
        if (completion) {
            completion(finalImage);
        }
    });
}

@end


📱 效果展示

长截图展示

🚀 使用方法

调用方式非常简单,只需一行代码。

// 在需要截图的地方调用
[webView captureEntireWebViewWithCompletion:^(UIImage *capturedImage) {
    if (capturedImage) {
        // ✅ 截图成功,处理结果
        // 例如:保存到相册
        UIImageWriteToSavedPhotosAlbum(capturedImage, nil, nil, nil);
        // 或:上传、分享、预览等
    } else {
        // ❌ 截图失败
        NSLog(@"截图失败");
    }
}];

📝 总结

本文提供的方案通过以下关键技术,优雅地解决了 WKWebView 长截图的难题:

  • 临时容器管理:隔离渲染环境,避免干扰主界面。
  • 分段渲染:将长内容分解为多个可管理的屏幕片段。
  • 状态恢复:完整保存并恢复 WebView 的原始状态,确保业务无感知。

如果你有更好的实现思路,或在实际应用中遇到了特殊场景,欢迎在评论区分享交流!

「共」型人才:AI 时代的个体进化论

2026年1月11日 08:00

当 AI 能够完美代劳记忆型事务、高效处理逻辑琐事时,一个焦虑也随之而来:作为个体,我们的核心竞争力究竟还剩什么?

传统的「T」型或「π」型人才理论,关注的是技能树的形状(深度与广度),在 AI 时代,这两个模型的达成路径和价值权重发生了根本性变化。于是我构想出了一个「共」型人才理论,这可能更符合 AI 时代对个体的要求。

什么是「共」型人才?

将「共」字拆解:

  • 下半部分(基石): 决定了一个人的底盘。只要基石稳固,即便行业被 AI 颠覆,也能迅速在新土壤中扎根。
  • 上半部分(建筑): 决定了一个人的高度。这是利用 AI 杠杆构建的双专业壁垒,以及独属于人类的整合创造力。

第一部分:基石(下半部)—— 内核的修炼

基石分为左右两点的「生命力」、「元能力」,以及承载它们的「职场通用力」。

一、左边的点:生命力(韧性)

这是个体的反脆弱系统。在快速变化的 AI 时代,比拼的往往不是谁跑得快,而是谁在逆境中不崩盘,并能从混乱中获益。

1. 情绪调节能力

即对他人的情绪有觉察,对自己的情绪有掌控。面对批评或压力,能迅速通过深呼吸、肌肉放松等技巧避免被情绪劫持。也能够穿透情绪的迷雾,看到对方发火背后的真实需求,将冲突转化为增进信任的契机。

2. 认知重构能力

决定我们情绪和行为的,往往不是发生的事情本身,而是我们对这件事情的看法(认知)。认知重构就是给大脑换个滤镜。这不是「阿Q精神」式的自欺欺人,而是用更具适应性的视角替代单一的消极视角。

比如朋友圈经常看到某某在外面玩,就很羡慕甚至有点嫉妒,这是下意识的反应,但不是完整的视角。更完善的思考可能是:

  • 经常在外面玩其实也挺累的,可能光顾着拍照了,没有很好的感受当地的风景和文化。
  • 辛苦劳作后的休憩最为舒适,经常玩,新鲜感和愉悦感就没那么强了。
  • 人家无论是通过家里的支持或自己的努力赢得了经常出去玩的机会,这也是应得的。

3. 课题分离能力

这是切断精神内耗的利刃,他的核心是:分清楚什么是你的事,什么是别人的事。专注解决自己的事,不过度干预别人的事,并接受「我无法控制别人,别人也无法控制我」这一事实。我能控制的是我的态度和行为,我不能控制的是别人的评价和结果。就像你可以把马带到河边(你的课题),但不能强按着马头喝水(马的课题)。

4. 求助能力

求助不是示弱,而是懂得利用外部资源扩展生存边界。通过向合适的人寻求支持,不仅解决了问题,更建立了一次潜在的高质量的社会连接,这是构建韧性网络的重要一环。

二、右边的点:元能力

元能力对应的是学习能力。用来构建知识网络,增强调用和处理知识的能力,以下是我觉得最为重要的 4 种元能力。

1. 认知性好奇心

这个我认为是最重要的,它不是单纯的想知道 What 的感知性/消遣性好奇心,而是对运行机制、底层原理的好奇,关注的是 How 和 Why, 追求的是填补认知空白和解决智力上的难题。

认知性好奇心产生于「我知道一点,但又不知道全部」的时候, 这个差距会带来一种类似「认知瘙痒」的不适感, 学习的过程,就是「止痒」的过程,所以最好的学习区,是在「已知」和「未知」的边缘。

2. 专注力

如果把学习比作「吃饭消化」,那么专注力就是「牙齿」和「食道」。它决定了你能把多少食物(信息)吃进嘴里,以及嚼得有多碎,但前提得先张开嘴巴,因为未被关注的信息,大脑不会存储。

如果注意力的强度不够,效果也不会好,就像在沙滩上写字,潮水一来就没了。只有在高强度的专注下,神经元才会高频放电,突触之间的连接才会变强,所以,专注力是一个很重要的能力。

3. 思维模型

思维模型就像是安装在大脑里的「应用程序」或「工具箱」。拥有一套多元化的模型组合(查理·芒格所谓的「格栅理论」),能在面对复杂问题时更有洞察力。以下是我认为最重要的一些思维模型。

第 0 类:元思维模型
  • 系统思维: 帮助理解「事物之间如何连接」的宏观框架,而不是割裂地看问题,主张看整体、看动态。核心元素: 反馈回路、存量与流量、瓶颈理论、滞后效应。
  • 结构化思维: 能够将复杂的信息、问题进行逻辑拆解、分类和整理的能力。 非结构化思维就像走进一个堆满杂物的仓库,书本、衣服、工具混在一起,你想找把锤子,可能要翻半天。 结构化思维就像走进一个管理完善的图书馆或药房。每一个区域都有分类,每一层架子都有标签,你能迅速定位并解决问题。
  • 抽象思维: 透过现象看本质的能力, 将我们感知到的具体事物,剥离掉细节,提取出其共同规律、本质特征或概念的思维过程。
第 1 类:提升决策质量(如何思考)
  • 第一性原理:打破一切既定的假设和类比,将问题拆解成最基本的事实(公理),然后从这些基本事实出发重新构建解决方案。
  • 逆向思维: 许多难题正向思考很难,反过来想就容易了。不仅要问“我如何获得成功?”,更要问“我如何才能避免失败?”。
  • 二阶思维: 吃甜食的直接后果是快乐(一阶),但二阶后果是血糖升高、长期可能导致肥胖。为了长期的健康,可能会需要放弃短期的一阶快乐。
第 2 类:提升效率与效能(如何行动)
  • 帕累托法则 (80/20 Rule): 在任何一组东西中,最重要的只占一小部分。约 80% 的产出源自 20% 的投入。
  • 复利效应: 只要坚持做正确的事,时间的加成会带来指数级的增长。这不仅适用于理财,更适用于知识积累、习惯养成和人际关系。
第 3 类:理解世界与自我(如何自处)
  • 地图不是疆域:地图只是对疆域的一种描绘,它永远无法包含疆域的所有细节。如果你看着地图以为这就是真实世界,你就会在现实中迷路。
  • 概率思维: 世界不是黑白分明的,而是由概率构成的灰色地带。不要追求 100% 的确定性,而要追求大概率正确的决策。
  • 汉隆剃刀: 能解释为愚蠢的,就不要解释为恶意。 同事没有回你邮件,不要觉得他是故意针对你(恶意),很可能只是他太忙漏看了或者系统出错了(疏忽/愚蠢)。这能帮你减少 90% 不必要的愤怒和冲突。

4. 认知偏误管理

认知偏误是大脑为了节省能量而采取的「思维捷径」。虽然它们在进化上曾帮助人类快速反应,但在现代复杂的决策环境中,它们往往会导致我们犯错。

第一维度:关于「自我认知」
  • 达克效应: 这是关于「无知者无畏」的经典解释。能力不足的人往往无法认识到自己的不足,因此会产生过度的自信;而真正的高手反而容易低估自己。
  • 确认偏误: 我们倾向于寻找、解释和记忆那些能够证实我们已有观点的信息,而自动过滤或忽略那些反驳我们的信息。
第二维度:关于「决策陷阱」
  • 沉没成本谬误: 我们会因为已经投入了时间、金钱或情感,而坚持继续做一件不理智的事情,即使它已经没有未来的价值。
  • 锚定效应: 我们在做判断时,极易受到获取的「第一条信息」(锚点)的影响,即使这个信息可能毫无关联。
第三维度:关于「看待世界」
  • 基本归因谬误: 就是我们在解释别人的行为时,倾向于高估其「内在性格」的影响,而低估「外部环境」的作用。 我们会想: “他做这件事,是因为他就是这种人。”。我们忽略:“他做这件事,可能是因为当时的情况迫使他这么做。”。
  • 幸存者偏差: 我们只看到了经过筛选后「活下来」的样本,而忽略了那些「死掉」的样本,从而得出错误的结论。

三、下面的一横:职场通用力

这是无论技术如何变迁,人与人协作都必须具备的接口协议。

1. 沟通能力

沟通能力是一个涵盖了输入、处理、输出、反馈四个维度的闭环系统,是一个高度复杂的复合能力。

  • 输入: 积极倾听,听懂话外音;敏锐观察,捕捉非语言信号。
  • 处理:同理心换位思考,用逻辑整理杂乱信息。
  • 输出: 精准表达,甚至用故事力包装枯燥逻辑。
  • 互动: 懂得即时反馈与冲突管理,将对抗转化为对话。

2. Sell 的能力

如果沟通能力是底层的基础设施(地基),那么 Sell 能力是在这个地基上盖起的、带有明确目的性的建筑。一个人可以沟通很好,但不会 Sell;但一个擅长 Sell 的人,一定是沟通的高手。

  • 认知引导: 沟通是基础,Sell 是目的。Sell 的本质是改变对方认知,促成决策。
  • 缔结结果: 不止于聊得开心,更在于能把对话推向一个确定的结论(Call to Action)。一个拥有 Sell 能力的人,具备更强的心理能量和目标导向。

3. 闭环思维

它不仅指把事情做完,更指把「事情做完」这个结果反馈给发起者,从而形成一个完整的圆环。也就是常说的: 凡事有交代,件件有着落,事事有回音。 如果没有「反馈」,这个环就是断裂的。在他人眼中,这就像把石头扔进深井里,听不到回声,不知道事情是成了、败了,还是被忘了。

4. Ownership

Ownership 精神的核心是:不给自己设限,着眼于全局目标,主动填补团队的「真空地带」。比如大家都在一条船上,船底漏了个洞。 打工心态:指着洞说“这不是我弄坏的,而且修船是维修工的事”,然后看着船沉。Ownership:哪怕不是我弄坏的,我也先想办法堵上,因为船沉了对谁都没好处。

有 Ownership 精神是好事,但需要很小心地处理好边界。

  • 是「负责结果」,不是「包揽一切」:Ownership 不代表你要亲自做每一件事,而是你要确保事情发生。如果资源不足,向老板争取资源、协调其他人来做,也是 Ownership 的体现。
  • 注意「越位」风险:当你插手别人负责的领域时,沟通方式很重要。不要直接替别人做决定,而是以「补位」和「协助」的姿态切入(例如:“我发现这里有个风险,需不需要我帮忙一起看一下?”)。
  • 自我保护:不要让 Ownership 成为别人甩锅给你的理由。在承担额外责任前,确保你的核心本职工作已经完成得很漂亮。 ⠀

第二部分:建筑(上半部)—— AI 时代的双核驱动

这部分是「共」型人才的核心差异点。在 AI 出现之前,成为「双专业人才」极难;但在 AI 时代,这变得触手可及。

一、两竖:AI 赋能的「双专业壁垒」

这两根柱子代表你在两个不同领域的专业深度。

1. 传统困境 vs. AI 破局

  • 过去(一万小时定律): 想要跨界(例如从营销跨到编程),需要耗费数年去记忆语法、熟悉框架 API、调试环境。极高的沉没成本让大多数人望而却步,只能停留在「T」型(一专)。
  • 现在(AI 杠杆): AI 极大地抹平了「硬知识」的门槛
    • 以编程为例: 你不再需要背诵复杂的 API 或纠结于标点符号的 bug。AI 是你的超级助手,你可以更专注在架构设计(Architecture)逻辑拆解Prompt 指令
    • 以设计为例: 你不需要精通每一笔的光影渲染,你更需要具备审美标准和创意构想,剩下的交给生成式 AI。

2. 新时代的「专业」定义

在 AI 的加持下,这两竖的构建不再依赖死记硬背,而是依赖:

  • 理解力与判断力: 你必须懂行,才能判断 AI 给出的结果是 60 分还是 90 分。
  • 逻辑互补性: 选择两个具备「中度相关性」的领域效果最佳。例如:心理学 + 算法内容创作 + 数据分析

AI 使得获取第二专业的成本指数级下降,为个体提供了前所未有的理论与工具支撑,让「共」型人才成为可能。

二、上面的一横:整合力

这是机器难以替代的人类高地。如果下面的一切是积木,那么这一横就是让积木变成摩天大楼的蓝图。它是 「1 + 1 > 2」 的化学反应。

1. 翻译器:降维打击沟通墙

在组织中,这种双语能力,可以让你在团队协作中成为了「节点型」人物,极大地降低了系统内的熵(混乱度)和沟通成本。

2. 迁移器:跨界降维打击

你拥有单领域专家不具备的独特视角。你可以拿着 A 领域的锤子(方法论),去解决 B 领域那颗顽固的钉子。这种跨界打击往往能产生奇效。

3. 孵化器:边缘创新的温床

当你打通了两根竖线,中间的空白地带就是创新的温床。

  • 懂代码 + 懂法律 智能合约专家 / 计算法学
  • 懂心理 + 懂产品 行为设计 / 增长黑客

结语

在「共」型人才模型中,AI 不再是我们的竞争对手,而是我们构建那「第二根竖线」的最强杠杆。

  • 下半部分(情绪、认知、沟通)让我们保持像人一样思考,拥有机器无法模拟的温度与韧性。
  • 上半部分(双专业整合)让我们像超级个体一样行动,利用 AI 快速拓展能力边界。

这不仅是职场竞争力的提升,更是一种更自由、更广阔的人生可能。

❌
❌