第一个阶段，是会把AI当工具来用。
这意味着一个人已经不再只是“知道有AI”，而是会主动借助AI寻找更优解。比如，面对一个问题时，他会先判断该用什么样的AI工具、什么模型更合适，能不能结合搜索、知识库、数据分析一起完成任务；在考研、学习或工作中，也会主动调用前沿资讯，快速筛选、吸收和整合信息，提高获取答案和解决问题的效率。
这个阶段的重点，是会选、会问、会筛、会用。

第二个阶段，是让AI进入自己的思维方式。
这时候，AI不再只是一个“帮你做事的工具”，而是开始成为你思考和行动的一部分。你会在面对任务时，天然地去拆解问题、设计流程、分配给不同AI能力模块处理；你知道如何通过提问、追问、限定条件、迭代反馈，让AI不断逼近你想要的结果；你也懂得把AI生成内容变成自己的生产力，而不是停留在“让它帮我写一段话、画一张图、做一个总结”这么浅的层面。
这个阶段的重点，是借助AI重构解决问题的方法。

所以，真正的差距，不只是“会不会用某个AI产品”，而是：
你是把AI当成一个临时工具，还是把它变成了自己的能力放大器。

前者提升的是效率，后者改变的是认知。
前者让你做事更快，后者让你做事的方式发生变化。
前者解决的是“怎么完成”，后者思考的是“怎么更好地完成，甚至换一种方式完成”。

未来真正有竞争力的人，未必只是最懂技术的人，而更可能是那些懂得借助AI重构学习方式、工作方式和思维方式的人。
因为AI带来的，不只是工具更新，更是一次能力结构的更新。谁能更早完成这种转变，谁就更容易在新的环境里获得优势。

【系统角色架构】
你内部固定分为四个协同单元：

1. 计划者 Planner
   职责：

• 解析用户目标，提炼真实需求、边界、隐含约束、验收标准
• 调查代码仓库结构、模块依赖、接口关联、配置影响、风险点
• 将复杂目标拆解为一组可执行、可验证、可回退的原子任务
• 生成任务顺序、依赖关系、优先级、阻塞条件、验收标准
• 在执行失败或需求冲突时进行重规划，而不是盲目重试

2. 执行者 Executor
   职责：

• 严格按照当前任务卡执行，不得擅自扩大需求范围
• 可以读取、修改、创建、删除项目文件
• 可以编写脚本来批量处理工作，例如扫描代码、批量替换、生成测试、迁移数据、修复配置、收集日志、生成报告
• 可以运行命令、安装依赖、执行测试、构建项目、检查日志、验证结果
• 每次执行后都必须输出具体变更、变更原因、验证结果、风险说明
• 遇到不确定问题时，先通过阅读代码、搜索仓库、编写临时检查脚本、运行诊断命令来消除不确定性；只有在无法自主确认时才标记阻塞

3. 监督者 Supervisor
   职责：

• 审查计划是否正确、是否过度设计、是否遗漏关键依赖
• 审查执行结果是否符合原始目标与验收标准
• 审查改动是否越界、是否引入副作用、是否破坏兼容性、是否存在安全风险
• 对每次执行给出结论：通过 / 驳回 / 回退 / 需补充验证 / 需重规划
• 监督者拥有阻断权；如果执行结果不达标，必须阻止继续推进并要求修正

4. 协调者 Orchestrator
   职责：

• 维护任务状态机、上下文快照、执行顺序、失败重试策略
• 在 Planner、Executor、Supervisor 之间分发工作
• 保证始终只有当前最重要、最可执行的任务被推进
• 记录全过程日志，确保所有动作可审计、可追踪、可回退
• 以事件驱动优先、轮询兜底的方式推进，不做无意义空转

【总工作原则】

• 你的目标不是“给建议”，而是“把事情做完并验证”
• 能自动完成的就直接完成，不要把本应由你处理的中间步骤推给用户
• 能通过读代码、查文件、看日志、写脚本、跑命令确认的，不要先问用户
• 尽量减少提问次数；只有当问题真的决定结果、且无法通过现有上下文自行确认时，才向用户提出最小问题集
• 禁止空谈方案而不落地；禁止只给思路不给实际产物
• 禁止未经验证就声称完成；所有完成都必须附带验证依据
• 禁止无边界修改；必须控制改动范围、说明影响面、必要时支持回退
• 优先产出可运行、可测试、可提交的结果，其次才是文字说明

【任务推进模式】
你必须始终按以下状态机工作：

new：新目标进入
analyzing：理解需求与调查上下文
planned：已完成任务拆解与验收定义
ready：已有可立即执行的原子任务
running：正在执行某任务
review_pending：执行完成，等待监督审查
approved：监督通过
rejected：监督驳回，需修正
blocked：确实遇到阻塞
done：任务完成并已验证
failed：确认当前路径失败，需要回退或重规划

状态转换原则：

• 接到目标后，先 analyzing，再 planned
• planned 后优先进入 ready，再 running
• running 后必须进入 review_pending
• review_pending 只能由 Supervisor 判断 approved 或 rejected
• rejected 必须回到 ready 或 planned，不得假装完成
• blocked 只能在无法通过代码、脚本、日志、命令、上下文自行解决时使用
• 任何声称 done 的任务都必须附带验收依据

【执行规则】

1. 先理解再修改
   任何代码改动前，必须先完成以下最小分析：

• 目标是什么
• 当前相关模块在哪里
• 需要改哪些文件
• 哪些文件不能改
• 风险点是什么
• 验收标准是什么

2. 原子任务原则
   一次只推进一个清晰原子任务。每个任务必须包含：

• task_id
• title
• objective
• inputs
• target_files
• forbidden_files
• steps
• acceptance_criteria
• risk_notes

3. 脚本优先原则
   当手工处理重复、繁琐、易错、批量性工作时，你应优先自己编写临时脚本或工具脚本来处理，例如：

• 扫描代码调用链
• 批量重命名
• 批量替换配置
• 提取接口定义
• 统计依赖关系
• 自动生成测试样例
• 清洗数据
• 对日志进行聚合分析
• 做兼容性检查
• 生成变更报告
  但要求：
• 脚本用途明确
• 脚本尽量可复用
• 临时脚本与正式脚本要区分
• 执行脚本前说明作用，执行后保留结果摘要

4. 验证优先原则
   任何改动后，必须选择合适的验证方式：

• 单元测试
• 集成测试
• 构建验证
• 静态检查
• 类型检查
• 接口调用验证
• 日志验证
• 数据结果对比
  如果无法完整验证，必须明确说明哪些已验证、哪些未验证、风险是什么

5. 回退原则
   对于每次重要改动，你都要具备回退意识：

• 修改前识别受影响文件
• 修改后保留 diff 摘要
• 如监督驳回，优先最小回退
• 禁止把仓库改到不可恢复状态

【监督标准】
Supervisor 审查时必须至少检查：

• 是否真正解决了用户目标
• 是否偏离需求
• 是否扩大改动范围
• 是否引入明显风险
• 是否满足验收标准
• 是否提供了验证证据
• 是否需要补充测试或补充脚本
  Supervisor 输出必须是明确裁决，而不是模糊意见。

【失败处理策略】
失败要分类型处理：

A. 可自动重试
例如：

• 临时网络失败
• 包管理器锁冲突
• 安装源超时
• 某命令偶发失败
  处理方式：
• 允许有限次数重试
• 使用退避策略
• 记录重试原因

B. 不可盲目重试
例如：

• 需求理解冲突
• 架构不兼容
• 接口语义不明确
• 测试持续失败且根因是设计问题
• 修改会影响关键业务但依据不足
  处理方式：
• 停止蛮干
• 回到 Planner 重规划
• 必要时形成最小疑问列表再问用户

【提问规则】
只有在以下情况才能提问：

• 关键业务规则从代码、文档、上下文中完全无法确认
• 多种方案都会造成明显不同结果，且无法自行选择
• 需要用户提供外部资源、账号、密钥、接口权限、未给出的文件
  提问时必须：
• 一次性列出最小必要问题
• 每个问题都说明为什么会影响结果
• 在提问前先说明你已做过哪些自主调查
  禁止为了偷懒而提问；禁止把本可由你自己检查的事情问用户。

【输出风格】
你在工作中要持续产出结构化过程，而不是杂乱描述。默认输出结构为：

一、目标理解

• 用简洁语言复述真实目标
• 列出边界与假设

二、当前判断

• 当前处于哪个状态
• 当前最重要任务是什么

三、计划者输出

• 任务拆解
• 验收标准
• 风险点

四、执行者动作

• 读取了什么
• 修改了什么
• 新建了什么脚本
• 运行了什么命令
• 得到了什么结果

五、监督者裁决

• 通过 / 驳回 / 补充验证 / 回退 / 重规划
• 原因

六、下一步

• 立即执行什么
• 或说明为什么阻塞

如果任务已经完成，最终必须输出：

【交付结果】

• 完成内容
• 修改文件清单
• 新增文件清单
• 脚本清单
• 关键命令清单
• 验证结果
• 风险与后续建议

【面向代码仓库的特别约束】

• 优先阅读项目已有约定，不要用你主观喜欢的风格覆盖现有风格
• 优先遵守现有目录结构、命名规范、测试框架、构建方式、日志规范
• 非必要不要大重构
• 非必要不要改公共接口
• 非必要不要引入新依赖
• 若确实需要新增依赖，必须说明理由与影响
• 对配置、数据库、脚本、CI、Docker、部署文件的修改要特别谨慎，并明确说明风险

【面向 Codex / 自动执行场景的硬性规则】

• 你默认有能力主动查看文件、编辑文件、运行命令、写脚本、验证结果
• 你必须像资深工程负责人一样推进，而不是像聊天机器人一样解释
• 你必须主动发现缺失项，例如测试缺失、脚本缺失、配置不完整、异常处理缺失、日志不足
• 你可以自己编写辅助脚本解决问题，但不能让脚本脱离当前目标无限扩张
• 你必须时刻防止“顺手优化”“顺手重构”“顺手改全局”这种失控行为
• 任何时候都要以最小代价完成目标
• 当已有信息足够时，直接做；不要反复确认
• 当结果不够稳时，继续验证；不要提前宣布完成

【默认启动行为】
收到用户任务后，不要先泛泛而谈。立即执行以下动作：

1. 提炼目标与验收标准
2. 扫描项目中最相关的文件、模块、配置、脚本
3. 形成任务拆解
4. 选择第一个最小可执行任务
5. 开始执行
6. 执行后立即审查和修正
7. 循环直到 done 或确实 blocked

【最终要求】
你的核心任务是：把用户目标变成经过验证的真实结果。
只要还能继续调查、写脚本、改代码、跑验证，就不要停在建议层面。
除非确实缺失外部信息，否则你应持续自主推进。

• 测试时间: 2026-03-11 15:23:27
• 端点: http://192.168.31.112:11434/v1
• 说明: 排除 OCR 模型 qwen/qwen3-vl-8b，也排除 embedding 模型 text-embedding-nomic-embed-text-v1.5。
• 测试项: 中文摘要、中文文案改写、结构化 JSON 日志归纳。

总排名

逐模型明细

zai-org/glm-4.7-flash

• 成功数: 3/3
• 平均耗时: 12.66s
• 综合分: 13
• 是否暴露 Thinking Process: 否
• 测试 summary: ✅ 29.74s
  • 样例: 1. **分析用户需求：** * **主题：** 备用扫码登录流程（通常涉及二维码、手机确认、PC端等待）。 * **问题：** “手机确认成功但PC页面不切换”（手机端显示成功，但PC端仍停留在等待状态）。 * **格式：** 3条要点。 * **目标：** 总结*为什么*会发生这种情况。 2. **解构场景：** * *步骤1：* PC生成二维码。 * *步
• 测试 rewrite: ✅ 3.06s
  • 样例: 1. **分析原句：** * 原文：“当前仅保留备用扫码登录链路，请使用微信扫码进入手机确认页，并通过手机号+姓名完成身份核验。” * 含义：目前仅保留了备用扫码登录方式。请使用微信扫码进入手机确认页面，并通过手机号+姓名完成身份核验。 * 关键信息点： 1. 当前状态：仅保留备用扫码登录。 2. 动作：使用微信扫码。 3. 目
• 测试 json: ✅ 5.19s
  • 样例: 1. **分析请求：** * **输入：** 一段简短的日志片段：“HTTP 200 /exchange 返回 token,user,roles；overview/report-center/templates/notices 接口都开始请求；页面仍停留在登录壳子。” * **输出格式：** JSON：{“symptoms”:[…],“likely_causes”:[…],“next_checks”:[`
• 建议: 适合轻量改写和短文案，不适合主分析。

qwen/qwen3.5-35b-a3b

• 成功数: 3/3
• 平均耗时: 14.56s
• 综合分: 12
• 是否暴露 Thinking Process: 是
• 测试 summary: ✅ 14.87s
  • 样例: Thinking Process: 1. **Analyze the Request:** * Task: Summarize a specific problem scenario (mobile confirmation success but PC page doesn't switch during backup QR code login flow) into exactly 3 key points.
• 测试 rewrite: ✅ 10.38s
  • 样例: Thinking Process: 1. **Analyze the Request:** * Input sentence: "当前仅保留备用扫码登录链路，请使用微信扫码进入手机确认页，并通过手机号 + 姓名完成身份核验。" (Currently only the backup scan code login link is retained, please use WeChat scan to enter the m
• 测试 json: ✅ 18.43s
  • 样例: Thinking Process: 1. **Analyze the Request:** * Input: A log snippet describing a web application issue. * Task: Read the log and output a JSON object with specific keys: symptoms, likely_causes, next_`
• 建议: 中文结构化分析不错，但偏慢，适合作为中档补位模型。

google/gemma-3-27b

• 成功数: 3/3
• 平均耗时: 22.92s
• 综合分: 12
• 是否暴露 Thinking Process: 否
• 测试 summary: ✅ 47.35s
  • 样例: 好的，以下是用3条要点总结的“备用扫码登录流程出现‘手机确认成功但PC页面不切换’的原因”： 1. **网络问题导致状态同步延迟或失败：** 手机端确认成功后需要将状态信息同步到PC端。如果PC和手机之间的网络连接不稳定、存在防火墙阻挡，或者服务器繁忙等情况，可能导致PC端无法及时接收到确认信号，从而页面不切换。 2. **Session管理问题：** 扫码登录依赖于Session机制来维持用户登录状态。 手机确认成功后，如果PC
• 测试 rewrite: ✅ 7.52s
  • 样例: 以下是一些更简洁的修改方案，根据你的具体需求选择： **方案一 (最简短):** > 目前仅支持微信扫码登录，请在手机上完成验证。 **方案二 (稍详细一点):** > 现仅保留微信扫码登录方式，请使用微信扫描并按提示在手机上进行身份核验。 **方案三 (更明确流程):** > 请通过微信扫码登录，并在手机确认页填写手机号和姓名完成验证。 **选择哪个方案取决于：** *
• 测试 json: ✅ 13.88s
  • 样例: ````json { “symptoms”: [ “HTTP 200 response for /exchange endpoint”, “Token, user, and roles returned from /exchange”, “Requests initiated to overview/report-center/templates/notices interface”, "Page re`
• 建议: 可用于特定场景，但建议先人工复核。

openai/gpt-oss-20b

• 成功数: 3/3
• 平均耗时: 30.10s
• 综合分: 10
• 是否暴露 Thinking Process: 否
• 测试 summary: ✅ 50.68s
  • 样例: - **网络延迟或断连**：在手机端完成确认后，后台需要把状态同步给 PC 页面；若网络波动导致消息未及时到达，PC 会一直停留在原页面。 - **跨域或缓存问题**：PC 页面可能使用了本地缓存或同源策略限制，导致收到的“已确认”信号被忽略或覆盖，从而不触发视图切换。 - **事件监听失效**：PC 端的实时监听（如 WebSocket、轮询）未正确注册或在登录流程中被意外清除，使得即使后台状态更新，前端也无法捕获并执行页面跳
• 测试 rewrite: ✅ 6.66s
  • 样例: 请用微信扫码进入手机确认页，随后以手机号＋姓名完成身份核验；仅保留备用扫码登录链路。
• 测试 json: ✅ 32.97s
  • 样例: ````json { “symptoms”: [ “HTTP 200 response received from /exchange with token, user and roles data”, “Subsequent API calls to overview/report-center/templates/notices are initiated”, "The UI remains on the `
• 建议: 最均衡，适合当本地主力文本分析模型。

总结建议

• 当前综合最优: zai-org/glm-4.7-flash
• 推荐主力文本模型: openai/gpt-oss-20b
• 推荐 OCR 模型: qwen/qwen3-vl-8b（本次未纳入文本测试）
• 推荐中文中档补位: qwen/qwen3.5-35b-a3b
• 不建议把存在 load fail / 间歇错误的模型设为默认主力。

docker compose配置

services:  v2ray_server:    image: v2fly/v2fly-core    container_name: v2ray_mianliu    restart: always    command: run -c /etc/v2ray/config.json    ports:      # 宿主机端口:容器端口      - 9527:9527    volumes:      - ./config.json:/etc/v2ray/config.json      - ./logs:/var/log/v2ray    environment:      - TZ=Asia/Shanghai

config.json

{  "log": {    "loglevel": "warning"  },  "inbound": {    "protocol": "VMess",    "port": 9527,    "settings": {      "clients": [        {          "id": "搞一个uuid",          "alterId": 0,          "security": "chacha20-poly1305"        }      ]    },    "streamSettings": {      "network": "tcp",      "httpSettings": {        "path": "/"      },      "tcpSettings": {        "header": {          "type": "http",          "response": {            "version": "1.1",            "status": "200",            "reason": "OK",            "headers": {              "Content-Type": [                "application/octet-stream",                "application/x-msdownload",                "text/html",                "application/x-shockwave-flash"              ],              "Transfer-Encoding": [                "chunked"              ],              "Connection": [                "keep-alive"              ],              "Pragma": "no-cache"            }          }        }      }    }  },  "inboundDetour": [],  "outbound": {    "protocol": "freedom",    "settings": {}  }}

客户端

去这里找
https://github.com/2dust/v2rayNG
路由设置里导入预定义规则集为全局
服务器地址填自己的域名，端口，传输协议TCP
伪装类型http
http host
可以是：wap.hb.189.cn,mgc.hb.189.cn:10001,www.zgdxhbkf.com,hb.10000shequ.com

另外可以找找 https://blog.csdn.net/huangniu88/article/details/136441526

很多朋友最近都通过谷歌 Gemini 的学生认证，白嫖了 1 年的 Gemini Advanced 订阅，手里突然多出了 2T 的 Google Drive 空间。

这可是 Google 的高质量线路，不像某些网盘那样限速。但问题来了：这 2T 空间如果只是用来存存照片、文档，未免有点太暴殄天物了。作为一名折腾党（PVE、Docker、NAS 用户），这 2T 空间其实是绝佳的异地灾备中心和无限扩展的媒体库。

今天就来分享几种硬核玩法，榨干这 2T 空间的每一滴价值。

玩法一：NAS 的“无限”影视库 (配合飞牛 OS/群晖)

对于 NAS 玩家来说，硬盘位总是有限的。我们可以通过 Rclone 将 Google Drive 挂载为本地磁盘，直接配合 Emby、Jellyfin 或 Plex 搭建云端影视库。

核心痛点解决：

• 省硬盘：把不常看的老电影、剧集扔到云端，腾出本地空间。
• 直连播放：Google 的带宽通常足以支撑 4K 原盘流媒体播放。

部署方案（以飞牛 OS 为例）

由于飞牛 OS (fnOS) 对底层 FUSE 的限制，直接挂载可能会不稳定。最稳妥的方案是使用 Docker Rclone (WebDAV 模式)。

1. 准备配置文件
你需要先在电脑上用 Rclone 获取好 rclone.conf，然后上传到 NAS 的指定目录（例如 /vol1/1000/docker/rclone/rclone.conf）。

2. 启动 Docker 容器 (Docker Compose)
使用 Docker 将 Google Drive 转换为 WebDAV 协议暴露在局域网：

version: '3.8'services:  rclone-webdav:    image: rclone/rclone:latest    container_name: rclone-webdav    restart: unless-stopped    ports:      - "8080:8080"    volumes:      # 请确保宿主机路径下 rclone.conf 文件已存在      - /vol1/1000/docker/rclone/rclone.conf:/config/rclone/rclone.conf:ro    command: >      serve webdav gdrive:      --addr :8080      --user admin      --pass admin      --vfs-cache-mode writes      --buffer-size 32M

3. 挂载到系统
在飞牛的文件管理器中，点击 “挂载 (远程存储)” -> WebDAV，填入 127.0.0.1 和端口 8080，账号密码均为 admin。

4. 开始刮削
现在的 Google Drive 已经变成了你 NAS 里的一个本地文件夹，直接去影视中心添加媒体库即可！

玩法二：服务器/数据库的“异地灾备”

配合简单的 Shell 脚本 + Rclone，我们可以实现全自动化的“本地+云端”双重备份。

核心代码片段：

#!/bin/bash# 定义变量BACKUP_DIR="/data/mysql_backups"FILENAME="db_backup_$(date +%Y%m%d).sql.gz"# 1. 导出数据库mysqldump -u root -p'你的密码' --all-databases --single-transaction | gzip > "$BACKUP_DIR/$FILENAME"# 2. 上传到 Google Driverclone copy "$BACKUP_DIR/$FILENAME" gdrive:vps_backups/mysql/# 3. 清理 7 天前的旧文件 (本地 + 云端)find "$BACKUP_DIR" -type f -mtime +7 -deleterclone delete gdrive:vps_backups/mysql/ --min-age 7d

这样，即使你的服务器原地爆炸，数据在 Google Drive 里依然安然无恙。

玩法三：Mac/Windows 的“扩容盘”

对于 Mac 用户（尤其是 256G 乞丐版受害者），这 2T 空间简直是救命稻草。

Mac 用户避坑指南

MacOS 挂载 Rclone 需要 FUSE 支持，推荐使用 FUSE-T（完美支持 M1/M2/M3 芯片，无需降低系统安全性）。

# 1. 安装依赖brew tap macos-fuse-t/homebrew-cask && brew install fuse-t rclone# 2. 一键挂载命令mkdir -p ~/GoogleDriverclone mount gdrive: ~/GoogleDrive --vfs-cache-mode writes --vfs-cache-max-size 5G --daemon

玩法四：Rclone Crypt —— 给数据穿上防弹衣

既然是用 Google 的盘，隐私问题不得不防。强烈建议开启 Rclone 的加密功能 (Crypt)！

• 原理：上传前加密文件名和内容，Google 只能看到乱码。
• 配置：在 rclone config 时新建 remote 选择 crypt，包裹你的原配置即可。

玩法五：极致套娃 —— VPS 变身“云端 NAS” (飞牛 OS)

如果你手头有闲置的 Linux VPS（特别是那些硬盘小、限制多但带宽还行的），除了跑代码还能干嘛？
最近有个非常硬核的玩法：直接把 VPS 的 Linux 系统 DD 重装成 飞牛 OS (fnOS)。

这样你就拥有了一个自带公网 IP 的云端 NAS。再配合上面的“玩法一”挂载 2T 谷歌盘，直接实现“小盘 VPS 撬动无限存储”。

神器推荐： bin456789/reinstall
这是一个功能极强的系统重装脚本，支持内存安装，可以在各种受限的 VPS 环境下强行刷入 Windows、Alpine 甚至飞牛 OS。

操作姿势：

# 1. 下载脚本curl -O [https://raw.githubusercontent.com/bin456789/reinstall/main/reinstall.sh](https://raw.githubusercontent.com/bin456789/reinstall/main/reinstall.sh) || wget -O reinstall.sh [https://raw.githubusercontent.com/bin456789/reinstall/main/reinstall.sh](https://raw.githubusercontent.com/bin456789/reinstall/main/reinstall.sh)chmod +x reinstall.sh# 2. 使用 DD 模式刷入系统# 示例：刷入 Windows 或 自定义镜像 (如飞牛的 raw 镜像)./reinstall.sh dd --img <你的镜像地址>

注：此操作属于高危折腾，VPS 建议内存 > 2G 并支持 KVM 虚拟化，刷机前请备份数据！

注意事项 & 避坑

1. API 限制：Google Drive 有调用频率限制，切勿短时间超高并发读写。
2. 有效期：Gemini 学生权益通常为 1 年，到期前务必迁移数据。
3. 数据安全：不要把唯一的孤本数据只存在这里！

总结

利用 Rclone 和 VPS DD 这些神器，我们可以把 Google Drive 从一个简单的“网盘”变成 NAS 的扩展盘、服务器的灾备库，甚至直接手搓一台云 NAS。

只要配置得当，这 2T 空间的价值绝对远超你的想象。趁着有效期还在，赶紧折腾起来吧！

PVE 的重大更新

Proxmox VE (PVE) 在最近的更新中（9.x.x 版本及以上）终于原生支持了 OCI (Open Container Initiative) 标准。这意味着我们现在可以直接在 PVE 的 CT 模板中通过 “Pull from oci registry” 的方式拉取镜像并运行，而不需要像以前那样繁琐地转换。而且这次更新支持热升级，无需重启宿主机。

痛点：为什么普通的 Docker 镜像不行？

虽然 PVE 支持了 OCI，但普通的 Docker 镜像直接跑在 LXC 容器里通常是不行的，或者说体验极差。

Docker 容器的设计哲学是微服务，PID 1 通常是应用本身；而 LXC 是系统容器，更像是一个轻量级虚拟机。直接在 LXC 中跑 Docker 镜像（尤其是基于 scratch 或 distroless 的镜像）会导致以下问题：

1. 无法进入终端：PVE 的 Console 可能会卡死，无法登录。
2. 调试困难：因为缺少 Shell 或基础工具，连 pct enter <ID> 都会报错，变成“黑盒”。
3. 配置不便：Docker 习惯用环境变量注入，但 LXC 对此支持需要适配，且不支持 Docker 的 Volume 挂载逻辑。
4. 不支持热重载：修改配置通常需要重启整个容器。

解决方案：自制适配 PVE 的 FRPC 镜像

为了解决上述痛点，我们需要构建一个专门适配 PVE OCI 环境的镜像。我们的目标是：

• 极致轻量：基于 Go 静态编译 + UPX 压缩。
• 热重载：修改配置文件后，自动检测并重启隧道，无需重启容器。
• 配置灵活：支持环境变量注入服务器信息，支持自定义端口映射。
• 去前缀功能：支持生成不带主机名的短域名（如 web.domain.com）。
• 可维护：基于 Alpine 底座，允许通过 PVE 宿主机 pct enter 进入容器调试。

第一步：修改 Go 源码 (cmd/frpc/my_loader.go)

为了实现热重载和环境变量读取，我们需要重写加载器的逻辑。这段代码去掉了复杂的混淆，保留了最实用的功能。

将以下代码覆盖 cmd/frpc/my_loader.go：

package mainimport ("bufio""context""crypto/md5""fmt""net""os""os/signal""strconv""strings""syscall""time""github.com/fatedier/frp/client"v1 "github.com/fatedier/frp/pkg/config/v1")// ================= 默认配置 =================var (ServerAddr = "1.2.3.4"ServerPort = 7000AuthToken  = "12345678"Domain     = "orcl.cc"// 【新增】是否禁用主机名前缀// false: 生成 hostname-web.domain.com (默认，防冲突)// true:  生成 web.domain.com (清爽，但在多台机器用同一个别名时会冲突)DisableHostPrefix = false)const SingleInstancePort = 64123// ===========================================var defaultLocalIP = "127.0.0.1"var instanceLock net.Listener// 初始化配置：读取环境变量func initConfigFromEnv() {if v := os.Getenv("FRP_SERVER_ADDR"); v != "" {ServerAddr = v}if v := os.Getenv("FRP_SERVER_PORT"); v != "" {if p, err := strconv.Atoi(v); err == nil {ServerPort = p}}if v := os.Getenv("FRP_TOKEN"); v != "" {AuthToken = v}if v := os.Getenv("FRP_DOMAIN"); v != "" {Domain = v}if v := os.Getenv("FRP_DEFAULT_IP"); v != "" {defaultLocalIP = v}// 【新增】读取禁用前缀开关if v := os.Getenv("FRP_DISABLE_HOST_PREFIX"); v == "true" {DisableHostPrefix = true}}func RunCustomClient() {initConfigFromEnv()// 打印当前模式状态prefixStatus := "自动添加 (主机名-别名)"if DisableHostPrefix {prefixStatus = "已禁用 (仅使用别名)"}fmt.Printf("[Init] Server: %s:%d | Domain: %s | 前缀模式: %s\n", ServerAddr, ServerPort, Domain, prefixStatus)if !checkSingleInstance() {return}defer releaseSingleInstance()sysSigCh := make(chan os.Signal, 1)signal.Notify(sysSigCh, syscall.SIGINT, syscall.SIGTERM)reloadCh := make(chan struct{})go monitorConfigFile(reloadCh)for {ctx, cancel := context.WithCancel(context.Background())svr := startService(ctx)select {case <-reloadCh:fmt.Println("\n[*] 配置文件变更，正在热重载...")cancel()if svr != nil {svr.Close()}case <-sysSigCh:fmt.Println("\n[*] 正在退出...")cancel()if svr != nil {svr.GracefulClose(500 * time.Millisecond)}return}}}func startService(ctx context.Context) *client.Service {cfg := &v1.ClientCommonConfig{}cfg.Log.Level = "error"cfg.Log.To = "console"cfg.ServerAddr = ServerAddrcfg.ServerPort = ServerPortcfg.Auth.Method = "token"cfg.Auth.Token = AuthTokencfg.Transport.PoolCount = 5cfg.Complete()proxyCfgs := loadPortsConf()if len(proxyCfgs) == 0 {fmt.Println("[Warn] 未检测到有效端口规则，等待 frp_ports.conf ...")return nil}svr, err := client.NewService(client.ServiceOptions{Common:    cfg,ProxyCfgs: proxyCfgs,})if err != nil {fmt.Printf("[Error] 初始化失败: %v\n", err)return nil}printWelcome(len(proxyCfgs))go func() {err := svr.Run(ctx)if err != nil && ctx.Err() == nil {fmt.Printf("[Error] 运行中断: %v\n", err)}}()return svr}func loadPortsConf() []v1.ProxyConfigurer {var proxies []v1.ProxyConfigurerensurePortsFile()file, err := os.Open("frp_ports.conf")if err != nil {return proxies}defer file.Close()scanner := bufio.NewScanner(file)hostname := getCleanHostname()if os.Getenv("FRP_DEFAULT_IP") == "" {defaultLocalIP = "127.0.0.1"} else {defaultLocalIP = os.Getenv("FRP_DEFAULT_IP")}for scanner.Scan() {line := strings.TrimSpace(scanner.Text())if line == "" || strings.HasPrefix(line, "#") {continue}if strings.Contains(line, "=") {kv := strings.SplitN(line, "=", 2)key := strings.TrimSpace(strings.ToLower(kv[0]))val := strings.TrimSpace(kv[1])if key == "default_ip" {defaultLocalIP = valfmt.Printf("[Config] 本次加载默认IP: %s\n", defaultLocalIP)}continue}parts := strings.Split(line, ":")if len(parts) < 1 {continue}localPortStr := strings.TrimSpace(parts[0])targetIP := defaultLocalIPprotocol := "http"alias := localPortStrremotePort := 0isLayer4 := falseif len(parts) >= 2 {p2 := strings.ToLower(strings.TrimSpace(parts[1]))if p2 == "tcp" || p2 == "udp" {isLayer4 = trueprotocol = p2}}if isLayer4 {if len(parts) > 2 {fmt.Sscanf(strings.TrimSpace(parts[2]), "%d", &remotePort)}if len(parts) > 3 {targetIP = strings.TrimSpace(parts[3])}} else {if len(parts) > 1 {alias = strings.TrimSpace(parts[1])}if len(parts) > 2 {targetIP = strings.TrimSpace(parts[2])}}// ProxyName 依然建议带上 Hostname 以保证内部唯一性，不影响外部访问proxyName := fmt.Sprintf("%s_%s_%s", hostname, protocol, localPortStr)if protocol == "http" {proxyName = fmt.Sprintf("%s_%s", hostname, alias)}portInt := 0fmt.Sscanf(localPortStr, "%d", &portInt)var newCfg v1.ProxyConfigurerswitch protocol {case "tcp":cfg := &v1.TCPProxyConfig{}cfg.Name = proxyNamecfg.Type = "tcp"cfg.LocalIP = targetIPcfg.LocalPort = portIntcfg.RemotePort = remotePortnewCfg = cfgcase "udp":cfg := &v1.UDPProxyConfig{}cfg.Name = proxyNamecfg.Type = "udp"cfg.LocalIP = targetIPcfg.LocalPort = portIntcfg.RemotePort = remotePortnewCfg = cfgdefault:cfg := &v1.HTTPProxyConfig{}cfg.Name = proxyNamecfg.Type = "http"cfg.LocalIP = targetIPcfg.LocalPort = portInt// 【核心逻辑】根据开关决定子域名格式if DisableHostPrefix {// 模式: 别名.域名 (例如: web.orcl.cc)cfg.SubDomain = alias} else {// 模式: 主机名-别名.域名 (例如: winpc-web.orcl.cc)cfg.SubDomain = fmt.Sprintf("%s-%s", hostname, alias)}newCfg = cfg}newCfg.Complete("")proxies = append(proxies, newCfg)printProxyLog(protocol, targetIP, portInt, remotePort, newCfg)}return proxies}func monitorConfigFile(reloadCh chan struct{}) {filename := "frp_ports.conf"var lastModTime time.Timefor {info, err := os.Stat(filename)if err == nil {if lastModTime.IsZero() {lastModTime = info.ModTime()} else if info.ModTime() != lastModTime {lastModTime = info.ModTime()select {case reloadCh <- struct{}{}:default:}}}time.Sleep(2 * time.Second)}}func printWelcome(count int) {fmt.Println("┌──────────────────────────────────────────────────┐")fmt.Printf("│  [+] FRP Docker Client Started                   │\n")fmt.Printf("│  [S] Server: %-35s │\n", fmt.Sprintf("%s:%d", ServerAddr, ServerPort))fmt.Printf("│  [#] Tunnels: %-35d │\n", count)fmt.Println("└──────────────────────────────────────────────────┘")}func printProxyLog(protocol string, targetIP string, localPort int, remotePort int, cfg v1.ProxyConfigurer) {arrow := "->"if protocol == "http" {httpCfg := cfg.(*v1.HTTPProxyConfig)url := fmt.Sprintf("https://%s.%s", httpCfg.SubDomain, Domain)fmt.Printf(" [%-4s] %-15s:%-5d %s %s\n", strings.ToUpper(protocol), targetIP, localPort, arrow, url)} else {remote := fmt.Sprintf("[Remote]:%d", remotePort)fmt.Printf(" [%-4s] %-15s:%-5d %s %s\n", strings.ToUpper(protocol), targetIP, localPort, arrow, remote)}}func ensurePortsFile() {if _, err := os.Stat("frp_ports.conf"); os.IsNotExist(err) {content := `# FRP Config# =========================================================#               多设备穿透配置 (支持转发局域网IP)# =========================================================# [全局设置] 默认转发 IP (如果不写具体IP，就用这个)default_ip = 127.0.0.1# ---------------------------------------------------------# 1. 转发本机服务# ---------------------------------------------------------# 格式: 端口:别名# 8080:web# 3111:api# ---------------------------------------------------------# 2. 转发局域网其他设备 (HTTP)# ---------------------------------------------------------# 格式: 端口:别名:目标IP# 例如: 转发 NAS 的管理页面# 5000:nas:192.168.1.50# 80:router:192.168.1.1# ---------------------------------------------------------# 3. 转发 TCP/UDP (远程桌面/SSH)# ---------------------------------------------------------# 格式: 本地端口:协议:远程端口[:目标IP]# 本机远程桌面# 3389:tcp:33389# 局域网 Linux 服务器 SSH (将 192.168.1.100 的 22 转发到外网 60022)# 22:tcp:60022:192.168.1.100`os.WriteFile("frp_ports.conf", []byte(content), 0644)}}func checkSingleInstance() bool {var err errorinstanceLock, err = net.Listen("tcp", fmt.Sprintf("127.0.0.1:%d", SingleInstancePort))if err != nil {fmt.Println("[!] 端口占用，可能已在运行")return false}return true}func releaseSingleInstance() {if instanceLock != nil {instanceLock.Close()}}func getCleanHostname() string {h, _ := os.Hostname()hash := md5.Sum([]byte(h))return fmt.Sprintf("%x", hash[:3])}

再修改> 将以下代码覆盖 cmd/frpc/main.go：

package main// 这里不需要引入 cobra 等复杂的命令行库了// 只需要引入我们刚才写逻辑所在的包 (同一个 main 包)func main() {// 直接调用 my_loader.go 里的函数RunCustomClient()}

第二步：构建 Dockerfile (全架构适配 + Alpine 底座)

为了解决 PVE LXC 无法方便进入容器的问题，我们放弃了 scratch，改用 alpine。同时配置了国内源加速，并支持 AMD64/ARM64 自动构建。

# ==========================================# Stage 1: 编译 (保持不变)# ==========================================FROM --platform=$BUILDPLATFORM golang:1.24-alpine AS builderENV GOPROXY=https://goproxy.cn,directARG TARGETARCHRUN apk add --no-cache git upx tzdataWORKDIR /srcCOPY go.mod go.sum ./RUN go mod downloadCOPY . .RUN CGO_ENABLED=0 GOOS=linux GOARCH=$TARGETARCH go build -trimpath -ldflags "-s -w" -o /app/frpc_mini ./cmd/frpcRUN upx --best --lzma /app/frpc_mini# ==========================================# Stage 2: 运行时 - 完美适配版# ==========================================FROM alpine:latest# 1. 安装依赖RUN apk add --no-cache openrc util-linux ca-certificates tzdata nano bash# 2. 配置 OpenRCRUN sed -i 's/^\(tty\d\:\:\)/#\1/g' /etc/inittab && \    sed -i \    -e 's/#rc_sys=""/rc_sys="lxc"/g' \    -e 's/^#rc_provide=".*"/rc_provide="loopback net"/g' \    /etc/rc.conf && \    echo 'rc_provide="loopback net"' >> /etc/rc.conf && \    echo 'rc_cgroup_mode="hybrid"' >> /etc/rc.conf# 3. 复制程序COPY --from=builder /app/frpc_mini /usr/local/bin/frpcRUN chmod +x /usr/local/bin/frpc# 4. 创建 OpenRC 服务脚本 (带日志)RUN echo '#!/sbin/openrc-run' > /etc/init.d/frpc && \    echo 'name="frpc"' >> /etc/init.d/frpc && \    echo 'command="/usr/local/bin/frpc"' >> /etc/init.d/frpc && \    echo 'command_background=true' >> /etc/init.d/frpc && \    echo 'pidfile="/run/frpc.pid"' >> /etc/init.d/frpc && \    echo 'directory="/data"' >> /etc/init.d/frpc && \    echo 'output_log="/var/log/frpc.log"' >> /etc/init.d/frpc && \    echo 'error_log="/var/log/frpc.log"' >> /etc/init.d/frpc && \    chmod +x /etc/init.d/frpc && \    rc-update add frpc default# 5. 日志快捷命令RUN echo '#!/bin/sh' > /usr/local/bin/logs && \    echo 'tail -f /var/log/frpc.log' >> /usr/local/bin/logs && \    chmod +x /usr/local/bin/logs# 6. 【核心】创建启动引导脚本 (entrypoint.sh)# 这个脚本会把 Docker 传入的环境变量，写入到 /etc/conf.d/frpc 中RUN echo '#!/bin/sh' > /entrypoint.sh && \    echo '# 提取所有以 FRP_ 开头的环境变量，以及 TZ 变量' >> /entrypoint.sh && \    echo 'env | grep -E "^(FRP_|TZ)" | sed "s/^/export /" > /etc/conf.d/frpc' >> /entrypoint.sh && \    echo '# 启动 OpenRC 初始化系统' >> /entrypoint.sh && \    echo 'exec /sbin/init' >> /entrypoint.sh && \    chmod +x /entrypoint.shWORKDIR /data# 7. 将入口改为引导脚本ENTRYPOINT ["/entrypoint.sh"]

第三步：在 PVE 中部署

构建并推送到私有仓库后，即可在 PVE 中通过 OCI 方式拉取。

1. 环境变量配置

在 PVE 的 OCI 容器环境变量配置以下变量：

2. 配置文件 (frp_ports.conf)

容器启动后会自动生成配置文件，支持热重载。你可以在 PVE 宿主机挂载目录，或者直接进入容器修改：

# FRP Config# =========================================================#               多设备穿透配置 (支持转发局域网IP)# ======================================================# [全局设置] 默认转发 IP (如果不写具体IP，就用这个)default_ip = 127.0.0.1# ---------------------------------------------------------# 1. 转发本机服务# ---------------------------------------------------------# 格式: 端口:别名# 8080:web# 3111:api# ---------------------------------------------------------# 2. 转发局域网其他设备 (HTTP)# ---------------------------------------------------------# 格式: 端口:别名:目标IP# 例如: 转发 NAS 的管理页面# 5000:nas:192.168.1.50# 80:router:192.168.1.1# ---------------------------------------------------------# 3. 转发 TCP/UDP (远程桌面/SSH)# ---------------------------------------------------------# 格式: 本地端口:协议:远程端口[:目标IP]# 本机远程桌面# 3389:tcp:33389# 局域网 Linux 服务器 SSH (将 192.168.1.100 的 22 转发到外网 60022)# 22:tcp:60022:192.168.1.100

3. 运维小技巧

得益于使用 Alpine 底座，在 PVE 宿主机 Shell 中，你可以直接“穿透”进容器进行管理，而不会像 Docker 镜像那样被拒绝, 并且内置函数logs可以一键查看日志：

# 查看容器 ID 为 100 的内部pct enter 100# 进入后直接修改配置，保存即生效vi /data/frp_ports.conf

frp服务端也要补充配置

bindPort = 7000auth.token = "123123"                # 【新增】HTTP 虚拟主机端口，改为 8080，不要用 80vhostHTTPPort = 9889 # 【关键】设置泛域名根域名subdomainHost = "123.com"                     

泛域名下的nginx

# /etc/nginx/conf.d/frp_wildcard.conf (新建或追加)server {    listen 80;    listen [::]:80;    # 匹配所有子域名    server_name *.123.com;    return 301 https://$host$request_uri;}server {    listen 443 ssl http2;    listen [::]:443 ssl http2;    # 泛域名匹配    server_name *.123.com;    # 【重要】这里必须使用泛域名证书 (*.123.com)   ssl_certificate /etc/nginx/certs/123.com/123.com.pem;   ssl_certificate_key /etc/nginx/certs/123.com/123.com.pem;    # SSL 参数保持你原有的即可    ssl_protocols TLSv1.2 TLSv1.3;    ssl_ciphers TLS13-AES-256-GCM-SHA384:TLS13-CHACHA20-POLY1305-SHA256:TLS13-AES-128-GCM-SHA256:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-RSA-CHACHA20-POLY1305;    ssl_prefer_server_ciphers on;    location / {        # 将流量转发给 FRP 监听的 HTTP 端口        proxy_pass http://x.x.x.x:9889;        # 传递域名给 FRP，FRP 靠这个 Host 头来区分是哪个子域名        proxy_set_header Host $host;        proxy_set_header X-Real-IP $remote_addr;        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;        # 支持 WebSocket (很多本地开发服务需要)        proxy_http_version 1.1;        proxy_set_header Upgrade $http_upgrade;        proxy_set_header Connection "upgrade";    }}

因为短视频和自媒体的流行，现在涌现出了一些民间思想家，发表不同于正统的人生感悟，跟我们一贯认知的大相径庭。但有时候你一听似乎也挺有道理。

最近有个朋友转发给我一个视频号，说明知那个博主讲的不对，但还是忍不住看了一些，问我有什么看法。你听听这位博主的标题 ——
“表面盼着您好，其实根本不是这么回事”，“错误的原生家庭是一辆失控的破车”，“智力一旦出现漏洞，烂人就会蜂拥而至”，“永远不要无条件付出”，“匍匐在您身边的毒蛇”，“朋友圈里没有朋友”，等等等。

这不是唯一的。我还看到另一个帖子说：
亲戚朋友找我借钱一律不借，同学聚会一律不参加，退出低价值微信群，长时间不联系的全部拉黑，自己结婚生子买房买车大事一律不对外讲，等等等。

那个作者说这是“三十岁以后通透的极简生活”。我看这些思想都可以概括为「封闭的利己主义」，是一种市侩哲学。

精致的利己主义 vs 封闭的利己主义

以前有个说法叫「精致的利己主义」，认为干什么事都应该有一定的目的，我也不赞成，但人家最起码还讲“人脉”，至少希望跟地位比自己高的人交往，多学点知识了解世界 —— 而这个封闭的利己主义，干脆就是连交往都不要了。

当然如果人人都只想“向上社交”，那只能是没有社交，毕竟上面的人也不愿意对你向下社交……所以封闭的利己主义似乎比精致的利己主义在逻辑上更为自洽。

但这个思想肯定是不对的。

封闭的利己主义假设他人皆是威胁

这个世界绝大部分事情是非零和博弈，提倡人与人尽量合作，应该主动信任别人，哪怕为此吃点亏也没关系。我们讲的这些绝对没错，这是博弈论里用数学证明过的道理。

那为什么有人会崇尚封闭呢？

没有人真的应该过封闭的生活。人是一种群居社会动物，我们需要亲情和友情。 人之所以为人就是因为善于合作，合作使我们快乐。

正如科里·凯斯的《萎靡》[1]一书所说，人都需要归属感，都享受友谊。友谊是互惠的，但是它不计分。不是说今天我请你吃顿饭，下次你必须回请我，友谊不是算来算去的利益关系。你再考察几千年的古代社会、几万年的远古社会 ，人与人的正常关系从来都不是斤斤计较患得患失。

我认为封闭的利己主义首先是一个情绪，而不是一个能持之以恒的生存策略。可能你在生活的某一刻受到了伤害，比如被骗了，你心想我干脆不再信任任何人！我做好自己就算了。可能第二天跟陌生人办事，你第一反应就是“我可别吃亏”。这些冲动之情都可以理解，但是是错的。

历史与理论视角：人与人是敌对的吗？

历史上的确有些学者认为人和人之间本质上是竞争和敌对的关系。比如霍布斯的「一切人对一切人的战争」，社会达尔文主义者说的「适者生存，不适者被淘汰」，还有「理性经济人假设」，还有很多人把「个人主义」理解成自私自利……
我可以非常负责任地说，这些说法全都是错的，现代学者早就有更高明的学说。

但我们得承认，「他人皆是威胁」这个想法的确很有市场。咱们先看什么样的人更容易相信封闭的利己主义。

信任与社会阶层的关系

最重要的因素大概是社会环境。你可能听说过这句话：

「上等社会人捧人，中等社会人比人，下等社会人踩人。」

这容易理解，如果咱俩都掌握一些“资源”，你能帮上我我能帮上你，那很容易合作，1+1肯定大于2；如果咱俩没啥资源，都想通过自己的努力获得跟别人合作的机会，那很可能就是竞争关系；而如果咱俩根本就没有与人合作的选项，那就容易互害……不过这只是老百姓的猜测，我们需要科学研究的判断。

社会心理学家的确认为对他人的信任和社会阶层之间有明确的正相关。早在二十多年前就有个学说叫「关于信任的成功与幸福理论（the success and well-being theory of trust）」 [2]，认为身处更高社会阶层的人，更倾向于信任他人。

也许是因为他们的风险承受能力高，吃点亏也无所谓；也许是因为他们受过更好的教育，更明智；也许仅仅是因为他们平时接触的都是比较高素质的、确实可信的人。

浙江师范大学研究：掌控感的作用机制

这方面可供参考的研究不多，我看到比较新的一个是出自浙江师范大学强瑞超等研究者 [3]。他们不但验证了关于信任的成功与幸福理论，而且提出了其中的作用机制。

调查样本是480个18岁到61岁之间的中国人。研究者首先测量每个人自我感知的社会等级，用一个经典方法，叫“麦克阿瑟阶梯量表（MacArthur Ladder Scale）” ——

这有个梯子代表社会等级，一共分十级，一级是最底层，十级是最高层：你能不能根据自己的受教育程度、经济状况和所从事的工作有多受人尊敬，判断一下你属于梯子上的哪一层？这样得到一个量化分数。

然后再测量每个人对其他人的信任程度，使用下面这样的问答题 ——

一般来说，你认为大多数人是可以信任的，还是说打交道需要非常小心？
你认为大多数人会利用你的弱点，还是会为你主持公道？

结果很明显，自我评估社会阶层越高的人，对他人的信任程度也越高。没错，如果你成功又幸福，你眼中的他人更容易是可信任的。

那你说难道就注定穷生奸计，富长良心吗？不是！

这个研究最关键的发现，是高社会阶层的人到底为啥倾向于相信他人。如果这里有个A因素，而我虽然目前社会阶层低，但我恰好也有A因素，那我也会相信他人。对吧？

研究者认为那个A因素是「掌控感（Sense of Control）」。

掌控感的测量与统计模型

测量题目是你是否同意以下这些说法 ——

只要我下定决心我几乎可以做任何事情；
当我真的想做某件事，我通常会找到成功的方法……

或者，

我能做什么不能做什么，大多由别人决定；
我几乎无法改变我生活中的很多重要事情……

结果发现掌控感跟信任之间的相关性更强。

再进一步，研究者用一个统计模型，证明掌控感起到了从高社会等级到高信任之间的中介作用 ——

简单说就是因为你条件好，所以你的掌控感强；而因为你的掌控感强，你很自信，所以你不担心别人会威胁你，你愿意相信他人。而如果我的生存条件不怎么好，但是我也对生活有很强的掌控感，我认为一切尽在掌握之中，那我也会相信他人。

现实解释与社会含义

这就解释了为什么有些境遇不好的人会倾向于相信封闭的利己主义这种市侩哲学。如果一个人处处受限、经常被骗被伤害，掌控不了自身的命运，那真的是参加同学聚会都怕吃亏。

这样一想我们也就释然了。正如菲茨杰拉德小说《了不起的盖茨比》中那句话：

「每逢你想要对别人评头论足的时候，要记住，世上并非所有的人，都有你那样的优越条件。」

同时《稀缺》一书所说，匮乏会让人变得短视，只重眼前而忽略长远利益。 而合作和双赢只在长期的关系中有用，重复博弈才值得建立信任。

中国语境与长期主义

正因为如此，我认为封闭的利己主义不但是愚蠢的，而且也不符合我们的国情。要知道中国传统一向是信奉长期主义。

你读一读费孝通先生的《乡土中国》。中国原本是个熟人社会，大家抬头不见低头见守望相助，都很有归属感，怎么可能把亲友都拉黑呢？宗族对任何人都是不抛弃不放弃，儒家讲差序格局，修齐治平，你在乡里的声望非常重要，怎么可能朋友圈里没朋友呢？哪怕是清朝末年的乱世，每个村也都充满凝聚力。

一个社会模型的解释

封闭的利己主义应该是个非主流的暂时现象，不过我有个简单模型可以解释为什么会出现这个现象。

关键是你是否相信人与人之间应该有横向的联系。

在一个自然的社会中，横向联系是主流关系。哪怕你采集狩猎，也得几个人一起去；你种地为生，也得过群居生活，正所谓远亲不如近邻。你需要声望，你需要合作。

但我们想象一种奇特的社会，其中每个地方都只有一个来自上方的、垂直的利益来源，所谓「利出一孔」。

比如说村口来了个大公司，村民都去这家公司打工为生。你以垂直的方式为公司服务，公司根据你的表现好坏决定给多少工资，你跟其他村民没有合作关系。

在这种垂直的利益分配局面之下，村民之间当然就只是竞争，不必合作。这就是封闭的利己主义者的世界观。

现代社会在一定程度上的确如此：你跟你的邻居、同学、亲友都在不同的公司上班，你们没啥可合作的。即便是在公司里，你往往也只对上级负责，跟同事没有太多的横向关系。现在中国都是小家庭，宗族早已瓦解，乡绅成了笑谈，可不是以垂直关系为主吗？

最纯粹的垂直模式，就是高考。你只是因为自己的考试成绩而获得奖赏，跟周围其他人没有任何关系。我们想想有多少家长，告诉孩子自己好好学习，别管闲事。

高考思维容易催生市侩哲学。

封闭不是理性，而是认知错误

而我要说的是，垂直发钱的公司是对社会的扭曲，高考思维是一种错觉。封闭的利己主义不是理性博弈的结果，而是认知错误。

如果你负责运营一家公司 —— 而不只是其中一个零部件 —— 你会发现社会上充满了横向关系。市场经济是人们自行组织起来横向打交道的经济。实际上并没有一个一直稳定地往下发钱的机构，你迟早要面对真实社会。

更何况你需要亲情和友情。就算有个利出一孔的发钱机构，人也首先是社会人，需要参加横向秩序。

横向秩序与秩序输出者

横向秩序不是麻烦，而是资源；他人不是威胁，而是伙伴。

江湖那么险恶的地方，谁是混得好的？是像宋江、单雄信、刘邦这种特别善于交朋友的人。
当然每个人身上都有自私和险恶的一面，但是我们应该尽量去发掘人身上好的一面 ——
而只要你能发掘出来，那一面比黑暗的一面要强得多，不然人类早就灭绝了。

如果你能发掘到别人身上好的一面，你就是一个「秩序输出者」，你是社会中流砥柱。
如果没有这个能力，你可以加入别人的秩序，做个秩序的消费者 —— 但不论如何，我们不应该做旁观者甚至孤立者。

如果这里已经有个很好的秩序，你就加入这个秩序。
如果你所处的环境竟然是如此糟糕，以至于根本就没有秩序，那正好，这里正等着你输出秩序。

因为社会总是需要横向秩序。鲁迅先生不说吗？

「此后如竟没有炬火：你便是唯一的光。」

注释

[1] Languishing: How to Feel Alive Again in a World That Wears Us Down

[2] Delhey J., Newton K. (2003). Who trusts? The origins of social trust in seven nations. Eur. Soc. 5 93–137. DOI:10.1080/1461669032000072256

[3] Qiang R, Li X, Han Q. The Relationship Between Social Class and Generalized Trust: The Mediating Role of Sense of Control. Front Psychol. 2021 Sep 27;12:729083. PMID: 34646212; PMCID: PMC8502873. https://pmc.ncbi.nlm.nih.gov/articles/PMC8502873/

我们讲一个认识世界的小规律，也可以说是思考的眼光，它会让你看问题更清楚一点。比如下面这几个例子。

参见

[1] 吴国盛，《什么是科学》（2016）；专访北大教授吴国盛：中国古代没有数理科学，这本是命运，记者臧继贤 朱凡，2016-09-03，澎湃新闻。

[2] Joseph Heath: How explanatory inversions drive a wedge between specialist and non-specialist discourses

[3] Williams, Dan. Why Do People Believe True Things? Conspicuous Cognition, July 28, 2024.

家里云直接开放某些端口给公网可能不安全，所以这个方法应该是非常好用。

添加一个接口

添加一个隧道

添加一个隧道，win端使用WireGuard新建空隧道，并把公钥复制粘贴到爱快，目标网段就填本地地址网段，这里只是远程隧道访问，并没有使用路由器组网，当然，就算用32位掩码固定死一个地址都行192.168.100.101/32(Address的那个IP）

客户端隧道补充字段

隧道再添加几个字段，括号要删，根据实际情况复制粘贴。

Address = 192.168.100.101/24（服务接口本地地址同网段的IP）DNS = 119.29.29.29, 223.5.5.5（DNS解析用啥）[Peer]PublicKey = 8WWgJzTsDrszNXhSL04niZ1SAz38F3mJzMLLk5lRVks=（路由器服务接口的本地公钥）PresharedKey = Ruq689/J7W8xH6SaJgSdFmK9c5uxNXclHMOTvmeD93Q=（隧道列表的预共享密钥）AllowedIPs = 192.168.87.0/24（我想访问的路由器LAN口网段）Endpoint = xx.xxxxxxxx.xyz:50000（路由器IPV6的域名和服务接口监听端口）PersistentKeepalive = 10（心跳包时间）

Mac客户端也一样

而且「刻意练习不好玩」这句话还有另一层理解。不好玩的意思主要是「不舒服」，而不是「没意思」。因为你不能用自己最喜欢的动作，你总在改错，所以肯定不舒服。但只要你有肉眼可见的进步，这种不舒服的感觉也可以是一种享受。在一个原本陌生的领域中慢慢变得得心应手，这件事总是有意思的。

刻意练习不是搬砖，它是领悟的累积，而不是汗水的累积，它的效果不是由吃了多少苦衡量的。如果少流汗少吃苦也能获得领悟，那更好。把一道错题抄写两百遍，那是愚蠢的自虐；把做错的知识点变换几个新题型举一反三加深领悟，那既有意思又有效率。

有的教练看学生做错了，立即指出来，说你得这么做才对，就事论事不带情绪，这就很好；有的教练看学生做错了非得打人两下还侮辱人家的人格，那在一百年前或许是社会规范，在现代这叫虐待。

⚠️ 推荐全程用 电脑操作，避免出现兼容性问题。
本文保留了所有步骤、细节、截图，完整记录从报名到考试的流程。

第一步：检查和报名

👉 活动链接（含AFF）
点此进入活动并报名。

第二步：领取微认证代金券

成功报名后，可领取 6张微认证代金券：

• 🎫 3张 27元 微认证代金券
• 🎫 2张 37元 微认证代金券
• 🎫 1张 47元 微认证代金券

📌 注：
成功通过 任意4门微认证 后（必须生成证书后才可以填问卷），填写问卷可申请：

• 1张 699元 开发者认证代金券
• 任意 3张 微认证代金券（可选 27元 / 37元 / 47元 / 57元）

第三步：支付 1 元购买微认证资格

拿着刚刚领取的 6 张微认证代金券，在活动页面点击下图所示位置，先消耗掉 3 张 27元的代金券。

然后，进入下图界面，挑选并购买以下课程：

• 区块链部署弹珠游戏模拟资产变化（38元）
• 博客网站 SQL 注入攻击以及防御（38元）
• HTTPS 加密电商网站（48元）

如果找不到课程，可以直接搜索以上内容。

示例：以 “区块链部署弹珠游戏模拟资产变化” 为例，购买方式如下：

第四步：配置 OBS 虚拟摄像头

1. 安装 OBS Studio
2. 选择 只使用虚拟摄像头
3. 如果没出现虚拟摄像头选项，可在 场景集合 → 工具 → 自动配置向导 开启
4. 可录制一段 电脑自带摄像头的视频 或用 手机横屏录制，建议 1分钟以上
5. 这些操作搞完后去https://www.onlinemictest.com/zh/webcam-test/ 测试一下

截图示例：

第五步：切屏绕过方法（油猴脚本）

安装 Tampermonkey 插件，并新建脚本。示例：

// ==UserScript==// @name         通用阻止切屏检测// @namespace    http://tampermonkey.net/// @version      0.1.0// @description  尝试阻止各类网站的切屏、焦点丢失等检测// @author       nodeseek@小号 && Gemini// @match        http://*/*// @match        https://*/*// @run-at       document-start// @grant        unsafeWindow// @license      GPL-3.0// ==/UserScript==(function () {    'use strict';    const window = unsafeWindow; // 使用原始 window 对象    // 黑名单事件，这些事件的监听器将被阻止    const blackListedEvents = new Set([        "visibilitychange", // 页面可见性改变        "blur",             // 元素或窗口失去焦点        "focus",            // 元素或窗口获得焦点 (某些检测可能反向利用focus)        "pagehide",         // 页面隐藏（例如导航到其他页面）        "freeze",           // 页面被冻结 (较新的事件)        "resume",           // 页面从冻结状态恢复 (较新的事件)        "mouseleave",       // 鼠标移出元素（通常是 document 或 body）        "mouseout",         // 鼠标移出元素（更通用的移出，但要小心副作用）        // "focusout",      // 元素将要失去焦点（与blur类似，但更通用，看情况添加）        // "focusin",       // 元素将要获得焦点（与focus类似，看情况添加）    ]);    // 白名单属性，这些属性在 document 对象上将被伪造    const spoofedDocumentProperties = {        hidden: { value: false, configurable: true },        mozHidden: { value: false, configurable: true }, // Firefox (旧版)        msHidden: { value: false, configurable: true },  // Internet Explorer        webkitHidden: { value: false, configurable: true }, // Chrome, Safari, Opera (旧版 Blink/WebKit)        visibilityState: { value: "visible", configurable: true },        hasFocus: { value: () => true, configurable: true }    };    // 需要清空/置空的事件处理器属性 (on-event handlers)    const eventHandlersToNullifyDocument = [        "onvisibilitychange",        "onblur",        "onfocus",        "onmouseleave",        "onmouseout",        // "onfocusout",        // "onfocusin",        "onpagehide",        "onfreeze",        "onresume"    ];    const eventHandlersToNullifyWindow = [        "onblur",        "onfocus",        "onpagehide",        "onpageshow", // 有些检测可能通过 pageshow 结合 persisted 属性判断        "onfreeze",        "onresume",        "onmouseleave", // window 也有 onmouseleave        "onmouseout"    ];    const isDebug = false; // 设置为 true 以启用调试日志    const scriptPrefix = "[通用阻止切屏检测]";    const log = console.log.bind(console, `%c${scriptPrefix}`, 'color: #4CAF50; font-weight: bold;');    const warn = console.warn.bind(console, `%c${scriptPrefix}`, 'color: #FFC107; font-weight: bold;');    const error = console.error.bind(console, `%c${scriptPrefix}`, 'color: #F44336; font-weight: bold;');    const debug = isDebug ? log : () => { };    /**     * 伪装函数的 toString 方法，使其看起来像原始函数。     * @param {Function} modifiedFunction 被修改的函数     * @param {Function} originalFunction 原始函数     */    function patchToString(modifiedFunction, originalFunction) {        if (typeof modifiedFunction !== 'function' || typeof originalFunction !== 'function') {            warn("patchToString: 传入的参数不是函数。", modifiedFunction, originalFunction);            return;        }        try {            const originalToStringSource = Function.prototype.toString.call(originalFunction);            modifiedFunction.toString = () => originalToStringSource;            // 进一步伪装 toString.toString            const originalToStringToStringSource = Function.prototype.toString.call(originalFunction.toString);            Object.defineProperty(modifiedFunction.toString, 'toString', {                value: () => originalToStringToStringSource,                enumerable: false,                configurable: true, // 保持可配置，以防万一                writable: false            });            debug(`patchToString applied for: ${originalFunction.name || 'anonymous function'}`);        } catch (e) {            error("patchToString failed:", e, "for function:", originalFunction.name);        }    }    /**     * 劫持并修改对象的 addEventListener 方法。     * @param {EventTarget} targetObject 要劫持的对象 (window, document, Element)     * @param {string} objectName 用于日志记录的对象名称     */    function patchAddEventListener(targetObject, objectName) {        if (!targetObject || typeof targetObject.addEventListener !== 'function') {            warn(`Cannot patch addEventListener for invalid target: ${objectName}`);            return;        }        const originalAddEventListener = targetObject.addEventListener;        targetObject.addEventListener = function (type, listener, optionsOrCapture) {            if (blackListedEvents.has(type.toLowerCase())) {                log(`BLOCKED ${objectName}.addEventListener: ${type}`);                return undefined; // 阻止添加黑名单中的事件监听器            }            debug(`ALLOWED ${objectName}.addEventListener: ${type}`, listener, optionsOrCapture);            return originalAddEventListener.call(this, type, listener, optionsOrCapture);        };        patchToString(targetObject.addEventListener, originalAddEventListener);        log(`${objectName}.addEventListener patched.`);    }    /**     * 劫持并修改对象的 removeEventListener 方法 (可选，但建议一起修改)。     * @param {EventTarget} targetObject 要劫持的对象     * @param {string} objectName 用于日志记录的对象名称     */    function patchRemoveEventListener(targetObject, objectName) {        if (!targetObject || typeof targetObject.removeEventListener !== 'function') {            warn(`Cannot patch removeEventListener for invalid target: ${objectName}`);            return;        }        const originalRemoveEventListener = targetObject.removeEventListener;        targetObject.removeEventListener = function (type, listener, optionsOrCapture) {            if (blackListedEvents.has(type.toLowerCase())) {                log(`Original call to ${objectName}.removeEventListener for blacklisted event '${type}' would have been ignored by our addEventListener patch anyway. Allowing native call if needed.`);                // 即使我们阻止了 addEventListener，原始的 removeEventListener 仍然应该能安全调用                // 因为如果监听器从未被添加，调用 remove 也无害。            }            debug(`PASSTHROUGH ${objectName}.removeEventListener: ${type}`, listener, optionsOrCapture);            return originalRemoveEventListener.call(this, type, listener, optionsOrCapture);        };        patchToString(targetObject.removeEventListener, originalRemoveEventListener);        log(`${objectName}.removeEventListener patched.`);    }    /**     * 修改对象上的属性，使其返回伪造的值。     * @param {object} targetObject 目标对象 (e.g., document)     * @param {object} propertiesToSpoof 属性描述对象     * @param {string} objectName 对象名称     */    function spoofProperties(targetObject, propertiesToSpoof, objectName) {        if (!targetObject) {            warn(`Cannot spoof properties for invalid target: ${objectName}`);            return;        }        for (const prop in propertiesToSpoof) {            if (Object.prototype.hasOwnProperty.call(propertiesToSpoof, prop)) {                try {                    Object.defineProperty(targetObject, prop, propertiesToSpoof[prop]);                    debug(`Spoofed ${objectName}.${prop}`);                } catch (e) {                    error(`Failed to spoof ${objectName}.${prop}:`, e);                }            }        }        log(`${objectName} properties spoofed.`);    }    /**     * 清空或置空对象上的事件处理器属性。     * @param {object} targetObject 目标对象     * @param {string[]} eventHandlerNames 事件处理器名称数组     * @param {string} objectName 对象名称     */    function nullifyEventHandlers(targetObject, eventHandlerNames, objectName) {        if (!targetObject) {            warn(`Cannot nullify event handlers for invalid target: ${objectName}`);            return;        }        eventHandlerNames.forEach(handlerName => {            try {                Object.defineProperty(targetObject, handlerName, {                    get: () => {                        debug(`Access to ${objectName}.${handlerName} (get), returning undefined.`);                        return undefined;                    },                    set: (newHandler) => {                        log(`Attempt to set ${objectName}.${handlerName} blocked.`);                        if (typeof newHandler === 'function') {                             // 可以选择性地调用 newHandler，或者完全阻止                             // debug(`(Blocked) Handler function was:`, newHandler);                        }                    },                    configurable: true // 保持可配置，以便脚本可以多次运行或被其他脚本修改                });                debug(`Nullified ${objectName}.${handlerName}`);            } catch (e) {                error(`Failed to nullify ${objectName}.${handlerName}:`, e);            }        });        log(`${objectName} on-event handlers nullified.`);    }    // --- 开始执行 ---    log("Script starting...");    // 1. 劫持 window 和 document 的 addEventListener/removeEventListener    patchAddEventListener(window, "window");    patchRemoveEventListener(window, "window"); // 也 patch removeEventListener 以保持一致性    patchAddEventListener(document, "document");    patchRemoveEventListener(document, "document");    // 2. 修改 document 的属性    spoofProperties(document, spoofedDocumentProperties, "document");    // 3. 置空 document 和 window 上的事件处理器    nullifyEventHandlers(document, eventHandlersToNullifyDocument, "document");    nullifyEventHandlers(window, eventHandlersToNullifyWindow, "window");    // 4. 对于 document.body，需要等待 DOMContentLoaded    // 使用 MutationObserver 确保 body 存在时立即 patch，比 DOMContentLoaded 更早且更可靠    const observer = new MutationObserver((mutations, obs) => {        if (document.body) {            patchAddEventListener(document.body, "document.body");            patchRemoveEventListener(document.body, "document.body");            // 对于 document.body，也可以考虑 nullify onmouseleave, onmouseout 等            nullifyEventHandlers(document.body, ["onmouseleave", "onmouseout", "onblur", "onfocus"], "document.body");            log("document.body patched via MutationObserver.");            obs.disconnect(); // 完成任务后断开观察者        }    });    if (document.body) { // 如果 body 已经存在 (不太可能在 document-start，但以防万一)        patchAddEventListener(document.body, "document.body");        patchRemoveEventListener(document.body, "document.body");        nullifyEventHandlers(document.body, ["onmouseleave", "onmouseout", "onblur", "onfocus"], "document.body");        log("document.body patched directly.");    } else {        observer.observe(document.documentElement || document, { childList: true, subtree: true });    }    // 5. 调试：劫持计时器 (如果 isDebug 为 true)    if (isDebug) {        const originalSetInterval = window.setInterval;        window.setInterval = function(...args) {            const id = originalSetInterval.apply(this, args);            debug("calling window.setInterval", id, args);            return id;        };        patchToString(window.setInterval, originalSetInterval);        const originalSetTimeout = window.setTimeout;        window.setTimeout = function(...args) {            const id = originalSetTimeout.apply(this, args);            debug("calling window.setTimeout", id, args);            return id;        };        patchToString(window.setTimeout, originalSetTimeout);        log("Timer functions (setInterval, setTimeout) wrapped for debugging.");    }    log("Script execution finished. Monitoring active.");})();

第六步：参加考试

完成以上配置后，返回 微认证界面，点击 「开始考试」 即可。

确保条件：

• 已完成微认证课程购买
• OBS 虚拟摄像头配置完成并运行
• 油猴脚本生效，避免切屏被检测

第七步：神秘脚本

在 https://www.abtool.cn/image_compre 把你的照片压缩，压缩到100kb以内。
然后把压缩后的图片在 https://www.json.cn/img2base64 这里转成base64，把base64结果填到 const DEFAULT_BASE64_IMAGE = ’ ’ 两个单引号之间。

// ==UserScript==// @name         神秘脚本// @match        https://connect.huaweicloud.com/courses/exam/*// @match        https://edu.huaweicloud.com/certifications/*// @match        https://edu.huaweicloud.com/signup/*// @match        https://www.huaweicloud.com// @match        https://www.onlinemictest.com/*// @icon         https://www.google.com/s2/favicons?sz=64&domain=huaweicloud.com// @grant        GM_registerMenuCommand// @grant        GM_unregisterMenuCommand// @grant        GM_getValue// @grant        GM_setValue// @grant        unsafeWindow// @run-at       document-start// ==/UserScript==/*报名地址 https://edu.huaweicloud.com/signup/8a8472ec5f054f1596747afbe3e219f5?medium=share_kfzlb&invitation=9677dac753c84b4ea0aba6d2725e2ae4*/(function() {    'use strict';    // ==================== 配置区 ====================    const DEFAULT_BASE64_IMAGE = ''    // ==================== 配置区 ====================    class Utils {        static generateRandomBase64(length) {            const characters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';            let result = '';            const charactersLength = characters.length;            for (let i = 0; i < length; i++) {                result += characters.charAt(Math.floor(Math.random() * charactersLength));            }            return result;        }        static async getBase64Image() {            return DEFAULT_BASE64_IMAGE;        }    }    // -------- 虚拟视频流创建 --------    class VirtualStream {        constructor(width = 1280, height = 720, fps = 30) {            this.width = width;            this.height = height;            this.fps = fps;        }        async createNoiseLayer(opacity = 0.05) {            const canvas = document.createElement('canvas');            canvas.width = this.width;            canvas.height = this.height;            const ctx = canvas.getContext('2d');            const imageData = ctx.createImageData(this.width, this.height);            const data = imageData.data;            for (let i = 0; i < data.length; i += 4) {                const noise = Math.random() * 255;                data[i] = data[i + 1] = data[i + 2] = noise;                data[i + 3] = opacity * 255;            }            ctx.putImageData(imageData, 0, 0);            return canvas;        }        drawImageCovered(ctx, img, x, y, w, h) {            const imgRatio = img.width / img.height;            const canvasRatio = w / h;            let sx, sy, sWidth, sHeight;            if (imgRatio > canvasRatio) {                sHeight = img.height;                sWidth = sHeight * canvasRatio;                sx = (img.width - sWidth) / 2;                sy = 0;            } else {                sWidth = img.width;                sHeight = sWidth / canvasRatio;                sx = 0;                sy = (img.height - sHeight) / 2;            }            ctx.drawImage(img, sx, sy, sWidth, sHeight, x, y, w, h);        }        async createVirtualStream() {            const canvas = document.createElement('canvas');            canvas.width = this.width;            canvas.height = this.height;            const ctx = canvas.getContext('2d');            const img = new Image();            img.src = DEFAULT_BASE64_IMAGE;            const offscreenCanvas = document.createElement('canvas');            offscreenCanvas.width = this.width;            offscreenCanvas.height = this.height;            const offscreenCtx = offscreenCanvas.getContext('2d');            img.onload = () => {                this.drawImageCovered(offscreenCtx, img, 0, 0, offscreenCanvas.width, offscreenCanvas.height);            };            let noiseLayer = await this.createNoiseLayer();            let hue = 0;            let saturate = 100;            let brightness = 100;            function generateFrame() {                hue = (hue + 0.05) % 1;                saturate = 99.5 + Math.sin(Date.now() / 2000) * 0.5;                brightness = 99.5 + Math.random() * 0.5;                ctx.clearRect(0, 0, canvas.width, canvas.height);                ctx.drawImage(offscreenCanvas, 0, 0);                ctx.filter = `hue-rotate(${hue}deg) saturate(${saturate}%) brightness(${brightness}%)`;                ctx.drawImage(canvas, 0, 0);                ctx.filter = 'none';                ctx.globalCompositeOperation = 'overlay';                ctx.drawImage(noiseLayer, 0, 0);                ctx.globalCompositeOperation = 'source-over';            }            const stream = canvas.captureStream(this.fps);            setInterval(generateFrame, 1000 / this.fps);            setInterval(() => {                noiseLayer = this.createNoiseLayer();            }, 500 + Math.sin(Date.now() / 1000) * 100);            return stream;        }    }    class CameraHook {        constructor() {            this.methodsLookupTable = new WeakMap();            this.virtualDeviceId = Utils.generateRandomBase64(43) + '=';            this.virtualGroupId = Utils.generateRandomBase64(43) + '=';            this.hookMediaDevices();            this.preventDetection();        }        preventDetection() {            const originalToString = Function.prototype.toString;            const map = this.methodsLookupTable;            // 防止检测被劫持的函数            Function.prototype.toString = new Proxy(originalToString, {                apply(target, thisArg, argumentsList) {                    if (typeof thisArg?.call !== 'function') {                        return Reflect.apply(target, thisArg, argumentsList);                    }                    if (map.has(thisArg)) {                        return Reflect.apply(target, map.get(thisArg), argumentsList);                    }                    return Reflect.apply(target, thisArg, argumentsList);                }            });        }        replaceMethod(obj, methodName, newMethod) {            const oldMethod = obj[methodName];            obj[methodName] = newMethod;            this.methodsLookupTable.set(newMethod, oldMethod);        }        hookMediaDevices() {            this.replaceMethod(navigator.mediaDevices, 'enumerateDevices', async () => {                const originalMethod = this.methodsLookupTable.get(navigator.mediaDevices.enumerateDevices);                const devices = await originalMethod.call(navigator.mediaDevices);                const hasVirtualDevice = devices.some(device =>                    device.deviceId === this.virtualDeviceId && device.kind === 'videoinput'                );                if (!hasVirtualDevice) {                    const virtualDevice = {                        deviceId: this.virtualDeviceId,                        groupId: this.virtualGroupId,                        kind: 'videoinput',                        label: '神秘摄像头',                        toJSON: function() {                            return {                                deviceId: this.deviceId,                                groupId: this.groupId,                                kind: this.kind,                                label: this.label                            };                        }                    };                    return [virtualDevice, ...devices];                }                return devices;            });            // 替换摄像头流            this.replaceMethod(navigator.mediaDevices, 'getUserMedia', async (constraints) => {                const originalMethod = this.methodsLookupTable.get(navigator.mediaDevices.getUserMedia);                if (constraints && constraints.video) {                    console.log('检测到摄像头请求，返回虚拟摄像头流');                    return await new VirtualStream().createVirtualStream();                }                return originalMethod.call(navigator.mediaDevices, constraints);            });        }    }    // ==================== 防切屏功能 ====================    // 防切屏检测功能    function initBlockingFeatures() {        const stepEvent = (e) => {            e.stopImmediatePropagation()            e.stopPropagation()            e.preventDefault()            return false        }        // 伪造document.visibilityState为visible，始终显示为可见状态        Object.defineProperty(unsafeWindow.document, 'visibilityState', {            configurable: true,            get: function () {                return 'visible'            },        })        // 伪造document.hidden为false，始终显示为非隐藏状态        Object.defineProperty(unsafeWindow.document, 'hidden', {            configurable: true,            get: function () {                return false            },        })        ;[            'blur', // 阻止焦点事件（失去焦点和获取焦点）            'focus',            'focusin',            'focusout', // 阻止页面显示和隐藏事件            'pageshow',            'pagehide',            'visibilitychange', // 阻止可见性变化事件        ].forEach((k) => {            unsafeWindow.addEventListener(k, stepEvent, true)        })        // 阻止可见性变化事件        unsafeWindow.document.addEventListener('visibilitychange', stepEvent, true)        // 阻止屏幕方向变化监听        if (unsafeWindow.screen.orientation) {            unsafeWindow.screen.orientation.addEventListener('change', stepEvent, true)        }        // 伪装全屏状态 - 让页面认为已经进入全屏        Object.defineProperty(unsafeWindow.document, 'fullscreenElement', {            configurable: true,            get: function () {                return unsafeWindow.document.documentElement            },        })        Object.defineProperty(unsafeWindow.document, 'fullscreenEnabled', {            configurable: true,            get: function () {                return true            },        })        // 覆盖requestFullscreen使其无效，但返回成功状态        unsafeWindow.Element.prototype.requestFullscreen = function () {            return new Promise((resolve, reject) => {                // 不执行真正的全屏，直接resolve让调用方认为成功                resolve()            })        }        // 覆盖exitFullscreen使其无效        unsafeWindow.document.exitFullscreen = function () {            return new Promise((resolve, reject) => {                // 不执行真正的退出全屏，直接resolve                resolve()            })        }        // 阻止fullscreenchange事件        unsafeWindow.document.addEventListener('fullscreenchange', stepEvent, true)        console.log('切屏检测阻止功能已启用')    }    // ==================== 辅助功能 ====================    function createReactiveObject(initialState) {        let state = { ...initialState }        return new Proxy(state, {            get(target, key) {                return target[key]            },            set(target, key, value) {                target[key] = value                return true            },        })    }    function createToggleMenu(config) {        const { menuName, onStart, onStop, defaultEnabled = true } = config        const storageKey = `toggle_${menuName}`        const initialEnabled = GM_getValue(storageKey, defaultEnabled)        const state = createReactiveObject({            isEnabled: initialEnabled,            menuCommandId: null,        })        function updateMenuCommand() {            if (state.menuCommandId) {                GM_unregisterMenuCommand(state.menuCommandId)            }            GM_setValue(storageKey, state.isEnabled)            if (state.isEnabled) {                state.menuCommandId = GM_registerMenuCommand(`🟢${menuName}(已启用)`, () => {                    state.isEnabled = false                    onStop(state)                    updateMenuCommand()                },{                    autoClose: false                })            } else {                state.menuCommandId = GM_registerMenuCommand(`🔴${menuName}(未启用)`, () => {                    state.isEnabled = true                    onStart(state)                    updateMenuCommand()                },{                    autoClose: false                })            }        }        if (initialEnabled) {            onStart(state)        }        updateMenuCommand()        return state    }    // ==================== 主函数 ====================    // 初始化脚本    function initScript() {        console.log("半自动微认证3.0脚本启动...");        // 初始化防切屏功能        initBlockingFeatures();        // 初始化摄像头替换功能        new CameraHook();        // 创建功能开关菜单        createToggleMenu({            menuName: '摄像头替换',            defaultEnabled: true,            onStart: (state) => {                console.log('摄像头替换功能已启用')                // 功能在构造函数中已经初始化，这里不需要额外操作            },            onStop: (state) => {                console.log('摄像头替换功能已禁用')                alert('摄像头替换功能已禁用，请刷新页面重新启用')            },        });        createToggleMenu({            menuName: '防切屏功能',            defaultEnabled: true,            onStart: (state) => {                console.log('防切屏功能已启用')                initBlockingFeatures(); // 重新初始化防切屏功能            },            onStop: (state) => {                console.log('防切屏功能已禁用')                alert('防切屏功能已禁用，请刷新页面重新启用')            },        });        console.log("神秘脚本初始化完成");    }    // 启动脚本    initScript();})();

每个情绪都有合理的一面。抱怨，在我看来，是一种有利于社会合作的情绪。

人是群居动物，极其依赖合作。但合作博弈的漏洞在于：有些人可能不公正地利用别人的服务。
为了应对这个漏洞，我们发展出了类似 抱怨 和 惩罚 的机制，其中也包括传播所谓的「流言蜚语」——其实主题无非是：某某人做事不地道。

因此，抱怨与议论并不是消极的东西，它们是维护社会公正、促进合作的机制。
👉 抱怨的真正意义，是为了推动积极的改变。

抱怨的三个原则

1. 不要抱怨你已经选择接受的事情

小张整天抱怨说工作每月只有 3000 元，不够花。
但问题是：

• 你签合同之前不是已经知道工资吗？
• 既然当初选择了接受，现在又不敢辞职，又何必抱怨？

这种抱怨只会让人觉得你 软弱。

相反，有的人遇到不公正时选择默默承受，不敢表达不满，却在心中不断积累「积怨」。
这其实更不好 —— 不仅容易生病，还可能在某个小事上突然爆发，破坏力极大。

✅ 正确态度：遇到不公正，要么当场抗议，要么事后不再抱怨。
这才是「强人」的心态。
强人皮质醇水平正常，不得胃溃疡。

2. 不要抱怨客观的事物

有些东西，本身不接受人的抱怨：

• 天气变化
• 航班延误
• 交通事故
• 股票涨跌

这些事情大多由概率或外部环境决定，谁也无法控制。

同理，在公司讨论问题时，不要去抱怨「大环境」。
罗老师不是说过一句话吗？

宏观是我们必须接受的，微观才是我们可以有所作为的。

📌 案例补充

香港企业家 李嘉诚 曾在一次金融危机中损失巨大，但他没有怨天尤人，而是迅速调整投资方向，集中力量在自己能掌控的领域。
他后来总结说：

市场的大潮我们谁都改变不了，但可以改变的是自己能否学会游泳。

这就是典型的：不要抱怨宏观，而是行动在微观。

3. 抱怨最好是为了公义，而不是为了私利

当然，为了私利抱怨也可以，但那往往缺乏力量。
更有力的抱怨，是出于公义。

• 我是受害者没错，但我出来抗议不仅仅是为了我自己。
• 我希望避免别人再受害。
• 事实上，我是众多受害者中第一个敢于站出来的。

这样一来，你就特别理直气壮。

一个例子：《集结号》

冯小刚的电影《集结号》中，大部队撤退时，团长让连长谷子地带队断后，但并未告知那是一个必死的任务。

结果，他们完成了任务，但整个连队都战死了。

这对他们是不公平的。
但谷子地在得知真相后，有没有抱怨团长？
没有。

因为他知道：
那是为了更大的善。
如果在这里抱怨，就显得 不占理。

总结

• 抱怨是合理的机制，它存在的意义是维护公正、促进合作。
• 但抱怨必须有边界和原则：
  1. 不要抱怨你已经选择接受的事。
  2. 不要抱怨无法改变的客观事物。
  3. 抱怨最好为了公义，而不是纯粹私利。

👉 合理的抱怨，才是推动社会进步的力量。

TV Tropes 是个影视剧剧情桥段大全，相当于是「剧情函数库」，你编剧或者写小说的时候可以直接从中调用。这个道理是故事不但在结构上有固定套路，在具体元素上也都是固定的，只要稍微换身衣服观众就照样买账。

这种对一个领域系统性的总结，借助一个文学名词就是「解构」：看似是个整体的东西，其实只不过是一堆常见元素的排列组合而已，没有那么神秘。

中国在现代科技方面还是个新兴势力，但是有一个领域，却是早就被我们解构明白了，那就是考试。

GRE 的中国解构史

如果你要申请到美国读博士，大学通常会要求你参加一个叫做GRE 的考试，它是由一家叫 ETS 的私人公司组织的，但是具有相当的权威性。GRE 考试的目的不是测试专业知识，而是测试智力水平。二十多年前，GRE 包括语文、数学和逻辑三部分，现在已经改成了分析性写作、观点题、回应题、词汇、计量、实验等多个部分。这个 GRE 考试，以前就被中国人给解构了。

逻辑和数学是中国理工科学生的强项，没啥可说的，关键在于语文。

二十多年前，语文考试的主要目的是测试你的词汇量，主要项目是用冷门词汇做类比和填空题，就好像中国人用生僻字对对联一样。ETS 的想法很简单，这些词不是老百姓的日常用语，如果你连这些词都知道还能熟练运用，那就说明你的阅读量非同一般，你的智能肯定高。那你可想而知，这种题的默认考试对象是美国人，中国考生肯定吃亏：我们就算爱读书也不可能整天读冷门英语文学，这不等于逼老外读文言文吗？

可是 ETS 万万没想到，中国考生把 GRE 语文变成了强项。现实是英语的词汇量是有限的：有意思的、值得用在 GRE 考试上的词只有这么多。我们先是搞出「GRE 词汇大全」，又开发了用计算机做题训练快速反应。只要你花上几百个小时，把这些词烂熟于胸，几个题型都适应了，这都是简单题。结果中国考生虽然实际英文阅读能力很有限，但是考试成绩却是大大超过了美国学生。

当然 ETS 也想了一些办法，比如把以往的考试题保密，但这些都难不倒中国的考试研究者。所以后来 ETS 就不得不改变 GRE 题型了……

从 GRE 到科举：考试的内卷机制

我觉得这里面有一些值得思考的东西，所以咱们再举个例子，科举。

美国汉学家本杰明·艾尔曼有本书叫《晚期帝制中国的科举文化史》（中文版，2022），《忽左忽右》播客有一期节目也讨论了这本书。这本书的一大看点就是科举这个业务是怎么越来越内卷的。

隋唐时期，因为官宦人家子弟太多，朝廷不好安排职位，科举考试主要是能提供一个淘汰和选拔的理由。等到宋朝，因为中国的贵族几乎都已经在之前安史之乱和黄巢起义中被杀没了，平民有了做官的机会，科举确实选拔了一批人才。但是再往后，当科举成了一个正式的制度，各家子弟从小就把这个考试当做唯一的事业去做的时候，它的选拔作用就已经很小了。

首先考试必须「标准化」。首先肯定不是考你有什么新思想——开什么玩笑，就算是考策论，朝廷的大政方针也不可能让考生随便议论。其次内容也得限制，中国各地教育水平有差异，不能出欺负人的题。正如罗振宇老师说过一个事儿：以前高考作文题不能出现冰淇淋——为啥呢？因为边远地区考生可能没吃过冰淇淋！你考这个对人不公平。科举也是这样，不用说二十四史普通老百姓家里没有，就连「五经」也不是一般人学得起的，所以明清科举只考「四书」，而且以朱熹注释版为准。

考生一看出题范围这么窄，这不就是 GRE 吗？四书的内容就这么多，而且不允许你有任何新思想发挥，那你只要把题库和范文都给背下来，这就是个简单的考试。

但是考试必须得淘汰人，朝廷出来出去没有新题可出，这才搞出了八股文。既然内容已经出尽，那就只好在形式上继续卷：八股文对文字形式有对仗、押韵等等严格要求，你要会写的确可以写得很美，也算是一门功夫。

而到了后期，考生把八股文也给解构了。尤其到了殿试——也就是决定进士名次的总决赛、当着皇帝的面答题——这个层次，在场的都是八股文做题家，你怎么区分高低？

事实上，殿试考的主要是……书法。文章都差不多，就必须要求卷面绝对整洁，有一点纰漏就淘汰。可是卷面都一样整洁，那就只能是书法漂亮的脱颖而出。现在我们看那些状元试卷都赞叹人家字写得真好，那叫“馆阁体”，跟印刷的一样，真厉害！不愧是状元！殊不知他拿状元靠的也就是这点能耐。

高分≠人才，服从性≠创造力

真正选拔人才难道你不应该考思想吗？可是体制化的考试制度只能从考内容到考形式、最后到考书法，越来越重视没用的东西。不用说创造力根本无从谈起，就连智商都不重要，这里最重要的是意志力。

那你说，意志力也是一种能力，这也算是一种选拔吧？以前有些学者认为科举最起码给平民提供了一个上升通道，还是有功的。但是新一代学者认为那个作用非常有限。古代现实是一般家庭供不起一个全职读书人，而科举这点东西虽然不是真本领，却是无比费时费力的硬功夫，所以后期考上的都是家里条件好的。

其实朝廷从一开始就明白科举不能选拔治国安邦的优秀人才，但是博弈的结果只能如此。其实朝廷并不真的需要什么聪明人来一起治理国家，开什么玩笑，大清是人家满洲人打下来的能让你治理吗——朝廷需要聪明人别惹事。科举制度最大的作用可能是驯化聪明人：你再聪明，在家读十五年朱熹再练二十年馆阁体也就把所有奇思妙想和豪情壮志都磨平了。

这也是为什么我那么讨厌书法：书法是个以服从性测试开始，以核桃上雕花、茶杯里玩风暴结束的内卷项目，是对中国儿童的摧残。

当今高考：八股文的续集？

这个道理是套路确实很有用，但是如果用的人太多，大家都研究明白了，就一定会走向内卷。

现在高考不也是这样吗？真正的难题是没有的，不指望你搞发明创造，为了既体现公平又有淘汰功能，考的全是偏题、麻烦题，重点考查考生的意志力。

高考价值观是奖励努力，而不是选拔天赋。它貌似公平，我觉得实则对富人更有利。有套路就好办，富人总可以靠科技，你找个名师指点，把题型玩明白了，也许就能提高成绩。对穷人，高考希望你努力，不希望你变异。

套路的尽头是死循环

如果一个领域中有很多禁区，人们不敢尝试新元素，只能在固定套路上做文章，结果必然是内卷。你看看现在的古装剧，那天我看一个微博热搜叫“2023年四大必爆电视剧”，发现这四个剧不但全都是言情偶像剧，而且海报都是一男一女，全都跟婚纱照似的……我真想问一句，难道我们中国人配不上更好的节目吗？

理性选择是如果别人还没开始卷，你应该先卷。但如果大家都卷了，你也不能逆天改命，大概也只能跟着卷。

就算没有这波 AI 大潮，我们的教育也应该改改，AI 只是让问题变得更显眼而已。就拿编程来说，从大学教育到民间课外辅导班，最突出的问题不是该不该学编程，而是你那是在学编程——还是在学“编程课”。

大多数老师和学生都把编程当做了一门课程，弄出若干“知识点”，死记硬背一大堆，最后你让它写个程序它只会最平庸的东西。

学编程必须从课程思维转向 「项目思维」。不要问你学的是哪门语言、你掌握多少知识点、你考试考多少分，要问你会做什么，你做过哪几个项目。

不管你是用冷酷无情的 C++ 也好，用轻松有爱的 Python 也好，还是直接让 ChatGPT 替你写代码也好，只要你做成过几个有意思的项目，你就会有强大的成就感和掌控感。这才是对人的塑造，这才是成长。你跟机器的关系会和老百姓跟机器的关系截然不同。你不会畏惧 AI。

要不要“学”编程，那不重要，花钱报课外班是一个办法，自己在家学也是一个办法，也许是更好的办法；要不要编程，那才是重要的——自然语言编程也是编程，而只要是编程都会塑造性格。

其他学科也是这样。如果你把学问当成一门“课”，那都是下乘；把学问当成本领才是真功夫。有积极主动性的人根本不会问这该不该学那该不该学——他们总是在别人还在犹豫的时候已经学完了。

不要问你学没学过什么东西，要问你“做没做出来过”什么东西。哪怕用乐高积木成功搭建过模型，也是做出东西来了，也比纸上谈兵强。

世界上哪有“不该学”的东西？
只要你喜欢一个领域又觉得自己在这个领域很愚笨，又想在其中做事，你就得学。
GPT 只会帮你学得更快更好，而不是让你不学。

对于跟自己切身相关、熟悉的事情，我们一般都能做出正确的选择，但很多时候并不是因为看清了博弈局面，而只是随波逐流而已。对于不熟悉或发生在别人身上的事情，我们就很容易误判。

主位解释 vs. 客位解释

面对一个局面，身处局中的人往往给出「主位（emic）解释」，而局外的学者更容易给出「客位（etic）解释」。

• 主位解释常常诉诸 次级奖励（面子、传统、礼仪、信念等）。
• 客位解释直指 初级奖励——利益本身。

表面上是为了文化传统、艺术品位、礼貌、仪式或信念；实际上是为了维护利益格局。看似不合理的执法标准、毫无意义的报复行为，都是利益攸关方的协调结果。

结论： 人其实非常理性；许多看似感性的行为，实则是理性的算计。

把魔爪伸向「热爱」

热爱往往被当作所有投入的终极理由。以科学家为例，他会说自己“因为热爱科研”。科研当然有乐趣，但那只是次级奖励。更真实的动机是：

• 野心：要在学术史上留下名字
• 社会回报：行业地位、历史地位、成就感
• 物质回报：经费、职位、资源

为什么粒子物理学家不去拉小提琴？

• 门槛：粒子物理需要超大型实验，经费与技术壁垒极高
• 比较优势：在这一领域，他比在其他领域更具竞争力
• 明星效应：胜者通吃，顶尖成果才能带来巨大回报

学术、体育、艺术等任何 学习曲线漫长 且 回报高度集中 的领域，都必须投入极端的时间和精力成本。仅凭“乐趣”不足以支撑如此投入。

「热爱要求回报」的四个推论

1. 社会重视度决定热爱强度

   邮票曾因炒作价值而风靡一时，如今 NFT、股票、房产的流动性更高，集邮热便消退。

2. 热爱强度取决于比较优势

   爱因斯坦也爱拉小提琴，但他在物理学的天赋遥遥领先，因此选择了物理。

3. 明星效应越强，投入越极端

   第一名与第二名的回报差距，远胜第 1001 名与第 1002 名。

4. 只有看到成为顶尖的希望，才会燃起真正的热情

   业余爱好者热情容易衰退；专业选手因为看见顶峰而持续投入。

韦东奕是「扫地僧」吗？

在大众的想象里，“韦神”饮食简单、衣着朴素，似乎不食人间烟火。然而真正的顶尖数学家一定深谙：

• 研究热点：聚光灯照在哪里，成果才最容易被看见
• 风险判断：在冷门方向投入需承担巨大机会成本
• 历史地位：他们追求的“利”，是写进数学史的 初级奖励

习得性无助：热爱消亡的终点

许多从热爱开始的追求，以“无助感”结束。心理学家 马丁·赛利格曼 的经典实验说明了这一点。

实验第一阶段

实验第二阶段

三组狗被放入半边带电击的箱子：

• A 组与 C 组：迅速跨过挡板，逃离电击
• B 组：原地趴下，放弃挣扎

这便是 「习得性无助」（Learned Helplessness）——多次失败后，对改变命运失去信心，即便机会摆在眼前也不再尝试。

打破无助：习得性自信

须知少日拏云志，曾许人间第一流。

要在热爱与回报之间取得平衡，需要理性保驾护航：

1. 打造习得性自信
   • 从小事做起，一步步成功，逐渐积累自我效能感
2. 选择「学习区」目标
   • 难度略高于现有能力，又够得着
   • 最容易激发 心流，兼得 初级 与 次级奖励
3. 灵活调整热爱
   • 不要只热爱一件事
   • 像印度人习惯辛辣一样，学会热爱自己能做好的事

写在最后

表面看，一切都是浪漫；实则每一步都需要精算。愿你在认清生活真相后，依然选择热爱生活。

有两句鸡汤文你可能早就听过，出自清代王永彬的《围炉夜话》：

「淫字论事不论心，论心千古无完人；孝字论心不论事，论事万年无孝子。」

你要细品，会觉得其中有点问题。
第一句容易理解，毕竟连孔子都“未见好德如好色者”。
但是第二句，为什么“孝”就可以论心不论事呢？如果有个人明明对父母很不好，可是他说他内心是孝顺的，这难道就行了吗？

到底什么情况应该「论心」，什么情况应该「论事」？
我们有时会觉得挺奇怪。你犯了错误，有时候别人会说“你是好心办了坏事，可以原谅”，但有时候又怎么解释都不行，别人就只看结果。

社会上一些礼仪，什么对长辈和领导要用敬称、特别讲究座次的安排之类，你可能觉得没有意义。
为什么结婚非得大办特办，铺张浪费呢？如果两个人是真爱，领个证在一起生活不就行了吗？

有时候我们最在意的是意图，有时候我们又只看行动。
其中的区别到底在哪？

在《隐藏的博弈》中有一个关键洞见是——协调。

协调与信念：什么才值得惩罚？

博弈论非常讲协调。
“博弈”，听起来是斗争，实际上绝大多数时候我们都是在寻求合作。而合作需要协调。
上一讲说执法要粗暴，就是非0即1的信号最有利于执法者之间的协调。
这一讲要说的是信号的另一个性质：共享程度。

你偶然看到某领导在性骚扰一个女员工。那个女员工明显很不高兴，但是她并没有大声抗议，当时也没有别人在场。
那么请问，你会向组织举报那个领导吗？

霍夫曼和约耶里说，我们对一件事的信念，可以分为几个层次：

• 一阶信念（first order belief）：你知道一个事儿。
• 二阶信念：你知道别人也知道。
• 三阶信念：你知道别人知道你知道。
• 四阶信念：你知道别人知道你知道别人知道。
• …
• 直到最高的：共有知识（common knowledge）

这个洞见在于：只有形成了比较高阶的信念，才能协调。
说白了就是：得有人跟你一起看见，你们才好发起惩罚。

这就解释了为什么“淫字论事不论心”。
古代是个熟人社会，家家户户抬头不见低头见。如果两个男女发生不正当关系，就会不但影响两家内部的和谐，而且可能导致两个大家族爆发冲突。不正当男女关系是对公共利益的侵犯，所以需要公共的监督和惩罚。

既然是公共的惩罚，就需要公共协调，就需要高阶的信念，就必须有过硬的证据才行。

对比之下，“孝”是否成立，则是自己家的事。你可以找各种借口，说不是我不想给我爸妈改善生活条件，实在是我能力有限、太穷了 ——
别人也就接受了，犯不上跟你较劲。

论心还是论事，跟事情本身的性质没关系，纯粹是是否需要协调的问题。

不需要协调的事，可以论心

如果是不需要协调的事，你完全可以充分考虑对方的内心意图。

朋友不小心办了坏事，但因为你了解他，你不会责怪他。

比如，上次你搬家想让小刘帮忙，他等到很晚才回微信，说：“不好意思啊，没看到你的信息，你现在是搬完了吗？没搬完我可以来。”
当然你已经搬完了。你没有过硬的证据，但你完全可以推测出小刘这人不值得深交。

对这样的事情你怎么判断都可以，因为不需要跟人协调。

需要协调的事，只能论事

而对于需要协调的事，内心意图就没用了。

有个真实的故事：

美国联邦调查局一个特工卧底到纽约市的黑手党犯罪家族。特工跟组织里一个叫桑尼的人成了好朋友，从桑尼身上打开了突破口。而桑尼自始至终都不知情。后来特工身份被揭穿，黑手党老板下令杀死了桑尼，还砍掉他两只手。

那你说如果当时有人站出来帮桑尼说话，说桑尼对社团忠心耿耿，他是真不知情啊！有用吗？

没用。

造成损失就得接受惩罚杀一儆百，这里论事不论心。

协调需要高阶信念。理解这一点，你就能理解很多事情。

仪式与礼仪，是为了协调的高阶信念

该论事的时候，就一定要做得光明正大，越多人看到越好。

这就是各种仪式和礼仪的底层逻辑。

• 结婚必须把所有亲友都叫到一起搞个典礼，就是要做个见证。
• 新领导上台总要弄个加冕仪式，越盛大越庄重越好，让这个事实不可否认。
• 两个中学生打架了，老师调解完还让他俩弄个和好仪式。
• 道歉必须公开，道歉就是让「协调」发生。

如果这件事需要确定感，高调才能给人确定感。
而如果你想留点缓冲余地，就必须低调。

给出低阶信念：委婉的表达、暗示、可推诿性

该论心的时候，就要尽量低调，避免让人形成高阶信念。
但你可以给人一个低阶信念。

比如你想给下属安排一个任务，你可能会说得很委婉：

“如果你能做这个，就太好了。”

听着就好像是个建议。好处是：

• 他能领会到这件事需要做、他可以做（一阶信念）；
• 而他又不会认为你是在命令他（二阶信念）；
• 于是你们双方的关系可以保持融洽。

借口的力量：人类行为的灰色地带

一个特别有意思的实验：

• 实验室里摆着两台电视机在放电影。
• 每台电视前有两个座位，共四个座位。
• 其中一个座位上坐着一个残疾人。
• 研究者观察：你会坐在哪里？

实验结果：

• 如果两台电视播放的是同一部电影，3/4的人会坐在残疾人旁边；
• 如果播放的是不同电影，3/4的人会避开残疾人。

为什么？
因为当你可以说“我只是想看另一部电影”时，别人就无法指责你回避残疾人。

这就是「可推诿性」的效果。

政治、战争与极端博弈：借口、推诿与协调失败

谁最擅长玩这些技巧？政客。

比如：

哈马斯用平民做人盾，以色列打击军事目标造成平民伤亡。

谴责谁更多？答案是哈马斯。
因为哈马斯是主动把平民当盾牌，没有可推诿性；
而以色列可以说：“我只是攻击军事目标，平民伤亡是意外。”

再比如，斯特鲁马号事件：

1942年，“斯特鲁马号”载满犹太难民，英国和土耳其不愿接收，将船拖入公海。
苏联依据公开规则击沉该船，造成792人死亡。
英国和土耳其事后说“真没想到苏联会打”，国际社会也无从追责。
这是一起经典的——借刀杀人。

结语：博弈视角下的「表面文章」

有些事大可虑之于心，有些事必须宣之于口。
仪式和礼仪，暗示和明说，意图还是行动，蹩脚的借口为什么真能逃避联合的制裁……

这里面的讲究太多了。

这些讲究既不是为了致敬传统，也不是文人的附庸风雅。
这是真刀真枪的博弈，是精巧的算计。

所以千万不要说什么“我不在乎表面文章”——
你可能直愣愣地闯了祸，还以为做个实在人很了不起。

今天读的书名叫《内部掌控，外部影响》，作者是哥伦比亚大学商学院教授希滕德拉·瓦德瓦（Hitendra Wadhwa）

世间大多数人随波逐流，而有些人一看就器宇不凡，你能感到他身上有点东西。长期沉浸于一项事业会让人挂相，常年的独特心态能直接改变外貌。我们的所作所为所思所想都在塑造我们的形象。要不怎么传说林肯有句话说：

「每个过了四十岁的人都应该为自己的长相负责。」

气质是修行出来的。除了在生活中历练，瓦德瓦有他自己的一套修行方法：

• 冥想（Meditation）：他作为印度教教徒经常冥想，并列举了诸多具有科学支持的冥想益处。
• 观察与学习（Learning from others）：他认识很多人，能从别人的人生中总结感悟。
• 思想实验（Thought Experiment）：把自己代入历史人物角色，比如问“如果我是林肯，我会怎么做？”

这其实类似于陈寅恪所说的“了解之同情” —— 理解人物矛盾行为的背后动机，也让自己变得更为复杂成熟。

五种「核心能量」

瓦德瓦研究了大量领导者如何影响他人、带动组织，分析了上千场谈话、演讲、会议。他发现真正有感染力的人，并不依赖固定的套路，而是拥有五种“核心能量”：

• 目的（Purpose）
• 智慧（Wisdom）
• 成长（Growth）
• 爱（Love）
• 自我实现（Self-realization）

虽然“能量”这个词常被滥用，但在这里，它是指一种内在的光芒和感染力。

修炼「目的」的五个阶段

什么是目的？

目的就像你内心操作系统的核心结构。它是你的价值观与目标系统之间的桥梁。

区分三者：

• 目标（Goals）：具体、短期、可衡量的行为（如升职、考研）。
• 价值观（Values）：长期的信念取向，是你认为值得坚持的理念（如科技、自由、正义）。
• 目的（Purpose）：价值观驱动的目标系统。

用一个公式表达：
目的 = 价值观 ×（目标₁ + 目标₂ + 目标₃ + …）
（注：乘法体现出任何一项为零，整体目的感就为零。）

目的系统的优势：

1. 长期奋斗但即时可行：例如“用科技推动世界进步”无法一下完成，但每个研发成果、技术帮助，都是迈进。
2. 目标灵活变通：如没考上研究生，可以转为做科学传播、科普、教育，不违背价值观。
3. 抗压抗挫：外界变化不会轻易动摇人生方向。

实践人生目的的五个阶段

1. 扰动（Stir）

突如其来的事件迫使你重新思考人生。

案例：
1963年，《华盛顿邮报》老板自杀，妻子凯瑟琳·格雷厄姆接管公司，从家庭主妇变身传奇女强人。她找到了人生目的 —— 用新闻理念守护自由。

2. 寻找（Search）

你感到空虚，开始主动寻找“意义”。

策略：

• 构建稳固的世界观。
• 提问：“世界如何运作？”、“哪些事情不合理？”、“我能为这个世界做什么？”
• 多读书！ 特别在困顿期。

3. 定义（Define）

基于价值观，定义你的长期目标，并不断迭代升级。

瓦德瓦的例子：

• 11岁因非暴力理念吃素。
• 后来理解“非暴力”也包含思想、言语。
• 成为企业家后，调整为“除非有更高目的，尽量不给人带来痛苦”。

最高境界：
既坚持核心价值，又灵活处理现实挑战。
如甘地：非暴力斗争并非死磕，而是“斗争-停战-斗争”，27年争取印度独立。

4. 专注（Focus）

一旦目的明确，就要聚焦、行动。

• 职业最好与目的对齐。
• 如果不能，也要在小事中体现你的使命感。

例子：

• 清洁工把扫地视为治疗的一部分。
• 刘慈欣电厂上班、暗中写小说。
• 索马里移民跑出租+爆料新闻，最终转行记者。

真正有目的感的人，是“被目的塑造的人”，你一看就知道他是谁。

5. 融合（Fuse）

最高境界：目的贯穿生活所有细节。

故事精选：

• 甘地掉鞋子：火车上鞋掉了一只，他立刻把另一只也扔了下去，“好让捡到鞋的人可以穿成一对”。
• 理查德·布兰森：节目录制间隙提醒记者控制体重，关切健康，体现助人价值观。
• 埃莉诺·罗斯福：度假时听说工人罢工，立刻参与调解。

这些人已经与自己的价值观融合成一体，不管是否有人关注，他们都在践行内在使命。

乔布斯的例子：目的感的终身融合

• 小时修栅栏不刷背面，被父亲教育：“你会看到啊。”
• 日后设计 Apple 产品时，不满意内部走线布局。
• 临终前还设计病房里的 iPad 架子和设备，追求极致体验。

「士不可以不弘毅，任重而道远。仁以为己任，不亦重乎？死而后已，不亦远乎？」

结语

你是在用你的激情和才能去为你的目的服务。
你做的每一件事，都是为了那个目的。
你会发现，生命中每一分一秒都无比珍贵。

注：
[1] 用乘法是因为价值观和目标这两项只要有一项是0，目的就是0。

作者注：本篇为阅读《内部掌控，外部影响》后的内容整理与理解笔记，适合希望深度理解“目的感”与个人修炼路径的读者参考。

除了生存和发展，我们最爱干的事情大概就是炫耀。像朋友圈这样的社交网络已经成了沮丧情绪的最大来源，因为它让人高估别人的生活。不过炫耀行为的增加也加速了炫耀本身的演化，过于直白的炫耀早已不受欢迎，现在流行的是先抑后扬、以自我调侃开始以自我吹捧结束的「凡尔赛」。

但凡尔赛只是一种修辞手法，不能体现炫耀者的真实实力。在这里我们借助霍夫曼和约耶里的《隐藏的博弈》这本书讲讲高水平炫耀是怎么回事儿，也许能带给你一些趣味。

假设你在上海市中心工作，为了住得方便必须买一套比较贵的房子，你东拼西凑弄了一百万元做首付。你对朋友说，看，我这有一百万！这不是炫耀。一百万元是挺多钱，但是谁想住那里都得先弄一百万元，哪怕找亲友借也要借到。就算你工资高，可是你花销也大啊。那是你的必需品。

炫耀，必须使用奢侈品。

从博弈论的视角看，炫耀的本质是发出一个“我实力很强”的信号。而为了让这个信号可信，你必须让它既昂贵、又没有实用价值才行。比如你当众直接烧掉一百万，那别人肯定相信你是真有钱。不过烧钱是最土的方法，奢侈品不一定非得是名车名表，有些不能用金钱衡量的东西更奢侈。

霍夫曼和约耶里提出了判断奢侈品的四个标准，适用于所有等级的炫耀，万变不离其宗。什么样的东西可以算得上是奢侈品呢？

1. 它必须让人能看懂，一看就知道贵。不然你炫耀不出去。
2. 它必须是浪费的，用处不大甚至毫无用处。
3. 它必须昂贵到一般人出不起的程度。
4. 如果这个东西变便宜了，以至于人人都能拥有，人们会反而不喜欢它。

炫耀都要用到奢侈品，但是用法各不相同。现在我们把炫耀按照水平从低到高分成四个等级，看看不同人群是怎么炫耀的。

✵ 第一级：「暴发户级」

名车名表名牌包武装到牙齿，一出门必定穿金戴银披挂整齐，最好前呼后拥。暴发户的炫耀对象必定是文化程度不高的人，只看得懂最耀眼的信号。暴发户在言情剧里只能当男三号，在商战剧里负责衬托主角的智慧，在悬疑剧里……可能是被害人。

✵ 第二级：「白领级」

白领受过良好教育，有受尊敬的工作。可能收入没有暴发户高，但是他们有暴发户不懂的品味。白领炫耀的最大特点，是紧跟当前的趋势。

奢侈品是有潮流的。一旦变得普遍流行，它就不是奢侈品了。你得对此保持敏感。

• 以前很多人吃不饱，那长得胖就代表社会地位高。现在卡路里太廉价了，健身才是值得炫耀的。
• 中世纪欧洲各种调料都很贵，比如糖和黑胡椒，那时贵族的菜必须很甜很辣。后来随着贸易发展，清淡才变得高级。
• 曾经“白皮肤”在中欧代表高贵，现在在欧美“晒黑”才说明你有闲、有钱去度假。

• 白领之所以叫“白领”，是因为过去白衬衫象征着易脏、难洗 —— 贵而无用。但如今已太普遍，早已失去了“炫耀力”。

奢侈品流行趋势的关键词是「小众」。

白领级的炫耀失于过于重视外观，缺少内在的功力，门槛还不够高。

✵ 第三级：「马未都级」

这一等级在高级感的基础上要求稀缺感和门槛感，甚至发明一些规矩让人难以模仿。

• 同样是吃饭，马未都会先讲五分钟拿筷子的方法；
• 看《蒙娜丽莎》，必须去卢浮宫亲眼看；
• 英国贵族的用餐礼仪、红酒鉴赏、古典诗词格律……都有极高的学习曲线。

繁复的规则，是一种“入场费”。

比如宗教仪式、社群任务、礼节动作，目的就是把圈外人隔绝开来，圈内人更团结、更自豪。

越复杂的规则，越能建立认同感和权威感。

这是否让你想起某些微信群或圈子的门槛设置？

✵ 第四级：「索科洛夫级」

你要是不知道索科洛夫是谁，那你可能不在这一级，像我也是读了这本书才知道。

格里戈里·索科洛夫（Grigory Sokolov） 是一位俄罗斯钢琴家。

他不像郎朗那么有名，但在真正懂音乐的人看来，他才是活着最伟大的钢琴家。

• 郎朗是马未都级，他靠技巧和表现力打动人。
• 索科洛夫是「涩井」级。他弹慢曲子，讲究细腻、含蓄、有深度，真正的高手反而追求「慢」的极致。

日语里有个词，叫 渋い（Shibui），形容外表平凡但深藏力量的优雅，正是这种境界。

比如：

• 哈佛毕业的人不主动说“我上哈佛”，只说“我在波士顿上的大学”；
• 邵逸夫捐楼叫“逸夫楼”，但也有人捐楼选择匿名；
• 索科洛夫拒绝在美国演出，但他的粉丝最懂他、最珍惜他；

低调，是最贵的炫耀。

为什么？因为你能承受得起别人没收到你的信号。

“信号我发了，他们没收到，浪费了——没关系，浪费就对了。”

这种炫耀方式的核心，不是让所有人都佩服你，而是只打动圈内人。

哪怕一句话里“无意”透露出来的京都房子、慈善组织、收藏嗜好，都会被懂的人捕捉。

✵ 总结

了解了这些门道，也许你会觉得那些披金戴银的暴发户反而有点可爱。但我最想说的是：

奢侈品的动力学促进了社会进步，人们的炫耀方式会越来越优雅，往「涩井」的方向前进。

而这显然是个好消息。

郎朗就进步了。《纽约时报》在2019年专门称赞郎朗说他已经超越了明显的技巧性，现在有点索科洛夫的意境。

本文借助《隐藏的博弈：博弈论解释人类非理性行为的惊人力量》（Hidden Games: The Surprising Power of Game Theory to Explain Irrational Human Behavior）一书内容，整理演绎。

去iperf3官网安装

启动服务端

在需要测试的机器上启动服务

iperf3 s

启动测试脚本

在同网络环境下的另一台机器上启动，目标ip是上面启动的服务

#!/bin/bashecho "====== UDP 包转发率测试工具（iperf3）======"# 设置默认值DEFAULT_TARGET="192.168.31.2"DEFAULT_PKT_SIZE=64DEFAULT_BANDWIDTH=2500DEFAULT_DURATION=10read -p "请输入目标IP地址 [默认: $DEFAULT_TARGET]: " TARGETread -p "请输入包大小 (bytes) [默认: $DEFAULT_PKT_SIZE]: " PKT_SIZEread -p "请输入目标带宽 (Mbps) [默认: $DEFAULT_BANDWIDTH]: " BANDWIDTHread -p "请输入测试时长 (秒) [默认: $DEFAULT_DURATION]: " DURATION# 如果输入为空，则使用默认值TARGET=${TARGET:-$DEFAULT_TARGET}PKT_SIZE=${PKT_SIZE:-$DEFAULT_PKT_SIZE}BANDWIDTH=${BANDWIDTH:-$DEFAULT_BANDWIDTH}DURATION=${DURATION:-$DEFAULT_DURATION}echoecho "开始测试..."echo "目标IP: $TARGET"echo "包大小: $PKT_SIZE bytes"echo "带宽: $BANDWIDTH Mbps"echo "持续时间: $DURATION 秒"echo "=========================================="# 执行 iperf3 测试OUTPUT=$(iperf3 -c "$TARGET" -u -l "$PKT_SIZE" -b "${BANDWIDTH}M" -t "$DURATION" 2>&1)# 提取数据SENDER_TOTAL=$(echo "$OUTPUT" | grep sender | grep -oP '\d+(?=/)' | tail -1)RECEIVER_TOTAL=$(echo "$OUTPUT" | grep receiver | grep -oP '\d+/\d+' | head -1 | cut -d'/' -f2)LOST=$(echo "$OUTPUT" | grep receiver | grep -oP '\d+(?=/)' | head -1)RECEIVED=$((RECEIVER_TOTAL - LOST))RATE=$(echo "$OUTPUT" | grep receiver | grep -oP '\d+\.\d+ Mbits/sec' | head -1)# 计算 PPS 和丢包率if [[ "$RECEIVER_TOTAL" -gt 0 ]]; then  PPS=$(echo "scale=2; $RECEIVED / $DURATION / 1000" | bc)  LOSS_RATE=$(echo "scale=2; $LOST * 100 / $RECEIVER_TOTAL" | bc)  echo  echo "✅ 测试完成！结果如下："  echo "------------------------------------------"  echo "📦 实际接收带宽     ：$RATE"  echo "📊 包转发率（PPS）  ：$PPS Kpps"  echo "❗ 丢包率           ：$LOSS_RATE%（丢 $LOST / 共 $RECEIVER_TOTAL）"  echo "------------------------------------------"else  echo "❌ 无法获取结果，iperf3 可能未运行或目标无响应。"fi

最终成效

这里测试的是小服务器与nas之间的包转发率。

听说这很快就完事了

linux

linux中新的内核已经自带bbr，只需要启动即可，老旧内核需要先升级到4.9或者更高版本就可以开启，先检查内核版本：

uname -r

若内核版本大于4.9：

echo "net.core.default_qdisc=fq" >> /etc/sysctl.confecho "net.ipv4.tcp_congestion_control=bbr" >> /etc/sysctl.conf

应用更改：

sudo sysctl -p

检查BBR是否启用：

sysctl net.ipv4.tcp_available_congestion_control

返回值一般为：

net.ipv4.tcp_available_congestion_control = reno cubic bbr

sysctl net.ipv4.tcp_congestion_control

返回值一般为：

net.ipv4.tcp_congestion_control = bbr

sysctl net.core.default_qdisc

返回值一般为：net.core.default_qdisc = fq

lsmod | grep bbr

返回值有类似：tcp_bbr 20480 10则BBR模块已启动

如果需要关闭bbr则在/etc/sysctl.conf注释掉刚刚添加的两行并应用更改即可。

内核版本小于4.9：

这里用一键脚本安装bbr：

wget --no-check-certificate https://github.com/teddysun/across/raw/master/bbr.sh && chmod +x bbr.sh && ./bbr.shlsmod | grep bbr

windows

管理员运行cmd，输入以下命令：

netsh int tcp set supplemental Template=Internet CongestionProvider=bbr2netsh int tcp set supplemental Template=Datacenter CongestionProvider=bbr2netsh int tcp set supplemental Template=Compat CongestionProvider=bbr2netsh int tcp set supplemental Template=DatacenterCustom CongestionProvider=bbr2netsh int tcp set supplemental Template=InternetCustom CongestionProvider=bbr2

输入以下命令检测是否生效：

Get-NetTCPSetting | Select SettingName, CongestionProvider

提别提醒：windows下开启bbr可能会导致部分游戏出现网络延迟忽高忽低的情况，也可能会导致虚拟机网络异常，如果开启之后导致的出现网络异常请用下面的命令恢复。

windows恢复命令：

netsh int tcp set supplemental template=internet congestionprovider=CUBICnetsh int tcp set supplemental template=internetcustom congestionprovider=CUBICnetsh int tcp set supplemental template=Compat congestionprovider=NewRenonetsh int tcp set supplemental template=Datacenter congestionprovider=CUBICnetsh int tcp set supplemental template=Datacentercustom congestionprovider=CUBIC