36氪获悉，“今日酒价”披露的批发参考价显示，2月12日，26年飞天茅台原箱较前一日上涨25元，报1715元/瓶；26年飞天茅台散瓶价格未变，报1660元/瓶。25年飞天茅台原箱较前一日上涨25元，报1725元/瓶；25年飞天茅台散瓶价格未变，报1670元/瓶。近期热门生肖马茅价格未变，报2100/瓶。

原文：Is it scrolled? Is it not? Let's find out with CSS @container scroll-state() queries

翻译：TUARAN

欢迎关注 {{前端周刊}}，每周更新国外论坛的前端热门文章，紧跟时事，掌握前端技术动态。

过去几年里，我们经常需要用 JavaScript（滚动事件、Intersection Observer）来回答一些看似简单的问题：

• 这个 sticky 头部现在真的“贴住”了吗？
• 这个 scroll-snap 列表现在“吸附到哪一项”了？
• 这个容器是否还能继续滚？左边/右边还有没有内容？

而 @container scroll-state（本文简称“scroll-state 查询”）提供了一种 CSS 原生的状态查询方式：容器可以根据自己的滚动状态，去样式化子元素。

快速回顾：scroll-state 查询怎么用

先把某个祖先设置为 scroll-state 容器：

.scroll-ancestor {
  container-type: scroll-state;
}

然后用容器查询按状态应用样式：

@container scroll-state(stuck: top) {
  .child-of-scroll-parent {
    /* 只有“贴住顶部”时才生效 */
  }
}

Chrome 133：三件套（stuck / snapped / scrollable）

1) stuck：sticky 是否真的“贴住”了

当你用 position: sticky 做吸顶 header 时，常见需求是：只有在 header 真的贴住时才加背景、阴影。

.sticky-header-wrapper {
  position: sticky;
  inset-block-start: 0;
  container-type: scroll-state;
}

@container scroll-state(stuck: top) {
  .main-header {
    background-color: var(--color-header-bg);
    box-shadow: 0 4px 15px rgba(0, 0, 0, 0.2);
  }
}

2) snapped：当前吸附项

对于 scroll-snap 画廊，你往往想高亮当前吸附项，例如放大当前卡片、改变滤镜。

.horizontal-track li {
  container-type: scroll-state;
}

@container scroll-state(snapped: inline) {
  .card-content img {
    transform: scale(1.1);
    filter: sepia(0);
  }
}

3) scrollable：某个方向上是否“还能滚”

这类需求过去常靠 JS 读 scrollLeft/scrollWidth/clientWidth。现在可以按方向做样式：

@container scroll-state(scrollable: left) {
  .scroll-arrow.left {
    opacity: 1;
  }
}

@container scroll-state(scrollable: right) {
  .scroll-arrow.right {
    opacity: 1;
  }
}

Chrome 144：新增 scrolled（最近一次滚动方向）

写作时 Chrome 144 带来了 scrolled，用于判断“最近一次滚动的方向”。这让一些常见的 UI 模式可以不写 JS：

经典的“hidey-bar” 头部

html {
  container-type: scroll-state;
}

@container scroll-state(scrolled: bottom) {
  .main-header {
    transform: translateY(-100%);
  }
}

@container scroll-state(scrolled: top) {
  .main-header {
    transform: translateY(0);
  }
}

“滚动提示”只在第一次交互后消失

例如横向滚动容器：用户一旦横向滚过，就隐藏提示。

@container scroll-state(scrolled: inline) {
  .scroll-indicator {
    opacity: 0;
  }
}

小结

scroll-state 查询把一部分“滚动状态机”的能力下放给 CSS：

• 能做渐进增强时，UI 代码会更轻、更稳定；
• 状态可由浏览器内部实现，避免滚动事件带来的性能与时序问题；
• 但要大规模依赖，还需要更完整的跨浏览器支持。

进一步阅读：

• Directional CSS with scroll-state(scrolled)：una.im/scroll-stat…

原文：Measuring SVG rendering time

翻译：TUARAN

欢迎关注 {{前端周刊}}，每周更新国外论坛的前端热门文章，紧跟时事，掌握前端技术动态。

本文想回答两个很直接的问题：

• 大型 SVG 的渲染是否显著比小 SVG 慢？有没有一个“超过就很糟糕”的尺寸阈值？
• 如果把这些 SVG 转成 PNG，渲染表现会怎样？

为此，作者生成了一批测试图片，并用自动化脚本测量“点击插入图片到下一次绘制”的时间（INP 相关）。

测试图片

一个 Python 脚本（gen.py）生成了 199 个 SVG 文件：

• 1KB 到 100KB：每 1KB 一个
• 200KB 到 10MB：每 100KB 一个

每个 SVG 都是 1000×1000，包含随机的路径、圆、矩形等形状；颜色、位置、线宽随机化。

然后用 convert-to-png.js（Puppeteer）把所有 SVG 转成 PNG：

• omitBackground: true（保持透明背景）
• 转完再过一遍 ImageOptim

作者用 chart-sizes.html 展示了 SVG 与 PNG 的文件大小分布：SVG 一路可以到 10MB，但 PNG 很少到那么大；在小尺寸区间往往 SVG 更小，而超过约 2MB 后，PNG 反而更小。

（原文附图）

接下来是渲染测试页：一次只渲染一张图。

测试页面

test.html 接受文件名参数，例如：?file=test_100KB&type=svg。

页面逻辑：

• 用 new Image() 预加载图片（因为我们不关心下载时间，只关心渲染）
• 预加载完成后显示一个 “inject” 按钮
• 点击按钮后，把图片 append 到 DOM

为了捕获交互到绘制的成本，用 PerformanceObserver 监听 event entries，并计算 INP 分解：

• input delay
• processing duration
• presentation delay

其中 presentation delay 指点击处理结束到浏览器实际绘制的时间；作者主要关注最终的 INP。

new PerformanceObserver((list) => {
  for (const entry of list.getEntries()) {
    if (entry.name === 'pointerup' || entry.name === 'click') {
      const inputDelay = entry.processingStart - entry.startTime;
      const processingDuration = entry.processingEnd - entry.processingStart;
      const presentationDelay =
        entry.duration - (entry.processingEnd - entry.startTime);
      const totalINP = entry.duration;
      // ...
    }
  }
}).observe({ type: 'event', buffered: true, durationThreshold: 16 });

自动化测量

measure.js 是一个 Puppeteer 脚本，流程大致是：

• 启动 Chrome
• 对每个测试文件：
  • 先打开 blank.html 重置状态
  • 再打开带参数的 test.html
  • 等预加载完成
  • 开始 DevTools trace
  • 点击 inject，把图片插入 DOM
  • 等待 PerformanceObserver 回报
  • 停止 trace
  • 从 observer 与 trace 中提取 INP
• 每个文件跑 3 次，取中位数
• 输出 JSON 结果

命令行参数：

• --png：测 PNG（默认测 SVG）
• --throttle=N：CPU 降速（例如 --throttle=4 表示 4× 变慢）
• --output=file.json：输出文件名

作者试过开/不开 throttle，整体趋势不变，差别主要体现在绝对耗时变大。

开跑

node measure.js --svg --output=results-svg.json
node measure.js --png --output=results-png.json

结果

可以在 chart.html 查看完整图表。

SVG 结果（全量）：

SVG 结果（<= 1MB）：

PNG 结果：

作者观察到：

• PerformanceObserver 的 INP 与 profiler 的 INP 很接近
• SVG 的渲染时间呈现一种“阶梯式”增长：
  • 小于约 400KB 的 SVG，渲染耗时差不多
  • 之后会在某些区间出现明显跃迁（例如约 1.2MB）
• PNG 也似乎有类似阶梯，但由于 1–2MB 区间样本较少，不如 SVG 明显
• 不管格式如何，400KB 以下基本都在同一渲染档位；当文件更大时，尤其是非常大时，PNG 倾向更快

作者还展示了生成图片的样子（例如 60KB 的 SVG），更大文件只是叠加更多形状以提高体积：

作者 | 张子怡

编辑 | 袁斯来

硬氪获悉，农业具身智能企业「禾芯动力」已于近日完成数千万元天使轮融资，投后估值达5亿元人民币。本轮投资由宜宾高新前沿科技产业创业投资基金与厦门国升追创机器人产业创业投资基金联合完成。本轮融资资金将主要用于核心产品迭代、全球场景拓展及人才引进。

禾芯动力成立于2025年，公司主攻“农业具身智能”方向，通过研发无人机、机器人及智能终端，解决农业劳动力短缺及作业标准化问题。目前，其产品线覆盖植保、巡检、采摘、运输、除草五大场景。

当前，农业自动化正面临从“机械化”向“智能化”转型的关口。传统自动化设备难以适应非标准化的田间作业环境，而具备高阶自主能力的机器人方案长期受制于海外产品的高昂定价，市场渗透率有限。数据显示，随着AI与机器人技术的结合，农业机器人市场规模正快速增长，全球市场规模预计到2030年将达到800亿元。

面对这一市场痛点，禾芯动力确立了“国内研发、全球落地”的商业策略。在技术端，公司联合清华大学、中国农科院及哈尔滨工业大学，重点攻克环境感知、农业专用AI模型、机器人运动控制及多机协同等底层技术。

在核心技术层面，禾芯动力并未采用通用的集成方案，而是从底层硬件与算法入手构建壁垒。硬件方面，公司掌握高速数字马达核心技术，已实现18万转至20万转/分钟马达的量产，该技术具备高推重比与高能源效率，被应用于其无人机与机器人动力系统中。

在算法与软件层面，针对植保场景，禾芯动力研发了施药飘移预测平台，通过风洞实验与悬滴法分析，明确了药液在不同飞行条件下的沉积与飘移规律。同时，公司构建了YOLO-Fi算法模型，能够适应烟草、主粮等特定作物的识别与定位需求，配合多光谱图像与RTK数据，实现精准变量喷洒。

基于上述技术，禾芯动力推出了多款针对性产品。其植保无人机系列，包括针对烟草等高杆作物的P70，以及针对水稻连片作业的P100S。通过优化气流与喷头布局，P70在烟草植保中可增强喷头穿透力，使药液更有效包裹整株作物。

农业机器人系列则是重点推出了温室蘑菇采摘机器人、巡检机器人与除草机器人。

蘑菇采摘机器人解决了传统自动化设备成本高、需改造产线的痛点。禾芯动力表示，相比国际竞品4AG Robotics超100万美元的售价，禾芯动力的解决方案成本控制在20万元人民币以内，且无需改造现有产线，机器人可直接进场工作，人效比达到2.5:1。

无人巡检机器人采用多足越野底盘或混联机械轮设计，具备越障能力，搭载视觉与激光雷达融合导航系统，可实现全天候监测与作物病害预警。

除草机器人基于RTK+视觉融合定位技术，田间通过率大于99%，并搭载自研的精准识别与分割算法，对主要杂草的精准识别准确率提升至98%，通过物理根除实现零化学农药的洁净农业。

商业化进展方面，禾芯动力采用了“研发在深圳、生产在内地、市场在全球”的策略。目前，公司已交付机器人10台，并在真实场景完成验收，多场景手握订单超百台，总金额达数千万元人民币。

在全球化布局上，禾芯动力已进入中亚、南美、非洲等市场。公司在尼日利亚建设了15平方公里的数智种植实验基地，进行无人机与机器人的商用测试。此外，公司计划在土耳其建立销售网络，并与俄罗斯当地企业合作研发耐寒农业设备。

团队方面，禾芯动力创始人兼CEO赵锋拥有14年农业战略投资经验，曾负责中非农业自贸区等多个跨国农业项目。CTO孙士龙为哈尔滨工业大学博导，曾主持多项国家级机器人与精准农业装备课题。CFO张疆曾任瑞银证券及华兴资本农业首席分析师。

赵锋表示，禾芯动力的目标是成为全球农田的标准化智能生产力单元，通过“具身智能”技术，让机器人能够理解农艺要求并适应非结构化的田间环境。随着全球农业自动化需求的增长，公司将持续推动产品在多国规模化农场的落地应用。

36氪获悉，2月10日，百度文心公布数据：自春节红包活动启动以来，文心助手MAU同比增长4倍；其中，生图功能调用量同比增长50倍，生视频功能同比增长40倍，AI打电话功能增长近4倍。

修复前

操作步骤

1、修改tsconfig.json，如下所示：

2、然后在vue.server 修改配置增加 include languages 增加一个nvue。可以ctrl/cmd + ,唤起

3、然后在files.associations增加 *.nvue------vue

修复后

前言

如果一个前端架构师对 nginx.conf 感到陌生，对 Dockerfile 感到恐惧，那他所谓的“效能优化”注定是虚幻的。

真正的交付体系，是让开发者从点击“Merge”的那一刻起，就能预见到代码在生产环境的完美运行。

---

一、 容器化：终结“我本地是好的”

前端环境看起来简单（不就是个 Node.js 吗？），但 Node 版本差异、构建依赖库（如 node-sass）的编译环境、甚至是操作系统层面的字符集，都会导致构建结果的偏差。

在没有 Docker 的时候，前端代码就像裸奔。你本地用 Node 18 编译得好好的，发到服务器上发现运维装的是 Node 14，结果因为一个可选链语法（?.）直接报错挂掉。

• 锁定新鲜度： Docker 把代码需要的 Node 版本、甚至系统底层依赖全部打包在一起。
• 拒绝对齐： 你不需要求着运维去升级服务器的 Node 环境。你的镜像自带 Node，服务器只需要支持运行 Docker 即可。

1.1 Docker 是前端的“保鲜膜”

不要再在服务器上直接安装 Node 环境。通过 Docker，我们将**“构建环境 + 运行时环境 + 静态资源”**打包成一个只读的镜像。

• 一致性： 开发、测试、生产使用同一个镜像，环境抖动率降为零。
• 分层构建 (Multi-stage Builds)： 这是前端镜像瘦身的必修课。

最佳实践示例：

1. 第一阶段（Build）： 使用 node 镜像安装依赖并执行 npm build。
2. 第二阶段（Production）： 丢弃 Node 环境，只将 dist 产物拷贝到极简的 nginx:alpine 镜像中。

结果： 镜像体积从 1GB 缩减到 20MB。

那么有人肯定会问了, 为什么呢?

第一阶段：重装武器的“工地”（Build Stage）

• 任务： npm install 下载成千上万个 node_modules。
• 重量： 包含整个 Node.js 运行时、各种编译工具、缓存文件。
• 结果： 这一层就像个巨大的厨房，占用了 1GB 空间，但这只是为了烤出一块饼干。

第二阶段：极简的“展示柜”（Production Stage）

• 任务： 只要第一阶段生成的 /dist 静态文件夹。
• 操作： 扔掉沉重的 Node 厨房，拿出一个只有几 MB 大小的 Nginx（静态资源服务器）。
• 结果： 最终交付的镜像里只有 Nginx + 你的 HTML/JS。体积瞬间缩减到 20MB 左右。

---

对比总结：为什么这是最佳实践？

维度	传统方式（直接装 Node）	Docker 多阶段构建
部署风险	高（“我本地明明是好的”）	极低（镜像即环境，全球统一）
服务器要求	必须安装指定版本的 Node/npm	只需安装 Docker，零环境依赖
传输效率	慢（传输 1GB 镜像到仓库）	快（20MB 镜像秒传）
安全性	源代码和 node_modules 暴露在生产环境	极高（只包含打包后的产物，源码不可见）

二、 CI/CD：自动化是效能的唯一出路

如果你还在手动运行脚本并上传产物，你不仅在浪费时间，还在制造事故。

2.1 现代前端流水线的“四道关卡”

一个合格的 CI/CD 管道（Pipeline）应该像工厂流水线一样严丝合缝：

1. 检测关 (Lint & Type Check)： 拒绝任何格式不符或 TS 类型报错的代码进入构建。
2. 质量关 (Test)： 运行单元测试和关键路径的 E2E 测试。
3. 构建关 (Build & Scan)： 云端构建，并自动扫描镜像漏洞和第三方库安全。
4. 分发关 (Deploy)： 自动推送到镜像仓库，并触发 K8s 或 CDN 更新。

---

三、 Nginx：前端架构的“守门神”

Nginx 不仅仅是反向代理，它是前端架构在网络层的延伸。

3.1 前端必须掌握的 Nginx 绝学

• 单页应用 (SPA) 路由支持： 解决刷新页面 404 的顽疾。 location / { try_files $uri$uriuri/ /index.html; }

• 极致压缩： 同时开启 Gzip 和 Brotli。Brotli 的压缩率比 Gzip 高 20%，对 JS/CSS 提速效果极其显著。

• 缓存策略治理： * index.html：设置 no-cache，确保用户总能拿到最新的入口。

  • static assets (带 hash 的资源)：设置 max-age=1y，实现永久缓存。

3.2 动态配置与 BFF 联通

在微前端或 BFF 架构下，Nginx 承担了流量分发的重任。架构师应学会利用 Nginx 的 proxy_pass 解决跨域问题，而不是在代码里写死 API 地址。

---

四、 架构演进：从“全量发布”到“优雅灰度”

交付的最高境界是：用户对发布无感知，且出错可秒级回滚。

• 蓝绿部署 (Blue-Green)： 同时存在两套环境，一键切换流量。
• 金丝雀发布 (Canary)： 先让 5% 的用户试用新版，观察监控指标（错误率、白屏率）无异常后再全量推开。
• 核心逻辑： 这种能力通常依赖于 K8s 的 Ingress 配置或 CDN 的边缘计算（Edge Functions）。

---

五、 总结：交付是架构的归宿

没有稳健的交付，再精妙的代码也是空中楼阁。 当我们把 Docker、CI/CD 和 Nginx 揉碎并内化到前端研发流程中时，我们打通的不只是技术链路，更是团队的信任链路。

架构师不应该只是“写代码的人”，更应该是“制定生产规则的人”。

---

结语：迈向“研发中台”

我们打通了零件（物料）和通路（交付），但随着业务线增加，每个项目都去配一套 Jenkins、写一遍 Dockerfile、调一遍 Nginx 依然是低效的。

我们需要一套**“一站式”**的系统，把这些能力封装起来，让开发者只需要关心业务逻辑。

Next Step:

既然每一个环节都已标准化，那我们为什么不把它们做成一个产品？ 下一节，我们将讨论前端基建的集大成者。 我们将探讨如何通过平台化思维，彻底终结“人肉配置”时代。

36氪获悉，港股智谱一度涨超12%，现涨10.24%，公司上调AI编程订阅套餐价格并将推出新模型。

作者 | 张子怡

编辑 | 袁斯来

大疆躺着赚钱的赛道，终于被更凶悍庞大的对手纳入狙击范围。

近日，vivo官方确认正式立项独立vlog相机产品，产品形态将直接对标大疆Osmo Pocket系列。而此前，媒体曾报道OPPO的首席产品官刘作虎，正亲自带队攻坚类似产品。

OPPO和vivo这样经历过无数血战，仍然屹立不倒的巨头，绝非大疆想要遭遇的对手。

但这场交锋，在Pocket 3爆红的那一刻已经埋下伏笔。

很少有消费电子单品能在很长一段时间中独占市场，大疆Osmo Pocket 3做到了。根据媒体报道，Pocket 3全球销量一年就超千万台，单款产品贡献营收超200亿元。由于产能不足，过去很长一段时间里，Osmo Pocket 3被戏称为“电子茅台”，二手溢价一度超过30%。直到大疆去年下半年主动降价，一货难求的故事才宣布告终。

大疆Osmo Pocket 3（图源/官网）

更重要的是，在用户心智中，云台相机某种程度上已经等同于“大疆Pocket”——无数消费电子公司渴望拿下的品类定义者角色，大疆似乎很轻松地收入了囊中。

如果放在5年前，手机厂商或许不会重注投入这一个品类。几家头部手机公司每年营收数千亿，比起手机、IoT这样的大赛道，Pocket这类产品投入产出比并不高。

“前两年手机还能折腾的时候，根本看不上Pocket这种品类，手机厂的人眼光比较高，只做大生意。而且之前手机IoT生意大且没那么艰难。”有手机厂商人士对硬氪分析。

如今，200亿营收的产品，也显出了诱惑力。“之前大家没意识到这是块儿肥肉，现在补品类做增量好挣钱。”另一位手机行业的人士评价。

这种故事的走向，对大疆来说有些苦涩。他们用整整七年时间验证了过去未被发现也未被证明的市场——Vlog创作者和旅行爱好者的拍摄需求。大疆前两代产品虽然新奇，但都只卖了百万台，三代产品的持续迭代才让Osmo Pocket 3成为终极“爆品”。

不过，这也是消费电子赛道公司必然迎接的战役。在3C产业链极度发达的中国，不可能有一家公司靠某个爆款长久地躺着挣钱，永恒的战斗才是他们的宿命。

当然，云台相机的制造壁垒其实并不低。Pocket 3之前，不少中小厂商倒在品类爆发前夜。即便手机厂商入场，也无法挖走大疆全部市场。但毫无疑问，影像硬件赛道群雄逐鹿的时代，终究发生在2026年。

01 越过云台壁垒却倒下的“先烈”

回溯Pocket 3的胜出轨迹，可以明显看到大疆在行业中领先的技术、资金和营销调度实力。

初代Pocket是大疆当时推出最小的三轴机械增稳云台相机，解决了用户在“手机拍不稳”和“专业太笨重”之间的需求空白地带，其物理云台在当时很好的弥补了手机拍摄采用的电子防抖技术所造成的画质下降问题。

迄今为止，云台增稳技术都是大疆Pocket系列产品的灵魂存在。

2020年前后，彼时Osmo Pocket 1 代刚刚验证了市场需求，一批嗅觉灵敏的硬件厂商曾蜂拥而入。魔爪（Moza）、飞宇（Feiyu）、随拍（Snoppa）都相继推出了云台相机。

这三家公司都有做手机云台和专业相机稳定器的经验和基因。魔爪曾经是“折叠手机云台”的推动者之一；飞宇则主营云台相机、手持稳定器等产品；随拍的Snoppa Atom也曾是其手机云台代表作，在海外众筹平台积累了不错的口碑。

其中命运最曲折的是随拍科技。

Snoppa Vmate发布于2019年，彼时大疆第一代Osmo Pocket 虽然开创了新品类，但有不少短板：屏幕太小，使得用户难以看清构图；无独立Wifi传输能力，需要蓝牙直联手机；不支持竖拍模式。

Snoppa Vmate的策略则是针对Osmo Pocket打补丁，其云台镜头可以物理旋转90度。让用户握持手柄的姿势不变，自由在横屏拍摄和竖屏拍摄之间切换——大疆直到 Pocket 3才通过旋转屏幕解决了竖拍构图问题。Vmate内置的Wi-Fi模块可以实现无线图传。这些设计在当时都非常先进。

然而，成也图传，败也图传。由于天线设计和软件优化不足，Vmate的图传经常卡顿、断连。用户在手机上看到的画面有几秒钟的延迟，难于实时监看。天才般的云台镜头旋转设计落地到实际生产层面也遇到问题，早期批次的Vmate品控较差，有的云台歪头，有的麦克风没声音。

更尴尬的是，当SnoppaVmate于2020年下半年开始大规模铺货并修复固件bug时，大疆Pocket 2发布了。Pocket 2拥有更大的传感器、更好的收音、更广的视角，硬件能力远胜于Vmate。还未来得及开发第二代产品，Vmate因芯片断供彻底退出云台相机的舞台。

唯一还在坚持出新品的是飞宇，他们也推出了类似产品，分体磁吸玩法比大疆更为灵活，价格不到2000元，远低于大疆Pocket 3。然而，飞宇的Pocket 3解决了云台防抖的问题，却并没能提升太多画质。

而大疆Osmo Pocket 3所采用的一英寸大底传感器，让其在夜景、色彩、后期空间表现上远超于同行，“拍得好看”成为Osmo Pocket 3风靡许久的重要原因。

有智能影像行业的市场营销人士回忆：“Pocket有个很出圈的营销，大概是跟iPhone做对比，它拍的东西会比iPhone还好看。但其实它取巧的是对比iPhone的前摄镜头。它肯定不能跟iPhone的后摄去对比，但这个营销方法还是很有意思的。而且上了一英寸大底之后，画质更好，创作者又是很重视画质，会让更多人觉得能用了，甚至能取代一些场景里对单反的需求。”

不止如此，在上述人士看来，Osmo Pocket 3更难复制的点在于，其已成为视频创作者的必备品。Pocket 3的系统设计符合视频创作者的需求，更重要的是大疆有丰富的产品矩阵，比如可以和无人机做搭配完成整套拍摄。

大疆Osmo Pocket 3（图源/官网）

事实上，使用一英寸传感器对硬件企业的工程化能力要求极高，要同时解决相机体积问题、散热问题和配套的算法。这不是飞宇这类中小厂商能够具备的能力，同样的，定位中低端的飞宇Pocket 3也没有大疆成熟的生态布局，

有云台技术基因的厂商或许能跟风推出产品，但都有软件能力、影像能力上的欠缺，云台相机仍然是极考验综合能力的单品。智能影像中小厂商眼前仍有难以逾越的鸿沟。

“大疆出Pocket第一代的时候，还有很多模仿者，到第三代的时候，模仿门槛上去了，几乎再没见到过同类产品。”一位智能影像企业资深从业人士告诉硬氪。

大疆凭借足够强悍的实力站稳桥头。但手机厂商入局，将行业带到一片和过去全然不同的战场，更加凶险和未知。

02 猛兽出山

OPPO的掌舵人陈明永喜欢围棋，也下得一手好棋。表面看，OPPO的动作也如《围棋十诀》中所论：入界宜缓。这也是行业中人对OPPO固有的印象：敢为人后，但很多时候一击必中。

而在vivo和OPPO中，后者甚至是更激进的那一个：vivo行事更稳健、低调。

然而，这两家公司绝非温吞之辈。它们在中国这样电子消费公司的绞肉机中存活下来，在需要装甲部队护送的国家开拓出渠道，不会缺少倾略性的一面。

“这几家能在手机行业活着，实力都不差，只不过一直在和更强的对比。去其他行业基本都是降维打击，比如小米去做汽车，一两年左右就改了市场格局。”一位手机大厂前员工分析。

对于能调动庞大资源的手机厂商，成败关键是话事人投入的决心。

而他们正面临一场海啸。随着三星、海力士等厂商将业务转移到AI使用的高带宽内存，手机厂商使用的内存产量减少，价格暴涨。

根据Counterpoint《2月内存价格追踪报告》显示，截至2026年第一季度，内存价格环比上涨80%-90%，创下历史纪录。用一位手机行业人士对硬氪的形容，大家都遇到“灭顶之灾”。

这些巨兽已经爆发出寻找出路的本能。

况且，影像赛道一直是手机厂商的老本行。OPPO、vivo在手机影像上都积累了十多年，软件算法早已逼近提升的临界点。

过去，他们尝试过以外接硬件拓展边界，vivo X200 Ultra就引入了外挂的增距镜。但对比在手机上接长枪短炮，经过市场验证的Pocket 3是更安全和可控的选择。

OPPO和vivo也不太需要做用户教育。“OV很适合搞云台相机，符合他们的用户心智。很多人都喜欢vivo x300pro的拍照，Pocket的原点人群其实差不多。”一位智能手机业内人士告诉硬氪。

至于硬件本身，关注硬件行业的投资人认为：硬件产品的壁垒都是暂时的，Pocket确实有着定制的元器件和算法调优的优势，但这都是“非常工程化的事情”，没有打不破的壁垒。在巨大的利益面前，会有不同的结盟，供应商、渠道商一起参与后都有可能打破大疆的垄断。

而不止一位手机厂商员工也告诉硬氪，技术本身“对于卷了这么多年的手机厂商，都不是事。”

除了影像算法和用户上的优势，OPPO和vivo最让人生畏的，是他们广阔的销售渠道。

根据谷歌地图的统计，大疆在全球的实体店（包含各类经销商）数量在数千家左右，而vivo在全球的线下实体店则超过30万家。

两者开设实体店的逻辑可能略有不同。前者构建的是“体验+教学+社群”的销售模式，后者则是强销售逻辑。而大疆在硬件厂商中，渠道建设算得上完善。

“大疆的产品流速很快，动销率很高，产品也基本没有竞争对手。所以大疆对授权商的把控度很高，一是能做到全球产品价格基本统一（去除关税因素），二是不允许代理商主动降价。”一位大疆前销售人士告诉硬氪。

但显然，大疆的渠道商并没有经历过手机品牌那种巷战。OPPO、vivo的核心代理都是从基层一点点打下地盘的铁军，而OPPO、vivo向来对渠道也极为大方。作为利益共同体，渠道很乐于引入Pocket这样高利润的产品。只要OPPO和vivo有10%的门店能转化成功，对大疆来说都是量级上的冲击。

当然，不能忽视的是，大疆的Osmo Pocket 3是款高度集成的产品，它不仅完美继承了大疆在微型云台上的技术能力，也在影像算法、软件生态上有极大的优势。

在社交媒体上，不少人会分享Osmo Pocket 3的拍摄参数，如何拍出富士相机的滤镜、海边蓝调、胶片复古、韩女氛围感.......参数分享背后是大疆软硬件结合的能力和沉淀。

“硬件可能都是那么回事，但难的是软件生态和社区，调色、剪辑的Know-how大疆已经运用在其整个产品生态里，这些从零开始的学习成本很高。”另一位关注硬件行业的投资人告诉硬氪。

终局还远未到来。

36氪获悉，离岸人民币兑美元涨破6.90关口，为2023年4月份来首次。

36氪获悉，创业板指涨超1%，沪指涨0.03%，深成指涨0.44%，算力、液冷服务器、CPO、半导体等方向领涨，沪深京三市上涨个股超1700只。

36氪获悉，证监会网站披露，西安聚能超导磁体科技股份有限公司于2026年2月11日在陕西证监局办理辅导备案登记，拟向不特定合格投资者公开发行股票并上市，辅导机构为中信建投证券。

36氪获悉，商务部办公厅发布关于做好2026年春节假期消费品以旧换新工作的通知。通知提出，顺应春节年俗、增添年味，鼓励消费者走出家门消费购物，2026年春节9天假期内（2月15—23日），充分保障消费者通过线下渠道申领家电以旧换新、数码和智能产品购新补贴。对在春节9天假期内购买新车的消费者，均可按政策要求申领汽车以旧换新补贴。

当我们的应用变慢，甚至崩溃时，这可能并不是代码逻辑问题，而是内存和性能问题。理解V8引擎的工作原理，掌握性能分析和优化技巧，是现代JavaScript开发者必备的核心能力。

前言：从一次真实的内存泄漏说起

class User {
    constructor(name) {
        this.name = name;
        this.element = document.createElement('div');
        this.element.textContent = `用户: ${name}`;
        // 将DOM元素存储在类实例中
        this.element.onclick = () => this.handleClick();
        document.body.appendChild(this.element);
    }
    handleClick() {
        console.log(`${this.name} 被点击了`);
    }
    // 缺少清理方法！
}

// 使用
const users = [];
for (let i = 0; i < 1000; i++) {
    users.push(new User(`用户${i}`));
}

上述代码存在几个问题：

1. 即使删除users数组，User实例也不会被垃圾回收：因为DOM元素和事件监听器仍然保持引用
2. 内存使用会持续增长，直到页面崩溃

这个简单的例子展示了 JavaScript 内存管理的复杂性，本篇文章将深入讲解其背后的原理。

JavaScript内存管理基础

内存的生命周期：分配 → 使用 → 释放

1. 内存分配

// 原始类型：直接分配在栈内存
let number = 42;           // 数字
let string = 'hello';      // 字符串
let boolean = true;        // 布尔值
let nullValue = null;      // null
let undefinedValue;        // undefined
let symbol = Symbol('id'); // Symbol
let bigInt = 123n;         // BigInt

// 引用类型：分配在堆内存，栈中存储引用地址
let array = [1, 2, 3];     // 数组
let object = { a: 1 };     // 对象
let functionRef = () => {}; // 函数
let date = new Date();     // Date对象

2. 内存使用

function processData(data) {
  // 创建局部变量
  const processed = data.map(item => item * 2);

  // 创建闭包
  const counter = (() => {
    let count = 0;
    return () => ++count;
  })();

  // 使用内存
  console.log('处理数据:', processed);
  console.log('计数:', counter());

  // 内存引用关系
  const refExample = {
    data: processed,
    counter: counter,
    self: null // 自引用
  };
  refExample.self = refExample; // 循环引用

  return refExample;
}

3. 内存释放（垃圾回收）

function createMemory() {
  const largeArray = new Array(1000000).fill('x');
  return () => largeArray[0]; // 闭包保持引用
}

let memoryHolder = createMemory(); // 创建闭包并保持引用

// 手动释放引用
memoryHolder = null;

垃圾回收算法

1. 引用计数（Reference Counting）

class ReferenceCountingExample {
  constructor() {
    this.refCount = 0;
  }

  addReference() {
    this.refCount++;
    console.log(`引用计数增加: ${this.refCount}`);
  }

  removeReference() {
    this.refCount--;
    console.log(`引用计数减少: ${this.refCount}`);
    if (this.refCount === 0) {
      console.log('没有引用，可以回收内存');
      this.cleanup();
    }
  }

  cleanup() {
    console.log('执行清理操作');
  }
}

引用计数算法的问题：当A和B相互引用时，即使外部不再引用A和B，引用计数也不为0，无法回收。

2. 标记清除（Mark-and-Sweep）

class MarkAndSweepDemo {
  constructor() {
    this.marked = false;
    this.children = [];
  }

  // 模拟标记阶段
  mark() {
    if (this.marked) return;

    this.marked = true;
    console.log(`标记对象: ${this.name || '匿名对象'}`);

    // 递归标记所有引用的对象
    this.children.forEach(child => child.mark());
  }

  // 模拟清除阶段
  static sweep(objects) {
    const survivors = [];

    objects.forEach(obj => {
      if (obj.marked) {
        obj.marked = false; // 重置标记
        survivors.push(obj);
      } else {
        console.log(`回收对象: ${obj.name || '匿名对象'}`);
        obj.cleanup();
      }
    });

    return survivors;
  }

  cleanup() {
    console.log('清理对象资源');
  }
}

内存泄漏的常见模式

意外的全局变量

示例1：忘记声明变量

function createGlobalVariable() {
  // 错误：忘记写 var/let/const
  globalLeak = '这是一个全局变量'; // 实际上：window.globalLeak = ...
  console.log('创建了全局变量:', globalLeak);
}

示例2：this指向全局

function accidentalGlobalThis() {
  // 在非严格模式下，this指向window
  this.leakedProperty = '意外添加到window';
  console.log('this指向:', this === window);
}

示例3：事件监听器的this问题

const button = document.createElement('button');
button.textContent = '点击我';

button.addEventListener('click', function() {
  // 这里的this指向button元素
  this.clicked = true; // 正确：添加到DOM元素
  window.leakedFromEvent = '来自事件的泄漏'; // 错误：添加到window
});

解决方案

1. 使用严格模式

'use strict';

2. 使用let/const

function safeFunction() {
  const localVar = '局部变量';
  let anotherLocal = '另一个局部变量';
}

3. 使用模块作用域

(function() {
  var moduleScoped = '模块作用域变量';
})();

4. 使用类字段

class SafeClass {
  // 类字段自动绑定到实例
  leaked = '不会泄漏到全局';

  constructor() {
    this.instanceProperty = '实例属性';
  }

  method() {
    const localVar = '局部变量';
  }
}

遗忘的定时器和回调

示例1：未清理的定时器

class TimerLeak {
  constructor(name) {
    this.name = name;
    this.data = new Array(10000).fill('timer data');

    // 启动定时器但忘记清理
    this.intervalId = setInterval(() => {
      console.log(`${this.name} 定时器运行中...`);
      this.processData();
    }, 1000);
  }

  processData() {
    // 模拟数据处理
    return this.data.map(item => item.toUpperCase());
  }

  // 缺少清理方法！
}

示例2：未移除的事件监听器

class EventListenerLeak {
  constructor(elementId) {
    this.element = document.getElementById(elementId) ||
      document.createElement('div');
    this.data = new Array(5000).fill('event data');

    // 添加事件监听器
    this.handleClick = this.handleClick.bind(this);
    this.element.addEventListener('click', this.handleClick);

    // 添加多个监听器
    this.element.addEventListener('mouseenter', this.handleMouseEnter.bind(this));
    window.addEventListener('resize', this.handleResize.bind(this));
  }

  handleClick() {
    console.log('元素被点击');
    this.processData();
  }

  handleMouseEnter() {
    console.log('鼠标进入');
  }

  handleResize() {
    console.log('窗口大小改变');
  }

  processData() {
    return this.data.slice();
  }

  // 忘记在销毁时移除监听器
}

示例3：Promise和回调地狱

class PromiseLeak {
  constructor() {
    this.data = new Array(10000).fill('promise data');
    this.pendingPromises = [];
  }

  startRequests() {
    for (let i = 0; i < 10; i++) {
      const promise = this.makeRequest(i)
        .then(response => {
          console.log(`请求 ${i} 完成`);
          this.processResponse(response);
        })
        .catch(error => {
          console.error(`请求 ${i} 失败:`, error);
        });

      this.pendingPromises.push(promise);
    }
  }

  makeRequest(id) {
    return new Promise(resolve => {
      setTimeout(() => {
        resolve({ id, data: this.data });
      }, Math.random() * 3000);
    });
  }

  processResponse(response) {
    // 处理响应
    return response;
  }

  // 忘记清理pendingPromises数组
}

解决方案

1. 正确的定时器管理

class SafeTimer {
  constructor(name) {
    this.name = name;
    this.data = new Array(1000).fill('safe data');
    this.intervals = new Set();
    this.timeouts = new Set();
  }

  startInterval(interval = 1000) {
    const id = setInterval(() => {
      console.log(`${this.name} 安全运行`);
    }, interval);

    this.intervals.add(id);
    return id;
  }

  startTimeout(delay = 2000) {
    const id = setTimeout(() => {
      console.log(`${this.name} 超时执行`);
      this.timeouts.delete(id);
    }, delay);

    this.timeouts.add(id);
    return id;
  }

  cleanup() {
    console.log(`清理 ${this.name}`);

    // 清理所有定时器
    this.intervals.forEach(id => clearInterval(id));
    this.timeouts.forEach(id => clearTimeout(id));

    this.intervals.clear();
    this.timeouts.clear();

    // 清理数据
    this.data.length = 0;
  }
}

2. 使用WeakRef和FinalizationRegistry

class WeakTimerManager {
  constructor() {
    this.timers = new Map(); // 保存定时器ID
    this.registry = new FinalizationRegistry((id) => {
      console.log(`对象被垃圾回收，清理定时器 ${id}`);
      clearInterval(id);
    });
  }

  register(object, callback, interval) {
    const weakRef = new WeakRef(object);
    const id = setInterval(() => {
      const obj = weakRef.deref();
      if (obj) {
        callback.call(obj);
      } else {
        console.log('对象已被回收，停止定时器');
        clearInterval(id);
      }
    }, interval);

    this.timers.set(object, id);
    this.registry.register(object, id, object);

    return id;
  }

  unregister(object) {
    const id = this.timers.get(object);
    if (id) {
      clearInterval(id);
      this.timers.delete(object);
      this.registry.unregister(object);
    }
  }
}

3. 事件监听器的正确管理

class SafeEventListener {
  constructor(element) {
    this.element = element;
    this.handlers = new Map(); // 存储事件处理函数
  }

  add(event, handler, options) {
    const boundHandler = handler.bind(this);
    this.element.addEventListener(event, boundHandler, options);

    // 保存引用以便清理
    if (!this.handlers.has(event)) {
      this.handlers.set(event, []);
    }
    this.handlers.get(event).push({ handler, boundHandler });

    return boundHandler;
  }

  remove(event, handler) {
    const handlers = this.handlers.get(event);
    if (handlers) {
      const index = handlers.findIndex(h => h.handler === handler);
      if (index !== -1) {
        const { boundHandler } = handlers[index];
        this.element.removeEventListener(event, boundHandler);
        handlers.splice(index, 1);
      }
    }
  }

  removeAll() {
    this.handlers.forEach((handlers, event) => {
      handlers.forEach(({ boundHandler }) => {
        this.element.removeEventListener(event, boundHandler);
      });
    });
    this.handlers.clear();
  }
}

4. 使用AbortController取消异步操作

class SafeAsyncOperations {
  constructor() {
    this.controllers = new Map();
  }

  async fetchWithTimeout(url, timeout = 5000) {
    const controller = new AbortController();
    const abortId = setTimeout(() => controller.abort(), timeout);

    try {
      const response = await fetch(url, {
        signal: controller.signal
      });
      clearTimeout(abortId);
      return response.json();
    } catch (error) {
      clearTimeout(abortId);
      if (error.name === 'AbortError') {
        console.log('请求被取消');
      }
      throw error;
    }
  }

  startPolling(url, interval = 30000) {
    const controller = new AbortController();
    const poll = async () => {
      if (controller.signal.aborted) return;

      try {
        const data = await this.fetchWithTimeout(url, 10000);
        console.log('轮询数据:', data);
      } catch (error) {
        console.error('轮询失败:', error);
      }

      if (!controller.signal.aborted) {
        setTimeout(poll, interval);
      }
    };

    poll();
    return controller;
  }
}

5. 使用清理回调模式

function withCleanup(callback) {
  const cleanups = [];

  const cleanup = () => {
    cleanups.forEach(fn => {
      try {
        fn();
      } catch (error) {
        console.error('清理错误:', error);
      }
    });
    cleanups.length = 0;
  };

  const api = {
    addTimeout(fn, delay) {
      const id = setTimeout(fn, delay);
      cleanups.push(() => clearTimeout(id));
      return id;
    },

    addInterval(fn, interval) {
      const id = setInterval(fn, interval);
      cleanups.push(() => clearInterval(id));
      return id;
    },

    addEventListener(element, event, handler, options) {
      element.addEventListener(event, handler, options);
      cleanups.push(() => element.removeEventListener(event, handler, options));
    },

    cleanup
  };

  try {
    callback(api);
  } catch (error) {
    cleanup();
    throw error;
  }

  return cleanup;
}

DOM 引用和闭包

示例1：DOM引用泄漏

class DOMMemoryLeak {
  constructor() {
    // 保存DOM引用
    this.elementRefs = [];
    this.dataStore = new Array(10000).fill('DOM data');
  }

  createElements(count = 100) {
    for (let i = 0; i < count; i++) {
      const div = document.createElement('div');
      div.className = 'leaky-element';
      div.textContent = `元素 ${i}: ${this.dataStore[i]}`;

      // 保存DOM引用
      this.elementRefs.push(div);

      // 添加到页面
      document.body.appendChild(div);
    }
  }

  removeElements() {
    // 从DOM移除，但引用仍然存在
    this.elementRefs.forEach(el => {
      if (el.parentNode) {
        el.parentNode.removeChild(el);
      }
    });

    // 忘记清理数组引用
    console.log('元素已从DOM移除，但引用仍保存在内存中');
  }
}

示例2：闭包保持外部引用

function createClosureLeak() {
  const largeData = new Array(100000).fill('闭包数据');
  let eventHandler;

  return {
    setup(element) {
      // 闭包保持对largeData的引用
      eventHandler = () => {
        console.log('数据大小:', largeData.length);
        // 即使不再需要，largeData也无法被回收
      };

      element.addEventListener('click', eventHandler);
    },

    teardown(element) {
      if (eventHandler) {
        element.removeEventListener('click', eventHandler);
        // 但是eventHandler闭包仍然引用largeData
      }
    }
  };
}

示例3：缓存的不当使用

class CacheLeak {
  constructor() {
    this.cache = new Map();
  }

  getData(key) {
    if (this.cache.has(key)) {
      return this.cache.get(key);
    }

    // 模拟获取数据
    const data = {
      id: key,
      content: new Array(10000).fill('缓存数据').join(''),
      timestamp: Date.now()
    };

    this.cache.set(key, data);

    // 问题：缓存永远增长，从不清理
    return data;
  }

  // 忘记实现缓存清理策略
}

解决方案

1. 使用WeakMap和WeakSet

class SafeDOMManager {
  constructor() {
    // WeakMap保持对DOM元素的弱引用
    this.elementData = new WeakMap();
    this.elementListeners = new WeakMap();
  }

  registerElement(element, data) {
    this.elementData.set(element, data);

    const handleClick = () => {
      const elementData = this.elementData.get(element);
      console.log('点击元素:', elementData);
    };

    element.addEventListener('click', handleClick);

    // 保存监听器以便清理
    this.elementListeners.set(element, {
      click: handleClick
    });
  }

  unregisterElement(element) {
    const listeners = this.elementListeners.get(element);
    if (listeners) {
      element.removeEventListener('click', listeners.click);
      this.elementListeners.delete(element);
    }
    this.elementData.delete(element);
  }
}

2. 使用WeakRef和FinalizationRegistry清理DOM引用

class DOMReferenceManager {
  constructor() {
    this.registry = new FinalizationRegistry((element) => {
      console.log('DOM元素被垃圾回收，清理相关资源');
      // 清理与元素关联的资源
    });

    this.weakRefs = new Set();
  }

  trackElement(element, data) {
    const weakRef = new WeakRef(element);
    this.weakRefs.add(weakRef);

    this.registry.register(element, {
      element: element,
      data: data
    }, weakRef);

    return weakRef;
  }
}

3. 避免闭包保持不必要引用

function createSafeClosure() {
  // 需要保持的数据
  const essentialData = {
    config: { maxSize: 100 },
    state: { count: 0 }
  };

  // 不需要保持的大数据
  let temporaryData = new Array(100000).fill('临时数据');

  const processTemporaryData = () => {
    // 处理临时数据
    const result = temporaryData.map(item => item.toUpperCase());

    // 处理后立即释放引用
    temporaryData = null;

    return result;
  };

  return {
    process: processTemporaryData,

    updateConfig(newConfig) {
      Object.assign(essentialData.config, newConfig);
    },

    getState() {
      return { ...essentialData.state };
    }
  };
}

V8引擎优化策略

隐藏类（Hidden Classes）

隐藏类是V8内部优化对象访问的机制，相同结构的对象共享同一个隐藏类：

function createOptimizedObject() {
  const obj = {};
  obj.a = 1;  // 创建隐藏类 C0
  obj.b = 2;  // 创建隐藏类 C1
  obj.c = 3;  // 创建隐藏类 C2
  return obj;
}

内联缓存（Inline Caching）

内联缓存是V8优化属性访问的重要机制，通过缓存对象的隐藏类和属性位置来加速访问：

单态（Monomorphic）：总是访问同一类型的对象

function monomorphicAccess(objects) {
  let sum = 0;
  for (const obj of objects) {
    sum += obj.value; // 总是访问相同隐藏类的对象
  }
  return sum;
}
const monomorphicObjects = [];
class TypeA { constructor(v) { this.value = v; } }
for (let i = 0; i < 10000; i++) {
  monomorphicObjects.push(new TypeA(i));
}

多态（Polymorphic）：访问少量不同类型的对象

function polymorphicAccess(objects) {
  let sum = 0;
  for (const obj of objects) {
    sum += obj.value; // 访问2-4种隐藏类的对象
  }
  return sum;
}
const polymorphicObjects = [];
class TypeA { constructor(v) { this.value = v; } }
class TypeB { constructor(v) { this.value = v; } }
for (let i = 0; i < 10000; i++) {
  polymorphicObjects.push(i % 2 === 0 ? new TypeA(i) : new TypeB(i));
}

超态（Megamorphic）：访问多种类型的对象

function megamorphicAccess(objects) {
  let sum = 0;
  for (const obj of objects) {
    sum += obj.value; // 访问超过4种隐藏类的对象
  }
  return sum;
}
const megamorphicObjects = [];
class TypeA { constructor(v) { this.value = v; } }
class TypeB { constructor(v) { this.value = v; } }
class TypeC { constructor(v) { this.value = v; } }
class TypeD { constructor(v) { this.value = v; } }
class TypeE { constructor(v) { this.value = v; } }
const types = [TypeA, TypeB, TypeC, TypeD, TypeE];
for (let i = 0; i < 10000; i++) {
  const Type = types[i % 5];
  megamorphicObjects.push(new Type(i));
}

内存管理黄金法则

• 及时释放不再需要的引用
• 避免创建不必要的全局变量
• 小心处理闭包和回调
• 使用弱引用管理缓存
• 定期检查和清理内存

结语

性能优化是一个持续的过程，而不是一次性的任务。最好的性能优化是在问题发生之前预防它。理解V8引擎的工作原理，掌握正确的工具使用方法，建立完善的监控体系，这样才能构建出高性能、高可用的Web应用。对于文章中错误的地方或者有任何问题，欢迎在评论区留言讨论！

车用固态电池第 1 部分国标拟于 7 月发布

据财联社报道，中汽中心首席科学家王芳近日在某行业会议上表示，GB/T《电动汽车用固态电池第 1 部分：术语和分类》已于 2025 年 12 月完成征求意见稿编制工作，征求意见期至 2026 年 2 月 28 日。

据悉，该国标将明确液态电池、混合固液电池（半固态电池）、固态电池（全固态电池）术语定义等。

报道指出，中汽中心将于 2026 年 1 月-2 月组织开展验证测试，进一步完善测试方法，确认判定指标；预计 2026 年 4 月审查和报批，7 月正式发布。

而据我们查询发现，目前《电动汽车用固态电池第 1 部分：术语和分类》已上线全国标准信息公共服务平台。

内容显示，主要起草单位为中国汽车技术研究中心有限公司 、宁德时代新能源科技股份有限公司 、合肥国轩高科动力能源有限公司等 。

我国完成首次载人飞船返回舱海上搜索回收任务

据新华社报道，2 月 11 日，在长征十号运载火箭系统低空演示验证与梦舟载人飞船系统最大动压逃逸飞行试验中，梦舟载人飞船成功实施最大动压逃逸并在海上安全溅落。

11 日 12 时 20 分，海上搜救分队完成返回舱搜索回收任务。这是我国首次在海上实施载人飞船搜索回收任务，为后续空间站应用与发展任务和载人登月任务积累了重要经验。

报道介绍，这次试验是继长征十号运载火箭系留点火、梦舟载人飞船零高度逃逸飞行、揽月着陆器着陆起飞综合验证等试验后，组织实施的又一项研制性飞行试验，标志着我国载人月球探测工程研制工作取得重要阶段性突破。

据中国载人航天工程办公室介绍，这次试验具有新型号火箭、新型号飞船、新发射工位，以及火箭、飞船海上回收新任务等诸多亮点，参加试验的火箭和飞船均为初样状态。

其中，火箭采用芯一级单级构型，前期进行了两次系留点火试验；飞船返回舱前期进行了零高度逃逸飞行试验。

为开展此次试验，相关参试产品均按照可重复使用要求和流程完成了适应性改造，文昌航天发射场按照边建设边使用的策略克服各种困难确保试验如期实施，着陆场系统围绕飞船返回舱首次海上溅落回收技术难点开展针对性训练和演练。

值得一提的是，这次试验是长征十号运载火箭首次初样状态下的点火飞行，是我国首次飞船最大动压逃逸试验，是我国首次载人飞船返回舱和火箭一级箭体海上溅落，也是文昌航天发射场新建发射工位首次执行点火飞行试验任务。

这次试验成功，验证了火箭一级上升段与回收段飞行、飞船最大动压逃逸与回收的功能性能，验证了工程各系统相关接口的匹配性，为后续载人月球探测任务积累了宝贵飞行数据和工程经验。

苹果 AI Siri 再延期：能力大削，或 9 月见

据彭博社报道，苹果内部已调整节奏，新 Siri 的部分功能将顺延至 iOS 26.5，甚至 9 月才上线的 iOS 27，需要跨越多个版本才能补齐能力。

在上线节奏上，新 Siri 最初承诺于 2025 年初完成落地，随后整体推迟至 2026 年 3 月发布的 iOS 26.4。但近期，工程团队已被要求改用 iOS 26.5 作为主要测试环境。

从整体规划看，苹果正将原本集中在单一版本中的 Siri 更新拆分成多段，部分功能预计落在 5 月的 iOS 26.5，其余继续后移至 iOS 27：

• 在当前测试阶段，新 Siri 暴露出多项短板，包括对语音请求理解不稳定、响应时间过长，以及在复杂指令场景下容易失败。测试人员还反馈，用户语速稍快时，Siri 会中途打断指令，测试体验很差；
• 原本被视为杀手级卖点的「个人数据深度调用」能力，正在被明显削弱。这项功能可让 Siri 直接从短信等个人内容中检索信息，并调用对应 app 功能。但在 iOS 26.5 内部版本中，它仅以需要手动开启的「预览」形式存在，说明体验并不成熟；
• 另一项进展缓慢的能力，是基于 App Intents 的高级语音控制，目标是一句话完成多步应用内操作，例如找图、编辑并发送。该机制已在内测系统中上线，但稳定性不足；
• 值得注意的是，iOS 26.4 与 26.5 的内部版本中，还包含两项尚未公开的新能力：网页搜索问答与图像生成。前者形态接近 Perplexity ，能够整合网页信息并给出摘要与链接；后者基于图乐园开发，但目前测试结果不佳；
• 面向 iOS 27、iPadOS 27 和 macOS 27，苹果内部还在推进代号为「Campo」的项目，目标是将 Siri 打造成更像聊天机器人的系统级 AI 入口，深度接入邮件、日历和 Safari 等核心应用；

据悉，Siri 升级推进缓慢的一个重要背景，是苹果对隐私的强硬立场。苹果坚持尽量在设备端完成推理，或仅使用具备隐私保护机制的服务器，并避免直接利用用户真实数据进行训练。而这与 LLM 模型的工作原理有所冲突。

在算力侧，库克近期对内部表示，Apple Silicon 正在用于构建专为苹果设备定制的数据中心解决方案。这个代号为 Baltra 的云端 AI 芯片项目，将用于支撑后续更重型的 Siri 与生成式 AI 任务。

显然，苹果不希望新 Siri 项目拖过 2026 年春季这一关键时间节点，但现实是，AI Siri 的麻烦还在继续，而目前来看，苹果也没有更好的解决方案。

48 小时不到，xAI 两名联创宣布离职

据界面新闻及公开信息显示，xAI 两名联合创始人——吴宇怀（Tony Wu）和吉米 · 巴（Jimmy Ba）分别在 10 号和 11 号分别宣布离职。

2 月 10 日，吴宇怀在社媒上发帖宣布从 xAI 公司离职，他表达了对这家公司的怀念和感谢全体同事，同时也感谢马斯克对「使命的信任」。

虽然吴宇怀未透露未来去向，但他提及「是时候开启我的下一章了，这是一个充满可能性的时代：一个配备 AI 的小团队可以移山倒海，重新定义可能性。」

信息显示，吴宇怀是 xAI 在数学推理和符号 AI 领域的核心人物。在去年 Grok-3 模型发布直播中，他作为核心研究者坐在马斯克身旁，该模型被马斯克誉为「地球上最聪明的人工智能」。

据悉，在吴宇怀离职前，xAI 曾进行架构调整，其多项工作职权已划归至张国栋（Guodong Zhang，音译）名下。

公开信息显示，张国栋是 xAI 核心团队成员，主要负责机器学习优化与训练工作，此前其所在团队致力于构建人工通用智能（AGI）并开源大模型 Grok 系列，加入 xAI 前，其职业经历覆盖微软亚洲研究院、谷歌大脑、DeepMind 等顶尖机构。

2 月 11 日，吉米 · 巴发文宣布表示，他已于当地时间周二离开马斯克的这家初创公司。

吉米 · 巴在文中表示：「是时候重新校准我对大局的认知梯度了。2026 年将会非同寻常，很可能是关乎人类未来最忙碌（也最具决定性）的一年。」

同时，他也向马斯克表达了感谢，提及自己有幸在 xAI 初创阶段参与联合创立，珍惜这段非凡的共事旅程，并承诺未来将以团队挚友的身份与公司保持紧密联系。

据悉，吉米 · 巴曾身居要职，直接向马斯克汇报工作，负责公司大部分业务运营。不过在去年年底，其多项核心职责已被拆分，移交至另外两位联合创始人吴宇怀与张国栋手中。

据去年年初的 xAI 组织架构图，他还曾负责管理一支超千名 AI 导师的团队，该职权也在去年 9 月由迭戈·帕西尼（Diego Pasini）接任。

另外，特斯拉副总裁 Raj Jegannathan 也在近期宣布离职。

Raj Jegannathan 在文中提到，自己 13 年的职业生涯很难一文讲清楚，但在特斯拉的旅程是一段持续进化的过程——

从设计、建造和运营世界上最大的 AI 集群的技术细节，到在 IT、安全、销售和服务方面做出有影响力的贡献，服务其中是一种荣幸。

腾讯×特斯拉：上线微信互联与目的地地服务

近日，腾讯与特斯拉共同升级车主座舱，上线「微信互联」、「目的地服务」两大功能。

据悉，两大功能依托腾讯生态与技术优势，共同打造无缝连接、智能便捷的座舱新体验。本次功能上线将通过 OTA 方式，覆盖国内市场超百万辆 Model3、Model Y 车型，后续将在全量新车中默认搭载。

微信互联功能基于腾讯随行互连能力，打通手机与车机间的位置流转。用户可将微信对话中的位置卡片，或来自腾讯地图、百度地图、高德地图等多种来源的 POI 信息，一键分享至特斯拉车机并直接发起导航。

目的地服务围绕出行场景提供智能化体验。当用户导航抵达咖啡厅、餐厅或景区等特定目的地时，系统将智能触发周边服务，支持通过手机推送或副驾扫码唤起商家小程序，实现即停即点、预约购票等便捷操作。

未来，更多功能将陆续上线，助力用户享受更便捷、更智慧的出行生活。

豆包、蚂蚁阿福加入春节红包大战

继元宝派红包、千问请喝奶茶之后，蚂蚁阿福以及豆包也在近期开启了春节红包活动：

• 蚂蚁阿福：2 月 11 日 – 2 月 12 日新注册用户来阿福，可得 16.8 元支付宝红包。
• 豆包：2 月 16 日除夕当晚，其将通过总台春晚，为全国观众送出超过 10 万份科技好礼，以及最高 8888 元新春现金红包。

此前，腾讯元宝宣布派发 10 亿新春红包；阿里千问则推出「请客瓜分 30 亿」，为用户进行奶茶、咖啡、订餐免单。

消息称字节跳动正研发 AI 芯片

据路透社消息，字节跳动正在推进自研 AI 芯片，并与三星洽谈代工与配套供货，核心目的就是给自家 AI 算力「保供」。

报道引知情人士称，字节在开发代号「SeedChip」的 AI 芯片，主要面向推理（inference）任务，并与三星就制造合作进行谈判。目标是 3 月底前拿样片，今年计划量产至少 10 万颗，后续或逐步拉升至 35 万颗。

针对该消息，字节跳动方面发言人向路透社回应称，自研芯片项目信息「不准确」，但未继续就此展开说明；三星方面，则对此不予置评。

报道还提到字节今年 AI 相关采购预算或超 1600 亿元人民币，其中一半以上仍会用于购买英伟达芯片（含 H200），同时继续推进自研芯片。

最近，随着 Seedance 2.0 模型的火爆出圈，虽然平台称关注超预期并已暂停真人素材参考，但事实上这类「音画同步」的高质量视频生成会把推理算力需求拉高。

字节加码采购与自研芯片，更像是在锁定关键供给、给峰值算力留余量，同时降低对单一供应链的依赖。

马斯克：要在月球建厂生产 AI 卫星

据《纽约时报》消息，马斯克于当地时间 2 月 10 日的 xAI 全员大会上表示，公司需要在月球上建造一座工厂来制造 AI 卫星，并配备一个巨大的弹射器将其发射到太空。

报道指出，马斯克在会议上喊出「必须去月球」。其表示，此举将帮助 xAI 领先其他公司，并且能够更强大地构建其 AI 设施。

马斯克还补充表示「很难想象那种规模的智能会思考什么，但看到这一切发生将令人无比兴奋。」

近期，xAI 与 SpaceX 刚宣布合并，以推动在外太空建设 AI 数据中心的计划。随后马斯克发文表示：

SpaceX 已经将重点转向在月球上建造一个自我生长的城市，因为我们可能不到 10 年就能实现，而火星则需要 20 多年。

马斯克指出，每 26 个月（六个月旅行时间）行星才会对齐，那时才有可能去火星。「而我们可以每 10 天发射一次去月球（两天旅行时间）。这意味着我们迭代建造月球城市比火星城市要快得多。」

其还表示，SpaceX 也将努力建造一个火星城市，并大约在 5 到 7 年内开始实施，但首要任务是确保文明的未来，而月球则更快。

可接 OpenClaw！Rokid Glasses 上线自定义智能体

2 月 11 日，Rokid 乐奇宣布，其 Rokid Glasses 的灵珠平台正式上线「自定义智能体」功能。

官方介绍，用户可以通过标准的 SSE（Server-Sent Events）接口，将 Rokid Glasses 接入任何想要的后端，能够私有部署 OpenClaw、DeepSeek R1、Qwen3、Kimi K2.5 等。

据 Rokid 介绍，Rokid Glasses 配合 OpenClaw 可以实现：

• 隐私数据主权：通过接入本地部署的 Agent（如运行在 Mac Mini 或家庭服务器上的 OpenClaw），用户的摄像头画面、私有知识库和个人记忆，直接在本地闭环处理；
• 更加强大的个人助手能力：OpenClaw 通过 ClawHub 的技能生态，能调用文件系统、操作浏览器、发送 IM 消息，甚至执行 Python 脚本；
• 完全自由的大模型基座：调用 Kimi K2.5 的长思考能力（Thinking Mode）攻克复杂推理，或部署本地量化版 Qwen 3 享受完全本地部署的端侧交互。

Rokid 表示，Rokid Glasses 负责「看」和「听」，OpenClaw 负责「思考」和「执行」，而这才是 AR 的终极形态。

于东来宣布「过年后正式退休」

据河南日报微信公众号消息，2 月 11 日，胖东来创始人于东来在社交平台发文宣布，过年后正式退休，将转为顾问，胖东来工作由胖东来决策委员会主持。

于东来文中提到，「自己六十岁了，为了科学先进的发展模式，让年轻人勇敢承担使命，过年后正式退休，转为顾问，胖东来工作由胖东来决策委员会主持」。

同时于东来也指出，「坚定为国家和社会的美好、坚定启迪更多人们轻松快乐的生活………相信一定会更加美好！」

据悉，2025 年胖东来合计销售额超 235.31 亿元。其中，超市业态占据核心 C 位，销售额达到 126.43 亿元，珠宝业态销量额达到 24.51 亿元，茶叶全年销量为 10.63 亿元。

Jony Ive：触屏不适合用作汽车的主要交互

日前，法拉利正式公布了其首款纯电车型「Luce」的内饰设计，该车型内饰采用了多个实体按键，并且能进行空调、座椅加热等功能调节。

据悉，Luce 的设计由苹果前首席设计官 Jony Ive 带队的 LoveFrom 团队参与。

而 Jony Ive 近期也透露了自己对于车辆中控交互的想法：触屏不适合用作汽车的主要交互。

Jony Ive 提到，在行驶中使用触摸屏，会导致驾驶者的视线离开道路，而这也是为什么，触控屏不适合作为主要交互界面的技术。

同时 Jony Ive 也提出，每一个实体按键的操作手感都会有所不同，因此不需要看，也能实现盲操。

当被记者问到「那为什么 iPhone 采用触控」时，Jony Ive 则直接表示「因为当时开发 iPhone 的核心思想是开发一个通用界面，它可以显示任何场景（如计算机、键盘、相机）」。

我认为设计汽车内饰的方式并不是像我们设计 iPhone 那样试图解决问题（指设计通用界面）。

智谱上线全新模型 GLM-5

刚刚，智谱正式上线并开源最新模型 GLM-5。

据介绍，GLM-5 是迈向 Agentic Engineering 的产物：在 Coding 与 Agent 能力上，其取得开源 SOTA 表现，在真实编程场景的使用体感逼近 Claude Opus 4.5，擅长复杂系统工程与长程 Agent 任务。

GLM-5 采用全新基座：参数规模从 355B（激活 32B）扩展至 744B（激活 40B），预训练数据从 23T 提升至 28.5T；构建全新的「Slime」框架，支持更大模型规模及更复杂的强化学习任务。

同时，GLM-5 还首次集成 DeepSeek Sparse Attention（稀疏注意力），在维持长文本效果无损的同时，大幅降低模型部署成本。

具体表现上：

• 在全球权威的 Artificial Analysis 榜单中，GLM-5 位居全球第四、开源第一。
• GLM-5 在编程能力上实现了对齐 Claude Opus 4.5，在业内公认的主流基准测试中取得开源模型 SOTA。
• GLM-5 在 SWE-bench-Verified 和 Terminal Bench 2.0 中分别获得 77.8 和 56.2 的开源模型最高分数，性能超过 Gemini 3 Pro。
• GLM-5 在 BrowseComp（联网检索与信息理解）、MCP-Atlas（大规模端到端工具调用）和 τ²-Bench（复杂场景下自动代理的工具规划和执行）均取得最高表现。

值得一提的是，目前 GLM-5 已完成与华为昇腾、摩尔线程、寒武纪、昆仑芯、沐曦、燧原、海光等国产算力平台的深度推理适配。通过底层算子优化与硬件加速，GLM-5 在国产芯片集群上已经实现高吞吐、低延迟的稳定运行。

即日起，GLM-5 在 Hugging Face 与 ModelScope 平台同步开源，模型权重遵循 MIT License。同时 GLM-5 已纳入 GLM Coding Plan Max 套餐。

在线体验

Z.ai：https://chat.z.ai

智谱清言APP/网页版：https://chatglm.cn

开源链接

GitHub：https://github.com/zai-org/GLM-5

Hugging Face：https://huggingface.co/zai-org/GLM-5

模型春节大战已悄悄开启

据我们观察发现，DeepSeek 近期悄悄更新了。

当关闭深度思考和联网搜索功能，向 DeepSeek 询问上下文长度和知识库截止日期，如果它回复自己是 1M（此前为 128k）以及知识库截止日期为 2025 年 5 月，而这也说明已进入新版本灰度范围。

不过，截至目前，该版本仍未开放多模态能力。

早前，《南华早报》援引知情人士消息称，DeepSeek 春节更可能推出的是针对 V3 系列模型的小幅更新。但该人士同时透露，真正的重头戏仍在路上：

DeepSeek 下一代旗舰模型预计将是一款万亿参数级别的基础模型，正因规模大幅跃升，训练速度明显放缓，导致发布进程有所延后。

另据我们观察发现，目前 MiniMax Agent 已上线了最新 MiniMax-M2.5 文本模型，并且支持选择使用。

目前暂无更多其他信息。

三星 Galaxy S26 系列有望月底发布

昨天，三星官网正式宣布，将于 2026 年 2 月 26 日凌晨 2 点举行 Galaxy 全球新品发布会，预计将会发布三星 Galaxy S26 系列新机、Galaxy Buds 4 系列耳机等产品。

从公布的预热视频来看，本次 Galaxy S26 系列预计会有三款新机。结合此前信息来看，Galaxy S26 系列将会提供 S26、S26+ 和 S26 Ultra。

目前曝光的信息来看，三款新机都将采用类似 Z Fold 7 的后置相机模组设计，并且均为前后直板+直边中框。

值得一提的是，新机能够提供全新的硬件级屏幕防窥功能。据悉该功能将通过纳米级光学调控实现像素级防窥，并且支持全屏开启隐私模式。

性能方面，S26 系列或采用双平台策略，部分地区采用 Exynos 2600 处理器（全球首款 2nm 制程芯片）；其中 S26 Ultra 还有望升级 60W 有线快充。

纯电汉兰达上线，同步家族式设计

昨天，丰田公布全新纯电版汉兰达，定位中大型 SUV。

外观方面，纯电版汉兰达采用丰田最新 C 字型日间行车灯设计，整车线条更加笔直硬朗；悬浮式 A 柱改为全黑车顶设计；尾灯改为贯穿式灯带设计。

整车尺寸增大：车身长度达 5m，轴距增加至 3m，车宽也进化到了 1.98m，同时车身高度下降至 1.7m。

新车将提供前驱以及四驱两个版本，并且拥有 77 度和 95.8 度两个版本电池选择，最高提供 514 公里（320 英里）续航。

内饰方面，新车采用 6 座布局，其中第二排支持电动放倒；配备 14 英寸中控屏幕（提供 5G 网络）以及 12.3 英寸仪表盘，前排配备双层夹胶玻璃。值得一提的是，纯电汉兰达自带行车记录仪。

蚂蚁开源全模态大模型 Ming-Flash-Omni 2.0

2 月 11 日，蚂蚁集团开源发布全模态大模型 Ming-Flash-Omni 2.0。

在多项公开基准测试中，Ming-Flash-Omni 2.0 在视觉语言理解、语音可控生成、图像生成与编辑等关键能力表现突出，部分指标超越 Gemini 2.5 Pro，成为开源全模态大模型性能新标杆。

据悉，Ming-Flash-Omni 2.0 也是业界首个全场景音频统一生成模型，可在同一条音轨中同时生成语音、环境音效与音乐。用户只需用自然语言下指令，即可对音色、语速、语调、音量、情绪与方言等进行精细控制。

模型在推理阶段实现了 3.1Hz 的极低推理帧率，实现了分钟级长音频的实时高保真生成，在推理效率与成本控制上保持业界领先。

值得一提的是，Ming-Flash-Omni 2.0 基于 Ling-2.0 架构（MoE，100B-A6B）训练，围绕「看得更准、听得更细、生成更稳」三大目标全面优化。

目前，Ming-Flash-Omni 2.0 的模型权重、推理代码已在 Hugging Face 等开源社区发布。用户也可通过蚂蚁百灵官方平台 Ling Studio 在线体验与调用。

UU 跑腿下架「代拜年」服务

日前，UU 跑腿推出一项名为「新春带拜年」的服务，其中提供「代拜长辈代磕头」，最高套餐售价 999 元，并引发热议。

昨日，UU 跑腿方面对于上述服务进行了回应。

平台方面表示，其推出相关服务的初衷，是为了满足身在异地、行动不便或海外等无法返乡拜年群体的特定需求。希望通过此类服务，帮助他们传递牵挂与心意，弥补无法当面问候的遗憾，提供更好的情绪价值。

UU 跑腿方面表示，「新春带拜年」服务并非对传统礼仪的亵渎与曲解。同时平台表示：

为维护积极健康和谐的网络舆论环境，避免因商业创新引发不必要的误解与对立，我们经过慎重评估，已主动将其中引发争议的服务项目予以下架。对于因下架导致无法履约的订单，我们将主动为用户提供三倍金额补偿，原路退还。感谢大家的理解。

同时，UU 跑腿还提出，根据网友所提出的有趣需求（如「代值班」「代相亲」「代照顾宠物」「换班照顾医院老人」等服务），他们也将在评估后尽快研究上架，帮助更多有需求的用户。

另外，UU 跑腿还表示，其将正式启动「安心吃个年夜饭」春节公益活动，以实际行动回馈社会：

除夕当天，针对所有为坚守工作岗位、无法回家与家人团聚的一线工作者——包括公安民警、医护人员、消防员、环卫工人等群体，其家人为他们配送年夜饭的相关跑腿订单，平台将全额免除跑腿费（师傅收入不受影响）。

微博公布「2025 热搜趋势报告」

昨日，微博热搜发布了「2025 微博热搜趋势报告」完整版。

据报告显示，「全运会」「电影哪吒出圈」「AI 浪潮」「高考」均有登上「十大事件」；而热搜「关键词」排名中，「回应」上榜次数最多，同时「雷军」「哪吒」「演唱会」「小米」「手机」等内容也在内。

值得一提的是，人工智能以及机器人几乎包揽了新兴领域关注趋势的关键词，其中 DeepSeek 上榜次数最多。

米哈游宣布「解雇」公司常年法律顾问

2 月 11 日，米哈游法务部发布《关于终止与上海市汇业律师事务所合作的声明》，宣布：

终止与原常年法律顾问汇业律所的一切合作关系，停止委托其处理任何与米哈游相关的法律事务，同时将上海市汇业律师事务所永久列入公司合作方黑名单，永不合作。

据米哈游方面信息：

此前，米哈游聘任上海市汇业律师事务所为公司常年法律顾问，由其为米哈游提供诉讼法律服务。在汇业律所为米哈游提供法律服务期间，汇业律所管委会委员、高级合伙人周开畅律师在明知代理远景公司诉讼案件（远景能源有限公司诉米哈游网络侵权责任纠纷案件）涉及利益冲突的情况下，仍私自实施超出与远景公司法律顾问合同服务范围外的、指派实习律师吴某继续帮助远景公司收集、固定诉讼证据，并提供给远景公司的行为，涉嫌违反《律师法》的相关规定。

米哈游表示，针对周开畅的行为，其已向上海市徐汇区司法局提出投诉。经徐汇区司法局立案调查，该局已依法对周开畅作出行政处罚。

此外，远景能源有限公司已向江阴市人民法院申请撤回前述其与米哈游之间网络侵权责任纠纷案件的起诉，江阴市人民法院已裁定准许其撤诉。

据悉，远景能源曾于去年 6 月，因《绝区零》反派叫「远景实业」将米哈游告上法庭，后者反向起诉商业诋毁。

元宝新玩法：可在「元宝派」畅享看 NBA 全明星赛

2 月 11 日，腾讯宣布，元宝派正式上线「一起看 NBA 全明星赛」专题活动，包括名人赛、新秀赛、单项赛及全明星正赛四场焦点战役。

2 月 14 日至 16 日，用户进入任意元宝派，点击下方的【+号】按钮，即可与派友一起看 2026 年 NBA 全明星赛，并支持在派内 @元宝 实时讨论赛况，还可畅享 1080P 高清直播体验。

据了解，此次活动深度整合了腾讯体育的高品质内容资源，除了高清直播福利，元宝派还创新性地融入了 AI 互动玩法，「元宝」将化身全能「懂球帝」，用户可随时在群内 @元宝，实时探讨球员数据、查询赛事规则或进行深度的战术解析。

目前，元宝派「一起听、一起看」功能，打通了 QQ 音乐和腾讯视频与两大优质内容库。

杨紫琼主演，短片《Sandiwara》发布预告

据新浪电影消息，杨紫琼主演，肖恩·贝克导演短片《Sandiwara》发布预告。

杨紫琼一人饰五个角色：视频播主、评论人、摊贩、侍者和歌手，设定在马来西亚槟城的夜市里，热闹之中的故事，聚焦当地文化、人文和人生。

据悉，该片即将在「柏林电影节」首映，杨紫琼也将在本届柏林获颁终身成就奖。

动画电影《八仙！》定档今年暑期

昨日，神仙喜剧动画电影《八仙！》定档 2026 年暑期并发布「瞒天过海」版先导海报。

据悉，故事围绕八个出身草根的凡人展开，他们面对强大的反派神仙，凭借机智与民间智慧巧妙周旋，最终被世人赞颂为「八仙」。

影片由东方梦工厂及华人影业出品，牟正洋执导，以喜剧风格和年轻化创新演绎这一经典传说。

#欢迎关注爱范儿官方微信公众号：爱范儿（微信号：ifanr），更多精彩内容第一时间为您奉上。

爱范儿 | 原文链接 · 查看评论 · 新浪微博

36氪获悉，A股三大指数集体高开，沪指高开0.12%，深成指高开0.12%，创业板指高开0.3%；AI算力概念大涨，美利云、海量数据涨停，优刻得涨超15%，英维克涨超5%；玻璃纤维概念走强，山东玻纤逼近涨停，中材科技涨超5%；传媒、航天股走弱，欢瑞世纪、横店影视跌停。

大家好，我是 Java陈序员。

在如今数字化运营时代，服务的稳定性直接决定用户体验。但搭建一套完善的服务监控体系往往门槛不低：要么是专业监控工具配置复杂、学习成本高，要么是轻量工具功能单一，难以覆盖全场景需求。

今天，给大家推荐一款高颜值的监控系统工具，轻量易部署！

项目介绍

coolmonitor —— 酷监控，一个高颜值的监控工具，支持网站监控、接口监控、HTTPS 证书监控等多种监控类型，帮助开发者及运维人员实时掌握网站、接口运行状态。

功能特色：

• 多维度监控覆盖：支持 HTTP、HTTPS 网站、API 接口、HTTPS 证书过期、TCP 端口、MySQL、Redis 数据库等多种监控
• 多渠道通知配置：支持邮件、Webhook、微信、钉钉、企业微信等多类型通知渠道
• 便捷的操作体验：响应式布局，适配桌面、平板、移动端，支持深色、浅色主题切换
• 数据可视化：监控数据支持可视化展示，通过 ECharts 生成响应时间趋势图，支持按小时、天维度查看
• 持久化存储：采用 SQLite 轻量数据库，监控配置、运行数据持久化存储，轻量级部署无需额外依赖

快速上手

coolmonitor 支持 Docker 部署，可通过 Docker 快速部署。

1、拉取镜像

docker pull star7th/coolmonitor:latest

2、创建挂载目录

mkdir -p /data/software/coolmonitor

3、运行容器

docker run -d \
--name coolmonitor \
-p 3333:3333 \
-v /data/software/coolmonitor:/app/data \
star7th/coolmonitor:latest

4、容器运行成功后，浏览器访问

http://{IP/域名}:3333

5、根据引导，设置管理员账号密码，完成系统初始化

功能体验

• 主面板

• 监控详情页

• 添加监控项

• 添加通知方式

• 状态页

coolmonitor 没有复杂的配置项，能覆盖日常监控的核心需求，颜值高、易部署、易维护，不管是个人开发者监控自己的小网站，还是中小企业监控内部服务，都非常适用。快去部署体验吧~

项目地址：https://github.com/star7th/coolmonitor

最后

推荐的开源项目已经收录到 GitHub 项目，欢迎 Star：

https://github.com/chenyl8848/great-open-source-project

或者访问网站，进行在线浏览：

https://chencoding.top:8090/#/

大家的点赞、收藏和评论都是对作者的支持，如文章对你有帮助还请点赞转发支持下，谢谢！

---

函数式编程不是一种新的语法，而是一种思考方式。它让我们用更简洁、更可预测、更可测试的方式编写代码。理解这些概念，将彻底改变我们编写 JavaScript 的方式。

前言：从命令式到声明式的转变

命令式编程：关注"怎么做"

const numbers = [1, 2, 3, 4, 5];
const doubled = [];

for (let i = 0; i < numbers.length; i++) {
    doubled.push(numbers[i] * 2);
}
console.log(doubled); // [2, 4, 6, 8, 10]

函数式编程：关注"做什么"

const numbers2 = [1, 2, 3, 4, 5];
const doubled2 = numbers2.map(n => n * 2);
console.log(doubled2); // [2, 4, 6, 8, 10]

立即调用函数表达式（IIFE）

IIFE 的基本概念

IIFE（Immediately Invoked Function Expression）是定义后立即执行的函数表达式。

IIFE的基本语法

语法1：括号包裹整个调用

(function() {
    console.log('括号包裹整个调用');
}());

语法2：括号包裹函数，然后调用

(function() {
    console.log('括号包裹函数，然后调用');
})();

注：以上两种写法只是两种不同的风格，它们在功能上完全等价，没有实质性区别。

语法对比：函数声明 vs 函数表达式 vs IIFE

1. 函数声明 - 不会立即执行

function greet() {
    console.log('Hello!');
}
greet(); // 需要显式调用

2. 函数表达式 - 也不会立即执行

const greetExpr = function() {
    console.log('Hello from expression!');
};
greetExpr(); // 需要显式调用

3. IIFE - 定义后立即执行

(function() {
    console.log('Hello from IIFE!'); // 立即执行
})();

IIFE操作符

在 JavaScript 中，以 function 开头的语句会被解析为函数声明，而函数声明不能直接跟 () 执行，因此出现了操作符。添加这些操作符后，JavaScript 引擎会将 function... 解析为函数表达式，这样就可以立即执行了。

逻辑非运算符!

const result = !function () {
  console.log('逻辑非');
}();
console.log(result);  // true

上述代码会将立即执行函数的返回值进行取反，由于上述函数没有明确返回值，故默认返回 undefined ， !undefined 结果为 true，因此 result 的值为 true 。

一元加运算符+

const result = +function () {
  console.log('一元加');
}();
console.log(result);  // NaN 

上述代码立即执行函数的返回值转换为数字，由于上述函数没有明确返回值，故默认返回 undefined ， undefined 转为为数字结果为 NaN，因此 result 的值为 NaN 。

void 运算符

const result = void function () {
  console.log('void');
}();
console.log(result);  // undefined

上述代码中，立即执行函数的返回值永远为 undefined ，这是 void 关键字的特性使然。

IIFE 的实际应用

应用1：创建私有作用域

使用IIFE可以创建模块作用域，模块作用域内变量在IIFE外部无法直接访问，即为私有作用域。在IIFE内部，我们可以提供公共方法，去访问这些私有作用域：

(function () {
  // 这些变量在IIFE外部无法访问
  var privateVar = '我是私有的';
  var secret = 42;

  // 提供公共方法访问私有变量
  myModule = {
    getSecret: function () {
      return secret;
    },
    publicMethod: function () {
      console.log('公共方法可以访问私有变量:', privateVar);
    }
  };
})();

console.log(myModule.getSecret()); // 42
myModule.publicMethod(); // "公共方法可以访问私有变量: 我是私有的"
console.log(privateVar); // ReferenceError: privateVar is not defined
console.log(secret); // ReferenceError: secret is not defined

应用2：避免变量冲突

假设有多个第三方库，它们都使用了同一个变量，如 jQuery 和 Prototype.js ，它们都用了 $ 符号，直接使用 $ 符号就会冲突。这种情况下，我们就可以采用 IIFE 的方式，将 $ 保护起来：

(function($) {
    // 在这个作用域内，$就是jQuery
    $(document).ready(function() {
        console.log('jQuery准备好了');
    });
})(jQuery); // 传入jQuery对象

// Prototype.js的$不受影响

IIFE 的现代替代方案

方案1：ES Module（最佳方案）

// module.js
const privateVar = '私有变量';
export const publicVar = '公共变量';
export function publicMethod() {
  return privateVar;
}

// main.js
import { publicVar, publicMethod } from './module.js';

方案2：块级作用域 + 闭包

{
  const privateData = '块级私有数据';
  let counter = 0;

  counterModule = {
    increment: () => ++counter,
    getValue: () => counter
  };
}

console.log(counterModule.increment()); // 1
console.log(counterModule.getValue());  // 1
// console.log(privateData); // ReferenceError
// console.log(counter); // ReferenceError

方案3：类与私有字段

class SecureModule {
  #secret = '绝密信息';
  #counter = 0;

  getSecret() {
    return this.#secret;
  }

  increment() {
    return ++this.#counter;
  }
}

const module = new SecureModule();
console.log(module.getSecret()); // "绝密信息"
console.log(module.increment()); // 1
// console.log(module.#secret); // SyntaxError

纯函数（Pure Functions）

什么是纯函数？

纯函数是函数式编程的基石，它具有两个核心特征：

• 相同的输入，总是得到相同的输出
• 没有副作用

纯函数 vs 非纯函数

纯函数示例

function add(a, b) {
  return a + b;
}

非纯函数示例

let counter = 0;
function increment() {
  counter++; // 修改外部状态
  return counter;
}

纯函数的优势

优势1：可预测性

纯函数中对于相同的输入，总是得到相同的输出，因此其结果是可以预测的：

const calculatePrice = (price, taxRate) => price * (1 + taxRate);
console.log('价格计算: $100 * 1.1 =', calculatePrice(100, 0.1)); // 110
console.log('再次计算: $100 * 1.1 =', calculatePrice(100, 0.1)); // 110（总是相同）

优势2：易于测试

function testCalculatePrice() {
  const result = calculatePrice(100, 0.1);
  const expected = 110;
  console.log(`测试 ${result === expected ? '通过' : '失败'}: ${result} === ${expected}`);
}
testCalculatePrice();

优势3：引用透明性

const price1 = calculatePrice(100, 0.1);
const price2 = calculatePrice(100, 0.1);
console.log('price1 === price2:', price1 === price2); // true
console.log('可以直接替换:', calculatePrice(100, 0.1) === 110); // true

优势4：可缓存性

function square(x) {
  console.log(`计算 ${x} 的平方`);
  return x * x;
}

// 缓存包装器
function memoize(fn) {
  const cache = {};
  return function (x) {
    if (cache[x] !== undefined) {
      console.log(`从缓存获取 ${x} 的平方`);
      return cache[x];
    }
    const result = fn(x);
    cache[x] = result;
    return result;
  };
}

// 使用缓存
const memoizedSquare = memoize(square);

console.log(memoizedSquare(5)); // 第一次计算
console.log(memoizedSquare(5)); // 从缓存获取

常见的副作用及其解决方案

副作用类型1：修改输入参数

const impureAddToArray = (array, item) => {
  array.push(item); // 副作用：修改输入参数
  return array;
};

解法方案：返回新数组，不修改原数组

const pureAddToArray = (array, item) => {
  return [...array, item]; // 返回新数组，不修改原数组
};

副作用类型2：修改外部变量

let globalCount = 0;
const impureIncrement = () => {
  globalCount++; // 副作用：修改全局状态
  return globalCount;
};

解决方案：返回新值

const pureIncrement = (count) => {
  return count + 1; // 不修改外部状态
};

副作用类型3：I/O操作

const impureFetchData = (url) => {
  // 副作用：网络请求
  fetch(url)
    .then(response => response.json())
    .then(data => console.log('数据:', data));
};

解决方案：返回一个函数，延迟执行副作用

const pureFetchData = (url) => {
  // 返回一个函数，延迟执行副作用
  return () => {
    return fetch(url)
      .then(response => response.json());
  };
};

副作用类型4：异常和错误

const impureParseJSON = (str) => {
  return JSON.parse(str); // 可能抛出异常
};

解决方案：异常捕获

const pureParseJSON = (str) => {
  try {
    return { success: true, data: JSON.parse(str) };
  } catch (error) {
    return { success: false, error: error.message };
  }
};

高阶函数（Higher-Order Functions）

什么是高阶函数？

高阶函数是指能够接受函数作为参数，或者返回函数作为结果的函数：

接受函数作为参数

const greet = (name, formatter) => {
  return formatter(name);
};
const shout = (name) => `${name.toUpperCase()}!`;
const whisper = (name) => `psst... ${name}...`;
console.log(greet('zhangsan', shout));   // "ZHANGSAN!"
console.log(greet('lisi', whisper));   // "psst... lisi..."

返回函数作为结果

const multiplier = (factor) => {
  return (number) => number * factor;
};
const double = multiplier(2);
const triple = multiplier(3);
console.log('double(5):', double(5)); // 10
console.log('triple(5):', triple(5)); // 15

同时接受和返回函数

const compose = (f, g) => {
  return (x) => f(g(x));
};
const addOne = (x) => x + 1;
const square = (x) => x * x;
const addOneThenSquare = compose(square, addOne);
console.log('addOneThenSquare(2):', addOneThenSquare(2));

柯里化（Currying）

什么是柯里化？

柯里化是把接受多个参数的函数变换成接受一个单一参数（最初函数的第一个参数）的函数，并且返回接受余下的参数而且返回结果的新函数的技术。

// 原始函数（多参数）
const addThreeNumbers = (a, b, c) => a + b + c;
console.log('原始函数:', addThreeNumbers(1, 2, 3)); // 6

// 柯里化版本
const curriedAdd = (a) => {
  return (b) => {
    return (c) => {
      return a + b + c;
    };
  };
};

console.log('柯里化版本:', curriedAdd(1)(2)(3)); // 6

柯里化的优势

1. 参数复用

const addFive = curriedAdd(5);
console.log('addFive(10)(15):', addFive(10)(15)); // 30

2. 延迟计算

const multiply = (a) => (b) => a * b;
const double = multiply(2);
const triple = multiply(3);

console.log('double(10):', double(10)); // 20
console.log('triple(10):', triple(10)); // 30

3. 函数组合

const greet = (greeting) => (name) => `${greeting}, ${name}!`;
const sayHello = greet('Hello');
const sayHi = greet('Hi');

console.log(sayHello('zhangsan')); // "Hello, zhangsan!"
console.log(sayHi('lisi'));      // "Hi, lisi!"

手动实现柯里化

const manualCurry = (fn) => {
  const arity = fn.length; // 函数期望的参数个数

  const curried = (...args) => {
    if (args.length >= arity) {
      return fn(...args);
    } else {
      return (...moreArgs) => {
        return curried(...args, ...moreArgs);
      };
    }
  };
  return curried;
};

函数组合（Function Composition）

什么是函数组合？

函数组合是将多个函数组合成一个新函数的过程，新函数的输出作为下一个函数的输入。

手动组合

const addOne = x => x + 1;
const double = x => x * 2;
const square = x => x * x;

// 手动组合：从右向左
const addOneThenDoubleThenSquare = (x) => {
  const afterAddOne = addOne(x);
  const afterDouble = double(afterAddOne);
  const afterSquare = square(afterDouble);
  return afterSquare;
};
console.log('手动组合:', addOneThenDoubleThenSquare(2)); // ((2+1)*2)^2 = 36

组合函数

const addOne = x => x + 1;
const double = x => x * 2;
const square = x => x * x;

// 组合函数
const compose = (...fns) => (x) => 
  fns.reduceRight((acc, fn) => fn(acc), x);

// 从右向左组合：square(double(addOne(x)))
const addOneThenDoubleThenSquare = compose(square, double, addOne);

console.log('函数组合:', addOneThenDoubleThenSquare(2));

管道函数

const addOne = x => x + 1;
const double = x => x * 2;
const square = x => x * x;

// 管道函数
const pipe = (...fns) => {
  return (initialValue) => {
    return fns.reduce((value, fn) => fn(value), initialValue);
  };
};

// 从左向右组合：addOne → double → square
const addOneThenDoubleThenSquarePipe = pipe(addOne, double, square);

console.log('管道组合:', addOneThenDoubleThenSquarePipe(2));

Pointfree 风格编程

Pointfree 风格（无参数风格）是一种编程风格，函数定义不显式提及它所操作的数据参数。

非 Pointfree 风格示例

const nonPointfree = (users) => {
  return users
    .filter(user => user.age >= 18)
    .map(user => user.name)
    .map(name => name.toUpperCase());
};

Pointfree 风格

const isAdult = user => user.age >= 18;
const getName = user => user.name;
const toUpperCase = str => str.toUpperCase();

const getAdultUserNames = (users) => {
  return users
    .filter(isAdult)
    .map(getName)
    .map(toUpperCase);
};

现代 JavaScript 中的函数式特性

1. 箭头函数

const add = (a, b) => a + b;

2. 解构与剩余参数

const processArgs = (first, second, ...rest) => {
  console.log('前两个:', first, second);
  console.log('其余:', rest);
};

3. 默认参数

const greet = (name, greeting = 'Hello') => `${greeting}, ${name}!`;

4. 数组和对象的扩展运算

const combine = (...arrays) => [].concat(...arrays);
const merge = (...objects) => Object.assign({}, ...objects);

5. Promise 和 async/await

const asyncPipe = (...fns) => async (initial) => {
  return fns.reduce(async (value, fn) => {
    const resolvedValue = await value;
    return fn(resolvedValue);
  }, Promise.resolve(initial));
};

6. 新的数组方法

const numbers = [1, 2, 3, 4, 5];
const flatMapped = numbers.flatMap(x => [x, x * 2]);

7. 可选链和空值合并

const safeGet = (obj, path) => {
  return path.split('.').reduce(
    (acc, key) => acc?.[key] ?? null,
    obj
  );
};

结语

函数式编程提供了一套强大的工具和思维方式，通过掌握这些核心概念，我们能够编写出更简洁、更可维护、更可测试的代码。对于文章中错误的地方或者有任何问题，欢迎在评论区留言讨论！

36氪获悉，中国央行公开市场开展1665亿元7天期逆回购操作，操作利率1.40%，与前次持平。今日央行开展4000亿元14天期逆回购操作。今日有1185亿元7天期逆回购到期。