阅读视图

发现新文章,点击刷新页面。

AI 时代掌握 Markdown,是最基础也最必要的技能 (小红书长文也可以用哦)

AI 时代一来,最常用、最通用、最省心的技能,是 Markdown

就那套:

# 是标题

- 是列表

三个反引号是代码块……

以前我把它当程序员小玩具,写 README 用的。

现在我写提示词写知识库写会议纪要写项目计划、甚至写小红书草稿都在用它

很多大模型默认吐出来的也是 Markdown

你不学也会天天用;你学了,就能把它用得更顺、更像人机协作的公共语言

这篇文章就把 AI 时代的 Markdown 技能讲清楚:

  • 为啥说 Markdown 是 AI 时代基础必修
  • 新手怎么用 30 分钟上手
  • 我踩过的坑
  • 直接给你几套能复制走就用的模板

AI 时代大家都在写『文档』

以前我们写作给人看的。

现在很多文字要同时两类读者看:

  • 人:扫一眼懂不懂、读起来顺不顺
  • AI:能不能切分、能不能检索、能不能执行、会不会误解

Markdown 的优势特别像夹在中间的翻译官

  • 对人:比 Word 清爽,写起来也不费手
  • 对模型:结构清晰、层级明确、token 还省(真的省)

一个很现实的事:会 Markdown,不代表你是技术人;但不会 Markdown,你在 AI 时代做事会莫名卡住

比如:

  • 你发提示词给模型,一大段纯文本没结构,模型抓不到重点
  • 你做个人知识库,内容堆在一起,RAG 切分一塌糊涂
  • 你写项目计划,别人看不懂,Agent 更执行不了

Markdown 其实就是把我要说的话变成可计算的文字

为什么它是新手最容易掌握的技能

你想学一个新技能,最怕两件事:

你掌握 10% 的语法,就能覆盖 90% 场景;你今天学,今天就能用在:提示词、笔记、文档、发文、写代码说明。

而且它是纯文本。

这意味着,不依赖软件、不依赖平台、不怕格式丢失、还能被 Git 管起来。

你换工具、换平台、换设备,Markdown 都能带走。

这在 AI 时代太重要了,因为你的内容会被喂给各种模型、各种工具链。

30 分钟上手法

我自己教朋友(完全小白那种)就用这四个:

1)标题:# 真的就够了

这是大标题

这是小标题

这是更小的标题

最常见的坑:# 后面要空一格。

写成 #标题 有的平台不认,真的会气到。

2)列表:用 -1.,全篇统一就行

无序列表

  • 这是一条

  • 这也是一条

  • 这也是一条

有序列表

  1. 这是一条

  2. 这也是一条

  3. 这也是一条

列表上下不空行,有的平台会在一起。你就当空行是免费的,随便用。

3)链接

这是链接文字

你以后写提示词、写文档、写小红书参考来源,这个非常好用。

4)代码块


npm i

新手最常见的痛苦:代码复制出来一坨。加上代码块,世界瞬间清净。

踩过的坑

坑 1:换行不是你以为的换行

Markdown 里回车一下不一定等于换行

很多渲染器会把同一段落里的换行当成空格。

解决办法就两个:

  • 真分段:中间空一行(部分渲染引擎支持)
  • 想强制换行:上一行行尾加 3 个空格再接回车一下即可,或者用 <br>

坑 2:你从 Markdown 复制到某些平台,会出现一堆 ###

比如你发到某些富文本编辑器(包括部分社媒的长文功能),它不完整支持 Markdown,就会把符号原样贴上去。

我的小技巧:

  • 在 VS Code 里(或者其他 Markdown 预览器)先打开预览(Mac:Cmd + Shift + V
  • 在预览里复制,再粘贴到平台

这个技巧我自己用来发公众号也挺稳。

坑 3:文件名有空格/中文,后面做知识库会很难受

我以前喜欢起名:“今天学 Markdown 好开心.md”

后来要做链接引用、做同步、做脚本处理,全变成麻烦。

解决办法:

  • kebab-caseai-markdown-guide.md
  • 或者加日期:2026-02-14-notes.md

中文当然也能用,只是后续工具链会更容易出小毛病(尤其跨平台)。

它不只是排版,它是结构化提示词的容器

我以前写提示词是:一大段话丢给模型,靠缘分。

后来我发现:你用 Markdown 把提示词分区,模型执行力会明显变好。

你可以直接复制这个模板:

你的角色

你是一个严谨但很会讲人话的编辑。

背景

我要写一篇小红书长文,主题是:掌握 Markdown 是 AI 时代的基础技能。

读者是完全新手。

输出要求

  • 口语化

  • 有真实使用场景

  • 不要“首先/其次/总结一下”那种模板腔

  • 给出可复制的 Markdown 示例

我已经有的素材

  • 我经常用 VS Code 写 Markdown

  • 我会把笔记喂给 AI 做总结

你需要交付

成稿 + 配图提示词

这玩意儿本质上就是,你用标题告诉模型这块是什么,减少它乱猜。

做个人知识库、做 RAG、做第二大脑

我以前记笔记是什么都往一个长文档里堆,然后想找东西就靠搜索,搜不到就崩溃。

后来我学会一个很简单的思路:

把一条知识写成一个小条目,用标题+短段落+列表。

你甚至可以给每条笔记加一个 YAML 头(有些工具会识别):


title: Markdown 换行规则

tags: [markdown, writing, ai]

created: 2026-02-14


结论

段落之间要空一行。需要强制换行就用行尾两个空格或 <br>

我踩过的坑

  • 直接回车在某些渲染器里不会换行

示例

第一行

第二行

这种结构对你也友好,对 AI 也友好,AI 检索的时候能更容易切到对的块,总结也更不容易跑偏

进阶一点点:表格、任务清单、引用

这几个我个人用得特别多,但我只在平台支持的时候用(比如 GitHub、Notion、一些博客系统)。

任务清单

  • 学会标题

  • 学会列表

  • 学会代码块

引用

这是一段引用。

我用它来放原文/结论/别人的观点。

表格

| 场景 | 用 Markdown 的原因 |

| --- | --- |

| 写提示词 | 结构清晰,模型更听话 |

| 写知识库 | 易切分,易检索 |

| 写文档 | 跨平台,不怕格式丢 |

写作这事,在 AI 时代更像你的生活感 + 结构能力的组合。

Markdown 负责结构,你负责生活感。

四部门:因地制宜打造休闲农业、乡村旅游、民宿经济、电商直播等新产业、新业态金融服务模式

中国央行等四部门发布《关于统筹建立常态化金融支持机制 助力防止返贫致贫和乡村全面振兴的意见》提出,保障农业全产业链金融需求。加大农业特色产业金融支持力度,以生产流通等关键环节为依托,在合规的前提下,开发应收账款融资、订(仓)单质押、供应链票据等供应链金融服务场景,提供结算、融资和财务管理等综合性金融服务。金融机构要积极对接核心企业及仓储、物流、运输等环节的管理系统,实现信息互联互通,提高服务能力和风险控制水平。积极对接全国农业品牌精品培育计划,针对优势特色产业集群等建立批量化授信模式,提高服务效率。因地制宜打造休闲农业、乡村旅游、民宿经济、电商直播等新产业、新业态金融服务模式,进一步拓展、提升农业综合收益。

四部门:强化重点领域金融资源投入,做好粮油生产金融服务

中国人民银行、金融监管总局、中国证监会、农业农村部印发《关于统筹建立常态化金融支持机制 助力防止返贫致贫和乡村全面振兴的意见》,《意见》强调,要强化重点领域金融资源投入,做好粮油生产金融服务,支持农业综合生产能力和质量效益提升。开发应收账款融资等供应链金融服务场景,保障农业全产业链金融需求,扩大县域富民产业发展金融供给。加大农村基础设施建设中长期资金投入,支持“农文旅”融合发展。要强化金融服务能力建设,健全金融组织体系。深化实施金融科技赋能乡村振兴示范工程,推动移动支付等新兴支付方式普及应用,持续开展“信用户、信用村、信用乡(镇)”及新型农业经营主体评定工作,夯实农村基础金融服务。

减排超90%,国内首艘甲醇单一燃料江海直达船成功首航

江苏勤丰船厂码头汽笛长鸣,国内首艘以甲醇为单一燃料的江海直达船舶——“创新19”轮正式启航,驶往宁波舟山港。这是我国首艘15000吨级甲醇单一燃料特定航线江海直达船舶,其首航标志着甲醇燃料在我国航运领域的商业化应用迈出关键一步。

TinyEngine 2.10 版本发布:零代码 CRUD、云端协作,开发效率再升级!

本文由体验技术团队Hexqi原创。

前言

TinyEngine 是一款面向未来的低代码引擎底座,致力于为开发者提供高度可定制的技术基础设施——不仅支持可视化页面搭建等核心能力,更可通过 CLI 工程化方式实现深度二次开发,帮助团队快速构建专属的低代码平台。

无论是资源编排、服务端渲染、模型驱动应用,还是移动端、大屏端、复杂页面编排场景,TinyEngine 都能灵活适配,成为你构建低代码体系的坚实基石。

最近我们正式发布 TinyEngine v2.10 版本,带来多项功能升级与体验优化:模型驱动、登录鉴权、应用中心等全新特性,同时还有Schema面板与画布节点同步、出码源码即时预览、支持添加自定义 MCP 服务器等功能进行了增强,以让开发协作、页面搭建变得更简单、更高效。

版本特性总览

核心特性

  • 模型驱动:零代码创建 CRUD
  • 多租户与登录鉴权能力
  • 新增应用中心与模板中心

功能增强

  • 出码支持即时查看代码
  • 自定义 MCP 服务器,扩展 AI 助手能力
  • 画布与 Schema 面板支持同步滚动
  • 页面 Schema CSS 字段格式优化
  • 图表物料更新,组件属性配置平铺优化
  • 多项细节优化与 Bug 修复

体验升级

  • 新官网:UI 全面焕新
  • 新文档:域名迁移与样式升级
  • 新演练场:真实前后端,完整功能体验

新特性详解

1. 【核心特性】模型驱动:零代码极速创建CRUD页面(体验版本)

背景与问题

在传统的后台管理系统开发中,创建一个包含表单、表格和完整 CRUD(增删改查) 功能的页面往往需要开发者:

  • 重复配置相似的表单和表格组件
  • 手动绑定数据源、编写事件处理逻辑
  • 数据模型变更时,同步修改多个组件配置

这种重复性劳动不仅耗时,还容易出错。

核心功能

模型驱动特性通过声明式的数据模型配置,自动生成对应的 UI 组件和数据交互逻辑,实现真正的"零代码"生成数据管理页面。

核心模块

模块 功能
模型管理器插件 可视化创建数据模型、配置字段和 API,管理模型
内置模型组件 表单、表格、组合表单+表格,基于模型自动生成表单、表格,或组合生成完整 CRUD 页面
模型绑定配置器组件 为模型生成 UI、绑定 CRUD 逻辑

支持的模型字段类型:String(字符串)、Number(数字)、Boolean(布尔)、Date(日期)、Enum(枚举)、ModelRef(关联模型)

1.png

价值亮点

  • 开发效率大幅提升:通过配置模型即可生成完整的 CRUD 页面,无需手动配置每个组件
  • 后端自动生成:使用默认接口路径时,自动生成数据库表结构和 CRUD 接口
  • UI 与接口自动绑定:拖拽组件选择模型后,UI 自动生成,接口自动绑定,一站式完成前后端搭建
  • 支持嵌套模型:字段可关联其他模型,实现复杂数据结构(如用户关联部门)(后续实现)
  • 标准化输出:基于统一模型生成的 UI 组件保证了一致性
  • 灵活扩展:可自定义字段类型和组件映射

使用场景

  • 后台管理系统的数据管理页面
  • 需要频繁进行增删改查操作的业务场景
  • 需要快速原型的项目

快速上手

1. 创建数据模型

打开模型管理器插件,创建数据模型(如"用户信息"):

  • 配置模型基本信息:中文名称、英文名称、描述
  • 添加模型字段(如姓名、年龄、邮箱等)
  • 配置字段类型、默认值、是否必填等属性

2. 配置接口路径(可选)

创建模型时,可以选择:

  • 使用默认路径:系统自动使用后端模型接口作为基础路径,并在后端自动生成对应的 SQL 表结构和 CRUD 接口
  • 自定义路径:指定自己的接口基础路径,对接已有后端服务

3. 拖拽模型组件到页面

在物料面板中选择模型组件拖拽到画布:

  • 表格模型:生成数据列表
  • 表单模型:生成数据录入表单
  • 页面模型:生成包含搜索、表格、编辑弹窗的完整 CRUD 页面

4. 绑定模型,自动生成

选中组件后,在右侧属性面板:
1) 点击"绑定模型数据",选择刚才创建的模型
2) 系统自动生成 UI 界面
3) 系统自动绑定 CRUD 接口
4) 一站式完成前后端搭建

5. 预览页面

预览即可看到包含搜索、新增、编辑、删除、分页功能的完整数据管理页面。

2.gif

核心流程图

graph LR
    A[创建数据模型] --> B{选择接口路径}
    B -->|默认路径| C[后端自动生成<br/>SQL表结构+CRUD接口]
    B -->|自定义路径| D[对接已有后端]
    C --> E[拖拽模型组件到页面]
    D --> E
    E --> F[绑定模型]
    F --> G[系统自动生成UI]
    F --> H[系统自动绑定接口]
    G --> I[预览完整CRUD页面]
    H --> I

    style A fill:#e1f5fe
    style C fill:#fff3e0
    style G fill:#f3e5f5
    style H fill:#f3e5f5
    style I fill:#e8f5e9

用户只需关注

定义好数据模型,前后端自动生成:

  • ✅ 无需手动编写表单 HTML
  • ✅ 无需手动编写表格渲染逻辑
  • ✅ 无需手动编写 API 调用代码
  • ✅ 无需手动编写数据验证规则
  • ✅ 无需手动编写分页排序逻辑

让用户专注于业务逻辑和模型设计,而非重复的 UI 代码编写。

2. 【核心特性】多租户与登录鉴权能力

功能概述

TinyEngine v2.10 引入了完整的用户认证系统,支持用户登录、注册、密码找回,并结合多租户体系,让您的设计作品可以实现云端保存、多设备同步和团队协作。

登录注册

  • 用户登录:基于用户名/密码的身份认证,Token 自动管理
  • 用户注册:支持新用户注册,注册成功后提供账户恢复码用于找回密码
  • 密码找回:通过账户恢复码重置密码,无需邮件验证

3.png

组织管理

  • 多组织支持:用户可属于多个组织,灵活切换不同工作空间
  • 组织切换:动态切换组织上下文,组织间数据隔离
  • 创建组织:一键创建新组织,邀请团队成员加入

4.png

登录鉴权流程

系统采用 Token 认证机制,通过 HTTP 拦截器实现统一的请求处理和权限验证:

sequenceDiagram
    participant 用户
    participant 前端应用
    participant HTTP拦截器
    participant 后端API

    用户->>前端应用: 1. 输入用户名/密码登录
    前端应用->>后端API: 2. POST /platform-center/api/user/login
    后端API-->>前端应用: 3. 返回 Token
    前端应用->>前端应用: 4. 保存 Token 到 localStorage

    Note over 前端应用,后端API: 后续请求自动携带 Token

    前端应用->>HTTP拦截器: 5. 发起业务请求
    HTTP拦截器->>HTTP拦截器: 6. 检查 Token 并注入 Authorization 头
    HTTP拦截器->>后端API: 7. 携带 Token 的请求
    后端API-->>HTTP拦截器: 8. 返回数据 或 认证失败(401)

    alt 认证失败
        HTTP拦截器->>前端应用: 9. 清除 Token,显示登录弹窗
        前端应用->>用户: 10. 提示重新登录
    end

访问入口

1)登录界面:访问 TinyEngine 时系统会自动弹出登录窗口,未登录用户需完成登录或注册。

2)组织切换:登录后可通过以下方式切换组织:

  • 点击顶部工具栏的用户头像,选择「切换组织」
  • 在用户菜单中直接选择目标组织

3)退出/重新登录:已登录用户可以点击右上角头像在菜单点击"退出登录",进入登录页面重新登录

使用场景

1)个人使用:登录后即可享受云端保存、多设备同步等功能,设计作品永不丢失。

2)团队协作

  • 创建组织:为团队或项目创建独立组织空间
  • 数据隔离:不同组织的资源完全隔离,清晰区分个人与团队项目

💡 提示:新注册用户默认属于 public 公共组织,所有数据公共可见,您也可以创建自定义组织隔离数据。

开发者指南

1)环境配置

  • 开发环境:通过 pnpm dev:withAuth 命令启用登录认证,pnpm dev 默认不启用(mock server)
  • 生产环境:自动启用完整登录认证系统

也可以修改配置文件来启动或关闭登录鉴权:

export default {
  // enableLogin: true // 打开或关闭登录认证
}

2)多租户机制

  • 用户可属于多个组织,通过 URL 参数标识当前组织上下文
  • 组织间数据完全隔离,切换组织可查看不同资源
  • 当 URL 未携带应用 ID 或组织 ID 时,系统自动跳转到应用中心

3. 【核心特性】应用中心与模板中心

应用中心和模板中心是此次版本新增的两大核心功能模块。通过应用中心可以集中管理您创建的所有低代码应用,为不同的场景创建不同的应用;模板中心则让优秀页面设计得以沉淀为可复用资产,团队成员可以基于模板快速搭建新页面,大幅提升协作效率。

应用中心

登录后进入应用中心,集中管理您创建的所有低代码应用。

功能亮点

  • 统一管理:在一个界面查看、创建、打开所有应用
  • 快速切换:无需手动输入 URL,一键进入任意应用编辑器
  • 组织隔离:不同组织的应用数据隔离,清晰区分个人与团队项目

5.png

模板中心

模板中心让页面设计资产得以沉淀和复用,提升团队协作效率。

核心价值

  • 设计复用:保存优秀页面设计为模板,避免重复造轮子
  • 快速启动:基于模板创建新页面,继承已有布局和样式
  • 团队共享:组织内共享设计资产,统一 UI 风格和设计规范

6.png

7.png

访问入口

在编辑器中点击左上角菜单按钮,悬停即可看到应用中心模板中心入口,点击即可前往。

使用说明

自动跳转规则

  • 如果访问编辑器时未携带应用 ID 或组织 ID 参数,系统会自动跳转到应用中心
  • 您可以在应用中心创建新应用,或打开已有应用进入编辑器

组织权限说明

  • public 组织:默认公共组织,所有用户的应用对所有人可见
  • 自定义组织:用户新建的组织默认仅创建者可见,需手动邀请成员加入
  • 切换组织可以查看不同组织下的应用和资源

特性开关

如果不需要使用应用中心与模板中心,可以在注册表中进行关闭:

// registry.js
export default {
  [META_APP.AppCenter]: false, // 关闭应用中心
  [META_APP.TemplateCenter]: false // 关闭模板中心
  // ...
}

4. 【增强】出码即时预览 - 导出前预览所见即所得

出码功能新增源码预览能力,用户在导出代码前可以实时查看生成的源码内容,提升代码导出体验和准确性。

功能特性

  • 左右分栏布局:左侧树形文件列表,右侧 Monaco 代码编辑器预览
  • 智能初始化:打开对话框时自动显示当前编辑页面对应的文件代码
  • 实时预览:点击树形列表中的任意文件,即可在右侧预览其代码内容
  • 灵活选择:支持勾选需要导出的文件

使用方法

1) 在编辑器中点击「出码」按钮
2) 打开的弹窗中左侧树形列表显示所有可生成的文件,当前页面对应文件自动展示在右侧
3) 点击任意文件预览源码,勾选需要导出的文件
4) 点击「确定」选择保存目录完成导出

8.png

5. 【增强】自定义 MCP 服务器 - 扩展 AI 助手能力

之前版本中,TinyEngine已经提供内置MCP 服务,可以通过MCP工具让AI调用平台提供的各种能力。 本次特性是在TinyEngine 中支持添加自定义 MCP (Model Context Protocol) 服务器,可以通过配置轻松集成第三方 MCP 服务,扩展 AI 开发助手的工具能力。

功能特性

  • 灵活配置:通过注册表简单的配置即可添加自定义服务器
  • 协议支持:支持 SSE 和 StreamableHttp 两种传输协议
  • 服务管理:在 AI 插件的配置界面即可管理 MCP 服务器的开关状态
  • 工具控制:可查看并切换各个工具的启用状态

使用步骤

1) 准备您的 MCP 服务器(需符合 MCP 协议规范

2) 在项目的 registry.js 中添加配置

// 使用示例
// registry.js
export default {
  [META_APP.Robot]: {
    options: {
      mcpConfig: {
        mcpServers: {
          'my-custom-server': {
            type: 'SSE',              // 支持 'SSE' 或 'StreamableHttp'
            url: 'https://your-server.com/sse',
            name: '我的自定义服务器',
            description: '提供xxx功能的工具',
            icon: 'https://your-icon.png'  // 可选
          }
        }
      }
    }
  }
}

3) 刷新编辑器,在 AI 插件 MCP 管理面板中即可看到新添加的服务器

9.png

4) 启用服务器,选择需要的工具,即可在 AI 助手中开始使用!

场景示例

您可以集成企业内部 MCP 服务、社区 MCP 服务、第三方 MCP 工具等,扩展 AI 助手的业务能力。

例如,下面是一个添加图片搜索MCP服务后使用AI生成带图片页面的场景示例:

10.gif

6. 【增强】画布与 Schema 面板支持同步滚动

Schema 面板新增"跟随画布"功能,启用后当在画布中选中组件时,Schema 面板会自动滚动到选中组件的对应位置并高亮显示。

使用场景

  • 快速定位:当页面元素较多时,能快速找到对应组件的 Schema 配置
  • 双向对照:可视化视图与 JSON 代码视图对照,便于理解页面结构

使用方法

打开 Schema 面板,勾选面板标题栏的"跟随画布"复选框启用。在画布中点击切换元素,即可看到 Schema 面板跟随变化。

效果如下:

11.gif

7. 【优化】页面 Schema CSS 字段格式优化

页面 Schema 中的 CSS 样式字段由字符串格式优化为对象格式,提升样式配置的可读性和可维护性。系统会自动处理对象与字符串的相互转换,出码时自动转换为标准 CSS 字符串格式,同时完美兼容之前的字符串格式。

优化场景

  • AI场景更友好:AI生成代码及修改样式场景,能够更快速地进行增量生成及修改
  • 编辑更直观:对象格式支持属性智能提示和语法高亮,编辑体验更佳
  • 阅读更清晰:结构化的对象格式易于查看和修改样式属性
  • 维护更便捷:新增或修改样式规则时,无需手动拼接 CSS 字符串

格式对比

之前(字符串格式)

"css": ".page-base-style { padding: 24px; background: #FFFFFF; } .block-base-style { margin: 16px; } .component-base-style { margin: 8px; }"

现在(对象格式)

"css": {
  ".page-base-style": {
    "padding": "24px",
    "background": "#FFFFFF"
  },
  ".block-base-style": {
    "margin": "16px"
  },
  ".component-base-style": {
    "margin": "8px"
  }
}

兼容性说明

  • 两种格式完全兼容,可在同一项目中混用
  • 系统自动识别格式类型并进行转换
  • 出码时统一转换为标准 CSS 字符串格式
  • 页面样式设置等场景使用都与之前保持一致,不受该特性影响

8. 【增强】图表物料更新,组件属性优化

图表物料进行了如下优化:

  • 添加三种常用图表组件物料:仪表盘、拓扑图、进度图
  • 图表组件的配置面板优化,将原有的图标配置属性由整体 options 配置拆分为独立的属性配置项(颜色、数据、坐标轴等),使配置更加清晰直观。

12.png

9. 【新体验】新演练场 - 完整的前后端体验

演练场进行了全面升级,从原来的前端 Mock 数据改为完整的前后端部署,带来真实的体验环境。

升级亮点

  • 完整的前后端部署:不再是拦截接口 Mock 数据,而是真实的服务端环境
  • 支持用户登录:可以使用真实账户登录演练场
  • 数据隔离:用户数据基于租户进行共享或隔离,更符合实际使用场景
  • 功能完整体验:之前无法体验的功能现在都可以正常使用,如AI助手插件自然语言生成页面

新演练场地址playground.opentiny.design/tiny-engine…

13.png

通过下面两个入口都可以访问:

如您希望继续使用旧版演练场,依旧可以通过下面地址继续访问: 旧版演练场:opentiny.design/tiny-engine…

10. 【新体验】新官网 - UI 全面焕新

TinyEngine 官网首页 UI 全面焕新,带来更现代、更清爽的视觉体验。

  • 全新设计:首页内容刷新,并采用现代化的设计语言,视觉更加清爽美观
  • 响应式布局:完美适配各种屏幕尺寸,移动端访问更友好

访问新版官网:opentiny.design/tiny-engine

14.png

11.【新体验】新文档 - 全新文档体验

TinyEngine 文档与其他OpenTiny产品文档统一迁移至新docs子域名:

新域名docs.opentiny.design/tiny-engine…

文档变化:

  • 整体更统一,方便查找切换其他文档
  • 同时也进行了全面的样式优化,阅读体验更佳

15.png

12. 【其他】功能细节优化&bug修复

结语

回首这一年,TinyEngine 在开源社区的成长离不开每一位开发者和贡献者的支持。v2.10 版本作为春节前的最后一次发布,我们为大家带来了多项重磅特性:

特性 核心价值
模型驱动 零代码 CRUD,开发效率跃升
多租户与登录鉴权 云端协作、团队协作
应用中心与模板中心 应用管理、资产沉淀
出码预览 导出前预览,提升代码导出体验
自定义 MCP 扩展 AI 能力,集成企业服务
Schema 面板同步滚动 画布与代码视图联动
CSS 字段格式优化 对象格式,可读性更强
图表物料更新 配置平铺,更直观
新演练场 真实前后端,完整体验
新官网/文档 UI 焕新,体验升级

致谢

本次版本的开发和问题修复诚挚感谢各位贡献者的积极参与!同时邀请大家加入开源社区的建设,让 TinyEngine 在新的一年里成长得更加优秀和茁壮!

新春祝福

值此新春佳节即将到来之际,TinyEngine 团队衷心祝愿大家:

🧧 新年快乐,万事如意! 🧧

愿新的一年里:

  • 代码如诗行云流水
  • 项目如期顺利上线
  • Bug 远离,需求清晰
  • 团队协作高效顺畅
  • 事业蒸蒸日上,生活幸福美满!

🎊 春节快乐,阖家幸福! 🎊

让我们在春节后带着满满的热情和能量,继续在未来道路上探索前行!

关于OpenTiny

欢迎加入 OpenTiny 开源社区。添加微信小助手:opentiny-official 一起参与交流前端技术~
OpenTiny 官网:opentiny.design
OpenTiny 代码仓库:github.com/opentiny
TinyEngine源码:github.com/opentiny/ti…

欢迎进入代码仓库 Star🌟TinyEngine、TinyVue、TinyPro、TinyNG、TinyCLI、TinyEditor
如果你也想要共建,可以进入代码仓库,找到 good first issue标签,一起参与开源贡献~

1月份国家铁路发送货物3.32亿吨

记者从中国国家铁路集团有限公司获悉,今年1月,国家铁路累计发送货物3.32亿吨,同比增长1.6%;日均装车18.07万车,同比增长3%,呈现量质齐升的良好态势。

Vue中默认插槽、具名插槽、作用域插槽如何区分与使用?

一、插槽的基本概念

在Vue组件化开发中,插槽(Slot)是一种强大的内容分发机制,它允许父组件向子组件传递任意模板内容,让子组件的结构更加灵活和可复用。你可以把插槽想象成子组件中预留的“占位符”,父组件可以根据需要在这些占位符中填充不同的内容,就像给积木玩具替换不同的零件一样。

插槽的核心思想是组件的结构与内容分离:子组件负责定义整体结构和样式,父组件负责提供具体的内容。这种设计让组件能够适应更多不同的场景,同时保持代码的可维护性。

二、默认插槽:最简单的内容分发

2.1 什么是默认插槽

默认插槽是最基础的插槽类型,它没有具体的名称,父组件传递的所有未指定插槽名的内容都会被渲染到默认插槽的位置。

2.2 基础使用示例

子组件(FancyButton.vue)

<template>
  <button class="fancy-btn">
    <slot></slot> <!-- 插槽出口:父组件的内容将在这里渲染 -->
  </button>
</template>

<style scoped>
.fancy-btn {
  padding: 8px 16px;
  border: none;
  border-radius: 4px;
  background-color: #42b983;
  color: white;
  cursor: pointer;
}
</style>

父组件使用

<template>
  <FancyButton>
    Click me! <!-- 插槽内容:将被渲染到子组件的slot位置 -->
  </FancyButton>
</template>

最终渲染出的HTML结构:

<button class="fancy-btn">Click me!</button>

2.3 为插槽设置默认内容

在父组件没有提供任何内容时,我们可以为插槽设置默认内容,确保组件在任何情况下都能正常显示。

子组件(SubmitButton.vue)

<template>
  <button type="submit" class="submit-btn">
    <slot>Submit</slot> <!-- 默认内容:当父组件没有传递内容时显示 -->
  </button>
</template>

父组件使用

<template>
  <!-- 不传递内容,显示默认的"Submit" -->
  <SubmitButton />
  
  <!-- 传递内容,覆盖默认值 -->
  <SubmitButton>Save Changes</SubmitButton>
</template>

三、具名插槽:精准控制内容位置

3.1 为什么需要具名插槽

当组件的结构比较复杂,包含多个需要自定义的区域时,默认插槽就不够用了。这时我们可以使用具名插槽,为每个插槽分配唯一的名称,让父组件能够精准地控制内容渲染到哪个位置。

3.2 基础使用示例

子组件(BaseLayout.vue)

<template>
  <div class="layout-container">
    <header class="layout-header">
      <slot name="header"></slot> <!-- 具名插槽:header -->
    </header>
    <main class="layout-main">
      <slot></slot> <!-- 默认插槽:未指定名称的内容将在这里渲染 -->
    </main>
    <footer class="layout-footer">
      <slot name="footer"></slot> <!-- 具名插槽:footer -->
    </footer>
  </div>
</template>

<style scoped>
.layout-container {
  max-width: 1200px;
  margin: 0 auto;
}
.layout-header {
  padding: 16px;
  border-bottom: 1px solid #eee;
}
.layout-main {
  padding: 24px;
}
.layout-footer {
  padding: 16px;
  border-top: 1px solid #eee;
  text-align: center;
}
</style>

父组件使用

<template>
  <BaseLayout>
    <!-- 使用#header简写指定内容渲染到header插槽 -->
    <template #header>
      <h1>我的博客</h1>
    </template>
    
    <!-- 未指定插槽名的内容将渲染到默认插槽 -->
    <article>
      <h2>Vue插槽详解</h2>
      <p>这是一篇关于Vue插槽的详细教程...</p>
    </article>
    
    <!-- 使用#footer简写指定内容渲染到footer插槽 -->
    <template #footer>
      <p>© 2025 我的博客 版权所有</p>
    </template>
  </BaseLayout>
</template>

3.3 动态插槽名

Vue还支持动态插槽名,你可以使用变

往期文章归档
免费好用的热门在线工具
量来动态指定要渲染的插槽:
<template>
  <BaseLayout>
    <template #[dynamicSlotName]>
      <p>动态插槽内容</p>
    </template>
  </BaseLayout>
</template>

<script setup>
import { ref } from 'vue'
const dynamicSlotName = ref('header') // 可以根据需要动态修改
</script>

四、作用域插槽:子组件向父组件传递数据

4.1 什么是作用域插槽

在之前的内容中,我们了解到插槽内容只能访问父组件的数据(遵循JavaScript的词法作用域规则)。但在某些场景下,我们希望插槽内容能够同时使用父组件和子组件的数据,这时就需要用到作用域插槽

作用域插槽允许子组件向插槽传递数据,父组件可以在插槽内容中访问这些数据。

4.2 基础使用示例

子组件(UserItem.vue)

<template>
  <div class="user-item">
    <!-- 向插槽传递user对象作为props -->
    <slot :user="user" :isAdmin="isAdmin"></slot>
  </div>
</template>

<script setup>
import { ref } from 'vue'
const user = ref({
  name: '张三',
  age: 28,
  avatar: 'https://via.placeholder.com/60'
})
const isAdmin = ref(true)
</script>

父组件使用

<template>
  <!-- 使用v-slot指令接收插槽props -->
  <UserItem v-slot="slotProps">
    <img :src="slotProps.user.avatar" alt="用户头像" class="avatar">
    <div class="user-info">
      <h3>{{ slotProps.user.name }}</h3>
      <p>年龄:{{ slotProps.user.age }}</p>
      <span v-if="slotProps.isAdmin" class="admin-tag">管理员</span>
    </div>
  </UserItem>
</template>

4.3 解构插槽Props

为了让代码更简洁,我们可以使用ES6的解构语法直接提取插槽Props:

<template>
  <UserItem v-slot="{ user, isAdmin }">
    <img :src="user.avatar" alt="用户头像" class="avatar">
    <div class="user-info">
      <h3>{{ user.name }}</h3>
      <p>年龄:{{ user.age }}</p>
      <span v-if="isAdmin" class="admin-tag">管理员</span>
    </div>
  </UserItem>
</template>

4.4 具名作用域插槽

具名插槽也可以传递Props,父组件需要在对应的具名插槽上接收:

子组件

<template>
  <div class="card">
    <slot name="header" :title="cardTitle"></slot>
    <slot :content="cardContent"></slot>
  </div>
</template>

<script setup>
import { ref } from 'vue'
const cardTitle = ref('卡片标题')
const cardContent = ref('这是卡片的内容...')
</script>

父组件

<template>
  <Card>
    <template #header="{ title }">
      <h2>{{ title }}</h2>
    </template>
    
    <template #default="{ content }">
      <p>{{ content }}</p>
    </template>
  </Card>
</template>

五、课后Quiz

题目

  1. 什么是默认插槽?请给出一个简单的使用示例。
  2. 具名插槽的主要作用是什么?如何在父组件中指定内容渲染到具名插槽?
  3. 作用域插槽解决了什么问题?请描述其工作原理。
  4. 如何为插槽设置默认内容?

答案解析

  1. 默认插槽是组件中没有指定名称的插槽,父组件传递的未指定插槽名的内容会被渲染到默认插槽的位置。示例:

    <!-- 子组件 -->
    <button><slot></slot></button>
    <!-- 父组件 -->
    <Button>点击我</Button>
    
  2. 具名插槽用于组件包含多个需要自定义的区域的场景,每个插槽有唯一的名称,父组件可以精准控制内容的渲染位置。父组件使用<template #插槽名>的语法传递内容到指定的具名插槽。

  3. 作用域插槽解决了插槽内容无法访问子组件数据的问题。工作原理:子组件在插槽出口上传递Props(类似组件Props),父组件使用v-slot指令接收这些Props,从而在插槽内容中访问子组件的数据。

  4. <slot>标签之间写入默认内容即可,当父组件没有传递内容时,默认内容会被渲染:

    <slot>默认内容</slot>
    

六、常见报错解决方案

1. 报错:v-slot指令只能用在<template>或组件标签上

原因v-slot指令只能用于<template>标签或组件标签,不能直接用于普通HTML元素。 解决办法:将v-slot指令移到<template>标签或组件标签上。例如:

<!-- 错误写法 -->
<div v-slot="slotProps">{{ slotProps.text }}</div>

<!-- 正确写法 -->
<template v-slot="slotProps">
  <div>{{ slotProps.text }}</div>
</template>

2. 报错:未定义的插槽Props

原因:父组件尝试访问子组件未传递的插槽Props。 解决办法

  • 确保子组件在插槽出口上传递了对应的Props;
  • 在父组件中使用可选链操作符(?.)避免报错:
    <MyComponent v-slot="{ text }">
      {{ text?.toUpperCase() }} <!-- 使用可选链操作符 -->
    </MyComponent>
    

3. 报错:具名插槽的内容未显示

原因

  • 父组件传递具名插槽内容时,插槽名拼写错误;
  • 子组件中没有定义对应的具名插槽。 解决办法
  • 检查插槽名是否拼写正确(注意大小写敏感);
  • 确保子组件中定义了对应的具名插槽:<slot name="header"></slot>

4. 报错:默认插槽和具名插槽同时使用时的作用域混淆

原因:当同时使用默认插槽和具名插槽时,直接为组件添加v-slot指令会导致编译错误,因为默认插槽的Props作用域会与具名插槽混淆。 解决办法:为默认插槽使用显式的<template>标签:

<!-- 错误写法 -->
<MyComponent v-slot="{ message }">
  <p>{{ message }}</p>
  <template #footer>
    <p>{{ message }}</p> <!-- message 属于默认插槽,此处不可用 -->
  </template>
</MyComponent>

<!-- 正确写法 -->
<MyComponent>
  <template #default="{ message }">
    <p>{{ message }}</p>
  </template>
  
  <template #footer>
    <p>页脚内容</p>
  </template>
</MyComponent>

参考链接

cn.vuejs.org/guide/compo…

财政部在全国范围开展数智化背景下会计相关典型案例征集工作

为了深入贯彻落实党的二十大和二十届历次全会精神,促进企业和行政事业单位(以下简称单位)高质量发展,总结、推广数智化背景下单位在会计核算、管理会计、内部控制、可持续信息披露、财会人才培养等领域的实践经验,积极推动会计工作数智化转型,经研究,决定在全国范围开展数智化背景下会计相关典型案例征集工作。

蚂蚁阿福下载量冲上苹果应用总榜第一

2月14日,苹果AppStore中国区免费应用排行榜显示,蚂蚁阿福、千问下载量包揽总榜前二。其中,蚂蚁阿福下载量登顶苹果应用总榜第一。春节期间,蚂蚁阿福上线了“健康福”活动,春节返乡高峰带动年轻人教家人用阿福的潮流,阿福App的下载量大涨。此外,阿福“健康福”红包活动将延续到除夕。

上海未来产业基金拟参与投资9只子基金

2月14日,上海未来产业基金发布消息称,拟参与投资9只子基金,分别为新途四方(上海)创业投资中心(有限合伙)、上海和谐汇资创业投资合伙企业(有限合伙)、南京耀途四期创业投资合伙企业(有限合伙)、上海昊辰二号创业投资合伙企业(有限合伙)(暂定名)、成都自知联锦创业投资合伙企业(有限合伙)、上海易启未来创业投资合伙企业(有限合伙)(暂定名)、上海启明融康私募基金合伙企业(有限合伙)、无锡博原兴成创业投资合伙企业(有限合伙)和安徽华盖尔臻股权投资基金合伙企业(有限合伙)。

React 样式——styled-components

在 React 开发中,样式管理一直是绕不开的核心问题 —— 全局 CSS 命名冲突、动态样式繁琐、样式与组件解耦难等痛点,长期困扰着前端开发者。而 styled-components 作为 React 生态中最主流的 CSS-in-JS 方案,彻底颠覆了传统样式编写方式,将样式与组件深度绑定,让样式管理变得简洁、可维护且灵活。本文将从核心原理、基础语法、进阶技巧到实战场景,全面拆解 styled-components 的使用精髓,涵盖原生标签、自定义组件、第三方组件适配等全场景用法。

一、什么是 styled-components?

styled-components 是一款专为 React/React Native 设计的 CSS-in-JS 库,核心思想是 “将 CSS 样式写在 JavaScript 中,并与组件一一绑定”。它由 Max Stoiber 于 2016 年推出,目前 GitHub 星数超 40k,被 Airbnb、Netflix、Spotify 等大厂广泛采用。

核心优势

  1. 样式封装,杜绝污染:每个样式组件生成唯一的 className,彻底解决全局 CSS 命名冲突问题;
  2. 动态样式,灵活可控:直接通过组件 props 控制样式,无需拼接 className 或写内联样式;
  3. 自动前缀,兼容省心:自动为 CSS 属性添加浏览器前缀(如 -webkit--moz-),无需手动处理兼容;
  4. 语义化强,易维护:样式与组件代码同文件,逻辑闭环,可读性和可维护性大幅提升;
  5. 按需打包,体积优化:打包时自动移除未使用的样式,减少冗余代码;
  6. 通用适配,场景全覆盖:既支持 HTML 原生标签,也兼容自定义组件、第三方 UI 组件(如 KendoReact/Ant Design)。

二、基础语法:从原生 HTML 标签到样式组件

styled-components 的核心语法分为两种形式,分别适配不同场景,是掌握该库的基础。

1. 安装

在 React 项目中安装核心依赖(TypeScript 项目可额外安装类型声明):

# npm
npm install styled-components

# yarn
yarn add styled-components

# TypeScript 类型声明(新版已内置,可选)
npm install @types/styled-components --save-dev

2. 语法形式 1:styled.HTML标签(原生标签快捷写法)

这是最常用的基础语法,styled. 后紧跟 HTML 原生标签名(如 div/button/p/h1/input 等),本质是 styled() 函数的语法糖,用于快速创建带样式的原生 HTML 组件。

多标签示例:覆盖高频 HTML 元素

import React from 'react';
import styled from 'styled-components';

// 1. 布局容器:div
const Container = styled.div`
  width: 90%;
  max-width: 1200px;
  margin: 20px auto;
  padding: 24px;
  border: 1px solid #e5e7eb;
  border-radius: 8px;
  box-shadow: 0 2px 4px rgba(0,0,0,0.05);
`;

// 2. 标题:h1/h2
const TitleH1 = styled.h1`
  color: #1f2937;
  font-size: 32px;
  font-weight: 700;
  margin-bottom: 16px;
`;

// 3. 文本:p/span
const Paragraph = styled.p`
  color: #4b5563;
  font-size: 16px;
  line-height: 1.6;
  margin-bottom: 12px;
`;
const HighlightText = styled.span`
  color: #2563eb;
  font-weight: 500;
`;

// 4. 交互:button/a
const PrimaryButton = styled.button`
  padding: 10px 20px;
  background-color: #2563eb;
  color: white;
  border: none;
  border-radius: 6px;
  cursor: pointer;
  &:hover { background-color: #1d4ed8; }
  &:disabled { background-color: #93c5fd; cursor: not-allowed; }
`;
const Link = styled.a`
  color: #2563eb;
  text-decoration: none;
  &:hover { text-decoration: underline; color: #1d4ed8; }
`;

// 5. 表单:input/label
const FormLabel = styled.label`
  display: block;
  font-size: 14px;
  color: #374151;
  margin-bottom: 6px;
`;
const Input = styled.input`
  width: 100%;
  padding: 10px 12px;
  border: 1px solid #d1d5db;
  border-radius: 6px;
  &:focus {
    outline: none;
    border-color: #2563eb;
    box-shadow: 0 0 0 2px rgba(37, 99, 235, 0.2);
  }
`;

// 6. 列表:ul/li
const List = styled.ul`
  margin: 16px 0;
  padding-left: 24px;
`;
const ListItem = styled.li`
  margin-bottom: 8px;
  &:last-child { margin-bottom: 0; }
`;

// 使用示例
function BasicTagDemo() {
  return (
    <Container>
      <TitleH1>原生标签样式化示例</TitleH1>
      <Paragraph>
        这是 <HighlightText>styled.p</HighlightText> 渲染的段落,支持 <HighlightText>styled.span</HighlightText> 行内样式。
      </Paragraph>
      <List>
        <ListItem>styled.div:布局容器核心标签</ListItem>
        <ListItem>styled.button:交互按钮,支持 hover/禁用状态</ListItem>
        <ListItem>styled.input:表单输入框,支持焦点样式</ListItem>
      </List>
      <FormLabel htmlFor="username">用户名</FormLabel>
      <Input id="username" placeholder="请输入用户名" />
      <PrimaryButton style={{ marginTop: '10px' }}>提交</PrimaryButton>
      <Link href="#" style={{ marginLeft: '10px' }}>忘记密码?</Link>
    </Container>
  );
}

3. 语法形式 2:styled(组件)(自定义 / 第三方组件适配)

当需要给自定义 React 组件第三方 UI 组件添加样式时,必须使用 styled() 通用函数(styled.xxx 仅支持原生标签)。

核心要求

被包裹的组件需接收并传递 className 属性到根元素(第三方组件库如 KendoReact/AntD 已内置支持)。

示例 1:给自定义组件加样式

import React from 'react';
import styled from 'styled-components';

// 自定义组件:必须传递 className 到根元素
const MyButton = ({ children, className }) => {
  // 关键:将 className 传给根元素 <button>,样式才能生效
  return <button className={className}>{children}</button>;
};

// 用 styled() 包裹自定义组件,添加样式
const StyledMyButton = styled(MyButton)`
  background-color: #28a745;
  color: white;
  border: none;
  padding: 8px 16px;
  border-radius: 4px;
  &:hover { background-color: #218838; }
`;

function CustomComponentDemo() {
  return <StyledMyButton>自定义组件样式化</StyledMyButton>;
}

示例 2:给第三方组件(KendoReact)加样式

import React from 'react';
import styled from 'styled-components';
// 引入 KendoReact 按钮组件
import { Button } from '@progress/kendo-react-buttons';

// 用 styled() 覆盖第三方组件默认样式
const StyledKendoButton = styled(Button)`
  background-color: #dc3545 !important; /* 覆盖组件内置样式 */
  border-color: #dc3545 !important;
  color: white !important;
  padding: 8px 16px !important;
  
  &:hover {
    background-color: #c82333 !important;
  }
`;

function ThirdPartyComponentDemo() {
  return <StyledKendoButton>自定义样式的 KendoReact 按钮</StyledKendoButton>;
}

4. 两种语法的关系

styled.xxxstyled('xxx') 的语法糖(如 styled.div = styled('div')),仅简化原生标签的写法;而 styled(组件) 是通用方案,覆盖所有组件类型,二者底层均基于 styled-components 的样式封装逻辑。

三、进阶技巧:提升开发效率与可维护性

掌握基础语法后,这些进阶技巧能适配中大型项目的复杂场景。

1. 动态样式:通过 Props 控制样式

这是 styled-components 最核心的特性之一,无需拼接 className,直接通过 props 动态调整样式,适配状态切换、主题变化等场景。

jsx

import React from 'react';
import styled from 'styled-components';

// 带 props 的动态按钮
const DynamicButton = styled.button`
  padding: ${props => props.size === 'large' ? '12px 24px' : '8px 16px'};
  background-color: ${props => {
    switch (props.variant) {
      case 'primary': return '#2563eb';
      case 'danger': return '#dc3545';
      case 'success': return '#28a745';
      default: return '#6c757d';
    }
  }};
  color: white;
  border: none;
  border-radius: 6px;
  cursor: pointer;
  &:hover { opacity: 0.9; }
`;

function DynamicStyleDemo() {
  return (
    <div style={{ gap: '10px', display: 'flex', padding: '20px' }}>
      <DynamicButton variant="primary" size="large">主要大按钮</DynamicButton>
      <DynamicButton variant="danger">危险默认按钮</DynamicButton>
      <DynamicButton variant="success">成功按钮</DynamicButton>
    </div>
  );
}

2. 样式继承:复用已有样式

基于已定义的样式组件扩展新样式,避免重复代码,提升复用性。

import styled from 'styled-components';

// 基础按钮(通用样式)
const BaseButton = styled.button`
  padding: 8px 16px;
  border: none;
  border-radius: 4px;
  color: white;
  cursor: pointer;
  font-size: 14px;
`;

// 继承基础按钮,扩展危险按钮样式
const DangerButton = styled(BaseButton)`
  background-color: #dc3545;
  &:hover { background-color: #c82333; }
`;

// 继承并覆盖样式:轮廓按钮
const OutlineButton = styled(BaseButton)`
  background-color: transparent;
  border: 1px solid #2563eb;
  color: #2563eb;
  &:hover {
    background-color: #2563eb;
    color: white;
    transition: all 0.2s ease;
  }
`;

3. 全局样式:重置与全局配置

通过 createGlobalStyle 定义全局样式(如重置浏览器默认样式、设置全局字体),只需在根组件中渲染一次即可生效。

import React from 'react';
import styled, { createGlobalStyle } from 'styled-components';

// 全局样式组件
const GlobalStyle = createGlobalStyle`
  /* 重置浏览器默认样式 */
  * {
    margin: 0;
    padding: 0;
    box-sizing: border-box;
  }

  /* 全局字体和背景 */
  body {
    font-family: 'Microsoft YaHei', sans-serif;
    background-color: #f8f9fa;
    color: #333;
  }

  /* 全局链接样式 */
  a {
    text-decoration: none;
    color: #2563eb;
  }
`;

// 根组件中使用
function App() {
  return (
    <>
      <GlobalStyle /> {/* 全局样式生效 */}
      <div>应用内容...</div>
    </>
  );
}

4. 主题管理(ThemeProvider):全局样式统一

在中大型项目中,通过 ThemeProvider 统一管理主题(主色、副色、字体),支持主题切换(如浅色 / 暗黑模式)。

import React, { useState } from 'react';
import styled, { ThemeProvider } from 'styled-components';

// 定义主题对象
const lightTheme = {
  colors: { primary: '#2563eb', background: '#f8f9fa', text: '#333' },
  fontSize: { small: '12px', medium: '14px' }
};
const darkTheme = {
  colors: { primary: '#198754', background: '#212529', text: '#fff' },
  fontSize: { small: '12px', medium: '14px' }
};

// 使用主题样式
const ThemedCard = styled.div`
  padding: 20px;
  background-color: ${props => props.theme.colors.background};
  color: ${props => props.theme.colors.text};
  border-radius: 8px;
`;
const ThemedButton = styled.button`
  padding: 8px 16px;
  background-color: ${props => props.theme.colors.primary};
  color: white;
  border: none;
  border-radius: 4px;
`;

function ThemeDemo() {
  const [isDark, setIsDark] = useState(false);
  return (
    <ThemeProvider theme={isDark ? darkTheme : lightTheme}>
      <div style={{ padding: '20px' }}>
        <button onClick={() => setIsDark(!isDark)}>
          切换{isDark ? '浅色' : '暗黑'}主题
        </button>
        <ThemedCard style={{ marginTop: '10px' }}>
          <ThemedButton>主题化按钮</ThemedButton>
        </ThemedCard>
      </div>
    </ThemeProvider>
  );
}

5. 嵌套样式:模拟 SCSS 语法

支持样式嵌套,贴合组件 DOM 结构,减少选择器冗余。

const Card = styled.div`
  width: 300px;
  padding: 20px;
  border: 1px solid #eee;
  border-radius: 8px;

  /* 嵌套子元素样式 */
  .card-title {
    font-size: 20px;
    margin-bottom: 10px;
  }
  .card-content {
    font-size: 14px;
    /* 深层嵌套 */
    .highlight { color: #2563eb; }
  }
`;

四、实战场景:什么时候用 styled-components?

  1. 中大型 React 项目:需要严格样式封装,避免多人协作时的样式冲突;
  2. 动态样式频繁的场景:如按钮状态切换、主题切换、响应式布局;
  3. 组件库开发:样式与组件逻辑内聚,便于组件发布和复用;
  4. 第三方组件库定制:覆盖 KendoReact/AntD 等组件的默认样式,精准且不污染全局;
  5. 响应式开发:通过媒体查询快速适配不同屏幕尺寸,样式与组件同文件更易维护。

五、注意事项与最佳实践

  1. 避免过度嵌套:嵌套层级建议不超过 2-3 层,否则可读性下降;
  2. 自定义组件必传 className:用 styled(组件) 时,确保组件将 className 传给根元素;
  3. 慎用!important:覆盖第三方组件样式时,优先提高选择器优先级,而非直接用 !important
  4. 样式组件定义在外部:避免在渲染函数内定义样式组件(导致每次渲染重新创建);
  5. 调试优化:安装 babel-plugin-styled-components 插件,让开发者工具显示有意义的 className;
  6. 抽离通用样式:将重复样式抽离为基础组件或主题变量,减少冗余。

六、总结

styled-components 并非简单的 “CSS 写在 JS 里”,而是 React 组件化思想在样式领域的延伸。其核心价值在于:

  1. 语法灵活styled.xxx 适配原生标签,styled(组件) 适配自定义 / 第三方组件,覆盖全场景;
  2. 样式闭环:样式与组件绑定,杜绝全局污染,提升可维护性;
  3. 动态能力:通过 props 和 ThemeProvider 轻松实现动态样式和主题管理;
  4. 生态兼容:无缝对接 KendoReact/AntD 等主流组件库,降低定制成本。

对于 React 开发者而言,掌握 styled-components 不仅能解决传统样式方案的痛点,更能构建出更健壮、易扩展的组件体系,是中大型 React 项目样式管理的首选方案。

国家能源局:1月核发绿证1.96亿个 其中可交易绿证1.51亿个

国家能源局发布2026年1月全国可再生能源绿色电力证书核发及交易数据。2026年1月,国家能源局核发绿证1.96亿个,涉及可再生能源发电项目83.20万个,其中可交易绿证1.51亿个,占比76.79%。本期核发2025年12月可再生能源电量对应绿证1.52亿个,占比77.49%。

深入浅出:CSS 中的“隐形结界”——BFC 详解

在前端面试和实际开发中,BFC(Block Formatting Context,块级格式化上下文)可以说是一个“神级”概念。它听起来很抽象,但实际上它是解决 CSS 布局疑难杂症(如外边距折叠、高度塌陷、浮动重叠)的一把万能钥匙。

今天我们就用通俗易懂的方式,把 BFC 这个“黑盒子”彻底打开。


1. 什么是 BFC?

官方定义:块级格式化上下文。它是 Web 页面中一块独立的渲染区域,只有块级元素参与,它规定了内部的块级元素如何布局,并且与外部毫不相干。

通俗理解: BFC 就像是一个 “完全隔离的独立房间”。 在这个房间(容器)里:

  • 元素怎么折腾(比如浮动、乱跑的 margin)都不会影响到房间外面的布局。
  • 外面的人也不会影响到房间里面。
  • 在这个房间里,一切都要算清楚,不能含糊其辞地溢出到外面去。

2. 如何触发(开启)BFC?

并不是所有元素天然就是 BFC,你需要满足特定条件才能触发它。只要满足下列 任意一条,该元素就会创建一个 BFC:

  1. overflow 值不为 visible (常用 ✅)
    • 例如:hidden, auto, scroll。这是最常用的方式,因为它副作用最小。
  2. display 设置为特殊值
    • inline-block, table-cell, flex, grid, flow-root
    • 注:display: flow-root 是专门为了创建 BFC 而生的新属性,无副作用,未来趋势。
  3. position 设置为脱离文档流的值
    • absolute, fixed
  4. float 设置为不为 none 的值
    • left, right

3. BFC 的三大“超能力”(实战应用)

一旦开启了 BFC,这个元素就拥有了三项特异功能:

(1) 阻止外边距折叠 (Margin Collapse)

  • 痛点:父子元素之间,子元素的 margin-top 经常会“穿透”父元素,带着父元素一起往下掉;或者两个相邻兄弟元素的上下 margin 会合并。
  • BFC 解法给父元素开启 BFC(例如 overflow: hidden)。
    • 原理:BFC 是一堵墙。父元素变成了独立房间,子元素的 margin 再大也撞不开这堵墙,只能乖乖在墙内撑开父元素的内容,无法穿透出去

(2) 清除浮动(解决高度塌陷)

  • 痛点:子元素全部浮动 (float: left) 后,父元素因为检测不到高度,高度会塌陷为 0,背景色消失,布局乱套。
  • BFC 解法给父元素开启 BFC(例如 overflow: hidden)。
    • 原理:普通容器计算高度时会忽略浮动元素,但 BFC 容器规定:计算高度时,浮动元素也参与计算。所以它能自动包裹住浮动的子元素。

(3) 防止元素被浮动元素覆盖(自适应两栏布局)

  • 痛点:左边一个浮动元素,右边的普通 div 会无视它,直接钻到它底下去,导致内容重叠。
  • BFC 解法给右边的 div 开启 BFC(例如 overflow: hidden)。
    • 原理:BFC 的区域不会与浮动盒子重叠。利用这一点,可以轻松实现“左边固定宽度,右边自动填满剩余空间”的经典布局。

4. 为什么 overflow: hidden 最常用?

虽然 float: leftposition: absolute 也能触发 BFC,但它们会让元素脱离文档流,改变布局结构(比如宽度变窄、位置飞走)。

overflow: hidden 通常保持了块级元素的原本特性(独占一行、宽度撑满),只是顺带开启了 BFC 功能,副作用最小,所以成为了大家的首选。


5. 小结

下次当你遇到:

  • Margin 莫名其妙穿透/合并了
  • 父元素高度莫名其妙没了(塌陷)
  • 元素莫名其妙重叠了

请先想一想:“我是不是需要给父容器加一个 overflow: hidden 来开启 BFC?”

这通常是解决 CSS 疑难杂症最快、最有效的方法。

gsap 配置解读 --3

drawSVG 是什么

  <div class="card">
    <h1>案例 15:DrawSVG 绘制路径</h1>
    <p>DrawSVGPlugin 可以控制路径的绘制百分比。</p>
    <svg viewBox="0 0 200 200">
      <path id="path" class="stroke" d="M40 100 C40 40, 160 40, 160 100 C160 160, 40 160, 40 100" />
    </svg>
    <button id="play">绘制路径</button>
  </div>
  <script src="https://cdn.jsdelivr.net/npm/gsap@3.14.1/dist/gsap.min.js"></script>

  <script src="https://cdn.jsdelivr.net/npm/gsap@3.14.1/dist/DrawSVGPlugin.min.js"></script>
  <script>
    const path = document.querySelector("#path");
    const playButton = document.querySelector("#play");

    // 注册 DrawSVGPlugin
    gsap.registerPlugin(DrawSVGPlugin);

    // drawSVG: "0% 100%" 表示从头绘制到尾
    const tween = gsap.fromTo(
      path,
      { drawSVG: "0% 0%" },
      { drawSVG: "0% 100%", duration: 1.6, ease: "power2.out", paused: true }
    );

    playButton.addEventListener("click", () => {
      tween.restart();
    });
  </script>

drawSVGGSAP(GreenSock Animation Platform)官方提供的一个强大插件 —— DrawSVGPlugin 的核心功能,专门用于以动画方式“绘制”或“擦除” SVG 路径(<path><line><polyline><polygon><rect><circle> 等),实现类似“手绘”、“描边动画”的效果。


📌 你的代码解释:

gsap.fromTo(
  path,
  { drawSVG: "0% 0%" },      // 起始状态:路径完全未绘制(0% 到 0%)
  { drawSVG: "0% 100%", duration: 1.6, ease: "power2.out", paused: true }
);

这段代码的作用是:

让 SVG 路径从“完全隐藏”状态,平滑地“画出来”,直到完整显示整个路径。

点击按钮后,调用 tween.restart() 重新播放这个绘制动画。


drawSVG 的工作原理

SVG 路径本身是一条“线”,但默认是立即完整显示的。
DrawSVGPlugin 通过动态控制 SVG 的 stroke-dasharraystroke-dashoffset 属性,来只显示路径的一部分,从而模拟“绘制”过程。

  • drawSVG: "0% 0%" → 显示 0% 到 0% → 完全隐藏
  • drawSVG: "0% 50%" → 显示前 50%
  • drawSVG: "0% 100%" → 显示全部 → 完整路径
  • drawSVG: "100% 100%" → 也完全隐藏(可以用来做“擦除”效果)

💡 它支持百分比("0% 100%")、绝对长度("0px 200px")或关键词("start", "end")。


🔧 常见用法示例

1. 从头到尾绘制(你的例子)
{ drawSVG: "0% 100%" }
2. 从尾到头绘制(反向)
{ drawSVG: "100% 0%" } // 注意顺序:起始 > 结束 = 反向
3. 中间一段高亮(常用于进度指示)
{ drawSVG: "40% 60%" }
4. 擦除效果(从完整到消失)
gsap.to(path, { drawSVG: "0% 0%", duration: 1 });
5. 循环绘制 + 擦除
gsap.to(path, {
  drawSVG: "0% 100%",
  duration: 1,
  yoyo: true,
  repeat: -1
});

✅ 支持的 SVG 元素

元素 是否支持
<path> ✅ 最常用
<line>
<polyline>
<polygon>
<rect> ✅(需有 stroke
<circle> / <ellipse>
<text> ❌(不支持,但可用 textPath 包裹路径)

⚠️ 要求元素必须有 stroke(描边),且 stroke-width > 0。填充(fill)不影响绘制动画。


🎨 样式建议(CSS)

.stroke {
  fill: none;           /* 通常设为无填充 */
  stroke: #3b82f6;      /* 描边颜色 */
  stroke-width: 4;      /* 描边宽度 */
  stroke-linecap: round;/* 线帽样式(可选)*/
}

⚠️ 注意事项

  1. 必须注册插件

    gsap.registerPlugin(DrawSVGPlugin);
    
  2. 路径必须是“单一线条”
    复杂组合路径(如多个子路径)可能表现异常,建议简化或拆分。

  3. 性能优秀
    DrawSVGPlugin 内部优化良好,即使在低端设备上也能流畅运行。

  4. 与 ScrollTrigger 结合极佳
    常用于“滚动触发动画”:

    gsap.to(path, {
      scrollTrigger: ".section",
      drawSVG: "0% 100%",
      duration: 1
    });
    

✅ 总结

术语 含义
drawSVG GSAP 的 DrawSVGPlugin 提供的属性,用于控制 SVG 路径的“绘制进度”
典型值 "0% 0%"(隐藏)、"0% 100%"(完整绘制)、"100% 0%"(反向绘制)

EaselPlugin是什么

<div class="card">
    <h1>案例 16:EaselPlugin + Canvas</h1>
    <p>用 GSAP 驱动 EaselJS 的对象属性。</p>
    <canvas id="stage" width="420" height="220"></canvas>
    <button id="play">播放动画</button>
  </div>
  <script src="https://code.createjs.com/1.0.0/easeljs.min.js"></script>
  <script src="https://cdn.jsdelivr.net/npm/gsap@3.14.1/dist/gsap.min.js"></script>

  <script src="https://cdn.jsdelivr.net/npm/gsap@3.14.1/dist/EaselPlugin.min.js"></script>
  <script>
    const canvas = document.querySelector("#stage");
    const playButton = document.querySelector("#play");

    // 创建 EaselJS 舞台与图形
    const stage = new createjs.Stage(canvas);
    const circle = new createjs.Shape();
    circle.graphics.beginFill("#38bdf8").drawCircle(0, 0, 26);
    circle.x = 60;
    circle.y = 110;
    stage.addChild(circle);
    stage.update();

    // 注册 EaselPlugin
    gsap.registerPlugin(EaselPlugin);

    // GSAP 让 EaselJS 图形移动与缩放
    const tween = gsap.to(circle, {
      x: 360,
      scaleX: 1.4,
      scaleY: 1.4,
      duration: 1.4,
      ease: "power2.out",
      paused: true
    });

    // 每帧刷新舞台
    gsap.ticker.add(() => {
      stage.update();
    });

    playButton.addEventListener("click", () => {
      tween.restart();
    });
  </script>

EaselJSCreateJS 套件中的一个核心库,专门用于在 HTML5 <canvas> 画布上进行高性能的 2D 图形绘制与交互开发。它提供了一套类似 Flash/ActionScript 的面向对象 API,让开发者能轻松创建、操作和动画化矢量图形、位图、文本等元素。


📌 在你的代码中,EaselJS 的作用是:

  1. 创建一个 Canvas 舞台(Stage)
  2. 绘制一个圆形(Shape)并添加到舞台上
  3. 通过 GSAP + EaselPlugin 控制该圆形的位置和缩放

EaselPlugin 是 GSAP 的一个官方插件,让 GSAP 能直接动画化 EaselJS 对象的属性(如 x, y, scaleX, rotation 等),并自动触发舞台重绘。


✅ EaselJS 核心概念

概念 说明
Stage 代表整个 <canvas> 画布,是所有显示对象的容器
DisplayObject 所有可视对象的基类(如 Shape, Bitmap, Text, Container
Shape 用于绘制矢量图形(圆、矩形、路径等)
Ticker EaselJS 自带的帧循环(但你的代码用的是 GSAP 的 ticker 来更新舞台)

🔍 你的代码逐行解析

// 1. 创建 EaselJS 舞台
const stage = new createjs.Stage(canvas);

// 2. 创建一个圆形 Shape
const circle = new createjs.Shape();
circle.graphics.beginFill("#38bdf8").drawCircle(0, 0, 26); // 画一个半径26的圆
circle.x = 60;
circle.y = 110;

// 3. 将圆形添加到舞台
stage.addChild(circle);

// 4. 首次渲染(否则看不到)
stage.update();
// 5. 注册 GSAP 插件
gsap.registerPlugin(EaselPlugin);

// 6. 用 GSAP 动画化 EaselJS 对象!
const tween = gsap.to(circle, {
  x: 360,       // EaselJS 对象的 x 属性
  scaleX: 1.4,  // 缩放
  scaleY: 1.4,
  duration: 1.4,
  ease: "power2.out",
  paused: true
});
// 7. 关键:每帧刷新 Canvas!
gsap.ticker.add(() => {
  stage.update(); // 告诉 EaselJS 重新绘制整个舞台
});

💡 如果没有 stage.update(),Canvas 不会更新,动画就“看不见”!


✅ 为什么需要 EaselPlugin

  • EaselJS 对象的属性(如 x, scaleX不是直接作用于 DOM 或 CSS,而是存储在 JavaScript 对象中。
  • GSAP 默认不知道如何“读取/写入”这些属性,也不知道何时需要调用 stage.update()
  • EaselPlugin 桥接了 GSAP 和 EaselJS
    • 自动识别 createjs.DisplayObject
    • 正确设置/获取 x, y, rotation, scaleX/Y, alpha 等属性
    • (可选)自动调用 stage.update()(但你的代码手动用 gsap.ticker 控制,更灵活)

🎯 EaselJS 的典型应用场景

场景 说明
游戏开发 2D 小游戏(平台跳跃、射击、解谜等)
数据可视化 动态图表、交互式信息图
广告 Banner HTML5 富媒体广告(替代 Flash)
教育/演示动画 复杂交互动画、流程演示
Canvas UI 组件 自定义控件、非 DOM 的界面

⚠️ 注意事项

  1. 性能 vs DOM
    Canvas 适合大量图形或高频更新(如游戏),但不支持 SEO、无障碍访问(a11y)。简单 UI 优先用 DOM + CSS。

  2. 坐标系
    EaselJS 使用标准 Canvas 坐标系:左上角 (0,0),向右为 X+,向下为 Y+。

  3. 事件处理
    EaselJS 支持鼠标/触摸事件(circle.on("click", handler)),但需启用:

    stage.enableMouseOver(10); // 启用 hover
    
  4. 替代方案
    现代项目也可考虑:

    • 纯 Canvas + requestAnimationFrame
    • PixiJS(更强大,支持 WebGL)
    • Three.js(3D)
    • SVG + GSAP(矢量、可访问性好)

✅ 总结

术语 含义
EaselJS 一个基于 HTML5 Canvas 的 2D 图形库,提供类似 Flash 的开发体验
EaselPlugin GSAP 插件,让 GSAP 能无缝动画化 EaselJS 对象的属性

你的代码展示了 “用 GSAP 驱动 Canvas 图形动画” 的经典模式:

  • EaselJS 负责 图形创建与渲染
  • GSAP 负责 复杂缓动、时间控制、序列编排
  • gsap.ticker 负责 每帧刷新画面

这种组合在需要精细控制 Canvas 动画时非常高效!

Flip 是什么

<div class="card">
    <h1>案例 17:Flip 位置变换</h1>
    <p>Flip 能把布局切换变成平滑动画。</p>
    <div class="grid" id="grid">
      <div class="item highlight">A</div>
      <div class="item">B</div>
      <div class="item">C</div>
      <div class="item">D</div>
      <div class="item">E</div>
      <div class="item">F</div>
    </div>
    <button id="toggle">切换布局</button>
  </div>
  <script src="https://cdn.jsdelivr.net/npm/gsap@3.14.1/dist/gsap.min.js"></script>

  <script src="https://cdn.jsdelivr.net/npm/gsap@3.14.1/dist/Flip.min.js"></script>
  <script>
    const grid = document.querySelector("#grid");
    const toggleButton = document.querySelector("#toggle");
    let expanded = false;

    // 注册 Flip 插件
    gsap.registerPlugin(Flip);

    toggleButton.addEventListener("click", () => {
      const items = gsap.utils.toArray(".item");

      // 记录布局状态
      const state = Flip.getState(items);

      // 切换布局
      expanded = !expanded;
      grid.style.gridTemplateColumns = expanded ? "repeat(2, 1fr)" : "repeat(3, 1fr)";
      items[0].classList.toggle("highlight", expanded);
      items[0].style.gridColumn = expanded ? "span 2" : "auto";

      // 用 Flip 生成补间动画
      Flip.from(state, {
        duration: 0.8,
        ease: "power2.inOut",
        stagger: 0.04
      });
    });
  </script>

FlipGSAP(GreenSock Animation Platform)官方提供的一个革命性插件 —— FlipPlugin,它的名字是 "First, Last, Invert, Play" 的缩写,是一种高效实现布局变换平滑动画的技术


🎯 核心思想:“记录变化前后的状态,自动生成中间过渡动画”

你不需要手动计算元素移动了多少像素、缩放了多少倍——
只需改变 DOM 结构或 CSS 布局(如 grid、flex、class、style),Flip 会自动检测差异并补间!


📌 你的代码解释:

// 1. 记录当前所有 .item 元素的状态(位置、尺寸等)
const state = Flip.getState(items);

// 2. 改变布局(这是“瞬间”的,没有动画)
expanded = !expanded;
grid.style.gridTemplateColumns = expanded ? "repeat(2, 1fr)" : "repeat(3, 1fr)";
items[0].classList.toggle("highlight", expanded);
items[0].style.gridColumn = expanded ? "span 2" : "auto";

// 3. 让 Flip 从“旧状态”动画到“新状态”
Flip.from(state, {
  duration: 0.8,
  ease: "power2.inOut",
  stagger: 0.04
});

效果:点击按钮后,网格从 3 列变为 2 列,第一个 item 跨两列并高亮,其他元素平滑地移动、缩放到新位置,而不是“跳变”。


🔍 Flip 的工作原理(F.L.I.P.)

步骤 含义 你的代码中
F - First 记录元素变化前的位置/尺寸 Flip.getState(items)
L - Last 应用新的布局(DOM/CSS 改变) 修改 gridTemplateColumnsgridColumn
I - Invert 通过 transform 将元素视觉上“倒回”到原始位置(用户看不见这一步) Flip 内部自动完成
P - Play 动画 transform 回到新位置,形成平滑过渡 Flip.from(state, {...})

💡 这种技术避免了强制重排(reflow),性能极高!


✅ Flip 的核心优势

优势 说明
零计算 无需手动算 x, y, width, height
自动处理复杂布局 支持 Grid、Flexbox、绝对定位、浮动等
高性能 只使用 transformopacity,60fps 流畅
智能匹配元素 自动根据 DOM 节点或 key 属性关联前后元素
支持嵌套、增删元素 可配合 onEnter, onLeave 处理新增/移除项

🔧 常见用法扩展

1. 指定唯一 key(推荐用于动态列表)
// 给每个 item 加 data-id
<div class="item" data-flip-id="A">A</div>

// Flip 会按 data-flip-id 匹配元素
Flip.from(state, { 
  absolute: true, // 使用绝对定位避免布局抖动
  simple: true    // 简化动画(仅位移+缩放)
});
2. 处理新增/删除元素
Flip.from(state, {
  onEnter: (elements) => gsap.from(elements, { opacity: 0, scale: 0 }), // 新增项淡入
  onLeave: (elements) => gsap.to(elements, { opacity: 0 })              // 移除项淡出
});
3. 与 React/Vue 集成

在虚拟 DOM 更新后调用 Flip.getState() → 触发渲染 → 调用 Flip.from(),实现声明式布局动画。


⚠️ 注意事项

  • 必须注册插件
    gsap.registerPlugin(Flip);
    
  • 元素需有明确尺寸和位置(避免 display: none 或未渲染状态)
  • 默认使用相对定位,若布局跳动可加 absolute: true
  • 不适用于纯颜色/文本内容变化(那是 CSS Transition 的领域)

✅ 总结

术语 含义
Flip (FlipPlugin) GSAP 插件,通过记录布局前后状态,自动生成平滑的元素位置/尺寸变换动画

你的代码是一个典型的 “响应式网格布局切换” 示例,广泛应用于:

  • 卡片列表 ↔ 网格视图切换
  • 侧边栏展开/收起
  • 动态表单布局调整
  • 数据可视化重排

💡 一句话记住 Flip
“改 CSS,记状态,自动生成动画” —— 布局动画从未如此简单!

什么是GSDevTools

 <div class="card">
      <h1>案例 18:GSDevTools 调试面板</h1>
      <p>GSDevTools 用来调试时间线与动画进度。</p>
      <div class="stage">
        <div class="block" id="block"></div>
      </div>
      <div class="hint">页面底部会出现调试面板</div>
    </div>
<script src="https://cdn.jsdelivr.net/npm/gsap@3.14.1/dist/gsap.min.js"></script>

<script src="https://cdn.jsdelivr.net/npm/gsap@3.14.1/dist/GSDevTools.min.js"></script>
    <script>
      const block = document.querySelector("#block");

      // 创建一个循环时间线
      const timeline = gsap.timeline({ repeat: -1, yoyo: true });
      timeline.to(block, { x: 460, duration: 1.4, ease: "power2.inOut" });
      timeline.to(block, { rotation: 180, duration: 0.8, ease: "power2.inOut" }, 0);

      // 创建调试面板
      GSDevTools.create({ animation: timeline });
    </script>

image.png

什么是 InertiaPlugin

<div class="card">
    <h1>案例 19:Inertia 惯性拖拽</h1>
    <p>松手后带惯性滑动。</p>
    <div class="stage">
      <div class="ball" id="ball"></div>
    </div>
    <div class="hint">拖动小球后快速松手</div>
  </div>
  <script src="https://cdn.jsdelivr.net/npm/gsap@3.14.1/dist/gsap.min.js"></script>

  <script src="https://cdn.jsdelivr.net/npm/gsap@3.14.1/dist/Draggable.min.js"></script>
  <script src="https://cdn.jsdelivr.net/npm/gsap@3.14.1/dist/InertiaPlugin.min.js"></script>
  <script>
    const ball = document.querySelector("#ball");

    // 注册插件
    gsap.registerPlugin(Draggable, InertiaPlugin);

    // 开启惯性效果
    Draggable.create(ball, {
      type: "x,y",
      bounds: ".stage",
      inertia: true
    });
  </script>

就是添加这个属性 是否开启惯性 inertia: true

MotionPathPlugin是什么

<div class="card">
      <h1>案例 20:MotionPath 路径运动</h1>
      <p>让元素沿着 SVG 路径运动。</p>
      <svg viewBox="0 0 420 220">
        <path
          id="track"
          class="path"
          d="M20 180 C120 40, 300 40, 400 180"
        />
        <circle id="dot" class="dot" r="10" cx="20" cy="180"></circle>
      </svg>
      <button id="play">沿路径运动</button>
    </div>
  <script src="https://cdn.jsdelivr.net/npm/gsap@3.14.1/dist/gsap.min.js"></script>

  <script src="https://cdn.jsdelivr.net/npm/gsap@3.14.1/dist/MotionPathHelper.min.js"></script>
  <script src="https://cdn.jsdelivr.net/npm/gsap@3.14.1/dist/MotionPathPlugin.min.js"></script>
    <script>
      const dot = document.querySelector("#dot");
      const track = document.querySelector("#track");
      const playButton = document.querySelector("#play");

      // 注册 MotionPathPlugin
      gsap.registerPlugin(MotionPathPlugin);

      const tween = gsap.to(dot, {
        duration: 1.8,
        ease: "power1.inOut",
        motionPath: {
          path: track,
          align: track,
          alignOrigin: [0.5, 0.5]
        },
        paused: true
      });

      playButton.addEventListener("click", () => {
        tween.restart();
      });
    </script>

motionPathGSAP(GreenSock Animation Platform) 动画库中的一个强大功能,由 MotionPathPlugin 插件提供,用于让元素沿着指定的 路径(path) 进行动画运动。


📌 简单定义:

motionPath 允许你将一个 DOM 元素(如 <div><circle> 等)沿着 SVG 路径(<path><circle><rect> 等)或一组坐标点进行平滑移动,并可自动旋转以对齐路径方向。


✅ 核心特性:

  1. 路径支持多种格式

    • SVG 的 <path> 元素(最常用)
    • 其他 SVG 形状(如 <circle>, <rect>, <polygon>
    • 一组 {x, y} 坐标点组成的数组
    • 字符串形式的 SVG 路径数据(d 属性)
  2. 自动对齐(align)

    • 可通过 align: path 让元素在移动时朝向路径切线方向(比如让飞机头始终指向飞行方向)。
    • alignOrigin 控制对齐的“锚点”,例如 [0.5, 0.5] 表示元素中心对齐。
  3. 精确控制

    • 支持 startend 属性,控制沿路径的起止位置(0 到 1)。
    • 可结合 GSAP 的时间轴、缓动函数(ease)、重复等高级功能。

gsap.to(dot, {
  duration: 1.8,
  ease: "power1.inOut",
  motionPath: {
    path: track,           // 沿着 #track 这个 SVG 路径移动
    align: track,          // 元素方向对齐路径
    alignOrigin: [0.5, 0.5] // 以圆点中心为对齐基准
  },
  paused: true
});
  • #dot(一个小圆)会从路径起点 (20,180) 开始,
  • 沿着贝塞尔曲线 M20 180 C120 40, 300 40, 400 180 移动到终点 (400,180)
  • 移动过程中,由于设置了 align,它会自动旋转以匹配路径的走向(虽然圆形看不出旋转,但如果是箭头就很明显)。

💡 注:圆形 (<circle>) 本身没有方向感,所以 align 效果不明显。若换成 <use> 引用一个飞机图标,就能看到“朝向路径”的效果。


🌟 应用场景:

  • 游戏角色沿轨道移动
  • 数据可视化中的动态轨迹
  • 引导式 UI 动画(如教程提示沿路径走)
  • 创意交互动画(如文字沿曲线飞入)

📚 官方文档:

👉 greensock.com/docs/v3/Plu…


总结:motionPath 是 GSAP 中实现“路径动画”的核心工具,让复杂轨迹运动变得简单、流畅且高度可控。

CSS 踩坑笔记:为什么列表底部的 margin-bottom 总是“失效”?

在开发移动端列表页(尤其是使用 uni-app 或 Vue 开发小程序)时,我们经常遇到这样一个经典问题:

“明明给列表最后一个元素设置了 margin-bottom: 60rpx,为什么滚动到底部时,它依然紧贴着屏幕边缘?就像这行代码没写一样?”

这是一个困扰过无数前端新手的“灵异现象”。今天我们就来彻底梳理它的成因、背后的原理以及标准的解决方案。


1. 现象复现

假设我们有一个长列表,结构如下:

<view class="container">
  <view class="content">
    <!-- 很多内容 -->
    ...
    <!-- 最后一个按钮 -->
    <view class="submit-btn">提交</view>
  </view>
</view>
.submit-btn {
  margin-bottom: 60rpx; /* 期望按钮下方留出空隙 */
}

结果:页面滚动到底部,.submit-btn 紧贴视口底部,60rpx 的间距凭空消失了。


2. 核心原因

这个问题通常由两个核心 CSS 机制共同导致:

(1) 外边距折叠(Margin Collapse)与穿透

这是最常见的原因。根据 CSS 规范,块级元素的垂直外边距(margin)有时会发生合并(折叠)

如果父容器(.content)没有设置以下属性之一:

  • border(边框)
  • padding(内边距)
  • overflow: hidden/auto(创建 BFC)

那么,最后一个子元素的 margin-bottom 会“穿透”父容器,溢出到父容器外面,变成父容器的外边距。

后果

  • 子元素的 margin 不再撑开父容器的高度。
  • 如果父容器已经是页面最底层的元素,这个溢出的 margin 就相当于推了个寂寞(下面没有其他元素了),所以在视觉上,按钮依然贴底。

(2) 滚动容器的计算机制(Scroll Height)

在某些渲染引擎(特别是 Webkit 内核及部分小程序环境)中,计算 scrollHeight(可滚动高度)时,不会将最后一个子元素的 margin 计算在内

它认为:“内容只到元素的边界(Border Box)为止,外面的 Margin 是空的,不算作‘有效内容’。”

因此,即使 margin 还在那里,浏览器也不会为你提供额外的滚动距离来展示这个 margin。


3. 涉及知识点

  1. CSS 盒模型 (Box Model):理解 Content, Padding, Border, Margin 的区别。
  2. 外边距折叠 (Margin Collapse):CSS 中非常重要的布局规则,尤其是父子元素之间的折叠。
  3. 块格式化上下文 (BFC):如何通过 overflow 等属性创建隔离环境,防止 margin 穿透。
  4. 滚动视口 (Scrollport):浏览器如何计算滚动区域的大小。

4. 解决方法

方案 A:使用 padding-bottom(推荐 ✅)

这是最稳健、最符合逻辑的解法。既然 margin 容易折叠或被忽略,那我们就用 padding。Padding 属于容器内部空间,永远会被计算在高度内。

代码修改

/* 给父容器设置 padding-bottom */
.content {
  /* 加上原本想要的间距 */
  padding-bottom: 60rpx; 
  
  /* 如果有底部安全区需求(如 iPhone X+),还能完美叠加 */
  padding-bottom: calc(60rpx + env(safe-area-inset-bottom));
}

/* 子元素的 margin-bottom 可以去掉了 */
.submit-btn {
  margin-bottom: 0;
}

方案 B:给父容器加“墙”(BFC 或 Border)

如果你非要用 margin,可以给父容器加一道“墙”,把 margin 挡在里面,强迫它撑开高度。

.content {
  /* 方法1:加个透明边框 */
  border-bottom: 1px solid transparent; 
  
  /* 或者 方法2:触发 BFC */
  overflow: hidden; 
}

缺点overflow: hidden 可能会裁切掉其他故意溢出的元素(如阴影、弹窗),使用需谨慎。

方案 C:加个空元素垫底(不推荐 ❌)

以前常用的土办法,在列表最后加一个空的 <view style="height: 60rpx"></view>缺点:代码冗余,不仅增加了无语义的 DOM 节点,还不够优雅。


5. 小结

在处理滚动容器(无论是 scroll-view 还是页面级滚动)的底部留白时,请牢记一条黄金法则

“外边距(Margin)是用来推开别人的,内边距(Padding)才是用来撑大自己的。”

当你想让容器底部留出一段空白区域,永远优先选择给容器设置 padding-bottom。它不仅能完美避开 margin 折叠的坑,还能配合 calc(env(safe-area-inset-bottom)) 轻松搞定全面屏适配。

Vite 项目优化分包填坑之依赖多版本冲突问题深度解析与解决方案

在前端开发中,依赖管理看似简单,实则暗藏玄机。最近在使用 Vite + pnpm 构建项目时,遇到了一个典型的多版本依赖冲突问题,值得深入探讨和分享。

问题现象

项目中引入了 ai-agent 这个第三方库后,发现构建上线后出现兼容性问题。经过排查,发现问题与 @vueuse/core 的版本冲突有关。

具体表现为:

  • 项目直接依赖:@vueuse/core@^10.4.1
  • ai-agent 依赖:@vueuse/core@^8.6.0
  • 当在 Vite 配置的 manualChunks 中对 @vueuse/core 进行单独分包时,应用运行异常
  • 注释掉相关分包配置后,问题消失

问题本质分析

npm/pnpm 的依赖解析机制

首先需要理解包管理器如何处理版本冲突:

npm 的嵌套依赖

node_modules/
├── @vueuse/core/           # v10.4.1 (项目依赖)
└── @frontend/
    └── ai-agent/
        └── node_modules/
            └── @vueuse/core/  # v8.6.0 (ai-agent 依赖)

pnpm 的符号链接

node_modules/
├── @vueuse/core → .pnpm/@vueuse+core@10.4.1/...
└── .pnpm/
    └── @frontend+ai-agent@1.0.12/
        └── node_modules/
            └── @vueuse/core → .pnpm/@vueuse+core@8.6.0/...

关键点:两个不同版本的 @vueuse/core 在文件系统中是完全独立的模块

Rollup 的模块处理机制

Rollup 默认情况下会根据完整的模块路径来区分不同的模块实例:

  • 路径 A: /node_modules/.pnpm/@vueuse+core@10.4.1/.../index.js
  • 路径 B: /node_modules/.pnpm/@frontend+ai-agent@1.0.12/.../@vueuse/core/index.js

这样,两个版本的代码会被分别打包,保持作用域隔离,互不干扰。

manualChunks 的陷阱

问题出在 manualChunks 配置:

// 危险的配置
manualChunks(id) {
  if (id.includes("@vueuse/core")) {
    return "vueuse"; // 强制所有 vueuse 模块进入同一 chunk
  }
}

这个配置的问题在于:

  1. 路径匹配过于宽泛:同时匹配到 v8 和 v10 的模块路径
  2. 破坏模块隔离:将两个不同版本的代码强制打包到同一个 chunk 中
  3. 运行时冲突:两个版本的实现可能互相覆盖或产生状态冲突

通过在 manualChunks 中添加日志可以验证:

console.log("vueuse===========", id);
// 输出两次,分别对应两个不同版本的完整路径

解决方案

方案一:移除 manualChunks 配置(推荐)

最简单有效的方案就是不要对存在版本冲突的依赖进行 manualChunks 分包

// 正确的做法:注释掉或删除相关配置
manualChunks(id) {
  if (id.includes("node_modules")) {
    // 不要对 @vueuse/core 进行特殊分包
    // if (id.includes("@vueuse/core")) {
    //   return "vueuse";
    // }
    
    // 其他安全的分包配置
    if (id.includes("axios")) {
      return "axios";
    }
    // ... 其他依赖
  }
}

优势

  • 简单可靠,无需额外配置
  • 保持 Rollup 默认的模块隔离机制
  • 避免人为干预导致的意外冲突

方案二:统一依赖版本

从根本上解决问题,确保整个项目使用同一版本:

使用 pnpm overrides

{
  "pnpm": {
    "overrides": {
      "@vueuse/core": "^10.4.1"
    }
  }
}

注意事项

  • 需要充分测试第三方库的兼容性
  • 可能导致 ai-agent 出现运行时错误
  • 适合对第三方库有控制权的场景

方案三:精确版本区分(不推荐)

理论上可以通过路径中的版本号进行精确区分:

manualChunks(id) {
  if (id.includes("node_modules")) {
    if (id.includes("@vueuse/core") && (id.includes("@8.") || id.includes("@8-"))) {
      return "vueuse-v8";
    }
    if (id.includes("@vueuse/core") && (id.includes("@10.") || id.includes("@10-"))) {
      return "vueuse-v10";
    }
    // ... 其他配置
  }
}

为什么不推荐

  • 路径匹配逻辑脆弱,容易失效
  • 增加维护成本
  • 仍然存在两个版本,只是分开了而已
  • 打包体积更大

经验总结

  1. 谨慎使用 manualChunks:只对版本稳定、无冲突风险的大型依赖进行分包
  2. 理解包管理器机制:npm/pnpm/yarn 在处理版本冲突时的行为差异
  3. 依赖版本一致性:尽量保持项目中核心依赖的版本统一
  4. 测试驱动配置:任何构建配置的修改都需要充分测试验证

这个问题虽然看似简单,但涉及了包管理、模块打包、依赖解析等多个层面的知识。通过深入理解这些机制,我们能够更好地避免类似的"坑",写出更健壮的构建配置。

JavaScript 深拷贝的完全解决方案

当我们说"深拷贝"时,我们到底在说什么?为什么简单的 JSON.parse(JSON.stringify(obj)) 不够用?如何优雅地处理循环引用、特殊对象、函数引用?本文将深入深拷贝的每一个角落,构建一个真正"完全"的深拷贝函数。

前言:一个看似简单的问题

我们先来看一个最简单的深拷贝:

const obj = { name: '张三', age: 25 };
const copy = JSON.parse(JSON.stringify(obj));
console.log(copy); // { name: '张三', age: 25 }

但这真的够用吗?如果我们有一个复杂对象:

const complexObj = {
  date: new Date(),
  regex: /test/gi,
  func: () => console.log('hello'),
  undef: undefined,
  inf: Infinity,
  nan: NaN,
  map: new Map([['key', 'value']]),
  set: new Set([1, 2, 3]),
  symbol: Symbol('test'),
  error: new Error('错误')
};

这时候应该如何处理呢?这就是为什么我们需要一个真正完善的深拷贝解决方案。

深拷贝的基础概念

深拷贝 vs 浅拷贝

  • 深拷贝:完全独立的副本,修改拷贝对象的属性值,不会影响原对象
  • 浅拷贝:只复制一层,修改拷贝对象的属性值,会影响原对象

浅拷贝示例

const original = {
  name: '张三',
  address: {
    city: '北京',
    street: '长安街'
  }
};

// 浅拷贝示例
const shallowCopy1 = Object.assign({}, original);
const shallowCopy2 = { ...original };

shallowCopy1.address.city = '上海';
console.log('original.address.city:', original.address.city); // 上海
console.log('shallowCopy1.address.city:', shallowCopy1.address.city); // 上海

深拷贝示例

const original = {
  name: '张三',
  address: {
    city: '北京',
    street: '长安街'
  }
};
function simpleDeepCopy(obj) {
  return JSON.parse(JSON.stringify(obj));
}

const deepCopy = simpleDeepCopy(original);
deepCopy.address.city = '广州';
console.log('original.address.city:', original.address.city); // 北京
console.log('deepCopy.address.city:', deepCopy.address.city); // 广州

为什么要深拷贝?

  • 状态管理要求不可变数据
  • 撤销/重做功能需要保存历史快照
  • 复杂表单的草稿保存
  • 数据处理的隔离环境
  • 跨线程/跨进程通信

深拷贝的挑战

  • 循环引用:对象相互引用导致无限递归
  • 特殊对象:需要保留原型链和构造函数
  • 函数:通常不拷贝,但需要处理
  • Symbol:作为属性名和值的处理
  • 不可枚举属性:需要遍历所有属性描述符
  • 原型链:是否需要继承
  • 性能:大量数据的拷贝效率

JSON 方法的全面评估

JSON 序列化的局限性

  1. undefined 会被忽略
  2. symbol 会被忽略
  3. function 会被忽略
  4. 特殊数值会变成 null
  5. Date / RegExp / Error 等对象会转成字符串
  6. Map / Set / WeakMap / WeakSet 等会变成空对象
  7. TypedArray / ArrayBuffer 会变成对象
  8. 循环引用会导致错误

JSON 方法的适用场景

  • 纯数据对象(只有普通对象、数组、字符串、数字、布尔值)
  • 与后端 API 通信的数据交换
  • 简单的本地存储(localStorage)
  • 不需要保持原对象类型的临时副本
  • 数据结构已知且可控的内部模块

完整深拷贝要考虑的问题

1. 基础功能

  • 支持所有原始类型
  • 支持普通对象和数组
  • 处理循环引用
  • 处理原型链

2. 内置对象

  • Date:保持 Date 对象
  • RegExp:保持正则表达式
  • Map:保持键值对结构
  • Set:保持集合结构
  • Error:保留错误信息
  • Promise:处理状态
  • Symbol:作为值和属性名

3. 二进制数据

  • ArrayBuffer
  • TypedArray 所有类型
  • DataView
  • SharedArrayBuffer

4. 其他特性

  • 支持不可枚举属性
  • 支持属性 getter/setter
  • 支持冻结/密封对象
  • 支持自定义类实例
  • 性能优化

递归实现与循环引用检测

基础递归实现

function basicDeepCopy(source) {
  // 原始类型直接返回
  if (source === null || typeof source !== 'object') {
    return source;
  }

  // 数组或对象
  const target = Array.isArray(source) ? [] : {};

  // 递归复制每个属性
  for (let key in source) {
    if (source.hasOwnProperty(key)) {
      target[key] = basicDeepCopy(source[key]);
    }
  }

  return target;
}

循环引用检测

function deepCopyWithCycleDetection(source, cache = new WeakMap()) {
  // 处理原始类型
  if (source === null || typeof source !== 'object') {
    return source;
  }

  // 检测循环引用
  if (cache.has(source)) {
    console.log('检测到循环引用,返回已缓存的对象');
    return cache.get(source);
  }

  // 创建目标对象
  const target = Array.isArray(source) ? [] : {};

  // 缓存当前对象
  cache.set(source, target);

  // 递归复制属性
  for (let key in source) {
    if (source.hasOwnProperty(key)) {
      target[key] = deepCopyWithCycleDetection(source[key], cache);
    }
  }

  return target;
}

性能优化版本

function optimizedDeepCopy(source, cache = new Map()) {
  // 快速路径:原始类型
  if (source === null || typeof source !== 'object') {
    return source;
  }

  // 快速路径:Date
  if (source instanceof Date) {
    return new Date(source);
  }

  // 快速路径:RegExp
  if (source instanceof RegExp) {
    return new RegExp(source.source, source.flags);
  }

  // 循环引用检测
  if (cache.has(source)) {
    return cache.get(source);
  }

  // 根据类型创建目标对象
  let target;

  if (Array.isArray(source)) {
    target = [];
  } else if (source instanceof Map) {
    target = new Map();
  } else if (source instanceof Set) {
    target = new Set();
  } else if (source instanceof WeakMap || source instanceof WeakSet) {
    // WeakMap/WeakSet 无法遍历,返回新实例
    return new source.constructor();
  } else {
    // 普通对象:使用原对象的构造函数
    target = Object.create(Object.getPrototypeOf(source));
  }

  // 缓存当前对象
  cache.set(source, target);

  // 处理数组
  if (Array.isArray(source)) {
    for (let i = 0; i < source.length; i++) {
      target[i] = optimizedDeepCopy(source[i], cache);
    }
    return target;
  }

  // 处理 Map
  if (source instanceof Map) {
    for (let [key, value] of source) {
      target.set(
        optimizedDeepCopy(key, cache),
        optimizedDeepCopy(value, cache)
      );
    }
    return target;
  }

  // 处理 Set
  if (source instanceof Set) {
    for (let value of source) {
      target.add(optimizedDeepCopy(value, cache));
    }
    return target;
  }

  // 处理普通对象
  const keys = [...Object.keys(source), ...Object.getOwnPropertySymbols(source)];

  for (let key of keys) {
    const descriptor = Object.getOwnPropertyDescriptor(source, key);

    if (descriptor) {
      // 复制属性描述符
      Object.defineProperty(target, key, {
        ...descriptor,
        value: optimizedDeepCopy(descriptor.value, cache)
      });
    }
  }

  return target;
}

内置对象的深拷贝

class BuiltInCopier {
  // Date 对象
  static copyDate(date) {
    return new Date(date.getTime());
  }

  // RegExp 对象
  static copyRegExp(regexp) {
    const flags =
      (regexp.global ? 'g' : '') +
      (regexp.ignoreCase ? 'i' : '') +
      (regexp.multiline ? 'm' : '') +
      (regexp.dotAll ? 's' : '') +
      (regexp.unicode ? 'u' : '') +
      (regexp.sticky ? 'y' : '');

    return new RegExp(regexp.source, flags);
  }

  // Error 对象
  static copyError(error) {
    const copy = new error.constructor(error.message);
    copy.stack = error.stack;
    copy.name = error.name;
    return copy;
  }

  // Map 对象
  static copyMap(map, copyFn) {
    const result = new Map();
    map.forEach((value, key) => {
      result.set(copyFn(key), copyFn(value));
    });
    return result;
  }

  // Set 对象
  static copySet(set, copyFn) {
    const result = new Set();
    set.forEach(value => {
      result.add(copyFn(value));
    });
    return result;
  }

  // WeakMap 对象
  static copyWeakMap(weakMap) {
    // WeakMap 不可遍历,返回空实例
    return new WeakMap();
  }

  // WeakSet 对象
  static copyWeakSet(weakSet) {
    // WeakSet 不可遍历,返回空实例
    return new WeakSet();
  }

  // ArrayBuffer 对象
  static copyArrayBuffer(arrayBuffer) {
    const copy = arrayBuffer.slice(0);
    return copy;
  }

  // TypedArray 对象
  static copyTypedArray(typedArray) {
    return new typedArray.constructor(typedArray);
  }

  // DataView 对象
  static copyDataView(dataView) {
    return new DataView(
      this.copyArrayBuffer(dataView.buffer),
      dataView.byteOffset,
      dataView.byteLength
    );
  }

  // Promise 对象
  static copyPromise(promise) {
    // Promise 无法复制,返回新的 pending Promise
    return new Promise(() => { });
  }
}

处理自定义类和原型链

自定义类的深拷贝

function copyCustomClass(instance, cache = new WeakMap()) {
  if (cache.has(instance)) {
    return cache.get(instance);
  }

  // 获取构造函数
  const Constructor = instance.constructor;

  // 创建新实例
  let copy;

  try {
    // 尝试使用构造函数创建新实例
    copy = Object.create(Constructor.prototype);
    Constructor.apply(copy, []);
  } catch (error) {
    // 如果构造函数需要参数,则使用 Object.create
    copy = Object.create(Constructor.prototype);
  }

  cache.set(instance, copy);

  // 复制所有属性
  const allKeys = Reflect.ownKeys(instance);

  for (const key of allKeys) {
    const descriptor = Object.getOwnPropertyDescriptor(instance, key);

    if (descriptor) {
      if (descriptor.value !== undefined) {
        descriptor.value = comprehensiveDeepCopy(descriptor.value, cache);
      }
      Object.defineProperty(copy, key, descriptor);
    }
  }

  return copy;
}

原型链的完整处理

function deepCopyWithPrototype(source, cache = new WeakMap()) {
  if (source === null || typeof source !== 'object') {
    return source;
  }

  if (cache.has(source)) {
    return cache.get(source);
  }

  let target;

  // 获取完整的原型链
  const getPrototypeChain = (obj) => {
    const chain = [];
    let proto = Object.getPrototypeOf(obj);
    while (proto && proto !== Object.prototype) {
      chain.unshift(proto);
      proto = Object.getPrototypeOf(proto);
    }
    return chain;
  };

  // 重建原型链
  const buildPrototypeChain = (obj, chain) => {
    if (chain.length === 0) {
      return obj;
    }

    let current = obj;
    for (let i = 0; i < chain.length; i++) {
      const proto = chain[i];
      const protoCopy = Object.create(Object.getPrototypeOf(proto));

      // 复制原型上的属性
      const keys = Reflect.ownKeys(proto);
      for (const key of keys) {
        const descriptor = Object.getOwnPropertyDescriptor(proto, key);
        if (descriptor) {
          if (descriptor.value !== undefined) {
            descriptor.value = deepCopyWithPrototype(descriptor.value, cache);
          }
          Object.defineProperty(protoCopy, key, descriptor);
        }
      }

      Object.setPrototypeOf(current, protoCopy);
      current = protoCopy;
    }

    return obj;
  };

  // 处理不同类型
  if (source instanceof Date) {
    target = new Date(source);
  } else if (source instanceof RegExp) {
    target = new RegExp(source);
  } else if (Array.isArray(source)) {
    target = [];
  } else if (source instanceof Map) {
    target = new Map();
  } else if (source instanceof Set) {
    target = new Set();
  } else {
    // 普通对象:先创建空对象,再设置原型链
    target = {};
  }

  cache.set(source, target);

  // 获取并重建原型链
  const protoChain = getPrototypeChain(source);
  buildPrototypeChain(target, protoChain);

  // 复制自身属性
  const allKeys = Reflect.ownKeys(source);
  for (const key of allKeys) {
    const descriptor = Object.getOwnPropertyDescriptor(source, key);
    if (descriptor) {
      if (descriptor.value !== undefined) {
        descriptor.value = deepCopyWithPrototype(descriptor.value, cache);
      }
      Object.defineProperty(target, key, descriptor);
    }
  }

  return target;
}

最终完整解决方案


// 深拷贝配置选项
class DeepCopyOptions {
  constructor({
    copySymbols = true,
    copyNonEnumerables = true,
    preservePrototype = true,
    copyFunctions = false,
    copyWeakCollections = false,
    maxDepth = Infinity,
    onError = (error, key, value) => console.warn(`拷贝 ${key} 时出错:`, error)
  } = {}) {
    this.copySymbols = copySymbols;
    this.copyNonEnumerables = copyNonEnumerables;
    this.preservePrototype = preservePrototype;
    this.copyFunctions = copyFunctions;
    this.copyWeakCollections = copyWeakCollections;
    this.maxDepth = maxDepth;
    this.onError = onError;
  }
}

// 最终版深拷贝
function cloneDeep(source, options = new DeepCopyOptions(), depth = 0, cache = new WeakMap()) {
  // 深度限制
  if (depth >= options.maxDepth) {
    return source;
  }

  // 处理原始类型
  if (source === null || typeof source !== 'object') {
    // 处理函数(可选)
    if (typeof source === 'function' && options.copyFunctions) {
      // 简单的函数复制,不保证完全等价
      return new Function('return ' + source.toString())();
    }
    return source;
  }

  // 循环引用检测
  if (cache.has(source)) {
    return cache.get(source);
  }

  let target;

  try {
    // 根据类型创建目标对象
    const constructor = source.constructor;

    // 内置对象处理
    switch (constructor) {
      case Date:
        target = new Date(source);
        break;

      case RegExp:
        target = new RegExp(source.source, source.flags);
        target.lastIndex = source.lastIndex;
        break;

      case Error:
        target = new source.constructor(source.message);
        target.stack = source.stack;
        target.name = source.name;
        break;

      case Map:
        target = new Map();
        cache.set(source, target);
        source.forEach((value, key) => {
          target.set(
            cloneDeep(key, options, depth + 1, cache),
            cloneDeep(value, options, depth + 1, cache)
          );
        });
        return target;

      case Set:
        target = new Set();
        cache.set(source, target);
        source.forEach(value => {
          target.add(cloneDeep(value, options, depth + 1, cache));
        });
        return target;

      case WeakMap:
        target = options.copyWeakCollections ? new WeakMap() : source;
        cache.set(source, target);
        return target;

      case WeakSet:
        target = options.copyWeakCollections ? new WeakSet() : source;
        cache.set(source, target);
        return target;

      case ArrayBuffer:
        target = source.slice(0);
        break;

      case DataView:
        target = new DataView(
          cloneDeep(source.buffer, options, depth + 1, cache),
          source.byteOffset,
          source.byteLength
        );
        break;

      default:
        // 检查 TypedArray
        if (ArrayBuffer.isView(source) && !(source instanceof DataView)) {
          target = new constructor(
            cloneDeep(source.buffer, options, depth + 1, cache),
            source.byteOffset,
            source.length
          );
          break;
        }

        // 普通对象或数组
        if (constructor === Object || constructor === Array) {
          target = Array.isArray(source) ? [] : {};
        } else if (options.preservePrototype) {
          // 保持原型链
          target = Object.create(constructor.prototype);
        } else {
          target = {};
        }
        break;
    }
  } catch (error) {
    options.onError(error, 'constructor', source);
    target = Array.isArray(source) ? [] : {};
  }

  // 缓存当前对象
  cache.set(source, target);

  // 处理数组
  if (Array.isArray(source)) {
    for (let i = 0; i < source.length; i++) {
      try {
        target[i] = cloneDeep(source[i], options, depth + 1, cache);
      } catch (error) {
        options.onError(error, i, source[i]);
        target[i] = undefined;
      }
    }
    return target;
  }

  // 获取所有属性键
  const allKeys = [];

  if (options.copySymbols) {
    allKeys.push(...Object.getOwnPropertySymbols(source));
  }

  if (options.copyNonEnumerables) {
    allKeys.push(...Object.getOwnPropertyNames(source));
  } else {
    allKeys.push(...Object.keys(source));
  }

  // 复制属性
  for (const key of allKeys) {
    try {
      const descriptor = Object.getOwnPropertyDescriptor(source, key);

      if (descriptor) {
        if (descriptor.value !== undefined) {
          descriptor.value = cloneDeep(descriptor.value, options, depth + 1, cache);
        }
        Object.defineProperty(target, key, descriptor);
      }
    } catch (error) {
      options.onError(error, key, source[key]);
    }
  }

  return target;
}

// 便利函数
const deepClone = {
  // 快速克隆(适用于大多数场景)
  quick: (obj) => cloneDeep(obj),

  // 完整克隆(保留所有特性)
  full: (obj) => cloneDeep(obj, new DeepCopyOptions({
    copySymbols: true,
    copyNonEnumerables: true,
    preservePrototype: true,
    copyFunctions: false,
    copyWeakCollections: false
  })),

  // 严格克隆(尽可能完整)
  strict: (obj) => cloneDeep(obj, new DeepCopyOptions({
    copySymbols: true,
    copyNonEnumerables: true,
    preservePrototype: true,
    copyFunctions: true,
    copyWeakCollections: true
  })),

  // 数据克隆(只保留可序列化的数据)
  data: (obj) => cloneDeep(obj, new DeepCopyOptions({
    copySymbols: false,
    copyNonEnumerables: false,
    preservePrototype: false,
    copyFunctions: false,
    copyWeakCollections: false
  }))
};

结语

最好的深拷贝是不需要深拷贝。通过良好的架构设计、使用不可变数据、避免深层嵌套等方式,可以减少对深拷贝的需求。当必须使用时,选择合适的实现方案,既满足需求又不过度设计。对于文章中错误的地方或者有任何问题,欢迎在评论区留言讨论!

❌